mirror of https://github.com/lukechilds/node.git
Browse Source
This reverts commit c0e7bf2d8c.
There are a few edge cases that can cause a crash
and need to be properly handled.
PR-URL: https://github.com/nodejs/io.js/pull/1862
Reviewed-By: Ben Noordhuis <info@bnoordhuis.nl>
v2.3.1-release
Evan Lucas
10 years ago
12 changed files with 275 additions and 1227 deletions
@ -1,15 +0,0 @@ |
|||
{ |
|||
'targets': [ |
|||
{ |
|||
'target_name': 'getopt', |
|||
'type': 'static_library', |
|||
'sources': [ |
|||
'getopt.h', |
|||
'getopt_long.c' |
|||
], |
|||
'defines': [ |
|||
'REPLACE_GETOPT' |
|||
] |
|||
} |
|||
] |
|||
} |
|||
@ -1,100 +0,0 @@ |
|||
/* $NetBSD: getopt.h,v 1.4 2000/07/07 10:43:54 ad Exp $ */ |
|||
/* $FreeBSD$ */ |
|||
|
|||
/*-
|
|||
* Copyright (c) 2000 The NetBSD Foundation, Inc. |
|||
* All rights reserved. |
|||
* |
|||
* This code is derived from software contributed to The NetBSD Foundation |
|||
* by Dieter Baron and Thomas Klausner. |
|||
* |
|||
* Redistribution and use in source and binary forms, with or without |
|||
* modification, are permitted provided that the following conditions |
|||
* are met: |
|||
* 1. Redistributions of source code must retain the above copyright |
|||
* notice, this list of conditions and the following disclaimer. |
|||
* 2. Redistributions in binary form must reproduce the above copyright |
|||
* notice, this list of conditions and the following disclaimer in the |
|||
* documentation and/or other materials provided with the distribution. |
|||
* |
|||
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS |
|||
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED |
|||
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
|||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS |
|||
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
|||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
|||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
|||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
|||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
|||
* POSSIBILITY OF SUCH DAMAGE. |
|||
*/ |
|||
|
|||
#ifndef _GETOPT_H_ |
|||
#define _GETOPT_H_ |
|||
|
|||
#ifndef __BEGIN_DECLS |
|||
#ifdef __cplusplus |
|||
#define __BEGIN_DECLS extern "C" { |
|||
#define __END_DECLS } |
|||
#else |
|||
#define __BEGIN_DECLS |
|||
#define __END_DECLS |
|||
#endif /* __cplusplus */ |
|||
#endif /* __BEGIN_DECLS */ |
|||
|
|||
#ifdef WIN32 |
|||
#ifdef _MSC_VER |
|||
/* ignore MSVC++ warnings that are annoying and hard to remove:
|
|||
4702 unreachable code |
|||
(there is an unreachable assert(0) in case somehow it is reached) |
|||
*/ |
|||
#pragma warning( disable : 4702 ) |
|||
#endif |
|||
|
|||
#endif /* WIN32 */ |
|||
|
|||
/*
|
|||
* GNU-like getopt_long()/getopt_long_only() with 4.4BSD optreset extension. |
|||
* getopt() is declared here too for GNU programs. |
|||
*/ |
|||
#define no_argument 0 |
|||
#define required_argument 1 |
|||
#define optional_argument 2 |
|||
|
|||
struct option { |
|||
/* name of long option */ |
|||
const char *name; |
|||
/*
|
|||
* one of no_argument, required_argument, and optional_argument: |
|||
* whether option takes an argument |
|||
*/ |
|||
int has_arg; |
|||
/* if not NULL, set *flag to val when option found */ |
|||
int *flag; |
|||
/* if flag not NULL, value to set *flag to; else return value */ |
|||
int val; |
|||
|
|||
/* add description for usage */ |
|||
const char *desc; |
|||
}; |
|||
|
|||
__BEGIN_DECLS |
|||
extern int getopt_long(int, char * const *, const char *, |
|||
const struct option *, int *); |
|||
extern int getopt_long_only(int, char * const *, const char *, |
|||
const struct option *, int *); |
|||
#ifndef _GETOPT_DECLARED |
|||
#define _GETOPT_DECLARED |
|||
int getopt(int, char * const [], const char *); |
|||
|
|||
extern char *optarg; /* getopt(3) external variables */ |
|||
extern int optind, opterr, optopt; |
|||
#endif |
|||
#ifndef _OPTRESET_DECLARED |
|||
#define _OPTRESET_DECLARED |
|||
extern int optreset; /* getopt(3) external variable */ |
|||
#endif |
|||
__END_DECLS |
|||
|
|||
#endif /* !_GETOPT_H_ */ |
|||
@ -1,634 +0,0 @@ |
|||
/* $OpenBSD: getopt_long.c,v 1.26 2013/06/08 22:47:56 millert Exp $ */ |
|||
/* $NetBSD: getopt_long.c,v 1.15 2002/01/31 22:43:40 tv Exp $ */ |
|||
|
|||
/*
|
|||
* Copyright (c) 2002 Todd C. Miller <Todd.Miller@courtesan.com> |
|||
* |
|||
* Permission to use, copy, modify, and distribute this software for any |
|||
* purpose with or without fee is hereby granted, provided that the above |
|||
* copyright notice and this permission notice appear in all copies. |
|||
* |
|||
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES |
|||
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF |
|||
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR |
|||
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
|||
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN |
|||
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF |
|||
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
|||
* |
|||
* Sponsored in part by the Defense Advanced Research Projects |
|||
* Agency (DARPA) and Air Force Research Laboratory, Air Force |
|||
* Materiel Command, USAF, under agreement number F39502-99-1-0512. |
|||
*/ |
|||
/*-
|
|||
* Copyright (c) 2000 The NetBSD Foundation, Inc. |
|||
* All rights reserved. |
|||
* |
|||
* This code is derived from software contributed to The NetBSD Foundation |
|||
* by Dieter Baron and Thomas Klausner. |
|||
* |
|||
* Redistribution and use in source and binary forms, with or without |
|||
* modification, are permitted provided that the following conditions |
|||
* are met: |
|||
* 1. Redistributions of source code must retain the above copyright |
|||
* notice, this list of conditions and the following disclaimer. |
|||
* 2. Redistributions in binary form must reproduce the above copyright |
|||
* notice, this list of conditions and the following disclaimer in the |
|||
* documentation and/or other materials provided with the distribution. |
|||
* |
|||
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS |
|||
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED |
|||
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
|||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS |
|||
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
|||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
|||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
|||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
|||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
|||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
|||
* POSSIBILITY OF SUCH DAMAGE. |
|||
*/ |
|||
|
|||
#if 0 |
|||
#if defined(LIBC_SCCS) && !defined(lint) |
|||
static char *rcsid = "$OpenBSD: getopt_long.c,v 1.16 2004/02/04 18:17:25 millert Exp $"; |
|||
#endif /* LIBC_SCCS and not lint */ |
|||
#endif |
|||
|
|||
#include <stdio.h> |
|||
#include <errno.h> |
|||
#include "getopt.h" |
|||
#include <stdlib.h> |
|||
#include <string.h> |
|||
|
|||
#ifdef WIN32 |
|||
#include <stdarg.h> |
|||
#if !defined(GETOPT_API) |
|||
#define GETOPT_API __declspec(dllimport) |
|||
#endif |
|||
|
|||
#ifdef _MSC_VER |
|||
/* ignore MSVC++ warnings that are annoying and hard to remove:
|
|||
4702 unreachable code |
|||
(there is an unreachable assert(0) in case somehow it is reached) |
|||
*/ |
|||
#pragma warning( disable : 4702 ) |
|||
#endif |
|||
|
|||
GETOPT_API extern char opterrmsg[128]; |
|||
char opterrmsg[128]; /* last error message is stored here */ |
|||
|
|||
static void warnx(const char *fmt, ...) |
|||
{ |
|||
va_list ap; |
|||
va_start(ap, fmt); |
|||
if (fmt != NULL) |
|||
_vsnprintf(opterrmsg, 128, fmt, ap); |
|||
else |
|||
opterrmsg[0]='\0'; |
|||
va_end(ap); |
|||
fprintf(stderr, opterrmsg); |
|||
fprintf(stderr, "\n"); |
|||
} |
|||
|
|||
#else /* WIN32 */ |
|||
#include <err.h> |
|||
#endif |
|||
|
|||
#define GNU_COMPATIBLE /* Be more compatible, configure's use us! */ |
|||
|
|||
#if 0 /* we prefer to keep our getopt(3) */
|
|||
#define REPLACE_GETOPT /* use this getopt as the system getopt(3) */ |
|||
#endif |
|||
|
|||
#ifdef REPLACE_GETOPT |
|||
int opterr = 1; /* if error message should be printed */ |
|||
int optind = 1; /* index into parent argv vector */ |
|||
int optopt = '?'; /* character checked for validity */ |
|||
int optreset; /* reset getopt */ |
|||
char *optarg; /* argument associated with option */ |
|||
#endif |
|||
|
|||
#define PRINT_ERROR ((opterr) && (*options != ':')) |
|||
|
|||
#define FLAG_PERMUTE 0x01 /* permute non-options to the end of argv */ |
|||
#define FLAG_ALLARGS 0x02 /* treat non-options as args to option "-1" */ |
|||
#define FLAG_LONGONLY 0x04 /* operate as getopt_long_only */ |
|||
|
|||
/* return values */ |
|||
#define BADCH (int)'?' |
|||
#define BADARG ((*options == ':') ? (int)':' : (int)'?') |
|||
#define INORDER (int)1 |
|||
|
|||
#define EMSG "" |
|||
|
|||
#ifdef GNU_COMPATIBLE |
|||
#define NO_PREFIX (-1) |
|||
#define D_PREFIX 0 |
|||
#define DD_PREFIX 1 |
|||
#define W_PREFIX 2 |
|||
#endif |
|||
|
|||
static int getopt_internal(int, char * const *, const char *, |
|||
const struct option *, int *, int); |
|||
static int parse_long_options(char * const *, const char *, |
|||
const struct option *, int *, int, int); |
|||
static int gcd(int, int); |
|||
static void permute_args(int, int, int, char * const *); |
|||
|
|||
static char *place = EMSG; /* option letter processing */ |
|||
|
|||
/* XXX: set optreset to 1 rather than these two */ |
|||
static int nonopt_start = -1; /* first non option argument (for permute) */ |
|||
static int nonopt_end = -1; /* first option after non options (for permute) */ |
|||
|
|||
/* Error messages */ |
|||
static const char recargchar[] = "option requires an argument -- %c"; |
|||
static const char illoptchar[] = "illegal option -- %c"; /* From P1003.2 */ |
|||
#ifdef GNU_COMPATIBLE |
|||
static int dash_prefix = NO_PREFIX; |
|||
static const char gnuoptchar[] = "invalid option -- %c"; |
|||
|
|||
static const char recargstring[] = "option `%s%s' requires an argument"; |
|||
static const char ambig[] = "option `%s%.*s' is ambiguous"; |
|||
static const char noarg[] = "option `%s%.*s' doesn't allow an argument"; |
|||
static const char illoptstring[] = "unrecognized option `%s%s'"; |
|||
#else |
|||
static const char recargstring[] = "option requires an argument -- %s"; |
|||
static const char ambig[] = "ambiguous option -- %.*s"; |
|||
static const char noarg[] = "option doesn't take an argument -- %.*s"; |
|||
static const char illoptstring[] = "unknown option -- %s"; |
|||
#endif |
|||
|
|||
/*
|
|||
* Compute the greatest common divisor of a and b. |
|||
*/ |
|||
static int |
|||
gcd(int a, int b) |
|||
{ |
|||
int c; |
|||
|
|||
c = a % b; |
|||
while (c != 0) { |
|||
a = b; |
|||
b = c; |
|||
c = a % b; |
|||
} |
|||
|
|||
return (b); |
|||
} |
|||
|
|||
/*
|
|||
* Exchange the block from nonopt_start to nonopt_end with the block |
|||
* from nonopt_end to opt_end (keeping the same order of arguments |
|||
* in each block). |
|||
*/ |
|||
static void |
|||
permute_args(int panonopt_start, int panonopt_end, int opt_end, |
|||
char * const *nargv) |
|||
{ |
|||
int cstart, cyclelen, i, j, ncycle, nnonopts, nopts, pos; |
|||
char *swap; |
|||
|
|||
/*
|
|||
* compute lengths of blocks and number and size of cycles |
|||
*/ |
|||
nnonopts = panonopt_end - panonopt_start; |
|||
nopts = opt_end - panonopt_end; |
|||
ncycle = gcd(nnonopts, nopts); |
|||
cyclelen = (opt_end - panonopt_start) / ncycle; |
|||
|
|||
for (i = 0; i < ncycle; i++) { |
|||
cstart = panonopt_end+i; |
|||
pos = cstart; |
|||
for (j = 0; j < cyclelen; j++) { |
|||
if (pos >= panonopt_end) |
|||
pos -= nnonopts; |
|||
else |
|||
pos += nopts; |
|||
swap = nargv[pos]; |
|||
/* LINTED const cast */ |
|||
((char **) nargv)[pos] = nargv[cstart]; |
|||
/* LINTED const cast */ |
|||
((char **)nargv)[cstart] = swap; |
|||
} |
|||
} |
|||
} |
|||
|
|||
/*
|
|||
* parse_long_options -- |
|||
* Parse long options in argc/argv argument vector. |
|||
* Returns -1 if short_too is set and the option does not match long_options. |
|||
*/ |
|||
static int |
|||
parse_long_options(char * const *nargv, const char *options, |
|||
const struct option *long_options, int *idx, int short_too, int flags) |
|||
{ |
|||
char *current_argv, *has_equal; |
|||
#ifdef GNU_COMPATIBLE |
|||
char *current_dash; |
|||
#endif |
|||
size_t current_argv_len; |
|||
int i, match, exact_match, second_partial_match; |
|||
|
|||
current_argv = place; |
|||
#ifdef GNU_COMPATIBLE |
|||
switch (dash_prefix) { |
|||
case D_PREFIX: |
|||
current_dash = "-"; |
|||
break; |
|||
case DD_PREFIX: |
|||
current_dash = "--"; |
|||
break; |
|||
case W_PREFIX: |
|||
current_dash = "-W "; |
|||
break; |
|||
default: |
|||
current_dash = ""; |
|||
break; |
|||
} |
|||
#endif |
|||
match = -1; |
|||
exact_match = 0; |
|||
second_partial_match = 0; |
|||
|
|||
optind++; |
|||
|
|||
if ((has_equal = strchr(current_argv, '=')) != NULL) { |
|||
/* argument found (--option=arg) */ |
|||
current_argv_len = has_equal - current_argv; |
|||
has_equal++; |
|||
} else |
|||
current_argv_len = strlen(current_argv); |
|||
|
|||
for (i = 0; long_options[i].name; i++) { |
|||
/* find matching long option */ |
|||
if (strncmp(current_argv, long_options[i].name, |
|||
current_argv_len)) |
|||
continue; |
|||
|
|||
if (strlen(long_options[i].name) == current_argv_len) { |
|||
/* exact match */ |
|||
match = i; |
|||
exact_match = 1; |
|||
break; |
|||
} |
|||
/*
|
|||
* If this is a known short option, don't allow |
|||
* a partial match of a single character. |
|||
*/ |
|||
if (short_too && current_argv_len == 1) |
|||
continue; |
|||
|
|||
if (match == -1) /* first partial match */ |
|||
match = i; |
|||
else if ((flags & FLAG_LONGONLY) || |
|||
long_options[i].has_arg != |
|||
long_options[match].has_arg || |
|||
long_options[i].flag != long_options[match].flag || |
|||
long_options[i].val != long_options[match].val) |
|||
second_partial_match = 1; |
|||
} |
|||
if (!exact_match && second_partial_match) { |
|||
/* ambiguous abbreviation */ |
|||
if (PRINT_ERROR) |
|||
warnx(ambig, |
|||
#ifdef GNU_COMPATIBLE |
|||
current_dash, |
|||
#endif |
|||
(int)current_argv_len, |
|||
current_argv); |
|||
optopt = 0; |
|||
return (BADCH); |
|||
} |
|||
if (match != -1) { /* option found */ |
|||
if (long_options[match].has_arg == no_argument |
|||
&& has_equal) { |
|||
if (PRINT_ERROR) |
|||
warnx(noarg, |
|||
#ifdef GNU_COMPATIBLE |
|||
current_dash, |
|||
#endif |
|||
(int)current_argv_len, |
|||
current_argv); |
|||
/*
|
|||
* XXX: GNU sets optopt to val regardless of flag |
|||
*/ |
|||
if (long_options[match].flag == NULL) |
|||
optopt = long_options[match].val; |
|||
else |
|||
optopt = 0; |
|||
#ifdef GNU_COMPATIBLE |
|||
return (BADCH); |
|||
#else |
|||
return (BADARG); |
|||
#endif |
|||
} |
|||
if (long_options[match].has_arg == required_argument || |
|||
long_options[match].has_arg == optional_argument) { |
|||
if (has_equal) |
|||
optarg = has_equal; |
|||
else if (long_options[match].has_arg == |
|||
required_argument) { |
|||
/*
|
|||
* optional argument doesn't use next nargv |
|||
*/ |
|||
optarg = nargv[optind++]; |
|||
} |
|||
} |
|||
if ((long_options[match].has_arg == required_argument) |
|||
&& (optarg == NULL)) { |
|||
/*
|
|||
* Missing argument; leading ':' indicates no error |
|||
* should be generated. |
|||
*/ |
|||
if (PRINT_ERROR) |
|||
warnx(recargstring, |
|||
#ifdef GNU_COMPATIBLE |
|||
current_dash, |
|||
#endif |
|||
current_argv); |
|||
/*
|
|||
* XXX: GNU sets optopt to val regardless of flag |
|||
*/ |
|||
if (long_options[match].flag == NULL) |
|||
optopt = long_options[match].val; |
|||
else |
|||
optopt = 0; |
|||
--optind; |
|||
return (BADARG); |
|||
} |
|||
} else { /* unknown option */ |
|||
if (short_too) { |
|||
--optind; |
|||
return (-1); |
|||
} |
|||
if (PRINT_ERROR) |
|||
warnx(illoptstring, |
|||
#ifdef GNU_COMPATIBLE |
|||
current_dash, |
|||
#endif |
|||
current_argv); |
|||
optopt = 0; |
|||
return (BADCH); |
|||
} |
|||
if (idx) |
|||
*idx = match; |
|||
if (long_options[match].flag) { |
|||
*long_options[match].flag = long_options[match].val; |
|||
return (0); |
|||
} else |
|||
return (long_options[match].val); |
|||
} |
|||
|
|||
/*
|
|||
* getopt_internal -- |
|||
* Parse argc/argv argument vector. Called by user level routines. |
|||
*/ |
|||
static int |
|||
getopt_internal(int nargc, char * const *nargv, const char *options, |
|||
const struct option *long_options, int *idx, int flags) |
|||
{ |
|||
char *oli; /* option letter list index */ |
|||
int optchar, short_too; |
|||
|
|||
if (options == NULL) |
|||
return (-1); |
|||
|
|||
/*
|
|||
* XXX Some GNU programs (like cvs) set optind to 0 instead of |
|||
* XXX using optreset. Work around this braindamage. |
|||
*/ |
|||
if (optind == 0) |
|||
optind = optreset = 1; |
|||
|
|||
if (*options == '-') |
|||
flags |= FLAG_ALLARGS; |
|||
if (*options == '+' || *options == '-') |
|||
options++; |
|||
|
|||
optarg = NULL; |
|||
if (optreset) |
|||
nonopt_start = nonopt_end = -1; |
|||
start: |
|||
if (optreset || !*place) { /* update scanning pointer */ |
|||
optreset = 0; |
|||
if (optind >= nargc) { /* end of argument vector */ |
|||
place = EMSG; |
|||
if (nonopt_end != -1) { |
|||
/* do permutation, if we have to */ |
|||
permute_args(nonopt_start, nonopt_end, |
|||
optind, nargv); |
|||
optind -= nonopt_end - nonopt_start; |
|||
} |
|||
else if (nonopt_start != -1) { |
|||
/*
|
|||
* If we skipped non-options, set optind |
|||
* to the first of them. |
|||
*/ |
|||
optind = nonopt_start; |
|||
} |
|||
nonopt_start = nonopt_end = -1; |
|||
return (-1); |
|||
} |
|||
if (*(place = nargv[optind]) != '-' || |
|||
#ifdef GNU_COMPATIBLE |
|||
place[1] == '\0') { |
|||
#else |
|||
(place[1] == '\0' && strchr(options, '-') == NULL)) { |
|||
#endif |
|||
place = EMSG; /* found non-option */ |
|||
if (flags & FLAG_ALLARGS) { |
|||
/*
|
|||
* GNU extension: |
|||
* return non-option as argument to option 1 |
|||
*/ |
|||
optarg = nargv[optind++]; |
|||
return (INORDER); |
|||
} |
|||
if (!(flags & FLAG_PERMUTE)) { |
|||
/*
|
|||
* If no permutation wanted, stop parsing |
|||
* at first non-option. |
|||
*/ |
|||
return (-1); |
|||
} |
|||
/* do permutation */ |
|||
if (nonopt_start == -1) |
|||
nonopt_start = optind; |
|||
else if (nonopt_end != -1) { |
|||
permute_args(nonopt_start, nonopt_end, |
|||
optind, nargv); |
|||
nonopt_start = optind - |
|||
(nonopt_end - nonopt_start); |
|||
nonopt_end = -1; |
|||
} |
|||
optind++; |
|||
/* process next argument */ |
|||
goto start; |
|||
} |
|||
if (nonopt_start != -1 && nonopt_end == -1) |
|||
nonopt_end = optind; |
|||
|
|||
/*
|
|||
* If we have "-" do nothing, if "--" we are done. |
|||
*/ |
|||
if (place[1] != '\0' && *++place == '-' && place[1] == '\0') { |
|||
optind++; |
|||
place = EMSG; |
|||
/*
|
|||
* We found an option (--), so if we skipped |
|||
* non-options, we have to permute. |
|||
*/ |
|||
if (nonopt_end != -1) { |
|||
permute_args(nonopt_start, nonopt_end, |
|||
optind, nargv); |
|||
optind -= nonopt_end - nonopt_start; |
|||
} |
|||
nonopt_start = nonopt_end = -1; |
|||
return (-1); |
|||
} |
|||
} |
|||
|
|||
/*
|
|||
* Check long options if: |
|||
* 1) we were passed some |
|||
* 2) the arg is not just "-" |
|||
* 3) either the arg starts with -- we are getopt_long_only() |
|||
*/ |
|||
if (long_options != NULL && place != nargv[optind] && |
|||
(*place == '-' || (flags & FLAG_LONGONLY))) { |
|||
short_too = 0; |
|||
#ifdef GNU_COMPATIBLE |
|||
dash_prefix = D_PREFIX; |
|||
#endif |
|||
if (*place == '-') { |
|||
place++; /* --foo long option */ |
|||
#ifdef GNU_COMPATIBLE |
|||
dash_prefix = DD_PREFIX; |
|||
#endif |
|||
} else if (*place != ':' && strchr(options, *place) != NULL) |
|||
short_too = 1; /* could be short option too */ |
|||
|
|||
optchar = parse_long_options(nargv, options, long_options, |
|||
idx, short_too, flags); |
|||
if (optchar != -1) { |
|||
place = EMSG; |
|||
return (optchar); |
|||
} |
|||
} |
|||
|
|||
if ((optchar = (int)*place++) == (int)':' || |
|||
(optchar == (int)'-' && *place != '\0') || |
|||
(oli = strchr(options, optchar)) == NULL) { |
|||
/*
|
|||
* If the user specified "-" and '-' isn't listed in |
|||
* options, return -1 (non-option) as per POSIX. |
|||
* Otherwise, it is an unknown option character (or ':'). |
|||
*/ |
|||
if (optchar == (int)'-' && *place == '\0') |
|||
return (-1); |
|||
if (!*place) |
|||
++optind; |
|||
#ifdef GNU_COMPATIBLE |
|||
if (PRINT_ERROR) |
|||
warnx(gnuoptchar, optchar); |
|||
#else |
|||
if (PRINT_ERROR) |
|||
warnx(illoptchar, optchar); |
|||
#endif |
|||
optopt = optchar; |
|||
return (BADCH); |
|||
} |
|||
if (long_options != NULL && optchar == 'W' && oli[1] == ';') { |
|||
/* -W long-option */ |
|||
if (*place) /* no space */ |
|||
/* NOTHING */; |
|||
else if (++optind >= nargc) { /* no arg */ |
|||
place = EMSG; |
|||
if (PRINT_ERROR) |
|||
warnx(recargchar, optchar); |
|||
optopt = optchar; |
|||
return (BADARG); |
|||
} else /* white space */ |
|||
place = nargv[optind]; |
|||
#ifdef GNU_COMPATIBLE |
|||
dash_prefix = W_PREFIX; |
|||
#endif |
|||
optchar = parse_long_options(nargv, options, long_options, |
|||
idx, 0, flags); |
|||
place = EMSG; |
|||
return (optchar); |
|||
} |
|||
if (*++oli != ':') { /* doesn't take argument */ |
|||
if (!*place) |
|||
++optind; |
|||
} else { /* takes (optional) argument */ |
|||
optarg = NULL; |
|||
if (*place) /* no white space */ |
|||
optarg = place; |
|||
else if (oli[1] != ':') { /* arg not optional */ |
|||
if (++optind >= nargc) { /* no arg */ |
|||
place = EMSG; |
|||
if (PRINT_ERROR) |
|||
warnx(recargchar, optchar); |
|||
optopt = optchar; |
|||
return (BADARG); |
|||
} else |
|||
optarg = nargv[optind]; |
|||
} |
|||
place = EMSG; |
|||
++optind; |
|||
} |
|||
/* dump back option letter */ |
|||
return (optchar); |
|||
} |
|||
|
|||
#ifdef REPLACE_GETOPT |
|||
/*
|
|||
* getopt -- |
|||
* Parse argc/argv argument vector. |
|||
* |
|||
* [eventually this will replace the BSD getopt] |
|||
*/ |
|||
int |
|||
getopt(int nargc, char * const *nargv, const char *options) |
|||
{ |
|||
|
|||
/*
|
|||
* We don't pass FLAG_PERMUTE to getopt_internal() since |
|||
* the BSD getopt(3) (unlike GNU) has never done this. |
|||
* |
|||
* Furthermore, since many privileged programs call getopt() |
|||
* before dropping privileges it makes sense to keep things |
|||
* as simple (and bug-free) as possible. |
|||
*/ |
|||
return (getopt_internal(nargc, nargv, options, NULL, NULL, 0)); |
|||
} |
|||
#endif /* REPLACE_GETOPT */ |
|||
|
|||
/*
|
|||
* getopt_long -- |
|||
* Parse argc/argv argument vector. |
|||
*/ |
|||
int |
|||
getopt_long(int nargc, char * const *nargv, const char *options, |
|||
const struct option *long_options, int *idx) |
|||
{ |
|||
|
|||
return (getopt_internal(nargc, nargv, options, long_options, idx, |
|||
FLAG_PERMUTE)); |
|||
} |
|||
|
|||
/*
|
|||
* getopt_long_only -- |
|||
* Parse argc/argv argument vector. |
|||
*/ |
|||
int |
|||
getopt_long_only(int nargc, char * const *nargv, const char *options, |
|||
const struct option *long_options, int *idx) |
|||
{ |
|||
|
|||
return (getopt_internal(nargc, nargv, options, long_options, idx, |
|||
FLAG_PERMUTE|FLAG_LONGONLY)); |
|||
} |
|||
@ -1,305 +0,0 @@ |
|||
#include "node_options.h" |
|||
#include "node_version.h" |
|||
#include "node_internals.h" |
|||
#include "getopt.h" |
|||
#include <stdio.h> |
|||
#include <stdlib.h> |
|||
#include <string.h> |
|||
|
|||
namespace node { |
|||
|
|||
enum { |
|||
OPT_NO_DEPRECATION = 1000, |
|||
OPT_THROW_DEPRECATION, |
|||
OPT_TRACE_DEPRECATION, |
|||
OPT_TRACE_SYNC_IO, |
|||
OPT_V8_OPTIONS, |
|||
OPT_ABORT_UNCAUGHT, |
|||
OPT_EXPOSE_INTERNALS, |
|||
OPT_DEBUG, |
|||
OPT_DEBUG_BRK, |
|||
OPT_DEBUG_PORT, |
|||
#if defined(NODE_HAVE_I18N_SUPPORT) |
|||
OPT_ICU_DATA_DIR |
|||
#endif |
|||
}; |
|||
|
|||
static struct option longopts[] = { |
|||
{ "help", no_argument, nullptr, 'h', "show help and usage" }, |
|||
{ "version", no_argument, nullptr, 'v', "print io.js version" }, |
|||
{ "eval", optional_argument, nullptr, 'e', "evaluate script" }, |
|||
{ "print", optional_argument, nullptr, 'p', |
|||
"evaluate script and print result" }, |
|||
{ "interactive", no_argument, nullptr, 'i', |
|||
"always enter the REPL even if stdin " |
|||
"does not appear to be a terminal" }, |
|||
{ "require", required_argument, nullptr, 'r', "module to preload" }, |
|||
{ "no-deprecation", no_argument, nullptr, OPT_NO_DEPRECATION, |
|||
"silence deprecation warnings" }, |
|||
{ "throw-deprecation", no_argument, nullptr, OPT_THROW_DEPRECATION, |
|||
"throw an exception anytime a deprecated function is used" }, |
|||
{ "trace-deprecation", no_argument, nullptr, OPT_TRACE_DEPRECATION, |
|||
"show stack traces on deprecations" }, |
|||
{ "trace-sync-io", no_argument, nullptr, OPT_TRACE_SYNC_IO, |
|||
"show stake trace when use of sync IO " |
|||
"is detected after the first tick" }, |
|||
{ "v8-options", no_argument, nullptr, OPT_V8_OPTIONS, |
|||
"print v8 command line options" }, |
|||
{ "v8_options", no_argument, nullptr, OPT_V8_OPTIONS, |
|||
"print v8 command line options" }, |
|||
{ "abort-on-uncaught-exception", no_argument, nullptr, OPT_ABORT_UNCAUGHT, |
|||
"abort on uncaught exception" }, |
|||
{ "abort_on_uncaught_exception", no_argument, nullptr, OPT_ABORT_UNCAUGHT, |
|||
"abort on uncaught exception" }, |
|||
{ "expose-internals", no_argument, nullptr, OPT_EXPOSE_INTERNALS, |
|||
"expose internal modules" }, |
|||
{ "expose_internals", no_argument, nullptr, OPT_EXPOSE_INTERNALS, |
|||
"expose internal modules" }, |
|||
{ "debug", optional_argument, nullptr, OPT_DEBUG, "enable debug mode" }, |
|||
{ "debug-brk", optional_argument, nullptr, OPT_DEBUG_BRK, |
|||
"break before starting" }, |
|||
{ "debug-port", required_argument, nullptr, OPT_DEBUG_PORT, |
|||
"specify debug port (defaults to 5858)" }, |
|||
#if defined(NODE_HAVE_I18N_SUPPORT) |
|||
{ "icu-data-dir", required_argument, nullptr, OPT_ICU_DATA_DIR }, |
|||
#endif |
|||
{ nullptr, 0, nullptr, 0, "" } |
|||
}; |
|||
|
|||
void NodeOptions::PrintHelp() { |
|||
printf("Usage: iojs [options] [ -e script | script.js ] [arguments] \n" |
|||
" iojs debug script.js [arguments] \n" |
|||
"\n" |
|||
"Options:\n"); |
|||
for (size_t i = 0; i < ARRAY_SIZE(longopts); i++) { |
|||
if (longopts[i].name == nullptr) |
|||
continue; |
|||
if (longopts[i].val < 1000) { |
|||
printf("\t-%c, --%-30s %-50s\n", |
|||
longopts[i].val, |
|||
longopts[i].name, |
|||
longopts[i].desc); |
|||
} else { |
|||
printf("\t --%-30s %-50s\n", longopts[i].name, longopts[i].desc); |
|||
} |
|||
} |
|||
|
|||
printf("\n"); |
|||
|
|||
printf("Environment variables:\n" |
|||
#ifdef _WIN32 |
|||
"\t NODE_PATH ';'-separated list of directories\n" |
|||
#else |
|||
"\t NODE_PATH ':'-separated list of directories\n" |
|||
#endif |
|||
"\t prefixed to the module search path.\n" |
|||
"\t NODE_DISABLE_COLORS Set to 1 to disable colors in the REPL\n" |
|||
#if defined(NODE_HAVE_I18N_SUPPORT) |
|||
"\t NODE_ICU_DATA Data path for ICU (Intl object) data\n" |
|||
#if !defined(NODE_HAVE_SMALL_ICU) |
|||
"\t (will extend linked-in data)\n" |
|||
#endif |
|||
#endif |
|||
"\n" |
|||
"Documentation can be found at https://iojs.org/\n"); |
|||
} |
|||
|
|||
void NodeOptions::ParseArgs(int* argc, |
|||
const char** argv, |
|||
int* exec_argc, |
|||
const char*** exec_argv, |
|||
int* v8_argc, |
|||
const char*** v8_argv) { |
|||
const unsigned int nargs = static_cast<unsigned int>(*argc); |
|||
const char** new_exec_argv = new const char*[nargs]; |
|||
const char** new_v8_argv = new const char*[nargs]; |
|||
const char** new_argv = new const char*[nargs]; |
|||
const char** local_preload_modules = new const char*[nargs]; |
|||
|
|||
// we are mutating the strings vector but not the strings themselves
|
|||
char** largv = const_cast<char**>(argv); |
|||
for (unsigned int i = 0; i < nargs; ++i) { |
|||
new_exec_argv[i] = nullptr; |
|||
new_v8_argv[i] = nullptr; |
|||
new_argv[i] = nullptr; |
|||
local_preload_modules[i] = nullptr; |
|||
} |
|||
|
|||
const char* port = nullptr; |
|||
|
|||
// exec_argv starts with the first option, the other two start with argv[0].
|
|||
unsigned int new_exec_argc = 0; |
|||
unsigned int new_v8_argc = 1; |
|||
unsigned int new_argc = 1; |
|||
new_v8_argv[0] = argv[0]; |
|||
new_argv[0] = argv[0]; |
|||
int rc = 0; |
|||
unsigned int index = 1; |
|||
bool is_eval = false; |
|||
bool is_print = false; |
|||
const char optstring[] = ":hve:p::ir:d::b::x:"; |
|||
while ((rc = getopt_long(*argc, largv, optstring, longopts, NULL)) != -1 && |
|||
argv[index][0] == '-') { |
|||
unsigned int args_consumed = 1; |
|||
const char* const arg = argv[index]; |
|||
switch (rc) { |
|||
case 'h': |
|||
PrintHelp(); |
|||
exit(0); |
|||
break; |
|||
case 'v': |
|||
printf("%s\n", NODE_VERSION); |
|||
exit(0); |
|||
break; |
|||
case 'e': |
|||
case 'p': |
|||
{ |
|||
if (!is_eval) |
|||
is_eval = (rc == 'e'); |
|||
|
|||
if (!is_print) |
|||
is_print = (rc == 'p'); |
|||
const char* name = is_eval ? "eval" : "print"; |
|||
print_eval = print_eval || is_print; |
|||
if (is_eval == true) { |
|||
eval_string = argv[index + 1]; |
|||
args_consumed += 1; |
|||
if (eval_string == nullptr) { |
|||
fprintf(stderr, "%s: %s requires an argument\n", argv[0], name); |
|||
exit(9); |
|||
} |
|||
} else if ((index + 1 < nargs) && |
|||
argv[index + 1] != nullptr && |
|||
argv[index + 1][0] != '-') { |
|||
eval_string = argv[index + 1]; |
|||
args_consumed += 1; |
|||
if (strncmp(eval_string, "\\-", 2) == 0) { |
|||
// Starts with "\\-": escaped expression, drop the backslash.
|
|||
eval_string += 1; |
|||
} |
|||
} |
|||
break; |
|||
} |
|||
case 'i': |
|||
force_repl = true; |
|||
break; |
|||
case 'r': |
|||
{ |
|||
const char* module = argv[index + 1]; |
|||
args_consumed += 1; |
|||
if (module == nullptr) { |
|||
fprintf(stderr, "%s: %s requires an argument\n", argv[0], arg); |
|||
exit(9); |
|||
} |
|||
local_preload_modules[preload_module_count++] = module; |
|||
break; |
|||
} |
|||
case OPT_NO_DEPRECATION: |
|||
no_deprecation = true; |
|||
break; |
|||
case OPT_THROW_DEPRECATION: |
|||
throw_deprecation = true; |
|||
break; |
|||
case OPT_TRACE_DEPRECATION: |
|||
trace_deprecation = true; |
|||
break; |
|||
case OPT_TRACE_SYNC_IO: |
|||
trace_sync_io = true; |
|||
break; |
|||
case OPT_V8_OPTIONS: |
|||
new_v8_argv[new_v8_argc] = "--help"; |
|||
new_v8_argc += 1; |
|||
break; |
|||
case OPT_ABORT_UNCAUGHT: |
|||
abort_on_uncaught_exception = true; |
|||
break; |
|||
case OPT_EXPOSE_INTERNALS: |
|||
// pass through
|
|||
break; |
|||
case OPT_DEBUG: |
|||
{ |
|||
use_debug_agent = true; |
|||
if (optarg != nullptr) { |
|||
port = const_cast<const char*>(optarg); |
|||
} |
|||
break; |
|||
} |
|||
case OPT_DEBUG_BRK: |
|||
{ |
|||
use_debug_agent = true; |
|||
debug_wait_connect = true; |
|||
if (optarg != nullptr) { |
|||
port = const_cast<const char*>(optarg); |
|||
} |
|||
break; |
|||
} |
|||
case OPT_DEBUG_PORT: |
|||
{ |
|||
port = optarg; |
|||
break; |
|||
} |
|||
#if defined(NODE_HAVE_I18N_SUPPORT) |
|||
case OPT_ICU_DATA_DIR: |
|||
{ |
|||
if (optarg != nullptr) { |
|||
icu_data_dir = const_cast<const char*>(optarg); |
|||
} |
|||
break; |
|||
} |
|||
#endif |
|||
case '?': |
|||
{ |
|||
if (arg[0] == '-') { |
|||
// V8 option. Pass through as-is.
|
|||
new_v8_argv[new_v8_argc] = arg; |
|||
new_v8_argc += 1; |
|||
} |
|||
break; |
|||
} |
|||
} |
|||
|
|||
memcpy(new_exec_argv + new_exec_argc, |
|||
largv + index, |
|||
args_consumed * sizeof(*largv)); |
|||
|
|||
new_exec_argc += args_consumed; |
|||
index += args_consumed; |
|||
} |
|||
|
|||
if (port != nullptr) { |
|||
debug_port = atoi(port); |
|||
if (debug_port < 1024 || debug_port > 65535) { |
|||
fprintf(stderr, "Debug port must be in range 1024 to 65535.\n"); |
|||
PrintHelp(); |
|||
exit(12); |
|||
} |
|||
} |
|||
|
|||
// Copy remaining arguments.
|
|||
const unsigned int args_left = nargs - index; |
|||
memcpy(new_argv + new_argc, argv + index, args_left * sizeof(*argv)); |
|||
new_argc += args_left; |
|||
|
|||
*exec_argc = new_exec_argc; |
|||
*exec_argv = new_exec_argv; |
|||
*v8_argc = new_v8_argc; |
|||
*v8_argv = new_v8_argv; |
|||
|
|||
// Copy new_argv over argv and update argc.
|
|||
memcpy(argv, new_argv, new_argc * sizeof(*argv)); |
|||
delete[] new_argv; |
|||
*argc = static_cast<int>(new_argc); |
|||
|
|||
// Copy the preload_modules from the local array to an appropriately sized
|
|||
// global array.
|
|||
if (preload_module_count > 0) { |
|||
CHECK(!preload_modules); |
|||
preload_modules = new const char*[preload_module_count]; |
|||
memcpy(preload_modules, |
|||
local_preload_modules, |
|||
preload_module_count * sizeof(*preload_modules)); |
|||
} |
|||
delete[] local_preload_modules; |
|||
} |
|||
|
|||
} // namespace node
|
|||
@ -1,62 +0,0 @@ |
|||
#ifndef SRC_NODE_OPTIONS_H_ |
|||
#define SRC_NODE_OPTIONS_H_ |
|||
|
|||
#include "node_version.h" |
|||
#include "util.h" |
|||
#include "getopt.h" |
|||
#include <stdio.h> |
|||
#include <stdlib.h> |
|||
#include <string.h> |
|||
|
|||
namespace node { |
|||
|
|||
class NodeOptions { |
|||
public: |
|||
bool print_eval = false; |
|||
bool force_repl = false; |
|||
bool trace_deprecation = false; |
|||
bool throw_deprecation = false; |
|||
bool abort_on_uncaught_exception = false; |
|||
bool trace_sync_io = false; |
|||
const char* eval_string = nullptr; |
|||
unsigned int preload_module_count = 0; |
|||
const char** preload_modules = nullptr; |
|||
bool use_debug_agent = false; |
|||
bool debug_wait_connect = false; |
|||
int debug_port = 5858; |
|||
bool no_deprecation = false; |
|||
#if defined(NODE_HAVE_I18N_SUPPORT) |
|||
// Path to ICU data (for i18n / Intl)
|
|||
const char* icu_data_dir = nullptr; |
|||
#endif |
|||
|
|||
NodeOptions() = default; |
|||
|
|||
// Print help to stdout
|
|||
void PrintHelp(); |
|||
|
|||
// Parse command line arguments.
|
|||
//
|
|||
// argv is modified in place. exec_argv and v8_argv are out arguments that
|
|||
// ParseArgs() allocates memory for and stores a pointer to the output
|
|||
// vector in. The caller should free them with delete[].
|
|||
//
|
|||
// On exit:
|
|||
//
|
|||
// * argv contains the arguments with node and V8 options filtered out.
|
|||
// * exec_argv contains both node and V8 options and nothing else.
|
|||
// * v8_argv contains argv[0] plus any V8 options
|
|||
void ParseArgs(int* argc, |
|||
const char** argv, |
|||
int* exec_argc, |
|||
const char*** exec_argv, |
|||
int* v8_argc, |
|||
const char*** v8_argv); |
|||
|
|||
private: |
|||
DISALLOW_COPY_AND_ASSIGN(NodeOptions); |
|||
}; |
|||
|
|||
} // namespace node
|
|||
|
|||
#endif // SRC_NODE_OPTIONS_H_
|
|||
@ -1,20 +0,0 @@ |
|||
'use strict'; |
|||
const common = require('../common'); |
|||
const assert = require('assert'); |
|||
const execFile = require('child_process').execFile; |
|||
const EOL = require('os').EOL; |
|||
var depmod = require.resolve('../fixtures/printA.js'); |
|||
var node = process.execPath; |
|||
|
|||
var debug = ['--debug', depmod]; |
|||
var debugPort = ['--debug=5859', depmod]; |
|||
|
|||
function handle(port) { |
|||
return function(er, stdout, stderr) { |
|||
assert.equal(er, null); |
|||
assert.equal(stderr, `Debugger listening on port ${port}${EOL}`); |
|||
}; |
|||
} |
|||
|
|||
execFile(node, debug, handle(5858)); |
|||
execFile(node, debugPort, handle(5859)); |
|||
@ -1,10 +0,0 @@ |
|||
'use strict'; |
|||
const assert = require('assert'); |
|||
const execFile = require('child_process').execFile; |
|||
|
|||
// test --help
|
|||
execFile(process.execPath, ['--help'], function(err, stdout, stderr) { |
|||
assert.equal(err, null); |
|||
assert.equal(stderr, ''); |
|||
assert.equal(/Usage/.test(stdout), true); |
|||
}); |
|||
@ -1,16 +0,0 @@ |
|||
'use strict'; |
|||
const common = require('../common'); |
|||
const assert = require('assert'); |
|||
const execFile = require('child_process').execFile; |
|||
|
|||
// test --v8-options and --v8_options
|
|||
(function runTest(flags) { |
|||
var flag = flags.pop(); |
|||
execFile(process.execPath, [flag], function(err, stdout, stderr) { |
|||
assert.equal(err, null); |
|||
assert.equal(stderr, ''); |
|||
assert.equal(stdout.indexOf('Usage') > -1, true); |
|||
if (flags.length > 0) |
|||
setImmediate(runTest, flags); |
|||
}); |
|||
})(['--v8-options', '--v8_options']); |
|||
@ -1,11 +0,0 @@ |
|||
'use strict'; |
|||
const assert = require('assert'); |
|||
const execFile = require('child_process').execFile; |
|||
|
|||
// test --version
|
|||
execFile(process.execPath, ['--version'], function(err, stdout, stderr) { |
|||
assert.equal(err, null); |
|||
assert.equal(stderr, ''); |
|||
// just in case the version ever has anything appended to it (nightlies?)
|
|||
assert.equal(/v([\d]+).([\d]+).([\d]+)(.*)/.test(stdout), true); |
|||
}); |
|||
Loading…
Reference in new issue