3477 lines
122 KiB
Plaintext
3477 lines
122 KiB
Plaintext
diff -ru2 unz60e03/unzip.c u6e3_np/unzip.c
|
|
--- unz60e03/unzip.c Wed Mar 19 13:08:38 2008
|
|
+++ u6e3_np/unzip.c Mon Mar 24 14:16:58 2008
|
|
@@ -128,4 +128,6 @@
|
|
"error: command line parameter #%d exceeds internal size limit\n";
|
|
#endif /* !SFX */
|
|
+static ZCONST char Far NoMemArgsList[] =
|
|
+ "error: no memory for arguments list";
|
|
|
|
#if (defined(REENTRANT) && !defined(NO_EXCEPT_SIGNALS))
|
|
@@ -245,5 +247,5 @@
|
|
static ZCONST char Far local3[] = "\
|
|
-Y treat \".nnn\" as \";nnn\" version -2 force ODS2 names\n\
|
|
- --D restore dir (-D: no) timestamps -M pipe through \"more\" pager\n\
|
|
+ -D- restore dir (-D: no) timestamps -M pipe through \"more\" pager\n\
|
|
(Must quote upper-case options, like \"-V\", unless SET PROC/PARSE=EXTEND.)\
|
|
\n\n";
|
|
@@ -251,5 +253,5 @@
|
|
static ZCONST char Far local3[] = "\n\
|
|
-Y treat \".nnn\" as \";nnn\" version -2 force ODS2 names\n\
|
|
- --D restore dir (-D: no) timestamps\n\
|
|
+ -D- restore dir (-D: no) timestamps\n\
|
|
(Must quote upper-case options, like \"-V\", unless SET PROC/PARSE=EXTEND.)\
|
|
\n\n";
|
|
@@ -694,5 +696,5 @@
|
|
char *p;
|
|
#endif
|
|
-#if (defined(DOS_FLX_H68_NLM_OS2_W32) || !defined(SFX))
|
|
+#if ((defined(WIN32) && defined(__RSXNT__)) || !defined(SFX))
|
|
int i;
|
|
#endif
|
|
@@ -1053,4 +1055,45 @@
|
|
* 'forward slashes' for user's convenience (include zipfile name itself)
|
|
*/
|
|
+ {
|
|
+ /* pfnames */
|
|
+
|
|
+ char **names;
|
|
+
|
|
+ for (names = G.pfnames; *names; names++) {
|
|
+#ifdef __human68k__
|
|
+ extern char *_toslash(char *);
|
|
+ _toslash(*names);
|
|
+#else /* !__human68k__ */
|
|
+ char *q = *names;
|
|
+
|
|
+ while (*q != '\0') {
|
|
+ if (*q == '\\')
|
|
+ *q = '/';
|
|
+ INCSTR(q);
|
|
+ }
|
|
+#endif /* ?__human68k__ */
|
|
+ }
|
|
+ }
|
|
+ {
|
|
+ /* G.wildzipfn */
|
|
+
|
|
+#ifdef __human68k__
|
|
+ extern char *_toslash(char *);
|
|
+ _toslash(*G.wildzipfn);
|
|
+#else /* !__human68k__ */
|
|
+ char *q = G.wildzipfn;
|
|
+
|
|
+ while (*q != '\0') {
|
|
+ if (*q == '\\')
|
|
+ *q = '/';
|
|
+ INCSTR(q);
|
|
+ }
|
|
+#endif /* ?__human68k__ */
|
|
+ }
|
|
+#endif /* DOS_FLX_H68_NLM_OS2_W32 */
|
|
+
|
|
+
|
|
+#if 0
|
|
+#ifdef DOS_FLX_H68_NLM_OS2_W32
|
|
#ifdef SFX
|
|
for (G.pfnames = argv, i = argc; i > 0; --i) {
|
|
@@ -1074,11 +1117,18 @@
|
|
}
|
|
#endif /* DOS_FLX_H68_NLM_OS2_W32 */
|
|
+#endif /* 0 */
|
|
|
|
+/*
|
|
#ifndef SFX
|
|
G.wildzipfn = *argv++;
|
|
#endif
|
|
+*/
|
|
|
|
#if (defined(SFX) && !defined(SFX_EXDIR)) /* only check for -x */
|
|
|
|
+# if 0
|
|
+ /* all this should be done in the options call now */
|
|
+
|
|
+
|
|
G.filespecs = argc;
|
|
G.xfilespecs = 0;
|
|
@@ -1104,7 +1154,10 @@
|
|
} else
|
|
G.process_all_files = TRUE; /* for speed */
|
|
+# endif
|
|
|
|
#else /* !SFX || SFX_EXDIR */ /* check for -x or -d */
|
|
|
|
+# if 0
|
|
+
|
|
G.filespecs = argc;
|
|
G.xfilespecs = 0;
|
|
@@ -1118,9 +1171,9 @@
|
|
while (*++pp) {
|
|
Trace((stderr, "pp - argv = %d\n", pp-argv));
|
|
-#ifdef CMS_MVS
|
|
+# ifdef CMS_MVS
|
|
if (!uO.exdir && STRNICMP(*pp, "-d", 2) == 0) {
|
|
-#else
|
|
+# else
|
|
if (!uO.exdir && strncmp(*pp, "-d", 2) == 0) {
|
|
-#endif
|
|
+# endif
|
|
int firstarg = (pp == argv);
|
|
|
|
@@ -1177,4 +1230,5 @@
|
|
} else
|
|
G.process_all_files = TRUE; /* for speed */
|
|
+# endif
|
|
|
|
if (uO.exdir != (char *)NULL && !G.extract_flag) /* -d ignored */
|
|
@@ -1260,4 +1314,269 @@
|
|
|
|
|
|
+/*
|
|
+ -------------------------------------------------------
|
|
+ Command Line Options
|
|
+ -------------------------------------------------------
|
|
+
|
|
+ Valid command line options.
|
|
+
|
|
+ The function get_option() uses this table to check if an
|
|
+ option is valid and if it takes a value (also called an
|
|
+ option parameter). To add an option to unzip just add it
|
|
+ to this table and add a case in the main switch to handle
|
|
+ it. If either shortopt or longopt not used set to "".
|
|
+
|
|
+ The fields:
|
|
+ option_group - UZO for UnZip option, ZIO for ZipInfo option
|
|
+ shortopt - short option name (1 or 2 chars)
|
|
+ longopt - long option name
|
|
+ value_type - see zip.h for constants
|
|
+ negatable - option is negatable with trailing -
|
|
+ ID - unsigned long int returned for option
|
|
+ name - short description of option which is
|
|
+ returned on some errors and when options
|
|
+ are listed with -so option, can be NULL
|
|
+*/
|
|
+
|
|
+/* Most option IDs are set to the shortopt char. For
|
|
+ multichar short options set to arbitrary unused constant. */
|
|
+#define o_so 0x101
|
|
+
|
|
+
|
|
+/* The below is from the old main command line code with a few changes.
|
|
+ Note that UnZip and ZipInfo filter out their own options based on the
|
|
+ option_group value, so the same option letter can be used for both. */
|
|
+
|
|
+static struct option_struct far options[] = {
|
|
+
|
|
+ /* UnZip options */
|
|
+
|
|
+ /* short longopt value_type negatable
|
|
+ ID name */
|
|
+#ifdef RISCOS
|
|
+ {UZO, "/", "", o_REQUIRED_VALUE, o_NEGATABLE,
|
|
+ '/', "override Unzip$Exts"},
|
|
+#endif
|
|
+ {UZO, "a", "", o_NO_VALUE, o_NEGATABLE,
|
|
+ 'a', "text conv (EOL char, ASCII->EBCDIC"},
|
|
+#if (defined(DLL) && defined(API_DOC))
|
|
+ {UZO, "A", "", o_NO_VALUE, o_NEGATABLE,
|
|
+ 'A', "extended help for API"},
|
|
+#endif
|
|
+ {UZO, "b", "", o_NO_VALUE, o_NEGATABLE,
|
|
+ 'b', "binary, no ASCII conversions"},
|
|
+#ifdef UNIXBACKUP
|
|
+ {UZO, "B", "", o_NO_VALUE, o_NEGATABLE,
|
|
+ 'B', "back up existing files"},
|
|
+#endif
|
|
+#ifdef CMS_MVS
|
|
+ {UZO, "B", "", o_NO_VALUE, o_NEGATABLE,
|
|
+ 'b', "CMS/MVS binary"},
|
|
+#endif
|
|
+ {UZO, "c", "", o_NO_VALUE, o_NEGATABLE,
|
|
+ 'c', "output to stdout"},
|
|
+#ifdef CMS_MVS
|
|
+ /* for CMS_MVS map to lower case */
|
|
+ {UZO, "C", "", o_NO_VALUE, o_NEGATABLE,
|
|
+ 'C', "CMS/MVS lower case"},
|
|
+#endif
|
|
+#if (!defined(SFX) || defined(SFX_EXDIR))
|
|
+ {UZO, "d", "", o_REQUIRED_VALUE, o_NEGATABLE,
|
|
+ 'd', "extraction root directory"},
|
|
+#endif
|
|
+#if (!defined(NO_TIMESTAMPS))
|
|
+ {UZO, "D", "", o_NO_VALUE, o_NEGATABLE,
|
|
+ 'D', "don't restore dir (-DD: any) timestamps"},
|
|
+#endif
|
|
+ {UZO, "e", "", o_NO_VALUE, o_NEGATABLE,
|
|
+ 'e', "extract (not used?)"},
|
|
+#ifdef MACOS
|
|
+ {UZO, "E", "", o_NO_VALUE, o_NEGATABLE,
|
|
+ 'E', "display Mac e.f. when restoring"},
|
|
+#endif
|
|
+ {UZO, "f", "", o_NO_VALUE, o_NEGATABLE,
|
|
+ 'f', "freshen (extract only newer files)"},
|
|
+#if (defined(RISCOS) || defined(ACORN_FTYPE_NFS))
|
|
+ {UZO, "F", "", o_NO_VALUE, o_NEGATABLE,
|
|
+ 'F', "Acorn filetype & NFS extension handling"},
|
|
+#endif
|
|
+ {UZO, "h", "", o_NO_VALUE, o_NOT_NEGATABLE,
|
|
+ 'h', "help"},
|
|
+#ifdef MACOS
|
|
+ {UZO, "i", "", o_NO_VALUE, o_NEGATABLE,
|
|
+ 'i', "ignore filenames stored in Mac ef"},
|
|
+#endif
|
|
+ {UZO, "j", "", o_NO_VALUE, o_NEGATABLE,
|
|
+ 'j', "junk directories, extract names only"},
|
|
+#if (defined(ATH_BEO) || defined(MACOS))
|
|
+ {UZO, "J", "", o_NO_VALUE, o_NEGATABLE,
|
|
+ 'J', "Junk AtheOS, BeOS or MacOS file attrs"},
|
|
+#endif
|
|
+#ifdef ATH_BEO_UNX
|
|
+ {UZO, "K", "", o_NO_VALUE, o_NEGATABLE,
|
|
+ 'K', "retain SUID/SGID/Tacky attrs"},
|
|
+#endif
|
|
+#ifndef SFX
|
|
+ {UZO, "l", "", o_NO_VALUE, o_NEGATABLE,
|
|
+ 'l', "listing verbosity"},
|
|
+#endif
|
|
+#ifndef CMS_MVS
|
|
+ {UZO, "L", "", o_NO_VALUE, o_NEGATABLE,
|
|
+ 'L', "convert (some) names to lower"},
|
|
+#endif
|
|
+#ifdef MORE
|
|
+# ifdef CMS_MVS
|
|
+ {UZO, "m", "", o_NO_VALUE, o_NEGATABLE,
|
|
+ 'm', "pipe output through more"},
|
|
+# endif
|
|
+ {UZO, "M", "", o_NO_VALUE, o_NEGATABLE,
|
|
+ 'M', "pipe output through more"},
|
|
+#endif /* MORE */
|
|
+ {UZO, "n", "", o_NO_VALUE, o_NEGATABLE,
|
|
+ 'n', "never overwrite files (no prompting)"},
|
|
+#ifdef AMIGA
|
|
+ {UZO, "N", "", o_NO_VALUE, o_NEGATABLE,
|
|
+ 'N', "restore comments as filenotes"},
|
|
+#endif
|
|
+ {UZO, "o", "", o_NO_VALUE, o_NEGATABLE,
|
|
+ 'o', "overwrite files without prompting"},
|
|
+ {UZO, "p", "", o_NO_VALUE, o_NEGATABLE,
|
|
+ 'p', "pipe extraction to stdout, no messages"},
|
|
+#if CRYPT
|
|
+ {UZO, "P", "", o_REQUIRED_VALUE, o_NEGATABLE,
|
|
+ 'P', "password"},
|
|
+#endif
|
|
+ {UZO, "q", "", o_NO_VALUE, o_NEGATABLE,
|
|
+ 'q', "quiet"},
|
|
+#ifdef QDOS
|
|
+ {UZO, "Q", "", o_NO_VALUE, o_NEGATABLE,
|
|
+ 'Q', "QDOS flags"},
|
|
+#endif
|
|
+#ifdef TANDEM
|
|
+ {UZO, "r", "", o_NO_VALUE, o_NEGATABLE,
|
|
+ 'r', "remove file extensions"},
|
|
+#endif
|
|
+#ifdef DOS_FLX_NLM_OS2_W32
|
|
+ {UZO, "s", "", o_NO_VALUE, o_NEGATABLE,
|
|
+ 's', "spaces to underscores"},
|
|
+#endif
|
|
+#ifdef VMS
|
|
+ {UZO, "S", "", o_NO_VALUE, o_NEGATABLE,
|
|
+ 'S', "VMS extract text as Stream LF"},
|
|
+#endif
|
|
+ {UZO, "t", "", o_NO_VALUE, o_NEGATABLE,
|
|
+ 't', "test"},
|
|
+#ifdef TIMESTAMP
|
|
+ {UZO, "T", "", o_NO_VALUE, o_NEGATABLE,
|
|
+ 'T', "timestamps"},
|
|
+#endif
|
|
+ {UZO, "u", "", o_NO_VALUE, o_NEGATABLE,
|
|
+ 'u', "update (extract only new/newer files)"},
|
|
+#ifdef UNICODE_SUPPORT
|
|
+ {UZO, "U", "", o_NO_VALUE, o_NEGATABLE,
|
|
+ 'U', "escape non-ASCII Unicode, disable Unicode"},
|
|
+#else /* !UNICODE_SUPPORT */
|
|
+# ifndef CMS_MVS
|
|
+ {UZO, "U", "", o_NO_VALUE, o_NEGATABLE,
|
|
+ 'U', "names to lower case"},
|
|
+# endif /* !CMS_MVS */
|
|
+#endif /* ?UNICODE_SUPPORT */
|
|
+#ifndef SFX
|
|
+ {UZO, "v", "", o_NO_VALUE, o_NEGATABLE,
|
|
+ 'v', "verbose"},
|
|
+#endif
|
|
+#ifndef CMS_MVS
|
|
+ {UZO, "V", "", o_NO_VALUE, o_NEGATABLE,
|
|
+ 'V', "don't strip VMS version numbers"},
|
|
+#endif
|
|
+#ifdef WILD_STOP_AT_DIR
|
|
+ {UZO, "W", "", o_NO_VALUE, o_NEGATABLE,
|
|
+ 'W', "wildcard * doesn't span /"},
|
|
+#endif
|
|
+ {UZO, "x", "", o_VALUE_LIST, o_NOT_NEGATABLE,
|
|
+ 'x', "exclude this list of files"},
|
|
+#if (defined(RESTORE_UIDGID) || defined(RESTORE_ACL))
|
|
+ {UZO, "X", "", o_NO_VALUE, o_NEGATABLE,
|
|
+ 'X', "restore owner/prot or UID/GID or ACLs"},
|
|
+#endif
|
|
+#ifdef VMS
|
|
+ {UZO, "Y", "", o_NO_VALUE, o_NEGATABLE,
|
|
+ 'Y', "VMS treat .nnn as ;nnn version"},
|
|
+#endif
|
|
+ {UZO, "z", "", o_NO_VALUE, o_NEGATABLE,
|
|
+ 'z', "display zipfile comment"},
|
|
+#ifndef SFX
|
|
+ {UZO, "Z", "", o_NO_VALUE, o_NOT_NEGATABLE,
|
|
+ 'Z', "ZipInfo mode"},
|
|
+#endif
|
|
+#ifdef VMS
|
|
+ {UZO, "2", "", o_NO_VALUE, o_NEGATABLE,
|
|
+ '2', "Force ODS2-compliant names."},
|
|
+#endif
|
|
+#ifdef DOS_H68_OS2_W32
|
|
+ {UZO, "$", "", o_NO_VALUE, o_NEGATABLE,
|
|
+ '$', "extract volume labels"},
|
|
+#endif
|
|
+#if (!defined(RISCOS) && !defined(CMS_MVS) && !defined(TANDEM))
|
|
+ {UZO, ":", "", o_NO_VALUE, o_NEGATABLE,
|
|
+ ':', "don't skip ../ path elements"},
|
|
+#endif
|
|
+#ifdef UNIX
|
|
+ {UZO, "^", "", o_NO_VALUE, o_NEGATABLE,
|
|
+ '^', "allow control chars in filenames"},
|
|
+#endif
|
|
+
|
|
+#ifndef NO_ZIPINFO
|
|
+ /* ZipInfo options */
|
|
+
|
|
+ /* short longopt value_type negatable
|
|
+ ID name (help text) */
|
|
+ {ZIO, "1", "", o_NO_VALUE, o_NEGATABLE,
|
|
+ '1', "shortest list"},
|
|
+ {ZIO, "2", "", o_NO_VALUE, o_NEGATABLE,
|
|
+ '2', "names and headers"},
|
|
+#ifndef CMS_MVS
|
|
+ {ZIO, "C", "", o_NO_VALUE, o_NEGATABLE,
|
|
+ 'C', "ignore case"},
|
|
+#endif
|
|
+ {ZIO, "h", "", o_NO_VALUE, o_NEGATABLE,
|
|
+ 'h', "header line"},
|
|
+ {ZIO, "l", "", o_NO_VALUE, o_NEGATABLE,
|
|
+ 'l', "longer listing"},
|
|
+ {ZIO, "m", "", o_NO_VALUE, o_NEGATABLE,
|
|
+ 'm', "medium listing"},
|
|
+#ifdef MORE
|
|
+ {ZIO, "M", "", o_NO_VALUE, o_NEGATABLE,
|
|
+ 'M', "output like more"},
|
|
+#endif
|
|
+ {ZIO, "s", "", o_NO_VALUE, o_NEGATABLE,
|
|
+ 's', "shorter list"},
|
|
+ {ZIO, "t", "", o_NO_VALUE, o_NEGATABLE,
|
|
+ 't', "totals line"},
|
|
+ {ZIO, "T", "", o_NO_VALUE, o_NEGATABLE,
|
|
+ 'T', "decimal time format"},
|
|
+#ifdef UNICODE_SUPPORT
|
|
+ {ZIO, "U", "", o_NO_VALUE, o_NEGATABLE,
|
|
+ 'U', "escape non-ASCII Unicode, disable Unicode"},
|
|
+#endif
|
|
+ {ZIO, "v", "", o_NO_VALUE, o_NEGATABLE,
|
|
+ 'v', "turbo-verbose listing"},
|
|
+#ifdef WILD_STOP_AT_DIR
|
|
+ {ZIO, "W", "", o_NO_VALUE, o_NEGATABLE,
|
|
+ 'W', "wild stop at /"},
|
|
+#endif
|
|
+ {ZIO, "x", "", o_VALUE_LIST, o_NOT_NEGATABLE,
|
|
+ 'x', "exclude this list of files"},
|
|
+ {ZIO, "z", "", o_NO_VALUE, o_NEGATABLE,
|
|
+ 'z', "print zipfile comment"},
|
|
+ {ZIO, "Z", "", o_NO_VALUE, o_NEGATABLE,
|
|
+ 'Z', "ZipInfo mode"},
|
|
+#endif /* !NO_ZIPINFO */
|
|
+
|
|
+ /* the end of the list */
|
|
+ {0, NULL, NULL, o_NO_VALUE, o_NOT_NEGATABLE,
|
|
+ 0, NULL} /* end has option_ID = 0 */
|
|
+ };
|
|
+
|
|
|
|
|
|
@@ -1271,502 +1590,649 @@
|
|
char ***pargv;
|
|
{
|
|
- char **argv, *s;
|
|
- int argc, c, error=FALSE, negative=0;
|
|
+ char **args;
|
|
+ int argc, error=FALSE;
|
|
|
|
+ /* used by get_option */
|
|
+ unsigned long option; /* option ID returned by get_option */
|
|
+ int argcnt = 0; /* current argcnt in args */
|
|
+ int argnum = 0; /* arg number */
|
|
+ int optchar = 0; /* option state */
|
|
+ char *value = NULL; /* non-option arg, option value or NULL */
|
|
+ int negative = 0; /* 1 = option negated */
|
|
+ int fna = 0; /* current first non-opt arg */
|
|
+ int optnum = 0; /* index in table */
|
|
|
|
- argc = *pargc;
|
|
- argv = *pargv;
|
|
|
|
- while (++argv, (--argc > 0 && *argv != NULL && **argv == '-')) {
|
|
- s = *argv + 1;
|
|
- while ((c = *s++) != 0) { /* "!= 0": prevent Turbo C warning */
|
|
-#ifdef CMS_MVS
|
|
- switch (tolower(c))
|
|
-#else
|
|
- switch (c)
|
|
-#endif
|
|
- {
|
|
- case ('-'):
|
|
- ++negative;
|
|
- break;
|
|
+ /* since get_option() returns xfiles and files one at a time, store them
|
|
+ in linked lists until have them all */
|
|
+
|
|
+ int file_count = 0;
|
|
+ struct file_list *next_file;
|
|
+
|
|
+ /* files to extract */
|
|
+ int in_files_count = 0;
|
|
+ struct file_list *in_files = NULL;
|
|
+ struct file_list *next_in_files = NULL;
|
|
+
|
|
+ /* files to exclude in -x list */
|
|
+ int in_xfiles_count = 0;
|
|
+ struct file_list *in_xfiles = NULL;
|
|
+ struct file_list *next_in_xfiles = NULL;
|
|
+
|
|
+ G.wildzipfn = NULL;
|
|
+
|
|
+ /* make copy of args that can use with insert_arg() used by get_option() */
|
|
+ args = copy_args(*pargv, 0);
|
|
+
|
|
+
|
|
+ /* Initialize lists */
|
|
+ G.filespecs = 0;
|
|
+ G.xfilespecs = 0;
|
|
+
|
|
+
|
|
+ /*
|
|
+ -------------------------------------------
|
|
+ Process command line using get_option
|
|
+ -------------------------------------------
|
|
+
|
|
+ Each call to get_option() returns either a command
|
|
+ line option and possible value or a non-option argument.
|
|
+ Arguments are permuted so that all options (-r, -b temp)
|
|
+ are returned before non-option arguments (zipfile).
|
|
+ Returns 0 when nothing left to read.
|
|
+ */
|
|
+
|
|
+ /* set argnum = 0 on first call to init get_option */
|
|
+ argnum = 0;
|
|
+
|
|
+ /* get_option returns the option ID and updates parameters:
|
|
+ args - usually same as argv if no argument file support
|
|
+ argcnt - current argc for args
|
|
+ value - char* to value (free() when done with it) or NULL if none
|
|
+ negated - option was negated with trailing -
|
|
+ */
|
|
+
|
|
+ while ((option = get_option(UZO, &args, &argcnt, &argnum,
|
|
+ &optchar, &value, &negative,
|
|
+ &fna, &optnum, 0)))
|
|
+ {
|
|
+ if(option == o_BAD_ERR) {
|
|
+ return(PK_PARAM);
|
|
+ }
|
|
+
|
|
+ switch (option)
|
|
+ {
|
|
#ifdef RISCOS
|
|
- case ('/'):
|
|
- if (negative) { /* negative not allowed with -/ swap */
|
|
- Info(slide, 0x401, ((char *)slide,
|
|
- "error: must give extensions list"));
|
|
- return(PK_PARAM); /* don't extract here by accident */
|
|
- }
|
|
- exts2swap = s; /* override Unzip$Exts */
|
|
- s += strlen(s);
|
|
- break;
|
|
-#endif
|
|
- case ('a'):
|
|
- if (negative) {
|
|
- uO.aflag = MAX(uO.aflag-negative,0);
|
|
- negative = 0;
|
|
- } else
|
|
- ++uO.aflag;
|
|
- break;
|
|
+ case ('/'):
|
|
+ if (negative) { /* negative not allowed with -/ swap */
|
|
+ Info(slide, 0x401, ((char *)slide,
|
|
+ "error: must give extensions list"));
|
|
+ return(PK_PARAM); /* don't extract here by accident */
|
|
+ }
|
|
+ exts2swap = value; /* override Unzip$Exts */
|
|
+ break;
|
|
+#endif
|
|
+ case ('a'):
|
|
+ if (negative) {
|
|
+ uO.aflag = MAX(uO.aflag-negative,0);
|
|
+ negative = 0;
|
|
+ } else
|
|
+ ++uO.aflag;
|
|
+ break;
|
|
#if (defined(DLL) && defined(API_DOC))
|
|
- case ('A'): /* extended help for API */
|
|
- APIhelp(__G__ argc, argv);
|
|
- *pargc = -1; /* signal to exit successfully */
|
|
- return 0;
|
|
+ case ('A'): /* extended help for API */
|
|
+ APIhelp(__G__ argc, args);
|
|
+ *pargc = -1; /* signal to exit successfully */
|
|
+ return 0;
|
|
#endif
|
|
- case ('b'):
|
|
- if (negative) {
|
|
+ case ('b'):
|
|
+ if (negative) {
|
|
#if (defined(TANDEM) || defined(VMS))
|
|
- uO.bflag = MAX(uO.bflag-negative,0);
|
|
+ uO.bflag = MAX(uO.bflag-negative,0);
|
|
#endif
|
|
- negative = 0; /* do nothing: "-b" is default */
|
|
- } else {
|
|
+ negative = 0; /* do nothing: "-b" is default */
|
|
+ } else {
|
|
#ifdef VMS
|
|
- if (uO.aflag == 0)
|
|
- ++uO.bflag;
|
|
+ if (uO.aflag == 0)
|
|
+ ++uO.bflag;
|
|
#endif
|
|
#ifdef TANDEM
|
|
- ++uO.bflag;
|
|
+ ++uO.bflag;
|
|
#endif
|
|
- uO.aflag = 0;
|
|
- }
|
|
- break;
|
|
+ uO.aflag = 0;
|
|
+ }
|
|
+ break;
|
|
#ifdef UNIXBACKUP
|
|
- case ('B'): /* -B: back up existing files */
|
|
- if (negative)
|
|
- uO.B_flag = FALSE, negative = 0;
|
|
- else
|
|
- uO.B_flag = TRUE;
|
|
- break;
|
|
-#endif
|
|
- case ('c'):
|
|
- if (negative) {
|
|
- uO.cflag = FALSE, negative = 0;
|
|
+ case ('B'): /* -B: back up existing files */
|
|
+ if (negative)
|
|
+ uO.B_flag = FALSE, negative = 0;
|
|
+ else
|
|
+ uO.B_flag = TRUE;
|
|
+ break;
|
|
+#endif
|
|
+ case ('c'):
|
|
+ if (negative) {
|
|
+ uO.cflag = FALSE, negative = 0;
|
|
#ifdef NATIVE
|
|
- uO.aflag = 0;
|
|
+ uO.aflag = 0;
|
|
#endif
|
|
- } else {
|
|
- uO.cflag = TRUE;
|
|
+ } else {
|
|
+ uO.cflag = TRUE;
|
|
#ifdef NATIVE
|
|
- uO.aflag = 2; /* so you can read it on the screen */
|
|
+ uO.aflag = 2; /* so you can read it on the screen */
|
|
#endif
|
|
#ifdef DLL
|
|
- if (G.redirect_text)
|
|
- G.redirect_data = 2;
|
|
+ if (G.redirect_text)
|
|
+ G.redirect_data = 2;
|
|
#endif
|
|
- }
|
|
- break;
|
|
+ }
|
|
+ break;
|
|
#ifndef CMS_MVS
|
|
- case ('C'): /* -C: match filenames case-insensitively */
|
|
- if (negative)
|
|
- uO.C_flag = FALSE, negative = 0;
|
|
- else
|
|
- uO.C_flag = TRUE;
|
|
- break;
|
|
+ case ('C'): /* -C: match filenames case-insensitively */
|
|
+ if (negative)
|
|
+ uO.C_flag = FALSE, negative = 0;
|
|
+ else
|
|
+ uO.C_flag = TRUE;
|
|
+ break;
|
|
#endif /* !CMS_MVS */
|
|
#if (!defined(SFX) || defined(SFX_EXDIR))
|
|
- case ('d'):
|
|
- if (negative) { /* negative not allowed with -d exdir */
|
|
+ case ('d'):
|
|
+ if (negative) { /* negative not allowed with -d exdir */
|
|
+ Info(slide, 0x401, ((char *)slide,
|
|
+ LoadFarString(MustGiveExdir)));
|
|
+ return(PK_PARAM); /* don't extract here by accident */
|
|
+ }
|
|
+ if (uO.exdir != (char *)NULL) {
|
|
+ Info(slide, 0x401, ((char *)slide,
|
|
+ LoadFarString(OnlyOneExdir)));
|
|
+ return(PK_PARAM); /* GRR: stupid restriction? */
|
|
+ } else {
|
|
+ /* first check for "-dexdir", then for "-d exdir" */
|
|
+ uO.exdir = value;
|
|
+ if (uO.exdir == NULL || *uO.exdir == '\0') {
|
|
Info(slide, 0x401, ((char *)slide,
|
|
LoadFarString(MustGiveExdir)));
|
|
- return(PK_PARAM); /* don't extract here by accident */
|
|
- }
|
|
- if (uO.exdir != (char *)NULL) {
|
|
- Info(slide, 0x401, ((char *)slide,
|
|
- LoadFarString(OnlyOneExdir)));
|
|
- return(PK_PARAM); /* GRR: stupid restriction? */
|
|
- } else {
|
|
- /* first check for "-dexdir", then for "-d exdir" */
|
|
- uO.exdir = s;
|
|
- if (*uO.exdir == '\0') {
|
|
- if (argc > 1) {
|
|
- --argc;
|
|
- uO.exdir = *++argv;
|
|
- if (*uO.exdir == '-') {
|
|
- Info(slide, 0x401, ((char *)slide,
|
|
- LoadFarString(MustGiveExdir)));
|
|
- return(PK_PARAM);
|
|
- }
|
|
- /* else uO.exdir points at extraction dir */
|
|
- } else {
|
|
- Info(slide, 0x401, ((char *)slide,
|
|
- LoadFarString(MustGiveExdir)));
|
|
- return(PK_PARAM);
|
|
- }
|
|
- }
|
|
- /* uO.exdir now points at extraction dir (-dexdir or
|
|
- * -d exdir); point s at end of exdir to avoid mis-
|
|
- * interpretation of exdir characters as more options
|
|
- */
|
|
- if (*s != 0)
|
|
- while (*++s != 0)
|
|
- ;
|
|
+ return(PK_PARAM);
|
|
}
|
|
- break;
|
|
+ /* else uO.exdir points at extraction dir */
|
|
+ }
|
|
+ break;
|
|
#endif /* !SFX || SFX_EXDIR */
|
|
#if (!defined(NO_TIMESTAMPS))
|
|
- case ('D'): /* -D: Skip restoring dir (or any) timestamp. */
|
|
- if (negative) {
|
|
- uO.D_flag = MAX(uO.D_flag-negative,0);
|
|
- negative = 0;
|
|
- } else
|
|
- uO.D_flag++;
|
|
- break;
|
|
+ case ('D'): /* -D: Skip restoring dir (or any) timestamp. */
|
|
+ if (negative) {
|
|
+ uO.D_flag = MAX(uO.D_flag-negative,0);
|
|
+ negative = 0;
|
|
+ } else
|
|
+ uO.D_flag++;
|
|
+ break;
|
|
#endif /* (!NO_TIMESTAMPS) */
|
|
- case ('e'): /* just ignore -e, -x options (extract) */
|
|
- break;
|
|
+ case ('e'): /* just ignore -e, -x options (extract) */
|
|
+ break;
|
|
#ifdef MACOS
|
|
- case ('E'): /* -E [MacOS] display Mac e.f. when restoring */
|
|
- if( negative ) {
|
|
- uO.E_flag = FALSE, negative = 0;
|
|
- } else {
|
|
- uO.E_flag = TRUE;
|
|
- }
|
|
- break;
|
|
+ case ('E'): /* -E [MacOS] display Mac e.f. when restoring */
|
|
+ if( negative ) {
|
|
+ uO.E_flag = FALSE, negative = 0;
|
|
+ } else {
|
|
+ uO.E_flag = TRUE;
|
|
+ }
|
|
+ break;
|
|
#endif /* MACOS */
|
|
- case ('f'): /* "freshen" (extract only newer files) */
|
|
- if (negative)
|
|
- uO.fflag = uO.uflag = FALSE, negative = 0;
|
|
- else
|
|
- uO.fflag = uO.uflag = TRUE;
|
|
- break;
|
|
+ case ('f'): /* "freshen" (extract only newer files) */
|
|
+ if (negative)
|
|
+ uO.fflag = uO.uflag = FALSE, negative = 0;
|
|
+ else
|
|
+ uO.fflag = uO.uflag = TRUE;
|
|
+ break;
|
|
#if (defined(RISCOS) || defined(ACORN_FTYPE_NFS))
|
|
- case ('F'): /* Acorn filetype & NFS extension handling */
|
|
- if (negative)
|
|
- uO.acorn_nfs_ext = FALSE, negative = 0;
|
|
- else
|
|
- uO.acorn_nfs_ext = TRUE;
|
|
- break;
|
|
+ case ('F'): /* Acorn filetype & NFS extension handling */
|
|
+ if (negative)
|
|
+ uO.acorn_nfs_ext = FALSE, negative = 0;
|
|
+ else
|
|
+ uO.acorn_nfs_ext = TRUE;
|
|
+ break;
|
|
#endif /* RISCOS || ACORN_FTYPE_NFS */
|
|
- case ('h'): /* just print help message and quit */
|
|
- *pargc = -1;
|
|
- return USAGE(PK_OK);
|
|
+ case ('h'): /* just print help message and quit */
|
|
+ *pargc = -1;
|
|
+ return USAGE(PK_OK);
|
|
#ifdef MACOS
|
|
- case ('i'): /* -i [MacOS] ignore filenames stored in Mac ef */
|
|
- if( negative ) {
|
|
- uO.i_flag = FALSE, negative = 0;
|
|
- } else {
|
|
- uO.i_flag = TRUE;
|
|
- }
|
|
- break;
|
|
+ case ('i'): /* -i [MacOS] ignore filenames stored in Mac ef */
|
|
+ if( negative ) {
|
|
+ uO.i_flag = FALSE, negative = 0;
|
|
+ } else {
|
|
+ uO.i_flag = TRUE;
|
|
+ }
|
|
+ break;
|
|
#endif /* MACOS */
|
|
- case ('j'): /* junk pathnames/directory structure */
|
|
- if (negative)
|
|
- uO.jflag = FALSE, negative = 0;
|
|
- else
|
|
- uO.jflag = TRUE;
|
|
- break;
|
|
+ case ('j'): /* junk pathnames/directory structure */
|
|
+ if (negative)
|
|
+ uO.jflag = FALSE, negative = 0;
|
|
+ else
|
|
+ uO.jflag = TRUE;
|
|
+ break;
|
|
#if (defined(ATH_BEO) || defined(MACOS))
|
|
- case ('J'): /* Junk AtheOS, BeOS or MacOS file attributes */
|
|
- if( negative ) {
|
|
- uO.J_flag = FALSE, negative = 0;
|
|
- } else {
|
|
- uO.J_flag = TRUE;
|
|
- }
|
|
- break;
|
|
+ case ('J'): /* Junk AtheOS, BeOS or MacOS file attributes */
|
|
+ if( negative ) {
|
|
+ uO.J_flag = FALSE, negative = 0;
|
|
+ } else {
|
|
+ uO.J_flag = TRUE;
|
|
+ }
|
|
+ break;
|
|
#endif /* ATH_BEO || MACOS */
|
|
#ifdef ATH_BEO_UNX
|
|
- case ('K'):
|
|
- if (negative) {
|
|
- uO.K_flag = FALSE, negative = 0;
|
|
- } else {
|
|
- uO.K_flag = TRUE;
|
|
- }
|
|
- break;
|
|
+ case ('K'):
|
|
+ if (negative) {
|
|
+ uO.K_flag = FALSE, negative = 0;
|
|
+ } else {
|
|
+ uO.K_flag = TRUE;
|
|
+ }
|
|
+ break;
|
|
#endif /* ATH_BEO_UNX */
|
|
#ifndef SFX
|
|
- case ('l'):
|
|
- if (negative) {
|
|
- uO.vflag = MAX(uO.vflag-negative,0);
|
|
- negative = 0;
|
|
- } else
|
|
- ++uO.vflag;
|
|
- break;
|
|
+ case ('l'):
|
|
+ if (negative) {
|
|
+ uO.vflag = MAX(uO.vflag-negative,0);
|
|
+ negative = 0;
|
|
+ } else
|
|
+ ++uO.vflag;
|
|
+ break;
|
|
#endif /* !SFX */
|
|
#ifndef CMS_MVS
|
|
- case ('L'): /* convert (some) filenames to lowercase */
|
|
- if (negative) {
|
|
- uO.L_flag = MAX(uO.L_flag-negative,0);
|
|
- negative = 0;
|
|
- } else
|
|
- ++uO.L_flag;
|
|
- break;
|
|
+ case ('L'): /* convert (some) filenames to lowercase */
|
|
+ if (negative) {
|
|
+ uO.L_flag = MAX(uO.L_flag-negative,0);
|
|
+ negative = 0;
|
|
+ } else
|
|
+ ++uO.L_flag;
|
|
+ break;
|
|
#endif /* !CMS_MVS */
|
|
#ifdef MORE
|
|
#ifdef CMS_MVS
|
|
- case ('m'):
|
|
+ case ('m'):
|
|
#endif
|
|
- case ('M'): /* send all screen output through "more" fn. */
|
|
+ case ('M'): /* send all screen output through "more" fn. */
|
|
/* GRR: eventually check for numerical argument => height */
|
|
- if (negative)
|
|
- G.M_flag = FALSE, negative = 0;
|
|
- else
|
|
- G.M_flag = TRUE;
|
|
- break;
|
|
+ if (negative)
|
|
+ G.M_flag = FALSE, negative = 0;
|
|
+ else
|
|
+ G.M_flag = TRUE;
|
|
+ break;
|
|
#endif /* MORE */
|
|
- case ('n'): /* don't overwrite any files */
|
|
- if (negative)
|
|
- uO.overwrite_none = FALSE, negative = 0;
|
|
- else
|
|
- uO.overwrite_none = TRUE;
|
|
- break;
|
|
+ case ('n'): /* don't overwrite any files */
|
|
+ if (negative)
|
|
+ uO.overwrite_none = FALSE, negative = 0;
|
|
+ else
|
|
+ uO.overwrite_none = TRUE;
|
|
+ break;
|
|
#ifdef AMIGA
|
|
- case ('N'): /* restore comments as filenotes */
|
|
- if (negative)
|
|
- uO.N_flag = FALSE, negative = 0;
|
|
- else
|
|
- uO.N_flag = TRUE;
|
|
- break;
|
|
+ case ('N'): /* restore comments as filenotes */
|
|
+ if (negative)
|
|
+ uO.N_flag = FALSE, negative = 0;
|
|
+ else
|
|
+ uO.N_flag = TRUE;
|
|
+ break;
|
|
#endif /* AMIGA */
|
|
- case ('o'): /* OK to overwrite files without prompting */
|
|
- if (negative) {
|
|
- uO.overwrite_all = MAX(uO.overwrite_all-negative,0);
|
|
- negative = 0;
|
|
- } else
|
|
- ++uO.overwrite_all;
|
|
- break;
|
|
- case ('p'): /* pipes: extract to stdout, no messages */
|
|
- if (negative) {
|
|
- uO.cflag = FALSE;
|
|
- uO.qflag = MAX(uO.qflag-999,0);
|
|
- negative = 0;
|
|
- } else {
|
|
- uO.cflag = TRUE;
|
|
- uO.qflag += 999;
|
|
- }
|
|
- break;
|
|
+ case ('o'): /* OK to overwrite files without prompting */
|
|
+ if (negative) {
|
|
+ uO.overwrite_all = MAX(uO.overwrite_all-negative,0);
|
|
+ negative = 0;
|
|
+ } else
|
|
+ ++uO.overwrite_all;
|
|
+ break;
|
|
+ case ('p'): /* pipes: extract to stdout, no messages */
|
|
+ if (negative) {
|
|
+ uO.cflag = FALSE;
|
|
+ uO.qflag = MAX(uO.qflag-999,0);
|
|
+ negative = 0;
|
|
+ } else {
|
|
+ uO.cflag = TRUE;
|
|
+ uO.qflag += 999;
|
|
+ }
|
|
+ break;
|
|
#if CRYPT
|
|
- /* GRR: yes, this is highly insecure, but dozens of people
|
|
- * have pestered us for this, so here we go... */
|
|
- case ('P'):
|
|
- if (negative) { /* negative not allowed with -P passwd */
|
|
- Info(slide, 0x401, ((char *)slide,
|
|
- LoadFarString(MustGivePasswd)));
|
|
- return(PK_PARAM); /* don't extract here by accident */
|
|
- }
|
|
- if (uO.pwdarg != (char *)NULL) {
|
|
+ /* GRR: yes, this is highly insecure, but dozens of people
|
|
+ * have pestered us for this, so here we go... */
|
|
+ case ('P'):
|
|
+ if (negative) { /* negative not allowed with -P passwd */
|
|
+ Info(slide, 0x401, ((char *)slide,
|
|
+ LoadFarString(MustGivePasswd)));
|
|
+ return(PK_PARAM); /* don't extract here by accident */
|
|
+ }
|
|
+ if (uO.pwdarg != (char *)NULL) {
|
|
/*
|
|
- GRR: eventually support multiple passwords?
|
|
+ GRR: eventually support multiple passwords?
|
|
+ Info(slide, 0x401, ((char *)slide,
|
|
+ LoadFarString(OnlyOnePasswd)));
|
|
+ return(PK_PARAM);
|
|
+*/
|
|
+ } else {
|
|
+ /* first check for "-Ppasswd", then for "-P passwd" */
|
|
+ uO.pwdarg = value;
|
|
+ if (uO.pwdarg == NULL || *uO.pwdarg == '\0') {
|
|
Info(slide, 0x401, ((char *)slide,
|
|
- LoadFarString(OnlyOnePasswd)));
|
|
+ LoadFarString(MustGivePasswd)));
|
|
return(PK_PARAM);
|
|
- */
|
|
- } else {
|
|
- /* first check for "-Ppasswd", then for "-P passwd" */
|
|
- uO.pwdarg = s;
|
|
- if (*uO.pwdarg == '\0') {
|
|
- if (argc > 1) {
|
|
- --argc;
|
|
- uO.pwdarg = *++argv;
|
|
- if (*uO.pwdarg == '-') {
|
|
- Info(slide, 0x401, ((char *)slide,
|
|
- LoadFarString(MustGivePasswd)));
|
|
- return(PK_PARAM);
|
|
- }
|
|
- /* else pwdarg points at decryption password */
|
|
- } else {
|
|
- Info(slide, 0x401, ((char *)slide,
|
|
- LoadFarString(MustGivePasswd)));
|
|
- return(PK_PARAM);
|
|
- }
|
|
- }
|
|
- /* pwdarg now points at decryption password (-Ppasswd or
|
|
- * -P passwd); point s at end of passwd to avoid mis-
|
|
- * interpretation of passwd characters as more options
|
|
- */
|
|
- if (*s != 0)
|
|
- while (*++s != 0)
|
|
- ;
|
|
+ /* else pwdarg points at decryption password */
|
|
}
|
|
- break;
|
|
+ }
|
|
+ break;
|
|
#endif /* CRYPT */
|
|
- case ('q'): /* quiet: fewer comments/messages */
|
|
- if (negative) {
|
|
- uO.qflag = MAX(uO.qflag-negative,0);
|
|
- negative = 0;
|
|
- } else
|
|
- ++uO.qflag;
|
|
- break;
|
|
+ case ('q'): /* quiet: fewer comments/messages */
|
|
+ if (negative) {
|
|
+ uO.qflag = MAX(uO.qflag-negative,0);
|
|
+ negative = 0;
|
|
+ } else
|
|
+ ++uO.qflag;
|
|
+ break;
|
|
#ifdef QDOS
|
|
- case ('Q'): /* QDOS flags */
|
|
- qlflag ^= strtol(s, &s, 10);
|
|
- break; /* we XOR this as we can config qlflags */
|
|
+ case ('Q'): /* QDOS flags */
|
|
+ qlflag ^= strtol(value, &value, 10);
|
|
+ break; /* we XOR this as we can config qlflags */
|
|
#endif
|
|
#ifdef TANDEM
|
|
- case ('r'): /* remove file extensions */
|
|
- if (negative)
|
|
- uO.rflag = FALSE, negative = 0;
|
|
- else
|
|
- uO.rflag = TRUE;
|
|
- break;
|
|
+ case ('r'): /* remove file extensions */
|
|
+ if (negative)
|
|
+ uO.rflag = FALSE, negative = 0;
|
|
+ else
|
|
+ uO.rflag = TRUE;
|
|
+ break;
|
|
#endif /* TANDEM */
|
|
#ifdef DOS_FLX_NLM_OS2_W32
|
|
- case ('s'): /* spaces in filenames: allow by default */
|
|
- if (negative)
|
|
- uO.sflag = FALSE, negative = 0;
|
|
- else
|
|
- uO.sflag = TRUE;
|
|
- break;
|
|
+ case ('s'): /* spaces in filenames: allow by default */
|
|
+ if (negative)
|
|
+ uO.sflag = FALSE, negative = 0;
|
|
+ else
|
|
+ uO.sflag = TRUE;
|
|
+ break;
|
|
#endif /* DOS_FLX_NLM_OS2_W32 */
|
|
#ifdef VMS
|
|
- /* VMS: extract "text" files in Stream_LF format (-a[a]) */
|
|
- case ('S'):
|
|
- if (negative)
|
|
- uO.S_flag = FALSE, negative = 0;
|
|
- else
|
|
- uO.S_flag = TRUE;
|
|
- break;
|
|
+ /* VMS: extract "text" files in Stream_LF format (-a[a]) */
|
|
+ case ('S'):
|
|
+ if (negative)
|
|
+ uO.S_flag = FALSE, negative = 0;
|
|
+ else
|
|
+ uO.S_flag = TRUE;
|
|
+ break;
|
|
#endif /* VMS */
|
|
- case ('t'):
|
|
- if (negative)
|
|
- uO.tflag = FALSE, negative = 0;
|
|
- else
|
|
- uO.tflag = TRUE;
|
|
- break;
|
|
+ case ('t'):
|
|
+ if (negative)
|
|
+ uO.tflag = FALSE, negative = 0;
|
|
+ else
|
|
+ uO.tflag = TRUE;
|
|
+ break;
|
|
#ifdef TIMESTAMP
|
|
- case ('T'):
|
|
- if (negative)
|
|
- uO.T_flag = FALSE, negative = 0;
|
|
- else
|
|
- uO.T_flag = TRUE;
|
|
- break;
|
|
-#endif
|
|
- case ('u'): /* update (extract only new and newer files) */
|
|
- if (negative)
|
|
- uO.uflag = FALSE, negative = 0;
|
|
- else
|
|
- uO.uflag = TRUE;
|
|
- break;
|
|
+ case ('T'):
|
|
+ if (negative)
|
|
+ uO.T_flag = FALSE, negative = 0;
|
|
+ else
|
|
+ uO.T_flag = TRUE;
|
|
+ break;
|
|
+#endif
|
|
+ case ('u'): /* update (extract only new and newer files) */
|
|
+ if (negative)
|
|
+ uO.uflag = FALSE, negative = 0;
|
|
+ else
|
|
+ uO.uflag = TRUE;
|
|
+ break;
|
|
#ifdef UNICODE_SUPPORT
|
|
- case ('U'): /* escape UTF-8, or disable UTF-8 support */
|
|
- if (negative) {
|
|
- uO.U_flag = MAX(uO.U_flag-negative,0);
|
|
- negative = 0;
|
|
- } else
|
|
- uO.U_flag++;
|
|
- break;
|
|
+ case ('U'): /* escape UTF-8, or disable UTF-8 support */
|
|
+ if (negative)
|
|
+ uO.U_flag = MAX(uO.U_flag - 1, 0);
|
|
+ else
|
|
+ uO.U_flag++;
|
|
+ break;
|
|
#else /* !UNICODE_SUPPORT */
|
|
#ifndef CMS_MVS
|
|
- case ('U'): /* obsolete; to be removed in version 6.0 */
|
|
- if (negative)
|
|
- uO.L_flag = TRUE, negative = 0;
|
|
- else
|
|
- uO.L_flag = FALSE;
|
|
- break;
|
|
+ case ('U'): /* obsolete; to be removed in version 6.0 */
|
|
+ if (negative)
|
|
+ uO.L_flag = TRUE, negative = 0;
|
|
+ else
|
|
+ uO.L_flag = FALSE;
|
|
+ break;
|
|
#endif /* !CMS_MVS */
|
|
#endif /* ?UNICODE_SUPPORT */
|
|
#ifndef SFX
|
|
- case ('v'): /* verbose */
|
|
- if (negative) {
|
|
- uO.vflag = MAX(uO.vflag-negative,0);
|
|
- negative = 0;
|
|
- } else if (uO.vflag)
|
|
- ++uO.vflag;
|
|
- else
|
|
- uO.vflag = 2;
|
|
- break;
|
|
+ case ('v'): /* verbose */
|
|
+ if (negative) {
|
|
+ uO.vflag = MAX(uO.vflag-negative,0);
|
|
+ negative = 0;
|
|
+ } else if (uO.vflag)
|
|
+ ++uO.vflag;
|
|
+ else
|
|
+ uO.vflag = 2;
|
|
+ break;
|
|
#endif /* !SFX */
|
|
#ifndef CMS_MVS
|
|
- case ('V'): /* Version (retain VMS/DEC-20 file versions) */
|
|
- if (negative)
|
|
- uO.V_flag = FALSE, negative = 0;
|
|
- else
|
|
- uO.V_flag = TRUE;
|
|
- break;
|
|
+ case ('V'): /* Version (retain VMS/DEC-20 file versions) */
|
|
+ if (negative)
|
|
+ uO.V_flag = FALSE, negative = 0;
|
|
+ else
|
|
+ uO.V_flag = TRUE;
|
|
+ break;
|
|
#endif /* !CMS_MVS */
|
|
#ifdef WILD_STOP_AT_DIR
|
|
- case ('W'): /* Wildcard interpretation (stop at '/'?) */
|
|
- if (negative)
|
|
- uO.W_flag = FALSE, negative = 0;
|
|
- else
|
|
- uO.W_flag = TRUE;
|
|
- break;
|
|
+ case ('W'): /* Wildcard interpretation (stop at '/'?) */
|
|
+ if (negative)
|
|
+ uO.W_flag = FALSE, negative = 0;
|
|
+ else
|
|
+ uO.W_flag = TRUE;
|
|
+ break;
|
|
#endif /* WILD_STOP_AT_DIR */
|
|
- case ('x'): /* extract: default */
|
|
-#ifdef SFX
|
|
- /* when 'x' is the only option in this argument, and the
|
|
- * next arg is not an option, assume this initiates an
|
|
- * exclusion list (-x xlist): terminate option-scanning
|
|
- * and leave uz_opts with argv still pointing to "-x";
|
|
- * the xlist is processed later
|
|
- */
|
|
- if (s - argv[0] == 2 && *s == '\0' &&
|
|
- argc > 1 && argv[1][0] != '-') {
|
|
- /* break out of nested loops without "++argv;--argc" */
|
|
- goto opts_done;
|
|
+ case ('x'): /* extract: default */
|
|
+ /* add -x file to linked list */
|
|
+
|
|
+ if (in_xfiles_count == 0) {
|
|
+ /* first entry */
|
|
+ if ((in_xfiles = (struct file_list *)
|
|
+ malloc(sizeof(struct file_list))
|
|
+ ) == NULL) {
|
|
+ Info(slide, 0x401, ((char *)slide,
|
|
+ LoadFarString(NoMemArgsList)));
|
|
+ return PK_MEM;
|
|
+ }
|
|
+ in_xfiles->name = value;
|
|
+ in_xfiles->next = NULL;
|
|
+ next_in_xfiles = in_xfiles;
|
|
+ } else {
|
|
+ /* add next entry */
|
|
+ if ((next_file = (struct file_list *)
|
|
+ malloc(sizeof(struct file_list))
|
|
+ ) == NULL) {
|
|
+ Info(slide, 0x401, ((char *)slide,
|
|
+ LoadFarString(NoMemArgsList)));
|
|
+ return PK_MEM;
|
|
}
|
|
+ next_in_xfiles->next = next_file;
|
|
+ next_file->name = value;
|
|
+ next_file->next = NULL;
|
|
+ next_in_xfiles = next_file;
|
|
+ }
|
|
+ in_xfiles_count++;
|
|
+
|
|
+#if 0
|
|
+#ifdef SFX
|
|
+ /* now get -x list one entry at a time */
|
|
+
|
|
+
|
|
+
|
|
+ /* when 'x' is the only option in this argument, and the
|
|
+ * next arg is not an option, assume this initiates an
|
|
+ * exclusion list (-x xlist): terminate option-scanning
|
|
+ * and leave uz_opts with argv still pointing to "-x";
|
|
+ * the xlist is processed later
|
|
+ */
|
|
+ if (s - argv[0] == 2 && *s == '\0' &&
|
|
+ argc > 1 && argv[1][0] != '-') {
|
|
+ /* break out of nested loops without "++argv;--argc" */
|
|
+ goto opts_done;
|
|
+ }
|
|
#endif /* SFX */
|
|
- break;
|
|
+#endif
|
|
+ break;
|
|
#if (defined(RESTORE_UIDGID) || defined(RESTORE_ACL))
|
|
- case ('X'): /* restore owner/protection info (need privs?) */
|
|
- if (negative) {
|
|
- uO.X_flag = MAX(uO.X_flag-negative,0);
|
|
- negative = 0;
|
|
- } else
|
|
- ++uO.X_flag;
|
|
- break;
|
|
+ case ('X'): /* restore owner/protection info (need privs?) */
|
|
+ if (negative) {
|
|
+ uO.X_flag = MAX(uO.X_flag-negative,0);
|
|
+ negative = 0;
|
|
+ } else
|
|
+ ++uO.X_flag;
|
|
+ break;
|
|
#endif /* RESTORE_UIDGID || RESTORE_ACL */
|
|
#ifdef VMS
|
|
- case ('Y'): /* Treat ".nnn" as ";nnn" version. */
|
|
- if (negative)
|
|
- uO.Y_flag = FALSE, negative = 0;
|
|
- else
|
|
- uO.Y_flag = TRUE;
|
|
- break;
|
|
+ case ('Y'): /* Treat ".nnn" as ";nnn" version. */
|
|
+ if (negative)
|
|
+ uO.Y_flag = FALSE, negative = 0;
|
|
+ else
|
|
+ uO.Y_flag = TRUE;
|
|
+ break;
|
|
#endif /* VMS */
|
|
- case ('z'): /* display only the archive comment */
|
|
- if (negative) {
|
|
- uO.zflag = MAX(uO.zflag-negative,0);
|
|
- negative = 0;
|
|
- } else
|
|
- ++uO.zflag;
|
|
- break;
|
|
+ case ('z'): /* display only the archive comment */
|
|
+ if (negative) {
|
|
+ uO.zflag = MAX(uO.zflag-negative,0);
|
|
+ negative = 0;
|
|
+ } else
|
|
+ ++uO.zflag;
|
|
+ break;
|
|
#ifndef SFX
|
|
- case ('Z'): /* should have been first option (ZipInfo) */
|
|
- Info(slide, 0x401, ((char *)slide, LoadFarString(Zfirst)));
|
|
- error = TRUE;
|
|
- break;
|
|
+ case ('Z'): /* should have been first option (ZipInfo) */
|
|
+ Info(slide, 0x401, ((char *)slide, LoadFarString(Zfirst)));
|
|
+ error = TRUE;
|
|
+ break;
|
|
#endif /* !SFX */
|
|
#ifdef VMS
|
|
- case ('2'): /* Force ODS2-compliant names. */
|
|
- if (negative)
|
|
- uO.ods2_flag = FALSE, negative = 0;
|
|
- else
|
|
- uO.ods2_flag = TRUE;
|
|
- break;
|
|
+ case ('2'): /* Force ODS2-compliant names. */
|
|
+ if (negative)
|
|
+ uO.ods2_flag = FALSE, negative = 0;
|
|
+ else
|
|
+ uO.ods2_flag = TRUE;
|
|
+ break;
|
|
#endif /* VMS */
|
|
#ifdef DOS_H68_OS2_W32
|
|
- case ('$'):
|
|
- if (negative) {
|
|
- uO.volflag = MAX(uO.volflag-negative,0);
|
|
- negative = 0;
|
|
- } else
|
|
- ++uO.volflag;
|
|
- break;
|
|
+ case ('$'):
|
|
+ if (negative) {
|
|
+ uO.volflag = MAX(uO.volflag-negative,0);
|
|
+ negative = 0;
|
|
+ } else
|
|
+ ++uO.volflag;
|
|
+ break;
|
|
#endif /* DOS_H68_OS2_W32 */
|
|
#if (!defined(RISCOS) && !defined(CMS_MVS) && !defined(TANDEM))
|
|
- case (':'): /* allow "parent dir" path components */
|
|
- if (negative) {
|
|
- uO.ddotflag = MAX(uO.ddotflag-negative,0);
|
|
- negative = 0;
|
|
- } else
|
|
- ++uO.ddotflag;
|
|
- break;
|
|
+ case (':'): /* allow "parent dir" path components */
|
|
+ if (negative) {
|
|
+ uO.ddotflag = MAX(uO.ddotflag-negative,0);
|
|
+ negative = 0;
|
|
+ } else
|
|
+ ++uO.ddotflag;
|
|
+ break;
|
|
#endif /* !RISCOS && !CMS_MVS && !TANDEM */
|
|
#ifdef UNIX
|
|
- case ('^'): /* allow control chars in filenames */
|
|
- if (negative) {
|
|
- uO.cflxflag = MAX(uO.cflxflag-negative,0);
|
|
- negative = 0;
|
|
- } else
|
|
- ++uO.cflxflag;
|
|
- break;
|
|
+ case ('^'): /* allow control chars in filenames */
|
|
+ if (negative) {
|
|
+ uO.cflxflag = MAX(uO.cflxflag-negative,0);
|
|
+ negative = 0;
|
|
+ } else
|
|
+ ++uO.cflxflag;
|
|
+ break;
|
|
#endif /* UNIX */
|
|
- default:
|
|
- error = TRUE;
|
|
- break;
|
|
-
|
|
- } /* end switch */
|
|
- } /* end while (not end of argument string) */
|
|
- } /* end while (not done with switches) */
|
|
+ case o_NON_OPTION_ARG:
|
|
+ /* not an option */
|
|
+ /* no more options as permuting */
|
|
+
|
|
+
|
|
+ if (G.wildzipfn == NULL) {
|
|
+ /* first non-option argument is zip file */
|
|
+ G.wildzipfn = value;
|
|
+
|
|
+ } else {
|
|
+ /* add include file to list */
|
|
+ if (in_files_count == 0) {
|
|
+ /* first entry */
|
|
+ if ((next_file = (struct file_list *)
|
|
+ malloc(sizeof(struct file_list))
|
|
+ ) == NULL) {
|
|
+ Info(slide, 0x401, ((char *)slide,
|
|
+ LoadFarString(NoMemArgsList)));
|
|
+ return PK_MEM;
|
|
+ }
|
|
+ next_file->name = value;
|
|
+ next_file->next = NULL;
|
|
+ in_files = next_file;
|
|
+ next_in_files = next_file;
|
|
+ } else {
|
|
+ /* add next entry */
|
|
+ if ((next_file = (struct file_list *)
|
|
+ malloc(sizeof(struct file_list))
|
|
+ ) == NULL) {
|
|
+ Info(slide, 0x401, ((char *)slide,
|
|
+ LoadFarString(NoMemArgsList)));
|
|
+ return PK_MEM;
|
|
+ }
|
|
+ next_in_files->next = next_file;
|
|
+ next_file->name = value;
|
|
+ next_file->next = NULL;
|
|
+ next_in_files = next_file;
|
|
+ }
|
|
+ in_files_count++;
|
|
+ }
|
|
+ break;
|
|
+ default:
|
|
+ error = TRUE;
|
|
+ break;
|
|
+
|
|
+ } /* end switch */
|
|
+ } /* get_option() */
|
|
+
|
|
+
|
|
+ /* convert files and xfiles lists to arrays */
|
|
+
|
|
+ /* convert files list to array */
|
|
+ if (in_files_count) {
|
|
+ if ((G.pfnames = (char **) malloc((in_files_count + 1) * sizeof(char *))
|
|
+ ) == NULL) {
|
|
+ Info(slide, 0x401, ((char *)slide, LoadFarString(NoMemArgsList)));
|
|
+ return PK_MEM;
|
|
+ }
|
|
+ file_count = 0;
|
|
+ for (next_file = in_files; next_file;) {
|
|
+ G.pfnames[file_count] = next_file->name;
|
|
+ in_files = next_file;
|
|
+ next_file = next_file->next;
|
|
+ free(in_files);
|
|
+ file_count++;
|
|
+ }
|
|
+ G.pfnames[file_count] = NULL;
|
|
+ G.filespecs = in_files_count;
|
|
+ }
|
|
+
|
|
+ /* convert xfiles list to array */
|
|
+ if (in_xfiles_count) {
|
|
+ if ((G.pxnames = (char **) malloc((in_xfiles_count + 1) * sizeof(char *))
|
|
+ ) == NULL) {
|
|
+ Info(slide, 0x401, ((char *)slide, LoadFarString(NoMemArgsList)));
|
|
+ return PK_MEM;
|
|
+ }
|
|
+ file_count = 0;
|
|
+ for (next_file = in_xfiles; next_file;) {
|
|
+ G.pxnames[file_count] = next_file->name;
|
|
+ in_xfiles = next_file;
|
|
+ next_file = next_file->next;
|
|
+ free(in_xfiles);
|
|
+ file_count++;
|
|
+ }
|
|
+ G.pxnames[file_count] = NULL;
|
|
+ G.xfilespecs = in_xfiles_count;
|
|
+ }
|
|
+
|
|
+ if (in_files_count || in_xfiles_count) {
|
|
+ G.process_all_files = FALSE;
|
|
+ } else {
|
|
+ G.process_all_files = TRUE; /* for speed */
|
|
+ }
|
|
+
|
|
+
|
|
+ /* it's possible the arg count could have been changed by get_option() */
|
|
+ argc = arg_count(args);
|
|
+
|
|
+
|
|
|
|
/*---------------------------------------------------------------------------
|
|
@@ -1774,7 +2240,77 @@
|
|
---------------------------------------------------------------------------*/
|
|
|
|
+ if ((uO.cflag && (uO.tflag || uO.uflag)) ||
|
|
+ (uO.tflag && uO.uflag) || (uO.fflag && uO.overwrite_none))
|
|
+ {
|
|
+ Info(slide, 0x401, ((char *)slide, LoadFarString(InvalidOptionsMsg)));
|
|
+ error = TRUE;
|
|
+ }
|
|
+ if (uO.aflag > 2)
|
|
+ uO.aflag = 2;
|
|
+#ifdef VMS
|
|
+ if (uO.bflag > 2)
|
|
+ uO.bflag = 2;
|
|
+ /* Clear -s flag when converting text files. */
|
|
+ if (uO.aflag <= 0)
|
|
+ uO.S_flag = 0;
|
|
+#endif /* VMS */
|
|
+ if (uO.overwrite_all && uO.overwrite_none) {
|
|
+ Info(slide, 0x401, ((char *)slide, LoadFarString(IgnoreOOptionMsg)));
|
|
+ uO.overwrite_all = FALSE;
|
|
+ }
|
|
+#ifdef MORE
|
|
+ if (G.M_flag && !isatty(1)) /* stdout redirected: "more" func. useless */
|
|
+ G.M_flag = 0;
|
|
+#endif
|
|
+
|
|
+#ifdef SFX
|
|
+ if (error)
|
|
+#else
|
|
+ if ((G.wildzipfn == NULL) || error)
|
|
+#endif
|
|
+ {
|
|
+ /* tell caller to exit */
|
|
+ if (argc <= 2)
|
|
+ argc = -1;
|
|
+
|
|
+ *pargc = argc;
|
|
+ *pargv = args;
|
|
+#ifndef SFX
|
|
+ if (uO.vflag >= 2 && argc == -1) { /* "unzip -v" */
|
|
+ show_version_info(__G);
|
|
+ return PK_OK;
|
|
+ }
|
|
+ if (!G.noargs && !error)
|
|
+ error = TRUE; /* had options (not -h or -v) but no zipfile */
|
|
+#endif /* !SFX */
|
|
+ return USAGE(error);
|
|
+ }
|
|
+
|
|
#ifdef SFX
|
|
-opts_done: /* yes, very ugly...but only used by UnZipSFX with -x xlist */
|
|
+ /* print our banner unless we're being fairly quiet */
|
|
+ if (uO.qflag < 2)
|
|
+ Info(slide, error? 1 : 0, ((char *)slide, LoadFarString(UnzipSFXBanner),
|
|
+ UZ_MAJORVER, UZ_MINORVER, UZ_PATCHLEVEL, UZ_BETALEVEL,
|
|
+ LoadFarStringSmall(VersionDate)));
|
|
+#ifdef BETA
|
|
+ /* always print the beta warning: no unauthorized distribution!! */
|
|
+ Info(slide, error? 1 : 0, ((char *)slide, LoadFarString(BetaVersion), "\n",
|
|
+ "SFX"));
|
|
+#endif
|
|
+#endif /* SFX */
|
|
+
|
|
+ if (uO.cflag || uO.tflag || uO.vflag || uO.zflag
|
|
+#ifdef TIMESTAMP
|
|
+ || uO.T_flag
|
|
#endif
|
|
+ )
|
|
+ G.extract_flag = FALSE;
|
|
+ else
|
|
+ G.extract_flag = TRUE;
|
|
+
|
|
+#if 0
|
|
+# ifdef SFX
|
|
+opts_done: /* yes, very ugly...but only used by UnZipSFX with -x xlist */
|
|
+# endif
|
|
|
|
if ((uO.cflag && (uO.tflag || uO.uflag)) ||
|
|
@@ -1786,5 +2322,5 @@
|
|
if (uO.aflag > 2)
|
|
uO.aflag = 2;
|
|
-#ifdef VMS
|
|
+# ifdef VMS
|
|
if (uO.bflag > 2)
|
|
uO.bflag = 2;
|
|
@@ -1792,23 +2328,23 @@
|
|
if (uO.aflag <= 0)
|
|
uO.S_flag = 0;
|
|
-#endif /* VMS */
|
|
+# endif /* VMS */
|
|
if (uO.overwrite_all && uO.overwrite_none) {
|
|
Info(slide, 0x401, ((char *)slide, LoadFarString(IgnoreOOptionMsg)));
|
|
uO.overwrite_all = FALSE;
|
|
}
|
|
-#ifdef MORE
|
|
+# ifdef MORE
|
|
if (G.M_flag && !isatty(1)) /* stdout redirected: "more" func. useless */
|
|
G.M_flag = 0;
|
|
-#endif
|
|
+# endif
|
|
|
|
-#ifdef SFX
|
|
+# ifdef SFX
|
|
if (error)
|
|
-#else
|
|
+# else
|
|
if ((argc-- == 0) || error)
|
|
-#endif
|
|
+# endif
|
|
{
|
|
*pargc = argc;
|
|
- *pargv = argv;
|
|
-#ifndef SFX
|
|
+ *pargv = args;
|
|
+# ifndef SFX
|
|
if (uO.vflag >= 2 && argc == -1) { /* "unzip -v" */
|
|
show_version_info(__G);
|
|
@@ -1817,9 +2353,9 @@
|
|
if (!G.noargs && !error)
|
|
error = TRUE; /* had options (not -h or -v) but no zipfile */
|
|
-#endif /* !SFX */
|
|
+# endif /* !SFX */
|
|
return USAGE(error);
|
|
}
|
|
|
|
-#ifdef SFX
|
|
+# ifdef SFX
|
|
/* print our banner unless we're being fairly quiet */
|
|
if (uO.qflag < 2)
|
|
@@ -1827,22 +2363,23 @@
|
|
UZ_MAJORVER, UZ_MINORVER, UZ_PATCHLEVEL, UZ_BETALEVEL,
|
|
LoadFarStringSmall(VersionDate)));
|
|
-#ifdef BETA
|
|
+# ifdef BETA
|
|
/* always print the beta warning: no unauthorized distribution!! */
|
|
Info(slide, error? 1 : 0, ((char *)slide, LoadFarString(BetaVersion), "\n",
|
|
"SFX"));
|
|
-#endif
|
|
-#endif /* SFX */
|
|
+# endif
|
|
+# endif /* SFX */
|
|
|
|
if (uO.cflag || uO.tflag || uO.vflag || uO.zflag
|
|
-#ifdef TIMESTAMP
|
|
+# ifdef TIMESTAMP
|
|
|| uO.T_flag
|
|
-#endif
|
|
+# endif
|
|
)
|
|
G.extract_flag = FALSE;
|
|
else
|
|
G.extract_flag = TRUE;
|
|
+#endif
|
|
|
|
*pargc = argc;
|
|
- *pargv = argv;
|
|
+ *pargv = args;
|
|
return PK_OK;
|
|
|
|
@@ -2314,2 +2851,1366 @@
|
|
#endif /* !SFX */
|
|
#endif /* !WINDLL */
|
|
+
|
|
+
|
|
+
|
|
+
|
|
+
|
|
+
|
|
+/*---------------------------------------------------------------
|
|
+ * Long option support
|
|
+ * 8/23/2003
|
|
+ * Updated 3/1/2008 to support UnZip
|
|
+ *
|
|
+ * Defines function get_option() to get and process the command
|
|
+ * line options and arguments from argv[]. The caller calls
|
|
+ * get_option() in a loop to get either one option and possible
|
|
+ * value or a non-option argument each loop.
|
|
+ *
|
|
+ * This version has been modified to work with UnZip and ZipInfo.
|
|
+ * the major changes are removing the error returns, instead
|
|
+ * passing back error codes for errors, and supporting separate
|
|
+ * groups of options for UnZip and ZipInfo and selecting the option
|
|
+ * group by an argument.
|
|
+ *
|
|
+ * This version does not include argument file support and can
|
|
+ * work directly on argv. The argument file code complicates things and
|
|
+ * it seemed best to leave it out for now. If argument file support
|
|
+ * (reading in command line arguments stored in a file and inserting into
|
|
+ * command line where @filename is found) is added later the arguments
|
|
+ * can change and a freeable copy of argv will be needed and can be
|
|
+ * created using copy_args in the left out code.
|
|
+ *
|
|
+ * Supports short and long options as defined in the array options[]
|
|
+ * in zip.c, multiple short options in an argument (like -jlv), long
|
|
+ * option abbreviation (like --te for --temp-file if --te unique),
|
|
+ * short and long option values (like -b filename or --temp-file filename
|
|
+ * or --temp-file=filename), optional and required values, option negation
|
|
+ * by trailing - (like -S- to not include hidden and system files in MSDOS),
|
|
+ * value lists (like -x a b c), argument permuting (returning all options
|
|
+ * and values before any non-option arguments), and argument files (where
|
|
+ * any non-option non-value argument in form @path gets substituted with
|
|
+ * the white space separated arguments in the text file at path). In this
|
|
+ * version argument file support has been removed to simplify development
|
|
+ * but may be added later.
|
|
+ *
|
|
+ * E. Gordon
|
|
+ */
|
|
+
|
|
+
|
|
+/* message output - char casts are needed to handle constants */
|
|
+#define oWARN(message) Info(slide, 0x401, ((char *)slide, (char *)message))
|
|
+
|
|
+
|
|
+
|
|
+/* Although the below provides some support for multibyte characters
|
|
+ the proper thing to do may be to use wide characters and support
|
|
+ Unicode. May get to it soon. Wide support would likely require
|
|
+ the ability to convert the command line to wide strings, which most
|
|
+ modern OS should support now. EG
|
|
+ */
|
|
+
|
|
+/* For now stay with multi-byte characters. May support wide characters
|
|
+ in Zip 3.1 and UnZip 6.1.
|
|
+ */
|
|
+
|
|
+/* multibyte character set support
|
|
+ Multibyte characters use typically two or more sequential bytes
|
|
+ to represent additional characters than can fit in a single byte
|
|
+ character set. The code used here is based on the ANSI mblen function. */
|
|
+#define MB_CLEN(ptr) CLEN(ptr)
|
|
+#define MB_NEXTCHAR(ptr) PREINCSTR(ptr)
|
|
+
|
|
+
|
|
+/* constants */
|
|
+
|
|
+/* function get_args_from_arg_file() can return this in depth parameter */
|
|
+#define ARG_FILE_ERR -1
|
|
+
|
|
+/* internal settings for optchar */
|
|
+#define SKIP_VALUE_ARG -1
|
|
+#define THIS_ARG_DONE -2
|
|
+#define START_VALUE_LIST -3
|
|
+#define IN_VALUE_LIST -4
|
|
+#define NON_OPTION_ARG -5
|
|
+#define STOP_VALUE_LIST -6
|
|
+/* 7/25/04 EG */
|
|
+#define READ_REST_ARGS_VERBATIM -7
|
|
+
|
|
+
|
|
+/* global veriables */
|
|
+
|
|
+int enable_permute = 1; /* yes - return options first */
|
|
+/* 7/25/04 EG */
|
|
+int doubledash_ends_options = 1; /* when -- what follows are not options */
|
|
+
|
|
+/* buffer for error messages (this sizing is a guess but must hold 2 paths) */
|
|
+#define OPTIONERR_BUF_SIZE (80+ 2*FILENAME_MAX)
|
|
+char optionerrbuf[OPTIONERR_BUF_SIZE + 1];
|
|
+
|
|
+/* error messages */
|
|
+static ZCONST char Far op_not_neg_err[] =
|
|
+ "option %s not negatable";
|
|
+static ZCONST char Far op_req_val_err[] =
|
|
+ "option %s requires a value";
|
|
+static ZCONST char Far op_no_allow_val_err[] =
|
|
+ "option %s does not allow a value";
|
|
+static ZCONST char Far sh_op_not_sup_err[] =
|
|
+ "short option '%c' not supported";
|
|
+static ZCONST char Far oco_req_val_err[] =
|
|
+ "option %s requires one character value";
|
|
+static ZCONST char Far oco_no_mbc_err[] =
|
|
+ "option %s does not support multibyte values";
|
|
+static ZCONST char Far num_req_val_err[] =
|
|
+ "option %s requires number value";
|
|
+static ZCONST char Far long_op_ambig_err[] =
|
|
+ "long option '%s' ambiguous";
|
|
+static ZCONST char Far long_op_not_sup_err[] =
|
|
+ "long option '%s' not supported";
|
|
+
|
|
+static ZCONST char Far no_arg_files_err[] = "argument files not enabled\n";
|
|
+
|
|
+
|
|
+/* below removed as only used for processing argument files */
|
|
+
|
|
+/* get_nextarg */
|
|
+/* get_args_from_string */
|
|
+/* get_args_from_arg_file */
|
|
+
|
|
+
|
|
+/* copy error, option name, and option description if any to buf */
|
|
+static int optionerr(options, buf, err, optind, islong)
|
|
+ struct option_struct *options;
|
|
+ char *buf;
|
|
+ ZCONST char Far *err;
|
|
+ int optind;
|
|
+ int islong;
|
|
+{
|
|
+ char optname[50];
|
|
+
|
|
+ if (options[optind].name && options[optind].name[0] != '\0') {
|
|
+ sprintf(optname, "'%s' (%s)",
|
|
+ LoadFarStringSmall2(islong ? options[optind].longopt
|
|
+ : options[optind].shortopt),
|
|
+ LoadFarStringSmall(options[optind].name));
|
|
+ } else {
|
|
+ sprintf(optname, "'%s'",
|
|
+ LoadFarStringSmall2(islong ? options[optind].longopt
|
|
+ : options[optind].shortopt));
|
|
+ }
|
|
+ sprintf(buf, LoadFarStringSmall(err), optname);
|
|
+ return 0;
|
|
+}
|
|
+
|
|
+
|
|
+/* copy_args
|
|
+ *
|
|
+ * Copy arguments in args, allocating storage with malloc.
|
|
+ * Copies until a NULL argument is found or until max_args args
|
|
+ * including args[0] are copied. Set max_args to 0 to copy
|
|
+ * until NULL. Always terminates returned args[] with NULL arg.
|
|
+ *
|
|
+ * Any argument in the returned args can be freed with free(). Any
|
|
+ * freed argument should be replaced with either another string
|
|
+ * allocated with malloc or by NULL if last argument so that free_args
|
|
+ * will properly work.
|
|
+ */
|
|
+char **copy_args(args, max_args)
|
|
+ char **args;
|
|
+ int max_args;
|
|
+{
|
|
+ int j;
|
|
+ char **new_args;
|
|
+
|
|
+ if (args == NULL) {
|
|
+ return NULL;
|
|
+ }
|
|
+
|
|
+ /* count args */
|
|
+ for (j = 0; args[j] && (max_args == 0 || j < max_args); j++) ;
|
|
+
|
|
+ if ((new_args = (char **) malloc((j + 1) * sizeof(char *))) == NULL) {
|
|
+ oWARN("memory - ca");
|
|
+ return NULL;
|
|
+ }
|
|
+
|
|
+ for (j = 0; args[j] && (max_args == 0 || j < max_args); j++) {
|
|
+ if (args[j] == NULL) {
|
|
+ /* null argument is end of args */
|
|
+ new_args[j] = NULL;
|
|
+ break;
|
|
+ }
|
|
+ if ((new_args[j] = malloc(strlen(args[j]) + 1)) == NULL) {
|
|
+ free_args(new_args);
|
|
+ oWARN("memory - ca");
|
|
+ return NULL;
|
|
+ }
|
|
+ strcpy(new_args[j], args[j]);
|
|
+ }
|
|
+ new_args[j] = NULL;
|
|
+
|
|
+ return new_args;
|
|
+}
|
|
+
|
|
+
|
|
+/* count args - count args in argv like array */
|
|
+int arg_count(args)
|
|
+ char **args;
|
|
+{
|
|
+ int i;
|
|
+
|
|
+ if (args == NULL) {
|
|
+ return 0;
|
|
+ }
|
|
+
|
|
+ for (i = 0; args[i]; i++) {
|
|
+ }
|
|
+ return i;
|
|
+}
|
|
+
|
|
+
|
|
+/* free args - free args created with one of these functions */
|
|
+int free_args(args)
|
|
+ char **args;
|
|
+{
|
|
+ int i;
|
|
+
|
|
+ if (args == NULL) {
|
|
+ return 0;
|
|
+ }
|
|
+
|
|
+ for (i = 0; args[i]; i++) {
|
|
+ free(args[i]);
|
|
+ }
|
|
+ free(args);
|
|
+ return i;
|
|
+}
|
|
+
|
|
+
|
|
+/* insert_arg
|
|
+ *
|
|
+ * Insert the argument arg into the array args before argument at_arg.
|
|
+ * If at_arg = -1 then append to end.
|
|
+ * Return the new count of arguments (argc).
|
|
+ *
|
|
+ * If free_args is true, this function frees the old args array
|
|
+ * (but not the component strings). DO NOT set free_args on original
|
|
+ * argv but only on args allocated with malloc.
|
|
+ */
|
|
+
|
|
+int insert_arg(pargs, arg, at_arg, free_args)
|
|
+ char ***pargs;
|
|
+ ZCONST char *arg;
|
|
+ int at_arg;
|
|
+ int free_args;
|
|
+{
|
|
+ char *newarg = NULL;
|
|
+ char **args;
|
|
+ char **newargs = NULL;
|
|
+ int argnum;
|
|
+ int newargnum;
|
|
+ int argcnt;
|
|
+ int newargcnt;
|
|
+
|
|
+ if (pargs == NULL) {
|
|
+ return 0;
|
|
+ }
|
|
+ args = *pargs;
|
|
+
|
|
+ /* count args */
|
|
+ if (args == NULL) {
|
|
+ argcnt = 0;
|
|
+ } else {
|
|
+ for (argcnt = 0; args[argcnt]; argcnt++) ;
|
|
+ }
|
|
+ if (arg == NULL) {
|
|
+ /* done */
|
|
+ return argcnt;
|
|
+ }
|
|
+ if (at_arg == -1) {
|
|
+ at_arg = argcnt;
|
|
+ }
|
|
+ newargcnt = argcnt + 1;
|
|
+
|
|
+ /* get storage for new args */
|
|
+ if ((newargs = (char **) malloc((newargcnt + 1) * sizeof(char *))) == NULL)
|
|
+ {
|
|
+ oWARN("memory - ia");
|
|
+ return 0;
|
|
+ }
|
|
+
|
|
+ /* copy argument pointers from args to position at_arg, copy the new arg,
|
|
+ then copy the rest of the args */
|
|
+ argnum = 0;
|
|
+ newargnum = 0;
|
|
+ if (args) {
|
|
+ for (; args[argnum] && argnum < at_arg; argnum++) {
|
|
+ newargs[newargnum++] = args[argnum];
|
|
+ }
|
|
+ }
|
|
+ /* copy new arg */
|
|
+ if ((newarg = (char *) malloc(strlen(arg) + 1)) == NULL) {
|
|
+ oWARN("memory - ia");
|
|
+ return 0;
|
|
+ }
|
|
+ strcpy(newarg, arg);
|
|
+
|
|
+ newargs[newargnum++] = newarg;
|
|
+ if (args) {
|
|
+ for ( ; args[argnum]; argnum++) {
|
|
+ newargs[newargnum++] = args[argnum];
|
|
+ }
|
|
+ }
|
|
+ newargs[newargnum] = NULL;
|
|
+
|
|
+ /* free old args array but not component strings - this assumes that
|
|
+ args was allocated with malloc as copy_args does. DO NOT DO THIS
|
|
+ on the original argv.
|
|
+ */
|
|
+ if (free_args)
|
|
+ free(args);
|
|
+
|
|
+ *pargs = newargs;
|
|
+
|
|
+ return newargnum;
|
|
+}
|
|
+
|
|
+/* ------------------------------------- */
|
|
+
|
|
+/* get_shortopt
|
|
+ *
|
|
+ * Get next short option from arg. The state is stored in argnum, optchar, and
|
|
+ * option_num so no static storage is used. Returns the option_ID.
|
|
+ *
|
|
+ * parameters:
|
|
+ * option_group - either UZO for UnZip options or ZIO for ZipInfo options
|
|
+ * args - argv array of arguments
|
|
+ * argnum - index of current arg in args
|
|
+ * optchar - pointer to index of next char to process. Can be 0 or
|
|
+ * const defined at top of this file like THIS_ARG_DONE
|
|
+ * negated - on return pointer to int set to 1 if option negated
|
|
+ * or 0 otherwise
|
|
+ * value - on return pointer to string set to value of option if any
|
|
+ * or NULL if none. If value is returned then the caller
|
|
+ * should free() it when not needed anymore.
|
|
+ * option_num - pointer to index in options[] of returned option or
|
|
+ * o_NO_OPTION_MATCH if none. Do not change as used by
|
|
+ * value lists.
|
|
+ * depth - recursion depth (0 at top level, 1 or more in arg files)
|
|
+ */
|
|
+static unsigned long get_shortopt(option_group, args, argnum, optchar, negated,
|
|
+ value, option_num, depth)
|
|
+ int option_group;
|
|
+ ZCONST char **args;
|
|
+ int argnum;
|
|
+ int *optchar;
|
|
+ int *negated;
|
|
+ char **value;
|
|
+ int *option_num;
|
|
+ int depth;
|
|
+{
|
|
+ ZCONST char *shortopt;
|
|
+ int clen;
|
|
+ ZCONST char *nextchar;
|
|
+ ZCONST char *s;
|
|
+ ZCONST char *start;
|
|
+ int op;
|
|
+ ZCONST char *arg;
|
|
+ int match = -1;
|
|
+
|
|
+
|
|
+ /* get arg */
|
|
+ arg = args[argnum];
|
|
+ /* current char in arg */
|
|
+ nextchar = arg + (*optchar);
|
|
+ clen = MB_CLEN(nextchar);
|
|
+ /* next char in arg */
|
|
+ (*optchar) += clen;
|
|
+ /* get first char of short option */
|
|
+ shortopt = arg + (*optchar);
|
|
+ /* no value */
|
|
+ *value = NULL;
|
|
+
|
|
+ if (*shortopt == '\0') {
|
|
+ /* no more options in arg */
|
|
+ *optchar = 0;
|
|
+ *option_num = o_NO_OPTION_MATCH;
|
|
+ return 0;
|
|
+ }
|
|
+
|
|
+ /* look for match in options */
|
|
+ clen = MB_CLEN(shortopt);
|
|
+ for (op = 0; options[op].option_ID; op++) {
|
|
+ /* Only look at options in this option group */
|
|
+ if (options[op].option_group == option_group) {
|
|
+ s = options[op].shortopt;
|
|
+ if (s && s[0] == shortopt[0]) {
|
|
+ if (s[1] == '\0' && clen == 1) {
|
|
+ /* single char match */
|
|
+ match = op;
|
|
+ } else {
|
|
+ /* 2 wide short opt. Could support more chars but should use long opts instead */
|
|
+ if (s[1] == shortopt[1]) {
|
|
+ /* match 2 char short opt or 2 byte char */
|
|
+ match = op;
|
|
+ if (clen == 1) (*optchar)++;
|
|
+ break;
|
|
+ }
|
|
+ }
|
|
+ }
|
|
+ }
|
|
+ }
|
|
+
|
|
+ if (match > -1) {
|
|
+ /* match */
|
|
+ clen = MB_CLEN(shortopt);
|
|
+ nextchar = arg + (*optchar) + clen;
|
|
+ /* check for trailing dash negating option */
|
|
+ if (*nextchar == '-') {
|
|
+ /* negated */
|
|
+ if (options[match].negatable == o_NOT_NEGATABLE) {
|
|
+ if (options[match].value_type == o_NO_VALUE) {
|
|
+ optionerr(options, optionerrbuf, op_not_neg_err, match, 0);
|
|
+ if (depth > 0) {
|
|
+ /* unwind */
|
|
+ oWARN(optionerrbuf);
|
|
+ return o_ARG_FILE_ERR;
|
|
+ } else {
|
|
+ oWARN(optionerrbuf);
|
|
+ return o_BAD_ERR;
|
|
+ }
|
|
+ }
|
|
+ } else {
|
|
+ *negated = 1;
|
|
+ /* set up to skip negating dash */
|
|
+ (*optchar) += clen;
|
|
+ clen = 1;
|
|
+ }
|
|
+ }
|
|
+
|
|
+ /* value */
|
|
+ clen = MB_CLEN(arg + (*optchar));
|
|
+ /* optional value, one char value, and number value must follow option */
|
|
+ if (options[match].value_type == o_ONE_CHAR_VALUE) {
|
|
+ /* one char value */
|
|
+ if (arg[(*optchar) + clen]) {
|
|
+ /* has value */
|
|
+ if (MB_CLEN(arg + (*optchar) + clen) > 1) {
|
|
+ /* multibyte value not allowed for now */
|
|
+ optionerr(options, optionerrbuf, oco_no_mbc_err, match, 0);
|
|
+ if (depth > 0) {
|
|
+ /* unwind */
|
|
+ oWARN(optionerrbuf);
|
|
+ return o_ARG_FILE_ERR;
|
|
+ } else {
|
|
+ oWARN(optionerrbuf);
|
|
+ return o_BAD_ERR;
|
|
+ }
|
|
+ }
|
|
+ if ((*value = (char *) malloc(2)) == NULL) {
|
|
+ oWARN("memory - gso");
|
|
+ return o_BAD_ERR;
|
|
+ }
|
|
+ (*value)[0] = *(arg + (*optchar) + clen);
|
|
+ (*value)[1] = '\0';
|
|
+ *optchar += clen;
|
|
+ clen = 1;
|
|
+ } else {
|
|
+ /* one char values require a value */
|
|
+ optionerr(options, optionerrbuf, oco_req_val_err, match, 0);
|
|
+ if (depth > 0) {
|
|
+ oWARN(optionerrbuf);
|
|
+ return o_ARG_FILE_ERR;
|
|
+ } else {
|
|
+ oWARN(optionerrbuf);
|
|
+ return o_BAD_ERR;
|
|
+ }
|
|
+ }
|
|
+ } else if (options[match].value_type == o_NUMBER_VALUE) {
|
|
+ /* read chars until end of number */
|
|
+ start = arg + (*optchar) + clen;
|
|
+ if (*start == '+' || *start == '-') {
|
|
+ start++;
|
|
+ }
|
|
+ s = start;
|
|
+ for (; isdigit(*s); MB_NEXTCHAR(s)) ;
|
|
+ if (s == start) {
|
|
+ /* no digits */
|
|
+ optionerr(options, optionerrbuf, num_req_val_err, match, 0);
|
|
+ if (depth > 0) {
|
|
+ oWARN(optionerrbuf);
|
|
+ return o_ARG_FILE_ERR;
|
|
+ } else {
|
|
+ oWARN(optionerrbuf);
|
|
+ return o_BAD_ERR;
|
|
+ }
|
|
+ }
|
|
+ start = arg + (*optchar) + clen;
|
|
+ if ((*value = (char *) malloc((int)(s - start) + 1)) == NULL) {
|
|
+ oWARN("memory - gso");
|
|
+ return o_BAD_ERR;
|
|
+ }
|
|
+ *optchar += (int)(s - start);
|
|
+ strncpy(*value, start, (int)(s - start));
|
|
+ (*value)[(int)(s - start)] = '\0';
|
|
+ clen = MB_CLEN(s);
|
|
+ } else if (options[match].value_type == o_OPTIONAL_VALUE) {
|
|
+ /* optional value */
|
|
+ /* This seemed inconsistent so now if no value attached to argument look
|
|
+ to the next argument if that argument is not an option for option
|
|
+ value - 11/12/04 EG */
|
|
+ if (arg[(*optchar) + clen]) {
|
|
+ /* has value */
|
|
+ /* add support for optional = - 2/6/05 EG */
|
|
+ if (arg[(*optchar) + clen] == '=') {
|
|
+ /* skip = */
|
|
+ clen++;
|
|
+ }
|
|
+ if (arg[(*optchar) + clen]) {
|
|
+ if ((*value = (char *)malloc(strlen(arg + (*optchar) + clen) + 1))
|
|
+ == NULL) {
|
|
+ oWARN("memory - gso");
|
|
+ return o_BAD_ERR;
|
|
+ }
|
|
+ strcpy(*value, arg + (*optchar) + clen);
|
|
+ }
|
|
+ *optchar = THIS_ARG_DONE;
|
|
+ } else if (args[argnum + 1] && args[argnum + 1][0] != '-') {
|
|
+ /* use next arg for value */
|
|
+ if ((*value = (char *)malloc(strlen(args[argnum + 1]) + 1)) == NULL) {
|
|
+ oWARN("memory - gso");
|
|
+ return o_BAD_ERR;
|
|
+ }
|
|
+ /* using next arg as value */
|
|
+ strcpy(*value, args[argnum + 1]);
|
|
+ *optchar = SKIP_VALUE_ARG;
|
|
+ }
|
|
+ } else if (options[match].value_type == o_REQUIRED_VALUE ||
|
|
+ options[match].value_type == o_VALUE_LIST) {
|
|
+ /* see if follows option */
|
|
+ if (arg[(*optchar) + clen]) {
|
|
+ /* has value following option as -ovalue */
|
|
+ /* add support for optional = - 6/5/05 EG */
|
|
+ if (arg[(*optchar) + clen] == '=') {
|
|
+ /* skip = */
|
|
+ clen++;
|
|
+ }
|
|
+ if ((*value = (char *)malloc(strlen(arg + (*optchar) + clen) + 1))
|
|
+ == NULL) {
|
|
+ oWARN("memory - gso");
|
|
+ return o_BAD_ERR;
|
|
+ }
|
|
+ strcpy(*value, arg + (*optchar) + clen);
|
|
+ *optchar = THIS_ARG_DONE;
|
|
+ } else {
|
|
+ /* use next arg for value */
|
|
+ if (args[argnum + 1]) {
|
|
+ if ((*value = (char *)malloc(strlen(args[argnum + 1]) + 1))
|
|
+ == NULL) {
|
|
+ oWARN("memory - gso");
|
|
+ return o_BAD_ERR;
|
|
+ }
|
|
+ strcpy(*value, args[argnum + 1]);
|
|
+ if (options[match].value_type == o_VALUE_LIST) {
|
|
+ *optchar = START_VALUE_LIST;
|
|
+ } else {
|
|
+ *optchar = SKIP_VALUE_ARG;
|
|
+ }
|
|
+ } else {
|
|
+ /* no value found */
|
|
+ optionerr(options, optionerrbuf, op_req_val_err, match, 0);
|
|
+ if (depth > 0) {
|
|
+ oWARN(optionerrbuf);
|
|
+ return o_ARG_FILE_ERR;
|
|
+ } else {
|
|
+ oWARN(optionerrbuf);
|
|
+ return o_BAD_ERR;
|
|
+ }
|
|
+ }
|
|
+ }
|
|
+ }
|
|
+
|
|
+ *option_num = match;
|
|
+ return options[match].option_ID;
|
|
+ }
|
|
+ sprintf(optionerrbuf, LoadFarStringSmall(sh_op_not_sup_err), *shortopt);
|
|
+ if (depth > 0) {
|
|
+ /* unwind */
|
|
+ oWARN(optionerrbuf);
|
|
+ return o_ARG_FILE_ERR;
|
|
+ } else {
|
|
+ oWARN(optionerrbuf);
|
|
+ return o_BAD_ERR;
|
|
+ }
|
|
+ return 0;
|
|
+}
|
|
+
|
|
+
|
|
+/* get_longopt
|
|
+ *
|
|
+ * Get the long option in args array at argnum.
|
|
+ * Parameters same as for get_shortopt.
|
|
+ */
|
|
+
|
|
+static unsigned long get_longopt(option_group, args, argnum, optchar, negated,
|
|
+ value, option_num, depth)
|
|
+ int option_group;
|
|
+ ZCONST char **args;
|
|
+ int argnum;
|
|
+ int *optchar;
|
|
+ int *negated;
|
|
+ char **value;
|
|
+ int *option_num;
|
|
+ int depth;
|
|
+{
|
|
+ char *longopt;
|
|
+ char *lastchr;
|
|
+ char *valuestart;
|
|
+ int op;
|
|
+ char *arg;
|
|
+ int match = -1;
|
|
+ *value = NULL;
|
|
+
|
|
+ if (args == NULL) {
|
|
+ *option_num = o_NO_OPTION_MATCH;
|
|
+ return 0;
|
|
+ }
|
|
+ if (args[argnum] == NULL) {
|
|
+ *option_num = o_NO_OPTION_MATCH;
|
|
+ return 0;
|
|
+ }
|
|
+ /* copy arg so can chop end if value */
|
|
+ if ((arg = (char *)malloc(strlen(args[argnum]) + 1)) == NULL) {
|
|
+ oWARN("memory - glo");
|
|
+ return o_BAD_ERR;
|
|
+ }
|
|
+ strcpy(arg, args[argnum]);
|
|
+
|
|
+ /* get option */
|
|
+ longopt = arg + 2;
|
|
+ /* no value */
|
|
+ *value = NULL;
|
|
+
|
|
+ /* find = */
|
|
+ for (lastchr = longopt, valuestart = longopt;
|
|
+ *valuestart && *valuestart != '=';
|
|
+ lastchr = valuestart, MB_NEXTCHAR(valuestart)) ;
|
|
+ if (*valuestart) {
|
|
+ /* found =value */
|
|
+ *valuestart = '\0';
|
|
+ valuestart++;
|
|
+ } else {
|
|
+ valuestart = NULL;
|
|
+ }
|
|
+
|
|
+ if (*lastchr == '-') {
|
|
+ /* option negated */
|
|
+ *negated = 1;
|
|
+ *lastchr = '\0';
|
|
+ } else {
|
|
+ *negated = 0;
|
|
+ }
|
|
+
|
|
+ /* look for long option match */
|
|
+ for (op = 0; options[op].option_ID; op++) {
|
|
+ /* Only look at options in the option group */
|
|
+ if (options[op].option_group == option_group) {
|
|
+ if (options[op].longopt &&
|
|
+ strcmp(LoadFarStringSmall(options[op].longopt), longopt) == 0) {
|
|
+ /* exact match */
|
|
+ match = op;
|
|
+ break;
|
|
+ }
|
|
+ if (options[op].longopt &&
|
|
+ strncmp(LoadFarStringSmall(options[op].longopt),
|
|
+ longopt, strlen(longopt)) == 0) {
|
|
+ if (match > -1) {
|
|
+ sprintf(optionerrbuf, LoadFarStringSmall(long_op_ambig_err),
|
|
+ longopt);
|
|
+ free(arg);
|
|
+ if (depth > 0) {
|
|
+ /* unwind */
|
|
+ oWARN(optionerrbuf);
|
|
+ return o_ARG_FILE_ERR;
|
|
+ } else {
|
|
+ oWARN(optionerrbuf);
|
|
+ return o_BAD_ERR;
|
|
+ }
|
|
+ }
|
|
+ match = op;
|
|
+ }
|
|
+ }
|
|
+ }
|
|
+
|
|
+ if (match == -1) {
|
|
+ sprintf(optionerrbuf, LoadFarStringSmall(long_op_not_sup_err), longopt);
|
|
+ free(arg);
|
|
+ if (depth > 0) {
|
|
+ oWARN(optionerrbuf);
|
|
+ return o_ARG_FILE_ERR;
|
|
+ } else {
|
|
+ oWARN(optionerrbuf);
|
|
+ return o_BAD_ERR;
|
|
+ }
|
|
+ }
|
|
+
|
|
+ /* one long option an arg */
|
|
+ *optchar = THIS_ARG_DONE;
|
|
+
|
|
+ /* if negated then see if allowed */
|
|
+ if (*negated && options[match].negatable == o_NOT_NEGATABLE) {
|
|
+ optionerr(options, optionerrbuf, op_not_neg_err, match, 1);
|
|
+ free(arg);
|
|
+ if (depth > 0) {
|
|
+ /* unwind */
|
|
+ oWARN(optionerrbuf);
|
|
+ return o_ARG_FILE_ERR;
|
|
+ } else {
|
|
+ oWARN(optionerrbuf);
|
|
+ return o_BAD_ERR;
|
|
+ }
|
|
+ }
|
|
+ /* get value */
|
|
+ if (options[match].value_type == o_OPTIONAL_VALUE) {
|
|
+ /* optional value in form option=value */
|
|
+ if (valuestart) {
|
|
+ /* option=value */
|
|
+ if ((*value = (char *)malloc(strlen(valuestart) + 1)) == NULL) {
|
|
+ free(arg);
|
|
+ oWARN("memory - glo");
|
|
+ return o_BAD_ERR;
|
|
+ }
|
|
+ strcpy(*value, valuestart);
|
|
+ }
|
|
+ } else if (options[match].value_type == o_REQUIRED_VALUE ||
|
|
+ options[match].value_type == o_NUMBER_VALUE ||
|
|
+ options[match].value_type == o_ONE_CHAR_VALUE ||
|
|
+ options[match].value_type == o_VALUE_LIST) {
|
|
+ /* handle long option one char and number value as required value */
|
|
+ if (valuestart) {
|
|
+ /* option=value */
|
|
+ if ((*value = (char *)malloc(strlen(valuestart) + 1)) == NULL) {
|
|
+ free(arg);
|
|
+ oWARN("memory - glo");
|
|
+ return o_BAD_ERR;
|
|
+ }
|
|
+ strcpy(*value, valuestart);
|
|
+ } else {
|
|
+ /* use next arg */
|
|
+ if (args[argnum + 1]) {
|
|
+ if ((*value = (char *)malloc(strlen(args[argnum + 1]) + 1)) == NULL) {
|
|
+ free(arg);
|
|
+ oWARN("memory - glo");
|
|
+ return o_BAD_ERR;
|
|
+ }
|
|
+ /* using next arg as value */
|
|
+ strcpy(*value, args[argnum + 1]);
|
|
+ if (options[match].value_type == o_VALUE_LIST) {
|
|
+ *optchar = START_VALUE_LIST;
|
|
+ } else {
|
|
+ *optchar = SKIP_VALUE_ARG;
|
|
+ }
|
|
+ } else {
|
|
+ /* no value found */
|
|
+ optionerr(options, optionerrbuf, op_req_val_err, match, 1);
|
|
+ free(arg);
|
|
+ if (depth > 0) {
|
|
+ /* unwind */
|
|
+ oWARN(optionerrbuf);
|
|
+ return o_ARG_FILE_ERR;
|
|
+ } else {
|
|
+ oWARN(optionerrbuf);
|
|
+ return o_BAD_ERR;
|
|
+ }
|
|
+ }
|
|
+ }
|
|
+ } else if (options[match].value_type == o_NO_VALUE) {
|
|
+ /* this option does not accept a value */
|
|
+ if (valuestart) {
|
|
+ /* --option=value */
|
|
+ optionerr(options, optionerrbuf, op_no_allow_val_err, match, 1);
|
|
+ free(arg);
|
|
+ if (depth > 0) {
|
|
+ oWARN(optionerrbuf);
|
|
+ return o_ARG_FILE_ERR;
|
|
+ } else {
|
|
+ oWARN(optionerrbuf);
|
|
+ return o_BAD_ERR;
|
|
+ }
|
|
+ }
|
|
+ }
|
|
+ free(arg);
|
|
+
|
|
+ *option_num = match;
|
|
+ return options[match].option_ID;
|
|
+}
|
|
+
|
|
+
|
|
+
|
|
+/* get_option
|
|
+ *
|
|
+ * Main interface for user. Use this function to get options, values and
|
|
+ * non-option arguments from a command line provided in argv form.
|
|
+ *
|
|
+ * To use get_option() first define valid options by setting
|
|
+ * the global variable options[] to an array of option_struct. Also
|
|
+ * either change defaults below or make variables global and set elsewhere.
|
|
+ * Zip uses below defaults.
|
|
+ *
|
|
+ * Call get_option() to get an option (like -b or --temp-file) and any
|
|
+ * value for that option (like filename for -b) or a non-option argument
|
|
+ * (like archive name) each call. If *value* is not NULL after calling
|
|
+ * get_option() it is a returned value and the caller should either store
|
|
+ * the char pointer or free() it before calling get_option() again to avoid
|
|
+ * leaking memory. If a non-option non-value argument is returned get_option()
|
|
+ * returns o_NON_OPTION_ARG and value is set to the entire argument.
|
|
+ * When there are no more arguments get_option() returns 0.
|
|
+ *
|
|
+ * The parameters argnum (after set to 0 on initial call),
|
|
+ * optchar, first_nonopt_arg, option_num, and depth (after initial
|
|
+ * call) are set and maintained by get_option() and should not be
|
|
+ * changed. The parameters argc, negated, and value are outputs and
|
|
+ * can be used by the calling program. get_option() returns either the
|
|
+ * option_ID for the current option, a special value defined in
|
|
+ * zip.h, or 0 when no more arguments.
|
|
+ *
|
|
+ * The value returned by get_option() is the ID value in the options
|
|
+ * table. This value can be duplicated in the table if different
|
|
+ * options are really the same option. The index into the options[]
|
|
+ * table is given by option_num, though the ID should be used as
|
|
+ * option numbers change when the table is changed. The ID must
|
|
+ * not be 0 for any option as this ends the table. If get_option()
|
|
+ * finds an option not in the table it calls oERR to post an
|
|
+ * error and exit. Errors also result if the option requires a
|
|
+ * value that is missing, a value is present but the option does
|
|
+ * not take one, and an option is negated but is not
|
|
+ * negatable. Non-option arguments return o_NON_OPTION_ARG
|
|
+ * with the entire argument in value.
|
|
+ *
|
|
+ * For Zip and UnZip, permuting is on and all options and their values
|
|
+ * are returned before any non-option arguments like archive name.
|
|
+ *
|
|
+ * The arguments "-" alone and "--" alone return as non-option arguments.
|
|
+ * Note that "-" should not be used as part of a short option
|
|
+ * entry in the table but can be used in the middle of long
|
|
+ * options such as in the long option "a-long-option". Now "--" alone
|
|
+ * stops option processing, returning any arguments following "--" as
|
|
+ * non-option arguments instead of options.
|
|
+ *
|
|
+ * Argument file support is removed from this version. It may be added later.
|
|
+ *
|
|
+ * After each call:
|
|
+ * argc is set to the current size of args[] but should not change
|
|
+ * with argument file support removed,
|
|
+ * argnum is the index of the current arg,
|
|
+ * value is either the value of the returned option or non-option
|
|
+ * argument or NULL if option with no value,
|
|
+ * negated is set if the option was negated by a trailing dash (-)
|
|
+ * option_num is set to either the index in options[] for the option or
|
|
+ * o_NO_OPTION_MATCH if no match.
|
|
+ * Negation is checked before the value is read if the option is negatable so
|
|
+ * that the - is not included in the value. If the option is not negatable
|
|
+ * but takes a value then the - will start the value. If permuting then
|
|
+ * argnum and first_nonopt_arg are unreliable and should not be used.
|
|
+ *
|
|
+ * Command line is read from left to right. As get_option() finds non-option
|
|
+ * arguments (arguments not starting with - and that are not values to options)
|
|
+ * it moves later options and values in front of the non-option arguments.
|
|
+ * This permuting is turned off by setting enable_permute to 0. Then
|
|
+ * get_option() will return options and non-option arguments in the order
|
|
+ * found. Currently permuting is only done after an argument is completely
|
|
+ * processed so that any value can be moved with options they go with. All
|
|
+ * state information is stored in the parameters argnum, optchar,
|
|
+ * first_nonopt_arg and option_num. You should not change these after the
|
|
+ * first call to get_option(). If you need to back up to a previous arg then
|
|
+ * set argnum to that arg (remembering that args may have been permuted) and
|
|
+ * set optchar = 0 and first_nonopt_arg to the first non-option argument if
|
|
+ * permuting. After all arguments are returned the next call to get_option()
|
|
+ * returns 0. The caller can then call free_args(args) if appropriate.
|
|
+ *
|
|
+ * get_option() accepts arguments in the following forms:
|
|
+ * short options
|
|
+ * of 1 and 2 characters, e.g. a, b, cc, d, and ba, after a single
|
|
+ * leading -, as in -abccdba. In this example if 'b' is followed by 'a'
|
|
+ * it matches short option 'ba' else it is interpreted as short option
|
|
+ * b followed by another option. The character - is not legal as a
|
|
+ * short option or as part of a 2 character short option.
|
|
+ *
|
|
+ * If a short option has a value it immediately follows the option or
|
|
+ * if that option is the end of the arg then the next arg is used as
|
|
+ * the value. So if short option e has a value, it can be given as
|
|
+ * -evalue
|
|
+ * or
|
|
+ * -e value
|
|
+ * and now
|
|
+ * -e=value
|
|
+ * but now that = is optional a leading = is stripped for the first.
|
|
+ * This change allows optional short option values to be defaulted as
|
|
+ * -e=
|
|
+ * Either optional or required values can be specified. Optional values
|
|
+ * now use both forms as ignoring the later got confusing. Any
|
|
+ * non-value short options can preceed a valued short option as in
|
|
+ * -abevalue
|
|
+ * Some value types (one_char and number) allow options after the value
|
|
+ * so if oc is an option that takes a character and n takes a number
|
|
+ * then
|
|
+ * -abocVccn42evalue
|
|
+ * returns value V for oc and value 42 for n. All values are strings
|
|
+ * so programs may have to convert the "42" to a number. See long
|
|
+ * options below for how value lists are handled.
|
|
+ *
|
|
+ * Any short option can be negated by following it with -. Any - is
|
|
+ * handled and skipped over before any value is read unless the option
|
|
+ * is not negatable but takes a value and then - starts the value.
|
|
+ *
|
|
+ * If the value for an optional value is just =, then treated as no
|
|
+ * value.
|
|
+ *
|
|
+ * long options
|
|
+ * of arbitrary length are assumed if an arg starts with -- but is not
|
|
+ * exactly --. Long options are given one per arg and can be abbreviated
|
|
+ * if the abbreviation uniquely matches one of the long options.
|
|
+ * Exact matches always match before partial matches. If ambiguous an
|
|
+ * error is generated.
|
|
+ *
|
|
+ * Values are specified either in the form
|
|
+ * --longoption=value
|
|
+ * or can be the following arg if the value is required as in
|
|
+ * --longoption value
|
|
+ * Optional values to long options must be in the first form.
|
|
+ *
|
|
+ * Value lists are specified by o_VALUE_LIST and consist of an option
|
|
+ * that takes a value followed by one or more value arguments.
|
|
+ * The two forms are
|
|
+ * --option=value
|
|
+ * or
|
|
+ * -ovalue
|
|
+ * for a single value or
|
|
+ * --option value1 value2 value3 ... --option2
|
|
+ * or
|
|
+ * -o value1 value2 value3 ...
|
|
+ * for a list of values. The list ends at the next option, the
|
|
+ * end of the command line, or at a single "@" argument.
|
|
+ * Each value is treated as if it was preceeded by the option, so
|
|
+ * --option1 val1 val2
|
|
+ * with option1 value_type set to o_VALUE_LIST is the same as
|
|
+ * --option1=val1 --option1=val2
|
|
+ *
|
|
+ * Long options can be negated by following the option with - as in
|
|
+ * --longoption-
|
|
+ * Long options with values can also be negated if this makes sense for
|
|
+ * the caller as:
|
|
+ * --longoption-=value
|
|
+ * If = is not followed by anything it is treated as no value.
|
|
+ *
|
|
+ * @path
|
|
+ * Argument files support removed from this version. It may be added
|
|
+ * back later.
|
|
+ *
|
|
+ * non-option argument
|
|
+ * is any argument not given above. If enable_permute is 1 then
|
|
+ * these are returned after all options, otherwise all options and
|
|
+ * args are returned in order. Returns option ID o_NON_OPTION_ARG
|
|
+ * and sets value to the argument.
|
|
+ *
|
|
+ *
|
|
+ * Arguments to get_option:
|
|
+ * int option_group - either UZO for UnZip or ZIO for ZipInfo
|
|
+ * char ***pargs - pointer to arg array in the argv form
|
|
+ * int *argc - returns the current argc for args incl. args[0]
|
|
+ * int *argnum - the index of the current argument (caller
|
|
+ * should set = 0 on first call and not change
|
|
+ * after that)
|
|
+ * int *optchar - index of next short opt in arg or special
|
|
+ * int *first_nonopt_arg - used by get_option to permute args
|
|
+ * int *negated - option was negated (had trailing -)
|
|
+ * char *value - value of option if any (free when done with it)
|
|
+ * or NULL
|
|
+ * int *option_num - the index in options of the last option returned
|
|
+ * (can be o_NO_OPTION_MATCH)
|
|
+ * int recursion_depth - current depth of recursion
|
|
+ * (always set to 0 by caller)
|
|
+ * (always 0 with argument files support removed)
|
|
+ *
|
|
+ * Caller should only read the returned option ID and the value, negated,
|
|
+ * and option_num (if required) parameters after each call.
|
|
+ *
|
|
+ * Ed Gordon
|
|
+ * 8/24/2003 (last updated 3/1/2008 EG)
|
|
+ *
|
|
+ */
|
|
+
|
|
+unsigned long get_option(option_group, pargs, argc, argnum, optchar, value,
|
|
+ negated, first_nonopt_arg, option_num, recursion_depth)
|
|
+ int option_group;
|
|
+ char ***pargs;
|
|
+ int *argc;
|
|
+ int *argnum;
|
|
+ int *optchar;
|
|
+ char **value;
|
|
+ int *negated;
|
|
+ int *first_nonopt_arg;
|
|
+ int *option_num;
|
|
+ int recursion_depth;
|
|
+{
|
|
+ char **args;
|
|
+ unsigned long option_ID;
|
|
+
|
|
+ int argcnt;
|
|
+ int first_nonoption_arg;
|
|
+ char *arg = NULL;
|
|
+ int h;
|
|
+ int optc;
|
|
+ int argn;
|
|
+ int j;
|
|
+ int v;
|
|
+ int read_rest_args_verbatim = 0; /* 7/25/04 - ignore options and arg files for rest args */
|
|
+
|
|
+ /* caller should free value or assign it to another
|
|
+ variable before calling get_option again. */
|
|
+ *value = NULL;
|
|
+
|
|
+ /* if args is NULL then done */
|
|
+ if (pargs == NULL) {
|
|
+ *argc = 0;
|
|
+ return 0;
|
|
+ }
|
|
+ args = *pargs;
|
|
+ if (args == NULL) {
|
|
+ *argc = 0;
|
|
+ return 0;
|
|
+ }
|
|
+
|
|
+ /* count args */
|
|
+ for (argcnt = 0; args[argcnt]; argcnt++) ;
|
|
+
|
|
+ /* if no provided args then nothing to do */
|
|
+ if (argcnt < 1 || (recursion_depth == 0 && argcnt < 2)) {
|
|
+ *argc = argcnt;
|
|
+ /* return 0 to note that no args are left */
|
|
+ return 0;
|
|
+ }
|
|
+
|
|
+ *negated = 0;
|
|
+ first_nonoption_arg = *first_nonopt_arg;
|
|
+ argn = *argnum;
|
|
+ optc = *optchar;
|
|
+
|
|
+ if (optc == READ_REST_ARGS_VERBATIM) {
|
|
+ read_rest_args_verbatim = 1;
|
|
+ }
|
|
+
|
|
+ if (argn == -1 || (recursion_depth == 0 && argn == 0)) {
|
|
+ /* first call */
|
|
+ /* if depth = 0 then args[0] is argv[0] so skip */
|
|
+ *option_num = o_NO_OPTION_MATCH;
|
|
+ optc = THIS_ARG_DONE;
|
|
+ first_nonoption_arg = -1;
|
|
+ }
|
|
+
|
|
+ /* if option_num is set then restore last option_ID in case continuing
|
|
+ value list */
|
|
+ option_ID = 0;
|
|
+ if (*option_num != o_NO_OPTION_MATCH) {
|
|
+ option_ID = options[*option_num].option_ID;
|
|
+ }
|
|
+
|
|
+ /* get next option if any */
|
|
+ for (;;) {
|
|
+ if (read_rest_args_verbatim) {
|
|
+ /* rest of args after "--" are non-option args if doubledash_ends_options
|
|
+ set */
|
|
+ argn++;
|
|
+ if (argn > argcnt || args[argn] == NULL) {
|
|
+ /* done */
|
|
+ option_ID = 0;
|
|
+ break;
|
|
+ }
|
|
+ arg = args[argn];
|
|
+ if ((*value = (char *)malloc(strlen(arg) + 1)) == NULL) {
|
|
+ oWARN("memory - go");
|
|
+ return o_BAD_ERR;
|
|
+ }
|
|
+ strcpy(*value, arg);
|
|
+ *option_num = o_NO_OPTION_MATCH;
|
|
+ option_ID = o_NON_OPTION_ARG;
|
|
+ break;
|
|
+
|
|
+ /* permute non-option args after option args so options are returned
|
|
+ first */
|
|
+ } else if (enable_permute) {
|
|
+ if (optc == SKIP_VALUE_ARG || optc == THIS_ARG_DONE ||
|
|
+ optc == START_VALUE_LIST || optc == IN_VALUE_LIST ||
|
|
+ optc == STOP_VALUE_LIST) {
|
|
+ /* moved to new arg */
|
|
+ if (first_nonoption_arg > -1 && args[first_nonoption_arg]) {
|
|
+ /* do the permuting - move non-options after this option */
|
|
+ /* if option and value separate args or starting list skip option */
|
|
+ if (optc == SKIP_VALUE_ARG || optc == START_VALUE_LIST) {
|
|
+ v = 1;
|
|
+ } else {
|
|
+ v = 0;
|
|
+ }
|
|
+ for (h = first_nonoption_arg; h < argn; h++) {
|
|
+ arg = args[first_nonoption_arg];
|
|
+ for (j = first_nonoption_arg; j < argn + v; j++) {
|
|
+ args[j] = args[j + 1];
|
|
+ }
|
|
+ args[j] = arg;
|
|
+ }
|
|
+ first_nonoption_arg += 1 + v;
|
|
+ }
|
|
+ }
|
|
+ } else if (optc == NON_OPTION_ARG) {
|
|
+ /* if not permuting then already returned arg */
|
|
+ optc = THIS_ARG_DONE;
|
|
+ }
|
|
+
|
|
+ /* value lists */
|
|
+ if (optc == STOP_VALUE_LIST) {
|
|
+ optc = THIS_ARG_DONE;
|
|
+ }
|
|
+
|
|
+ if (optc == START_VALUE_LIST || optc == IN_VALUE_LIST) {
|
|
+ if (optc == START_VALUE_LIST) {
|
|
+ /* already returned first value */
|
|
+ argn++;
|
|
+ optc = IN_VALUE_LIST;
|
|
+ }
|
|
+ argn++;
|
|
+ arg = args[argn];
|
|
+ /* if end of args and still in list and there are non-option args then
|
|
+ terminate list */
|
|
+ if (arg == NULL && (optc == START_VALUE_LIST || optc == IN_VALUE_LIST)
|
|
+ && first_nonoption_arg > -1) {
|
|
+ /* terminate value list with @ */
|
|
+ /* this is only needed for argument files */
|
|
+ /* but is also good for show command line so command lines with lists
|
|
+ can always be read back in */
|
|
+ argcnt = insert_arg(&args, "@", first_nonoption_arg, 1);
|
|
+ argn++;
|
|
+ if (first_nonoption_arg > -1) {
|
|
+ first_nonoption_arg++;
|
|
+ }
|
|
+ }
|
|
+
|
|
+ arg = args[argn];
|
|
+ if (arg && arg[0] == '@' && arg[1] == '\0') {
|
|
+ /* inserted arguments terminator */
|
|
+ optc = STOP_VALUE_LIST;
|
|
+ continue;
|
|
+ } else if (arg && arg[0] != '-') { /* not option */
|
|
+ /* - and -- are not allowed in value lists unless escaped */
|
|
+ /* another value in value list */
|
|
+ if ((*value = (char *)malloc(strlen(args[argn]) + 1)) == NULL) {
|
|
+ oWARN("memory - go");
|
|
+ return o_BAD_ERR;
|
|
+ }
|
|
+ strcpy(*value, args[argn]);
|
|
+ break;
|
|
+
|
|
+ } else {
|
|
+ argn--;
|
|
+ optc = THIS_ARG_DONE;
|
|
+ }
|
|
+ }
|
|
+
|
|
+ /* move to next arg */
|
|
+ if (optc == SKIP_VALUE_ARG) {
|
|
+ argn += 2;
|
|
+ optc = 0;
|
|
+ } else if (optc == THIS_ARG_DONE) {
|
|
+ argn++;
|
|
+ optc = 0;
|
|
+ }
|
|
+ if (argn > argcnt) {
|
|
+ break;
|
|
+ }
|
|
+ if (args[argn] == NULL) {
|
|
+ /* done unless permuting and non-option args */
|
|
+ if (first_nonoption_arg > -1 && args[first_nonoption_arg]) {
|
|
+ /* return non-option arguments at end */
|
|
+ if (optc == NON_OPTION_ARG) {
|
|
+ first_nonoption_arg++;
|
|
+ }
|
|
+ /* after first pass args are permuted but skipped over non-option
|
|
+ args */
|
|
+ /* swap so argn points to first non-option arg */
|
|
+ j = argn;
|
|
+ argn = first_nonoption_arg;
|
|
+ first_nonoption_arg = j;
|
|
+ }
|
|
+ if (argn > argcnt || args[argn] == NULL) {
|
|
+ /* done */
|
|
+ option_ID = 0;
|
|
+ break;
|
|
+ }
|
|
+ }
|
|
+
|
|
+ /* after swap first_nonoption_arg points to end which is NULL */
|
|
+ if (first_nonoption_arg > -1 && (args[first_nonoption_arg] == NULL)) {
|
|
+ /* only non-option args left */
|
|
+ if (optc == NON_OPTION_ARG) {
|
|
+ argn++;
|
|
+ }
|
|
+ if (argn > argcnt || args[argn] == NULL) {
|
|
+ /* done */
|
|
+ option_ID = 0;
|
|
+ break;
|
|
+ }
|
|
+ if ((*value = (char *)malloc(strlen(args[argn]) + 1)) == NULL) {
|
|
+ oWARN("memory - go");
|
|
+ return o_BAD_ERR;
|
|
+ }
|
|
+ strcpy(*value, args[argn]);
|
|
+ optc = NON_OPTION_ARG;
|
|
+ option_ID = o_NON_OPTION_ARG;
|
|
+ break;
|
|
+ }
|
|
+
|
|
+ arg = args[argn];
|
|
+
|
|
+ /* is it an option */
|
|
+ if (arg[0] == '-') {
|
|
+ /* option */
|
|
+ if (arg[1] == '\0') {
|
|
+ /* arg = - */
|
|
+ /* treat like non-option arg */
|
|
+ *option_num = o_NO_OPTION_MATCH;
|
|
+ if (enable_permute) {
|
|
+ /* permute args to move all non-option args to end */
|
|
+ if (first_nonoption_arg < 0) {
|
|
+ first_nonoption_arg = argn;
|
|
+ }
|
|
+ argn++;
|
|
+ } else {
|
|
+ /* not permute args so return non-option args when found */
|
|
+ if ((*value = (char *)malloc(strlen(arg) + 1)) == NULL) {
|
|
+ oWARN("memory - go");
|
|
+ return o_BAD_ERR;
|
|
+ }
|
|
+ strcpy(*value, arg);
|
|
+ optc = NON_OPTION_ARG;
|
|
+ option_ID = o_NON_OPTION_ARG;
|
|
+ break;
|
|
+ }
|
|
+
|
|
+ } else if (arg[1] == '-') {
|
|
+ /* long option */
|
|
+ if (arg[2] == '\0') {
|
|
+ /* arg = -- */
|
|
+ if (doubledash_ends_options) {
|
|
+ /* Now -- stops permuting and forces the rest of
|
|
+ the command line to be read verbatim - 7/25/04 EG */
|
|
+
|
|
+ /* never permute args after -- and return as non-option args */
|
|
+ if (first_nonoption_arg < 1) {
|
|
+ /* -- is first non-option argument - 8/7/04 EG */
|
|
+ argn--;
|
|
+ } else {
|
|
+ /* go back to start of non-option args - 8/7/04 EG */
|
|
+ argn = first_nonoption_arg - 1;
|
|
+ }
|
|
+
|
|
+ /* disable permuting and treat remaining arguments as not
|
|
+ options */
|
|
+ read_rest_args_verbatim = 1;
|
|
+ optc = READ_REST_ARGS_VERBATIM;
|
|
+
|
|
+ } else {
|
|
+ /* treat like non-option arg */
|
|
+ *option_num = o_NO_OPTION_MATCH;
|
|
+ if (enable_permute) {
|
|
+ /* permute args to move all non-option args to end */
|
|
+ if (first_nonoption_arg < 0) {
|
|
+ first_nonoption_arg = argn;
|
|
+ }
|
|
+ argn++;
|
|
+ } else {
|
|
+ /* not permute args so return non-option args when found */
|
|
+ if ((*value = (char *)malloc(strlen(arg) + 1)) == NULL) {
|
|
+ oWARN("memory - go");
|
|
+ return o_BAD_ERR;
|
|
+ }
|
|
+ strcpy(*value, arg);
|
|
+ optc = NON_OPTION_ARG;
|
|
+ option_ID = o_NON_OPTION_ARG;
|
|
+ break;
|
|
+ }
|
|
+ }
|
|
+
|
|
+ } else {
|
|
+ option_ID = get_longopt(option_group, (ZCONST char **)args, argn,
|
|
+ &optc, negated,
|
|
+ value, option_num, recursion_depth);
|
|
+ if (option_ID == o_BAD_ERR) {
|
|
+ return o_BAD_ERR;
|
|
+ } else if (option_ID == o_ARG_FILE_ERR) {
|
|
+ /* unwind as only get this if recursion_depth > 0 */
|
|
+ return option_ID;
|
|
+ }
|
|
+ break;
|
|
+ }
|
|
+
|
|
+ } else {
|
|
+ /* short option */
|
|
+ option_ID = get_shortopt(option_group, (ZCONST char **)args, argn,
|
|
+ &optc, negated,
|
|
+ value, option_num, recursion_depth);
|
|
+
|
|
+ if (option_ID == o_BAD_ERR) {
|
|
+ return o_BAD_ERR;
|
|
+ } else if (option_ID == o_ARG_FILE_ERR) {
|
|
+ /* unwind as only get this if recursion_depth > 0 */
|
|
+ return option_ID;
|
|
+ }
|
|
+
|
|
+ if (optc == 0) {
|
|
+ /* if optc = 0 then ran out of short opts this arg */
|
|
+ optc = THIS_ARG_DONE;
|
|
+ } else {
|
|
+ break;
|
|
+ }
|
|
+ }
|
|
+
|
|
+#if 0
|
|
+ /* argument file code left out
|
|
+ so for now let filenames start with @
|
|
+ */
|
|
+
|
|
+ } else if (allow_arg_files && arg[0] == '@') {
|
|
+ /* arg file */
|
|
+ oERR(PK_PARMS, no_arg_files_err);
|
|
+#endif
|
|
+
|
|
+ } else {
|
|
+ /* non-option */
|
|
+ if (enable_permute) {
|
|
+ /* permute args to move all non-option args to end */
|
|
+ if (first_nonoption_arg < 0) {
|
|
+ first_nonoption_arg = argn;
|
|
+ }
|
|
+ argn++;
|
|
+ } else {
|
|
+ /* no permute args so return non-option args when found */
|
|
+ if ((*value = (char *)malloc(strlen(arg) + 1)) == NULL) {
|
|
+ oWARN("memory - go");
|
|
+ return o_BAD_ERR;
|
|
+ }
|
|
+ strcpy(*value, arg);
|
|
+ *option_num = o_NO_OPTION_MATCH;
|
|
+ optc = NON_OPTION_ARG;
|
|
+ option_ID = o_NON_OPTION_ARG;
|
|
+ break;
|
|
+ }
|
|
+
|
|
+ }
|
|
+ }
|
|
+
|
|
+ *pargs = args;
|
|
+ *argc = argcnt;
|
|
+ *first_nonopt_arg = first_nonoption_arg;
|
|
+ *argnum = argn;
|
|
+ *optchar = optc;
|
|
+
|
|
+ return option_ID;
|
|
+}
|
|
diff -ru2 unz60e03/unzpriv.h u6e3_np/unzpriv.h
|
|
--- unz60e03/unzpriv.h Mon Mar 24 11:53:24 2008
|
|
+++ u6e3_np/unzpriv.h Mon Mar 24 14:13:02 2008
|
|
@@ -1271,4 +1271,89 @@
|
|
#endif
|
|
|
|
+
|
|
+/*--------------------------------------------------------------------
|
|
+ Long option support
|
|
+ 23 August 2003
|
|
+ Updated for UnZip 1 March 2008
|
|
+ See unzip.c
|
|
+ --------------------------------------------------------------------*/
|
|
+
|
|
+/* The below is for use in the caller-provided options table */
|
|
+
|
|
+/* option groups */
|
|
+#define UZO 1 /* UnZip option */
|
|
+#define ZIO 2 /* ZipInfo option */
|
|
+
|
|
+
|
|
+/* value_type - value is always returned as a string. */
|
|
+#define o_NO_VALUE 0 /* this option does not take a value */
|
|
+#define o_REQUIRED_VALUE 1 /* this option requires a value */
|
|
+#define o_OPTIONAL_VALUE 2 /* value is optional (see get_option() for details) */
|
|
+#define o_VALUE_LIST 3 /* this option takes a list of values */
|
|
+#define o_ONE_CHAR_VALUE 4 /* next char is value (does not end short opt string) */
|
|
+#define o_NUMBER_VALUE 5 /* value is integer (does not end short opt string) */
|
|
+
|
|
+
|
|
+/* negatable - a dash following the option (but before any value) sets negated. */
|
|
+#define o_NOT_NEGATABLE 0 /* trailing '-' to negate either starts value or generates error */
|
|
+#define o_NEGATABLE 1 /* trailing '-' sets negated to TRUE */
|
|
+
|
|
+
|
|
+/* option_num can be this when option not in options table */
|
|
+#define o_NO_OPTION_MATCH -1
|
|
+
|
|
+/* special values returned by get_option - do not use these as option IDs */
|
|
+#define o_NON_OPTION_ARG ((unsigned long) 0xFFFF) /* returned for non-option
|
|
+ args */
|
|
+#define o_ARG_FILE_ERR ((unsigned long) 0xFFFE) /* internal recursion
|
|
+ return (user never sees) */
|
|
+#define o_BAD_ERR ((unsigned long) 0xFFFD) /* bad error */
|
|
+
|
|
+/* options array is set in unzip.c */
|
|
+struct option_struct {
|
|
+ int option_group; /* either UZO for UnZip or ZIO for ZipInfo syntax */
|
|
+ char Far *shortopt; /* pointer to short option string */
|
|
+ char Far *longopt; /* pointer to long option string */
|
|
+ int value_type; /* from above */
|
|
+ int negatable; /* from above */
|
|
+ unsigned long option_ID; /* value returned by get_option when this option
|
|
+ is found */
|
|
+ char Far *name; /* optional string for option returned on some
|
|
+ errors */
|
|
+};
|
|
+
|
|
+/* structure used to create -x and include file lists */
|
|
+struct file_list {
|
|
+ char *name;
|
|
+ struct file_list *next;
|
|
+};
|
|
+
|
|
+
|
|
+/* function prototypes */
|
|
+
|
|
+/* get the next option from args */
|
|
+unsigned long get_option OF((int option_group,
|
|
+ char ***pargs, int *argc, int *argnum,
|
|
+ int *optchar,
|
|
+ char **value, int *negated, int *first_nonopt_arg,
|
|
+ int *option_num, int recursion_depth));
|
|
+
|
|
+/* copy args - copy an args array, allocating space as needed */
|
|
+char **copy_args OF((char **args, int max_args));
|
|
+
|
|
+/* arg count - count args in argv like array */
|
|
+int arg_count OF((char **args));
|
|
+
|
|
+/* free args - free args created with one of these functions */
|
|
+int free_args OF((char **args));
|
|
+
|
|
+/* insert arg - copy an arg into args */
|
|
+int insert_arg OF((char ***args, ZCONST char *arg, int insert_at,
|
|
+ int free_args));
|
|
+
|
|
+/*--------------------------------------------------------------------
|
|
+ End of Long option support
|
|
+ --------------------------------------------------------------------*/
|
|
+
|
|
/***********************************/
|
|
/* LARGE_FILE_SUPPORT */
|
|
diff -ru2 unz60e03/vms/cmdline.c u6e3_np/vms/cmdline.c
|
|
--- unz60e03/vms/cmdline.c Tue Feb 12 01:37:42 2008
|
|
+++ u6e3_np/vms/cmdline.c Mon Mar 24 14:13:10 2008
|
|
@@ -34,4 +34,6 @@
|
|
** Modified by:
|
|
**
|
|
+** 02-014 E. Gordon 10-Mar-2008 03:12
|
|
+** Modified to work with get_options().
|
|
** 02-013 S. Schweda, C. Spieler 29-Dec-2007 03:34
|
|
** Extended /RESTORE qualifier to support timestamp restoration
|
|
@@ -172,10 +174,10 @@
|
|
$DESCRIPTOR(cli_text_auto, "TEXT.AUTO"); /* -a */
|
|
$DESCRIPTOR(cli_text_all, "TEXT.ALL"); /* -aa */
|
|
-$DESCRIPTOR(cli_text_none, "TEXT.NONE"); /* ---a */
|
|
+$DESCRIPTOR(cli_text_none, "TEXT.NONE"); /* -a- */
|
|
$DESCRIPTOR(cli_text_stmlf, "TEXT.STMLF"); /* -S */
|
|
$DESCRIPTOR(cli_binary, "BINARY"); /* -b[b] */
|
|
$DESCRIPTOR(cli_binary_auto, "BINARY.AUTO"); /* -b */
|
|
$DESCRIPTOR(cli_binary_all, "BINARY.ALL"); /* -bb */
|
|
-$DESCRIPTOR(cli_binary_none, "BINARY.NONE"); /* ---b */
|
|
+$DESCRIPTOR(cli_binary_none, "BINARY.NONE"); /* -b- */
|
|
$DESCRIPTOR(cli_case_insensitive,"CASE_INSENSITIVE"); /* -C */
|
|
$DESCRIPTOR(cli_screen, "SCREEN"); /* -c */
|
|
@@ -202,5 +204,5 @@
|
|
$DESCRIPTOR(cli_restore_own, "RESTORE.OWNER_PROT"); /* -X */
|
|
$DESCRIPTOR(cli_restore_date, "RESTORE.DATE"); /* -DD */
|
|
-$DESCRIPTOR(cli_restore_date_all, "RESTORE.DATE.ALL"); /* --D */
|
|
+$DESCRIPTOR(cli_restore_date_all, "RESTORE.DATE.ALL"); /* -D- */
|
|
$DESCRIPTOR(cli_restore_date_files, "RESTORE.DATE.FILES"); /* -D */
|
|
$DESCRIPTOR(cli_dot_version, "DOT_VERSION"); /* -Y */
|
|
@@ -299,4 +301,6 @@
|
|
** SS$_ABORT - Bad time value
|
|
**
|
|
+** Modified to work with the get_option() command line parser. 10 March 2008
|
|
+**
|
|
*/
|
|
register unsigned long status;
|
|
@@ -419,5 +423,4 @@
|
|
if (status != CLI$_ABSENT) {
|
|
*ptr++ = '-';
|
|
- *ptr++ = '-';
|
|
*ptr++ = 'b';
|
|
if ((status & 1) &&
|
|
@@ -427,4 +430,5 @@
|
|
*ptr++ = 'b';
|
|
}
|
|
+ *ptr++ = '-';
|
|
}
|
|
|
|
@@ -436,5 +440,4 @@
|
|
if (status != CLI$_ABSENT) {
|
|
*ptr++ = '-';
|
|
- *ptr++ = '-';
|
|
*ptr++ = 'a';
|
|
if ((status & 1) &&
|
|
@@ -446,4 +449,5 @@
|
|
*ptr++ = 'S';
|
|
}
|
|
+ *ptr++ = '-';
|
|
}
|
|
|
|
diff -ru2 unz60e03/zipinfo.c u6e3_np/zipinfo.c
|
|
--- unz60e03/zipinfo.c Mon Mar 24 14:23:54 2008
|
|
+++ u6e3_np/zipinfo.c Mon Mar 24 14:25:24 2008
|
|
@@ -171,4 +171,6 @@
|
|
static ZCONST char Far ZipfileCommTruncMsg[] =
|
|
"\ncaution: zipfile comment truncated\n";
|
|
+static ZCONST char Far NoMemArguments[] =
|
|
+ "envargs: cannot get memory for arguments";
|
|
|
|
static ZCONST char Far CentralDirEntry[] =
|
|
@@ -459,10 +461,48 @@
|
|
__GDEF
|
|
{
|
|
- char **argv, *s;
|
|
- int argc, c, error=FALSE, negative=0;
|
|
+ int argc, error=FALSE;
|
|
int hflag_slmv=TRUE, hflag_2=FALSE; /* diff options => diff defaults */
|
|
int tflag_slm=TRUE, tflag_2v=FALSE;
|
|
int explicit_h=FALSE, explicit_t=FALSE;
|
|
|
|
+ char **args;
|
|
+
|
|
+
|
|
+ /* used by get_option */
|
|
+ unsigned long option; /* option ID returned by get_option */
|
|
+ int argcnt = 0; /* current argcnt in args */
|
|
+ int argnum = 0; /* arg number */
|
|
+ int optchar = 0; /* option state */
|
|
+ char *value = NULL; /* non-option arg, option value or NULL */
|
|
+ int negative = 0; /* 1 = option negated */
|
|
+ int fna = 0; /* current first non-opt arg */
|
|
+ int optnum = 0; /* index in table */
|
|
+
|
|
+
|
|
+ /* since get_option() returns xfiles and files one at a time, store them in
|
|
+ linked lists until have them all */
|
|
+
|
|
+ int file_count;
|
|
+ struct file_list *next_file;
|
|
+
|
|
+ /* files to extract */
|
|
+ int in_files_count = 0;
|
|
+ struct file_list *in_files = NULL;
|
|
+ struct file_list *next_in_files = NULL;
|
|
+
|
|
+ /* files to exclude in -x list */
|
|
+ int in_xfiles_count = 0;
|
|
+ struct file_list *in_xfiles = NULL;
|
|
+ struct file_list *next_in_xfiles = NULL;
|
|
+
|
|
+ G.wildzipfn = NULL;
|
|
+
|
|
+ /* make copy of args that can use with insert_arg() used by get_option() */
|
|
+ args = copy_args(*pargv, 0);
|
|
+
|
|
+
|
|
+ /* Initialize lists */
|
|
+ G.filespecs = 0;
|
|
+ G.xfilespecs = 0;
|
|
|
|
#ifdef MACOS
|
|
@@ -470,17 +510,41 @@
|
|
#endif
|
|
G.extract_flag = FALSE; /* zipinfo does not extract to disk */
|
|
- argc = *pargc;
|
|
- argv = *pargv;
|
|
|
|
- while (--argc > 0 && (*++argv)[0] == '-') {
|
|
- s = argv[0] + 1;
|
|
- while ((c = *s++) != 0) { /* "!= 0": prevent Turbo C warning */
|
|
- switch (c) {
|
|
- case '-':
|
|
- ++negative;
|
|
- break;
|
|
+
|
|
+ /*
|
|
+ -------------------------------------------
|
|
+ Process command line using get_option
|
|
+ -------------------------------------------
|
|
+
|
|
+ Each call to get_option() returns either a command
|
|
+ line option and possible value or a non-option argument.
|
|
+ Arguments are permuted so that all options (-r, -b temp)
|
|
+ are returned before non-option arguments (zipfile).
|
|
+ Returns 0 when nothing left to read.
|
|
+ */
|
|
+
|
|
+ /* set argnum = 0 on first call to init get_option */
|
|
+ argnum = 0;
|
|
+
|
|
+ /* get_option returns the option ID and updates parameters:
|
|
+ args - usually same as argv if no argument file support
|
|
+ argcnt - current argc for args
|
|
+ value - char* to value (free() when done with it) or NULL if no value
|
|
+ negated - option was negated with trailing -
|
|
+ */
|
|
+
|
|
+ while ((option = get_option(ZIO, &args, &argcnt, &argnum,
|
|
+ &optchar, &value, &negative,
|
|
+ &fna, &optnum, 0)))
|
|
+ {
|
|
+ if(option == o_BAD_ERR) {
|
|
+ return(PK_PARAM);
|
|
+ }
|
|
+
|
|
+ switch (option)
|
|
+ {
|
|
case '1': /* shortest listing: JUST filenames */
|
|
if (negative)
|
|
- uO.lflag = -2, negative = 0;
|
|
+ uO.lflag = -2;
|
|
else
|
|
uO.lflag = 1;
|
|
@@ -488,5 +552,5 @@
|
|
case '2': /* just filenames, plus headers if specified */
|
|
if (negative)
|
|
- uO.lflag = -2, negative = 0;
|
|
+ uO.lflag = -2;
|
|
else
|
|
uO.lflag = 2;
|
|
@@ -495,5 +559,5 @@
|
|
case ('C'): /* -C: match filenames case-insensitively */
|
|
if (negative)
|
|
- uO.C_flag = FALSE, negative = 0;
|
|
+ uO.C_flag = FALSE;
|
|
else
|
|
uO.C_flag = TRUE;
|
|
@@ -502,5 +566,5 @@
|
|
case 'h': /* header line */
|
|
if (negative)
|
|
- hflag_2 = hflag_slmv = FALSE, negative = 0;
|
|
+ hflag_2 = hflag_slmv = FALSE;
|
|
else {
|
|
hflag_2 = hflag_slmv = explicit_h = TRUE;
|
|
@@ -511,5 +575,5 @@
|
|
case 'l': /* longer form of "ls -l" type listing */
|
|
if (negative)
|
|
- uO.lflag = -2, negative = 0;
|
|
+ uO.lflag = -2;
|
|
else
|
|
uO.lflag = 5;
|
|
@@ -517,5 +581,5 @@
|
|
case 'm': /* medium form of "ls -l" type listing */
|
|
if (negative)
|
|
- uO.lflag = -2, negative = 0;
|
|
+ uO.lflag = -2;
|
|
else
|
|
uO.lflag = 4;
|
|
@@ -524,5 +588,5 @@
|
|
case 'M': /* send output through built-in "more" */
|
|
if (negative)
|
|
- G.M_flag = FALSE, negative = 0;
|
|
+ G.M_flag = FALSE;
|
|
else
|
|
G.M_flag = TRUE;
|
|
@@ -531,5 +595,5 @@
|
|
case 's': /* default: shorter "ls -l" type listing */
|
|
if (negative)
|
|
- uO.lflag = -2, negative = 0;
|
|
+ uO.lflag = -2;
|
|
else
|
|
uO.lflag = 3;
|
|
@@ -537,5 +601,5 @@
|
|
case 't': /* totals line */
|
|
if (negative)
|
|
- tflag_2v = tflag_slm = FALSE, negative = 0;
|
|
+ tflag_2v = tflag_slm = FALSE;
|
|
else {
|
|
tflag_2v = tflag_slm = explicit_t = TRUE;
|
|
@@ -546,5 +610,5 @@
|
|
case ('T'): /* use (sortable) decimal time format */
|
|
if (negative)
|
|
- uO.T_flag = FALSE, negative = 0;
|
|
+ uO.T_flag = FALSE;
|
|
else
|
|
uO.T_flag = TRUE;
|
|
@@ -552,8 +616,7 @@
|
|
#ifdef UNICODE_SUPPORT
|
|
case ('U'): /* escape UTF-8, or disable UTF-8 support */
|
|
- if (negative) {
|
|
- uO.U_flag = MAX(uO.U_flag-negative,0);
|
|
- negative = 0;
|
|
- } else
|
|
+ if (negative)
|
|
+ uO.U_flag = MAX(uO.U_flag - 1, 0);
|
|
+ else
|
|
uO.U_flag++;
|
|
break;
|
|
@@ -561,5 +624,5 @@
|
|
case 'v': /* turbo-verbose listing */
|
|
if (negative)
|
|
- uO.lflag = -2, negative = 0;
|
|
+ uO.lflag = -2;
|
|
else
|
|
uO.lflag = 10;
|
|
@@ -568,12 +631,36 @@
|
|
case ('W'): /* Wildcard interpretation (stop at '/'?) */
|
|
if (negative)
|
|
- uO.W_flag = FALSE, negative = 0;
|
|
+ uO.W_flag = FALSE;
|
|
else
|
|
uO.W_flag = TRUE;
|
|
break;
|
|
#endif /* WILD_STOP_AT_DIR */
|
|
+ case ('x'): /* extract: default */
|
|
+ /* add -x file to linked list */
|
|
+
|
|
+ if (in_xfiles_count == 0) {
|
|
+ /* first entry */
|
|
+ if ((in_xfiles = (struct file_list *) malloc(sizeof(struct file_list))) == NULL) {
|
|
+ Info(slide, 0x401, ((char *)slide, LoadFarString(NoMemArguments)));
|
|
+ return PK_MEM;
|
|
+ }
|
|
+ in_xfiles->name = value;
|
|
+ in_xfiles->next = NULL;
|
|
+ next_in_xfiles = in_xfiles;
|
|
+ } else {
|
|
+ /* add next entry */
|
|
+ if ((next_file = (struct file_list *) malloc(sizeof(struct file_list))) == NULL) {
|
|
+ Info(slide, 0x401, ((char *)slide, LoadFarString(NoMemArguments)));
|
|
+ return PK_MEM;
|
|
+ }
|
|
+ next_in_xfiles->next = next_file;
|
|
+ next_file->name = value;
|
|
+ next_file->next = NULL;
|
|
+ next_in_xfiles = next_file;
|
|
+ }
|
|
+ in_xfiles_count++;
|
|
case 'z': /* print zipfile comment */
|
|
if (negative)
|
|
- uO.zflag = negative = 0;
|
|
+ uO.zflag = 0;
|
|
else
|
|
uO.zflag = 1;
|
|
@@ -581,13 +668,96 @@
|
|
case 'Z': /* ZipInfo mode: ignore */
|
|
break;
|
|
+ case o_NON_OPTION_ARG:
|
|
+ /* not an option */
|
|
+ /* no more options as permuting */
|
|
+
|
|
+
|
|
+ if (G.wildzipfn == NULL) {
|
|
+ /* first non-option argument is zip file */
|
|
+ G.wildzipfn = value;
|
|
+
|
|
+ } else {
|
|
+ /* add include file to list */
|
|
+ if (in_files_count == 0) {
|
|
+ /* first entry */
|
|
+ if ((next_file = (struct file_list *) malloc(sizeof(struct file_list))) == NULL) {
|
|
+ Info(slide, 0x401, ((char *)slide, LoadFarString(NoMemArguments)));
|
|
+ return PK_MEM;
|
|
+ }
|
|
+ next_file->name = value;
|
|
+ next_file->next = NULL;
|
|
+ in_files = next_file;
|
|
+ next_in_files = next_file;
|
|
+ } else {
|
|
+ /* add next entry */
|
|
+ if ((next_file = (struct file_list *) malloc(sizeof(struct file_list))) == NULL) {
|
|
+ Info(slide, 0x401, ((char *)slide, LoadFarString(NoMemArguments)));
|
|
+ return PK_MEM;
|
|
+ }
|
|
+ next_in_files->next = next_file;
|
|
+ next_file->name = value;
|
|
+ next_file->next = NULL;
|
|
+ next_in_files = next_file;
|
|
+ }
|
|
+ in_files_count++;
|
|
+ }
|
|
+ break;
|
|
default:
|
|
error = TRUE;
|
|
break;
|
|
- }
|
|
- }
|
|
+ } /* switch */
|
|
+ } /* get_option() */
|
|
+
|
|
+ /* convert files and xfiles lists to arrays */
|
|
+
|
|
+ /* convert files list to array */
|
|
+ if (in_files_count) {
|
|
+ if ((G.pfnames = (char **) malloc((in_files_count + 1) * sizeof(char *))) == NULL) {
|
|
+ Info(slide, 0x401, ((char *)slide, LoadFarString(NoMemArguments)));
|
|
+ return PK_MEM;
|
|
+ }
|
|
+ file_count = 0;
|
|
+ for (next_file = in_files; next_file;) {
|
|
+ G.pfnames[file_count] = next_file->name;
|
|
+ in_files = next_file;
|
|
+ next_file = next_file->next;
|
|
+ free(in_files);
|
|
+ file_count++;
|
|
+ }
|
|
+ G.pfnames[file_count] = NULL;
|
|
+ G.filespecs = in_files_count;
|
|
+ }
|
|
+
|
|
+ /* convert xfiles list to array */
|
|
+ if (in_xfiles_count) {
|
|
+ if ((G.pxnames = (char **) malloc((in_xfiles_count + 1) * sizeof(char *))) == NULL) {
|
|
+ Info(slide, 0x401, ((char *)slide, LoadFarString(NoMemArguments)));
|
|
+ return PK_MEM;
|
|
+ }
|
|
+ file_count = 0;
|
|
+ for (next_file = in_xfiles; next_file;) {
|
|
+ G.pxnames[file_count] = next_file->name;
|
|
+ in_xfiles = next_file;
|
|
+ next_file = next_file->next;
|
|
+ free(in_xfiles);
|
|
+ file_count++;
|
|
+ }
|
|
+ G.pxnames[file_count] = NULL;
|
|
+ G.xfilespecs = in_xfiles_count;
|
|
}
|
|
- if ((argc-- == 0) || error) {
|
|
+
|
|
+ if (in_files_count || in_xfiles_count) {
|
|
+ G.process_all_files = FALSE;
|
|
+ } else {
|
|
+ G.process_all_files = TRUE; /* for speed */
|
|
+ }
|
|
+
|
|
+ /* it's possible the arg count could have been changed by get_option() */
|
|
+ argc = arg_count(args);
|
|
+
|
|
+ if ((G.wildzipfn == NULL) || error) {
|
|
+ argc = -1; /* tell the caller to stop processing */
|
|
*pargc = argc;
|
|
- *pargv = argv;
|
|
+ *pargv = args;
|
|
return USAGE(error);
|
|
}
|
|
@@ -628,5 +798,5 @@
|
|
|
|
*pargc = argc;
|
|
- *pargv = argv;
|
|
+ *pargv = args;
|
|
return 0;
|
|
|