static cv_flags_t
get_flag(char *attr)
{
if (strnEQ(attr, "method", 6))
return CVf_METHOD;
else if (strnEQ(attr, "locked", 6))
return CVf_LOCKED;
else
return 0;
}
/* Load a YAML scalar into a Perl scalar */
SV *
load_scalar(perl_yaml_loader_t *loader)
{
SV *scalar;
char *string = (char *)loader->event.data.scalar.value;
STRLEN length = (STRLEN)loader->event.data.scalar.length;
char *anchor = (char *)loader->event.data.scalar.anchor;
char *tag = (char *)loader->event.data.scalar.tag;
if (tag) {
char *class;
char *prefix = TAG_PERL_PREFIX "regexp";
if (strnEQ(tag, prefix, strlen(prefix)))
return load_regexp(loader);
prefix = TAG_PERL_PREFIX "scalar:";
if (*tag == '!')
prefix = "!";
else if (strlen(tag) <= strlen(prefix) ||
! strnEQ(tag, prefix, strlen(prefix))
) croak(ERRMSG "bad tag found for scalar: '%s'", tag);
class = tag + strlen(prefix);
scalar = sv_setref_pvn(newSV(0), class, string, strlen(string));
SvUTF8_on(scalar);
return scalar;
}
if (loader->event.data.scalar.style == YAML_PLAIN_SCALAR_STYLE) {
if (strEQ(string, "~"))
return newSV(0);
else if (strEQ(string, ""))
return newSV(0);
else if (strEQ(string, "null"))
return newSV(0);
else if (strEQ(string, "true"))
return &PL_sv_yes;
else if (strEQ(string, "false"))
return &PL_sv_no;
}
scalar = newSVpvn(string, length);
if (loader->event.data.scalar.style == YAML_PLAIN_SCALAR_STYLE && looks_like_number(scalar) ) {
/* numify */
SvIV_please(scalar);
}
SvUTF8_on(scalar);
if (anchor)
hv_store(loader->anchors, anchor, strlen(anchor), SvREFCNT_inc(scalar), 0);
return scalar;
}
/* Load a YAML sequence into a Perl array */
SV *
load_sequence(perl_yaml_loader_t *loader)
{
SV *node;
AV *array = newAV();
SV *array_ref = (SV *)newRV_noinc((SV *)array);
char *anchor = (char *)loader->event.data.sequence_start.anchor;
char *tag = (char *)loader->event.data.mapping_start.tag;
if (anchor)
hv_store(loader->anchors, anchor, strlen(anchor), SvREFCNT_inc(array_ref), 0);
while ((node = load_node(loader))) {
av_push(array, node);
}
if (tag && strEQ(tag, TAG_PERL_PREFIX "array"))
tag = NULL;
if (tag) {
char *class;
char *prefix = TAG_PERL_PREFIX "array:";
if (*tag == '!')
prefix = "!";
else if (strlen(tag) <= strlen(prefix) ||
! strnEQ(tag, prefix, strlen(prefix))
) croak(
loader_error_msg(loader, form("bad tag found for array: '%s'", tag))
);
class = tag + strlen(prefix);
sv_bless(array_ref, gv_stashpv(class, TRUE));
}
return array_ref;
}
GV *
Perl_gv_fetchmeth_autoload(pTHX_ HV *stash, const char *name, STRLEN len, I32 level)
{
GV *gv = gv_fetchmeth(stash, name, len, level);
if (!gv) {
char autoload[] = "AUTOLOAD";
STRLEN autolen = sizeof(autoload)-1;
CV *cv;
GV **gvp;
if (!stash)
return Nullgv; /* UNIVERSAL::AUTOLOAD could cause trouble */
if (len == autolen && strnEQ(name, autoload, autolen))
return Nullgv;
if (!(gv = gv_fetchmeth(stash, autoload, autolen, FALSE)))
return Nullgv;
cv = GvCV(gv);
if (!(CvROOT(cv) || CvXSUB(cv)))
return Nullgv;
/* Have an autoload */
if (level < 0) /* Cannot do without a stub */
gv_fetchmeth(stash, name, len, 0);
gvp = (GV**)hv_fetch(stash, name, len, (level >= 0));
if (!gvp)
return Nullgv;
return *gvp;
}
return gv;
}
/* Load a scalar marked as a regexp as a Perl regular expression.
* This operation is less common and is tricky, so doing it in Perl code for
* now.
*/
SV *
load_regexp(perl_yaml_loader_t * loader)
{
dSP;
char *string = (char *)loader->event.data.scalar.value;
STRLEN length = (STRLEN)loader->event.data.scalar.length;
char *anchor = (char *)loader->event.data.scalar.anchor;
char *tag = (char *)loader->event.data.scalar.tag;
char *prefix = TAG_PERL_PREFIX "regexp:";
SV *regexp = newSVpvn(string, length);
SvUTF8_on(regexp);
ENTER;
SAVETMPS;
PUSHMARK(sp);
XPUSHs(regexp);
PUTBACK;
call_pv("YAML::XS::__qr_loader", G_SCALAR);
SPAGAIN;
regexp = newSVsv(POPs);
if (strlen(tag) > strlen(prefix) && strnEQ(tag, prefix, strlen(prefix))) {
char *class = tag + strlen(prefix);
sv_bless(regexp, gv_stashpv(class, TRUE));
}
GV *
Perl_gv_fetchmethod_autoload(pTHX_ HV *stash, const char *name, I32 autoload)
{
register const char *nend;
const char *nsplit = 0;
GV* gv;
for (nend = name; *nend; nend++) {
if (*nend == '\'')
nsplit = nend;
else if (*nend == ':' && *(nend + 1) == ':')
nsplit = ++nend;
}
if (nsplit) {
const char *origname = name;
name = nsplit + 1;
if (*nsplit == ':')
--nsplit;
if ((nsplit - origname) == 5 && strnEQ(origname, "SUPER", 5)) {
/* ->SUPER::method should really be looked up in original stash */
SV *tmpstr = sv_2mortal(Perl_newSVpvf(aTHX_ "%s::SUPER",
CopSTASHPV(PL_curcop)));
stash = gv_stashpvn(SvPVX(tmpstr), SvCUR(tmpstr), TRUE);
DEBUG_o( Perl_deb(aTHX_ "Treating %s as %s::%s\n",
origname, HvNAME(stash), name) );
}
else
stash = gv_stashpvn(origname, nsplit - origname, TRUE);
}
gv = gv_fetchmeth(stash, name, nend - name, 0);
if (!gv) {
if (strEQ(name,"import") || strEQ(name,"unimport"))
gv = (GV*)&PL_sv_yes;
else if (autoload)
gv = gv_autoload4(stash, name, nend - name, TRUE);
}
else if (autoload) {
CV* cv = GvCV(gv);
if (!CvROOT(cv) && !CvXSUB(cv)) {
GV* stubgv;
GV* autogv;
if (CvANON(cv))
stubgv = gv;
else {
stubgv = CvGV(cv);
if (GvCV(stubgv) != cv) /* orphaned import */
stubgv = gv;
}
autogv = gv_autoload4(GvSTASH(stubgv),
GvNAME(stubgv), GvNAMELEN(stubgv), TRUE);
if (autogv)
gv = autogv;
}
}
return gv;
}
/*
* True if the string argument contains the revision number we want.
*/
static bool
rev_in_string(const char *string)
{
const char *s;
size_t patlen;
if (revision == NULL)
return true;
patlen = strlen(revision);
if (strnEQ(string, revision, patlen) && isspace((unsigned char)string[patlen]))
return true;
for (s = string; *s; s++) {
if (isspace((unsigned char)*s) && strnEQ(s + 1, revision, patlen) &&
isspace((unsigned char)s[patlen + 1])) {
return true;
}
}
return false;
}
GV*
Perl_gv_autoload4(pTHX_ HV *stash, const char *name, STRLEN len, I32 method)
{
char autoload[] = "AUTOLOAD";
STRLEN autolen = sizeof(autoload)-1;
GV* gv;
CV* cv;
HV* varstash;
GV* vargv;
SV* varsv;
if (len == autolen && strnEQ(name, autoload, autolen))
return Nullgv;
if (!(gv = gv_fetchmeth(stash, autoload, autolen, FALSE)))
return Nullgv;
cv = GvCV(gv);
if (!CvROOT(cv))
return Nullgv;
/*
* Inheriting AUTOLOAD for non-methods works ... for now.
*/
if (ckWARN(WARN_DEPRECATED) && !method &&
(GvCVGEN(gv) || GvSTASH(gv) != stash))
Perl_warner(aTHX_ WARN_DEPRECATED,
"Use of inherited AUTOLOAD for non-method %s::%.*s() is deprecated",
HvNAME(stash), (int)len, name);
/*
* Given &FOO::AUTOLOAD, set $FOO::AUTOLOAD to desired function name.
* The subroutine's original name may not be "AUTOLOAD", so we don't
* use that, but for lack of anything better we will use the sub's
* original package to look up $AUTOLOAD.
*/
varstash = GvSTASH(CvGV(cv));
vargv = *(GV**)hv_fetch(varstash, autoload, autolen, TRUE);
ENTER;
#ifdef USE_THREADS
sv_lock((SV *)varstash);
#endif
if (!isGV(vargv))
gv_init(vargv, varstash, autoload, autolen, FALSE);
LEAVE;
varsv = GvSV(vargv);
#ifdef USE_THREADS
sv_lock(varsv);
#endif
sv_setpv(varsv, HvNAME(stash));
sv_catpvn(varsv, "::", 2);
sv_catpvn(varsv, name, len);
SvTAINTED_off(varsv);
return gv;
}
/*
* Make filenames more reasonable.
*/
char *
fetchname(const char *at, bool *exists, int strip_leading)
{
char *fullname, *name, *t;
int sleading, tab;
struct stat filestat;
if (at == NULL || *at == '\0')
return NULL;
while (isspace((unsigned char)*at))
at++;
#ifdef DEBUGGING
if (debug & 128)
say("fetchname %s %d\n", at, strip_leading);
#endif
/* So files can be created by diffing against /dev/null. */
if (strnEQ(at, _PATH_DEVNULL, sizeof(_PATH_DEVNULL) - 1))
return NULL;
name = fullname = t = savestr(at);
tab = strchr(t, '\t') != NULL;
/* Strip off up to `strip_leading' path components and NUL terminate. */
for (sleading = strip_leading; *t != '\0' && ((tab && *t != '\t') ||
!isspace((unsigned char)*t)); t++) {
if (t[0] == '/' && t[1] != '/' && t[1] != '\0')
if (--sleading >= 0)
name = t + 1;
}
*t = '\0';
/*
* If no -p option was given (957 is the default value!), we were
* given a relative pathname, and the leading directories that we
* just stripped off all exist, put them back on.
*/
if (strip_leading == 957 && name != fullname && *fullname != '/') {
name[-1] = '\0';
if (stat(fullname, &filestat) == 0 && S_ISDIR(filestat.st_mode)) {
name[-1] = '/';
name = fullname;
}
}
name = savestr(name);
free(fullname);
*exists = stat(name, &filestat) == 0;
return name;
}
/*
* Load a YAML mapping into a Perl hash
*/
SV *
load_mapping(perl_yaml_loader_t *loader, char *tag)
{
SV *key_node;
SV *value_node;
HV *hash = newHV();
SV *hash_ref = (SV *)newRV_noinc((SV *)hash);
char *anchor = (char *)loader->event.data.mapping_start.anchor;
if (!tag)
tag = (char *)loader->event.data.mapping_start.tag;
/* Store the anchor label if any */
if (anchor)
hv_store(loader->anchors, anchor, strlen(anchor), SvREFCNT_inc(hash_ref), 0);
/* Get each key string and value node and put them in the hash */
while ((key_node = load_node(loader))) {
assert(SvPOK(key_node));
value_node = load_node(loader);
hv_store_ent(
hash, key_node, value_node, 0
);
}
/* Deal with possibly blessing the hash if the YAML tag has a class */
if (tag && strEQ(tag, TAG_PERL_PREFIX "hash"))
tag = NULL;
if (tag) {
char *class;
char *prefix = TAG_PERL_PREFIX "hash:";
if (*tag == '!') {
prefix = "!";
}
else if (strlen(tag) <= strlen(prefix) ||
! strnEQ(tag, prefix, strlen(prefix))
) croak(
loader_error_msg(loader, form("bad tag found for hash: '%s'", tag))
);
class = tag + strlen(prefix);
sv_bless(hash_ref, gv_stashpv(class, TRUE));
}
return hash_ref;
}
SRL_STATIC_INLINE void
srl_read_header(pTHX_ srl_decoder_t *dec)
{
UV header_len;
/* 4 byte magic string + version/flags + hdr len at least */
ASSERT_BUF_SPACE(dec, 4 + 1 + 1," while reading header");
if (strnEQ((char*)dec->pos, SRL_MAGIC_STRING, 4)) {
dec->pos += 4;
dec->proto_version_and_flags = *dec->pos++;
if (expect_false( (dec->proto_version_and_flags & SRL_PROTOCOL_VERSION_MASK) != 1 ))
SRL_ERRORf1("Unsupported Sereal protocol version %u",
dec->proto_version_and_flags & SRL_PROTOCOL_VERSION_MASK);
if ((dec->proto_version_and_flags & SRL_PROTOCOL_ENCODING_MASK) == SRL_PROTOCOL_ENCODING_RAW) {
/* no op */
}
else
if (
( dec->proto_version_and_flags & SRL_PROTOCOL_ENCODING_MASK ) == SRL_PROTOCOL_ENCODING_SNAPPY
||
( dec->proto_version_and_flags & SRL_PROTOCOL_ENCODING_MASK ) == SRL_PROTOCOL_ENCODING_SNAPPY_INCREMENTAL
) {
if (expect_false( SRL_DEC_HAVE_OPTION(dec, SRL_F_DECODER_REFUSE_SNAPPY) )) {
SRL_ERROR("Sereal document is compressed with Snappy, "
"but this decoder is configured to refuse Snappy-compressed input.");
}
dec->flags |= SRL_F_DECODER_DECOMPRESS_SNAPPY;
}
else
{
SRL_ERRORf1( "Sereal document encoded in an unknown format '%d'",
(dec->proto_version_and_flags & SRL_PROTOCOL_ENCODING_MASK) >> 4 );
}
/* Must do this via a temporary as it modifes dec->pos itself */
header_len= srl_read_varint_uv_length(aTHX_ dec, " while reading header");
/* Skip header since we don't have any defined header-content in this
* protocol version. */
dec->pos += header_len;
} else {
EXTERN void
parse(pTHX_
PSTATE* p_state,
SV* chunk,
SV* self)
{
char *s, *beg, *end;
U32 utf8 = 0;
STRLEN len;
if (!chunk) {
/* eof */
char empty[1];
if (p_state->buf && SvOK(p_state->buf)) {
/* flush it */
s = SvPV(p_state->buf, len);
end = s + len;
utf8 = SvUTF8(p_state->buf);
assert(len);
while (s < end) {
if (p_state->literal_mode) {
if (strEQ(p_state->literal_mode, "plaintext") && !p_state->closing_plaintext)
break;
p_state->pending_end_tag = p_state->literal_mode;
p_state->literal_mode = 0;
s = parse_buf(aTHX_ p_state, s, end, utf8, self);
continue;
}
if (!p_state->strict_comment && !p_state->no_dash_dash_comment_end && *s == '<') {
p_state->no_dash_dash_comment_end = 1;
s = parse_buf(aTHX_ p_state, s, end, utf8, self);
continue;
}
if (!p_state->strict_comment && *s == '<') {
/* some kind of unterminated markup. Report rest as as comment */
token_pos_t token;
token.beg = s + 1;
token.end = end;
report_event(p_state, E_COMMENT, s, end, utf8, &token, 1, self);
s = end;
}
break;
}
if (s < end) {
/* report rest as text */
report_event(p_state, E_TEXT, s, end, utf8, 0, 0, self);
}
SvREFCNT_dec(p_state->buf);
p_state->buf = 0;
}
if (p_state->pend_text && SvOK(p_state->pend_text))
flush_pending_text(p_state, self);
if (p_state->ignoring_element) {
/* document not balanced */
SvREFCNT_dec(p_state->ignoring_element);
p_state->ignoring_element = 0;
}
report_event(p_state, E_END_DOCUMENT, empty, empty, 0, 0, 0, self);
/* reset state */
p_state->offset = 0;
if (p_state->line)
p_state->line = 1;
p_state->column = 0;
p_state->literal_mode = 0;
p_state->is_cdata = 0;
return;
}
#ifdef UNICODE_HTML_PARSER
if (p_state->utf8_mode)
sv_utf8_downgrade(chunk, 0);
#endif
if (p_state->buf && SvOK(p_state->buf)) {
sv_catsv(p_state->buf, chunk);
beg = SvPV(p_state->buf, len);
utf8 = SvUTF8(p_state->buf);
}
else {
beg = SvPV(chunk, len);
utf8 = SvUTF8(chunk);
if (p_state->offset == 0) {
report_event(p_state, E_START_DOCUMENT, beg, beg, 0, 0, 0, self);
/* Print warnings if we find unexpected Unicode BOM forms */
#ifdef UNICODE_HTML_PARSER
if (DOWARN &&
p_state->argspec_entity_decode &&
!p_state->utf8_mode && (
(!utf8 && len >= 3 && strnEQ(beg, "\xEF\xBB\xBF", 3)) ||
(utf8 && len >= 6 && strnEQ(beg, "\xC3\xAF\xC2\xBB\xC2\xBF", 6)) ||
(!utf8 && probably_utf8_chunk(aTHX_ beg, len))
)
)
{
warn("Parsing of undecoded UTF-8 will give garbage when decoding entities");
}
if (DOWARN && utf8 && len >= 2 && strnEQ(beg, "\xFF\xFE", 2)) {
warn("Parsing string decoded with wrong endianess");
}
#endif
if (DOWARN) {
if (!utf8 && len >= 4 &&
(strnEQ(beg, "\x00\x00\xFE\xFF", 4) ||
strnEQ(beg, "\xFE\xFF\x00\x00", 4))
)
{
warn("Parsing of undecoded UTF-32");
}
else if (!utf8 && len >= 2 &&
(strnEQ(beg, "\xFE\xFF", 2) || strnEQ(beg, "\xFF\xFE", 2))
)
{
warn("Parsing of undecoded UTF-16");
}
}
}
}
if (!len)
return; /* nothing to do */
end = beg + len;
s = parse_buf(aTHX_ p_state, beg, end, utf8, self);
if (s == end || p_state->eof) {
if (p_state->buf) {
SvOK_off(p_state->buf);
}
}
else {
/* need to keep rest in buffer */
if (p_state->buf) {
/* chop off some chars at the beginning */
if (SvOK(p_state->buf)) {
sv_chop(p_state->buf, s);
}
else {
sv_setpvn(p_state->buf, s, end - s);
if (utf8)
SvUTF8_on(p_state->buf);
else
SvUTF8_off(p_state->buf);
}
}
else {
p_state->buf = newSVpv(s, end - s);
if (utf8)
SvUTF8_on(p_state->buf);
}
}
return;
}
EXTERN SV*
argspec_compile(SV* src, PSTATE* p_state)
{
dTHX;
SV* argspec = newSVpvn("", 0);
STRLEN len;
char *s = SvPV(src, len);
char *end = s + len;
if (SvUTF8(src))
SvUTF8_on(argspec);
while (isHSPACE(*s))
s++;
if (*s == '@') {
/* try to deal with '@{ ... }' wrapping */
char *tmp = s + 1;
while (isHSPACE(*tmp))
tmp++;
if (*tmp == '{') {
char c = ARG_FLAG_FLAT_ARRAY;
sv_catpvn(argspec, &c, 1);
tmp++;
while (isHSPACE(*tmp))
tmp++;
s = tmp;
}
}
while (s < end) {
if (isHNAME_FIRST(*s) || *s == '@') {
char *name = s;
int a = ARG_SELF;
char **arg_name;
s++;
while (isHNAME_CHAR(*s))
s++;
/* check identifier */
for ( arg_name = argname; a < ARG_LITERAL ; ++a, ++arg_name ) {
if (strnEQ(*arg_name, name, s - name) &&
(*arg_name)[s - name] == '\0')
break;
}
if (a < ARG_LITERAL) {
char c = (unsigned char) a;
sv_catpvn(argspec, &c, 1);
if (a == ARG_LINE || a == ARG_COLUMN) {
if (!p_state->line)
p_state->line = 1; /* enable tracing of line/column */
}
if (a == ARG_SKIPPED_TEXT) {
if (!p_state->skipped_text) {
p_state->skipped_text = newSVpvn("", 0);
}
}
if (a == ARG_ATTR || a == ARG_ATTRARR || a == ARG_DTEXT) {
p_state->argspec_entity_decode++;
}
}
else {
croak("Unrecognized identifier %.*s in argspec", s - name, name);
}
}
else if (*s == '"' || *s == '\'') {
char *string_beg = s;
s++;
while (s < end && *s != *string_beg && *s != '\\')
s++;
if (*s == *string_beg) {
/* literal */
int len = s - string_beg - 1;
unsigned char buf[2];
if (len > 255)
croak("Literal string is longer than 255 chars in argspec");
buf[0] = ARG_LITERAL;
buf[1] = len;
sv_catpvn(argspec, (char*)buf, 2);
sv_catpvn(argspec, string_beg+1, len);
s++;
}
else if (*s == '\\') {
croak("Backslash reserved for literal string in argspec");
}
else {
croak("Unterminated literal string in argspec");
}
}
else {
croak("Bad argspec (%s)", s);
}
while (isHSPACE(*s))
s++;
if (*s == '}' && SvPVX(argspec)[0] == ARG_FLAG_FLAT_ARRAY) {
/* end of '@{ ... }' */
s++;
while (isHSPACE(*s))
s++;
if (s < end)
croak("Bad argspec: stuff after @{...} (%s)", s);
}
if (s == end)
break;
if (*s != ',') {
croak("Missing comma separator in argspec");
}
s++;
while (isHSPACE(*s))
s++;
}
return argspec;
}
/*
* Initialize locale awareness.
*/
int
Perl_init_i18nl10n(pTHX_ int printwarn)
{
int ok = 1;
/* returns
* 1 = set ok or not applicable,
* 0 = fallback to C locale,
* -1 = fallback to C locale failed
*/
#if defined(USE_LOCALE)
#ifdef USE_LOCALE_CTYPE
char *curctype = NULL;
#endif /* USE_LOCALE_CTYPE */
#ifdef USE_LOCALE_COLLATE
char *curcoll = NULL;
#endif /* USE_LOCALE_COLLATE */
#ifdef USE_LOCALE_NUMERIC
char *curnum = NULL;
#endif /* USE_LOCALE_NUMERIC */
#ifdef __GLIBC__
char *language = PerlEnv_getenv("LANGUAGE");
#endif
char *lc_all = PerlEnv_getenv("LC_ALL");
char *lang = PerlEnv_getenv("LANG");
bool setlocale_failure = FALSE;
#ifdef LOCALE_ENVIRON_REQUIRED
/*
* Ultrix setlocale(..., "") fails if there are no environment
* variables from which to get a locale name.
*/
bool done = FALSE;
#ifdef LC_ALL
if (lang) {
if (setlocale(LC_ALL, ""))
done = TRUE;
else
setlocale_failure = TRUE;
}
if (!setlocale_failure) {
#ifdef USE_LOCALE_CTYPE
if (! (curctype =
setlocale(LC_CTYPE,
(!done && (lang || PerlEnv_getenv("LC_CTYPE")))
? "" : Nullch)))
setlocale_failure = TRUE;
else
curctype = savepv(curctype);
#endif /* USE_LOCALE_CTYPE */
#ifdef USE_LOCALE_COLLATE
if (! (curcoll =
setlocale(LC_COLLATE,
(!done && (lang || PerlEnv_getenv("LC_COLLATE")))
? "" : Nullch)))
setlocale_failure = TRUE;
else
curcoll = savepv(curcoll);
#endif /* USE_LOCALE_COLLATE */
#ifdef USE_LOCALE_NUMERIC
if (! (curnum =
setlocale(LC_NUMERIC,
(!done && (lang || PerlEnv_getenv("LC_NUMERIC")))
? "" : Nullch)))
setlocale_failure = TRUE;
else
curnum = savepv(curnum);
#endif /* USE_LOCALE_NUMERIC */
}
#endif /* LC_ALL */
#endif /* !LOCALE_ENVIRON_REQUIRED */
#ifdef LC_ALL
if (! setlocale(LC_ALL, ""))
setlocale_failure = TRUE;
#endif /* LC_ALL */
if (!setlocale_failure) {
#ifdef USE_LOCALE_CTYPE
if (! (curctype = setlocale(LC_CTYPE, "")))
setlocale_failure = TRUE;
else
curctype = savepv(curctype);
#endif /* USE_LOCALE_CTYPE */
#ifdef USE_LOCALE_COLLATE
if (! (curcoll = setlocale(LC_COLLATE, "")))
setlocale_failure = TRUE;
else
curcoll = savepv(curcoll);
#endif /* USE_LOCALE_COLLATE */
#ifdef USE_LOCALE_NUMERIC
if (! (curnum = setlocale(LC_NUMERIC, "")))
setlocale_failure = TRUE;
else
curnum = savepv(curnum);
#endif /* USE_LOCALE_NUMERIC */
}
if (setlocale_failure) {
char *p;
bool locwarn = (printwarn > 1 ||
(printwarn &&
(!(p = PerlEnv_getenv("PERL_BADLANG")) || atoi(p))));
if (locwarn) {
#ifdef LC_ALL
PerlIO_printf(Perl_error_log,
"perl: warning: Setting locale failed.\n");
#else /* !LC_ALL */
PerlIO_printf(Perl_error_log,
"perl: warning: Setting locale failed for the categories:\n\t");
#ifdef USE_LOCALE_CTYPE
if (! curctype)
PerlIO_printf(Perl_error_log, "LC_CTYPE ");
#endif /* USE_LOCALE_CTYPE */
#ifdef USE_LOCALE_COLLATE
if (! curcoll)
PerlIO_printf(Perl_error_log, "LC_COLLATE ");
#endif /* USE_LOCALE_COLLATE */
#ifdef USE_LOCALE_NUMERIC
if (! curnum)
PerlIO_printf(Perl_error_log, "LC_NUMERIC ");
#endif /* USE_LOCALE_NUMERIC */
PerlIO_printf(Perl_error_log, "\n");
#endif /* LC_ALL */
PerlIO_printf(Perl_error_log,
"perl: warning: Please check that your locale settings:\n");
#ifdef __GLIBC__
PerlIO_printf(Perl_error_log,
"\tLANGUAGE = %c%s%c,\n",
language ? '"' : '(',
language ? language : "unset",
language ? '"' : ')');
#endif
PerlIO_printf(Perl_error_log,
"\tLC_ALL = %c%s%c,\n",
lc_all ? '"' : '(',
lc_all ? lc_all : "unset",
lc_all ? '"' : ')');
#if defined(USE_ENVIRON_ARRAY)
{
char **e;
for (e = environ; *e; e++) {
if (strnEQ(*e, "LC_", 3)
&& strnNE(*e, "LC_ALL=", 7)
&& (p = strchr(*e, '=')))
PerlIO_printf(Perl_error_log, "\t%.*s = \"%s\",\n",
(int)(p - *e), *e, p + 1);
}
}
#else
PerlIO_printf(Perl_error_log,
"\t(possibly more locale environment variables)\n");
#endif
PerlIO_printf(Perl_error_log,
"\tLANG = %c%s%c\n",
lang ? '"' : '(',
lang ? lang : "unset",
lang ? '"' : ')');
PerlIO_printf(Perl_error_log,
" are supported and installed on your system.\n");
}
#ifdef LC_ALL
if (setlocale(LC_ALL, "C")) {
if (locwarn)
PerlIO_printf(Perl_error_log,
"perl: warning: Falling back to the standard locale (\"C\").\n");
ok = 0;
}
else {
if (locwarn)
PerlIO_printf(Perl_error_log,
"perl: warning: Failed to fall back to the standard locale (\"C\").\n");
ok = -1;
}
#else /* ! LC_ALL */
if (0
#ifdef USE_LOCALE_CTYPE
|| !(curctype || setlocale(LC_CTYPE, "C"))
#endif /* USE_LOCALE_CTYPE */
#ifdef USE_LOCALE_COLLATE
|| !(curcoll || setlocale(LC_COLLATE, "C"))
#endif /* USE_LOCALE_COLLATE */
#ifdef USE_LOCALE_NUMERIC
|| !(curnum || setlocale(LC_NUMERIC, "C"))
#endif /* USE_LOCALE_NUMERIC */
)
{
if (locwarn)
PerlIO_printf(Perl_error_log,
"perl: warning: Cannot fall back to the standard locale (\"C\").\n");
ok = -1;
}
#endif /* ! LC_ALL */
#ifdef USE_LOCALE_CTYPE
curctype = savepv(setlocale(LC_CTYPE, Nullch));
#endif /* USE_LOCALE_CTYPE */
#ifdef USE_LOCALE_COLLATE
curcoll = savepv(setlocale(LC_COLLATE, Nullch));
#endif /* USE_LOCALE_COLLATE */
#ifdef USE_LOCALE_NUMERIC
curnum = savepv(setlocale(LC_NUMERIC, Nullch));
#endif /* USE_LOCALE_NUMERIC */
}
else {
#ifdef USE_LOCALE_CTYPE
new_ctype(curctype);
#endif /* USE_LOCALE_CTYPE */
#ifdef USE_LOCALE_COLLATE
new_collate(curcoll);
#endif /* USE_LOCALE_COLLATE */
#ifdef USE_LOCALE_NUMERIC
new_numeric(curnum);
#endif /* USE_LOCALE_NUMERIC */
}
#endif /* USE_LOCALE */
#ifdef USE_PERLIO
{
/* Set PL_utf8locale to TRUE if using PerlIO _and_
any of the following are true:
- nl_langinfo(CODESET) contains /^utf-?8/i
- $ENV{LC_ALL} contains /^utf-?8/i
- $ENV{LC_CTYPE} contains /^utf-?8/i
- $ENV{LANG} contains /^utf-?8/i
The LC_ALL, LC_CTYPE, LANG obey the usual override
hierarchy of locale environment variables. (LANGUAGE
affects only LC_MESSAGES only under glibc.) (If present,
it overrides LC_MESSAGES for GNU gettext, and it also
can have more than one locale, separated by spaces,
in case you need to know.)
If PL_utf8locale and PL_unicode (set by -C or by $ENV{PERL_UNICODE})
are true, perl.c:S_parse_body() will turn on the PerlIO :utf8 layer
on STDIN, STDOUT, STDERR, _and_ the default open discipline.
*/
bool utf8locale = FALSE;
char *codeset = NULL;
#if defined(HAS_NL_LANGINFO) && defined(CODESET)
codeset = nl_langinfo(CODESET);
#endif
if (codeset)
utf8locale = (ibcmp(codeset, "UTF-8", 5) == 0 ||
ibcmp(codeset, "UTF8", 4) == 0);
#if defined(USE_LOCALE)
else { /* nl_langinfo(CODESET) is supposed to correctly
* interpret the locale environment variables,
* but just in case it fails, let's do this manually. */
if (lang)
utf8locale = (ibcmp(lang, "UTF-8", 5) == 0 ||
ibcmp(lang, "UTF8", 4) == 0);
#ifdef USE_LOCALE_CTYPE
if (curctype)
utf8locale = (ibcmp(curctype, "UTF-8", 5) == 0 ||
ibcmp(curctype, "UTF8", 4) == 0);
#endif
if (lc_all)
utf8locale = (ibcmp(lc_all, "UTF-8", 5) == 0 ||
ibcmp(lc_all, "UTF8", 4) == 0);
}
#endif /* USE_LOCALE */
if (utf8locale)
PL_utf8locale = TRUE;
}
/* Set PL_unicode to $ENV{PERL_UNICODE} if using PerlIO.
This is an alternative to using the -C command line switch
(the -C if present will override this). */
{
char *p = PerlEnv_getenv("PERL_UNICODE");
PL_unicode = p ? parse_unicode_opts(&p) : 0;
}
#endif
#ifdef USE_LOCALE_CTYPE
Safefree(curctype);
#endif /* USE_LOCALE_CTYPE */
#ifdef USE_LOCALE_COLLATE
Safefree(curcoll);
#endif /* USE_LOCALE_COLLATE */
#ifdef USE_LOCALE_NUMERIC
Safefree(curnum);
#endif /* USE_LOCALE_NUMERIC */
return ok;
}
OP *
Perl_scalarvoid(pTHX_ OP *o)
{
dVAR;
OP *kid;
const char* useless = NULL;
SV* sv;
U8 want;
PERL_ARGS_ASSERT_SCALARVOID;
/* trailing mad null ops don't count as "there" for void processing */
if (PL_madskills &&
o->op_type != OP_NULL &&
o->op_sibling &&
o->op_sibling->op_type == OP_NULL)
{
OP *sib;
for (sib = o->op_sibling;
sib && sib->op_type == OP_NULL;
sib = sib->op_sibling) ;
if (!sib)
return o;
}
if (o->op_type == OP_NEXTSTATE
|| o->op_type == OP_DBSTATE
|| (o->op_type == OP_NULL && (o->op_targ == OP_NEXTSTATE
|| o->op_targ == OP_DBSTATE)))
PL_curcop = (COP*)o; /* for warning below */
/* assumes no premature commitment */
want = o->op_flags & OPf_WANT;
if ((want && want != OPf_WANT_SCALAR)
|| (PL_parser && PL_parser->error_count)
|| o->op_type == OP_RETURN)
{
return o;
}
if ((o->op_flags & OPf_TARGET_MY)
&& (PL_opargs[o->op_type] & OA_TARGLEX))/* OPp share the meaning */
{
return scalar(o); /* As if inside SASSIGN */
}
o->op_flags = (o->op_flags & ~OPf_WANT) | OPf_WANT_VOID;
switch (o->op_type) {
default:
if (!(PL_opargs[o->op_type] & OA_FOLDCONST))
break;
/* FALL THROUGH */
case OP_REPEAT:
if (o->op_flags & OPf_STACKED)
break;
goto func_ops;
case OP_SUBSTR:
case OP_VEC:
if (o->op_private == 4)
break;
/* FALL THROUGH */
case OP_GVSV:
case OP_GV:
case OP_PADSV:
case OP_REF:
case OP_SREFGEN:
case OP_DEFINED:
case OP_HEX:
case OP_OCT:
case OP_LENGTH:
case OP_INDEX:
case OP_RINDEX:
case OP_SPRINTF:
case OP_ASLICE:
case OP_HSLICE:
case OP_UNPACK:
case OP_PACK:
case OP_JOIN:
case OP_LSLICE:
case OP_SORT:
case OP_REVERSE:
case OP_RANGE:
case OP_CALLER:
case OP_FILENO:
case OP_EOF:
case OP_TELL:
case OP_GETSOCKNAME:
case OP_GETPEERNAME:
case OP_READLINK:
case OP_TELLDIR:
case OP_GETPPID:
case OP_GETPGRP:
case OP_GETPRIORITY:
case OP_TIME:
case OP_TMS:
case OP_LOCALTIME:
case OP_GMTIME:
case OP_GHBYNAME:
case OP_GHBYADDR:
case OP_GHOSTENT:
case OP_GNBYNAME:
case OP_GNBYADDR:
case OP_GNETENT:
case OP_GPBYNAME:
case OP_GPBYNUMBER:
case OP_GPROTOENT:
case OP_GSBYNAME:
case OP_GSBYPORT:
case OP_GSERVENT:
case OP_GPWNAM:
case OP_GPWUID:
case OP_GGRNAM:
case OP_GGRGID:
case OP_GETLOGIN:
case OP_PROTOTYPE:
func_ops:
if (!(o->op_private & (OPpLVAL_INTRO|OPpOUR_INTRO)))
/* Otherwise it's "Useless use of grep iterator" */
useless = OP_DESC(o);
break;
case OP_HELEM:
case OP_AELEM:
case OP_AELEMFAST:
if (!(o->op_private & (OPpLVAL_INTRO|OPpOUR_INTRO|OPpELEM_ADD)))
/* Otherwise it's "Useless use of grep iterator" */
useless = OP_DESC(o);
break;
case OP_ANONARRAY:
case OP_ANONHASH:
useless = OP_DESC(o);
break;
case OP_NOT:
kid = cUNOPo->op_first;
if (kid->op_type != OP_MATCH && kid->op_type != OP_SUBST) {
goto func_ops;
}
useless = "negative pattern binding (!~)";
break;
case OP_RV2GV:
case OP_RV2SV:
case OP_RV2AV:
case OP_RV2HV:
if (!(o->op_private & (OPpLVAL_INTRO|OPpOUR_INTRO)) &&
(!o->op_sibling || o->op_sibling->op_type != OP_READLINE))
useless = "a variable";
break;
case OP_CONST:
sv = cSVOPo_sv;
if (cSVOPo->op_private & OPpCONST_STRICT)
Perl_croak_at(aTHX_
o->op_location,
"Bareword \"%"SVf"\" not allowed while \"strict subs\" in use",
SVfARG(cSVOPo_sv));
else {
if (ckWARN(WARN_VOID)) {
useless = "a constant";
/* don't warn on optimised away booleans, eg
* use constant Foo, 5; Foo || print; */
if (cSVOPo->op_private & OPpCONST_SHORTCIRCUIT)
useless = NULL;
/* the constants 0 and 1 are permitted as they are
conventionally used as dummies in constructs like
1 while some_condition_with_side_effects; */
else if (SvNIOK(sv) && (SvNV(sv) == 0.0 || SvNV(sv) == 1.0))
useless = NULL;
else if (SvPOK(sv)) {
/* perl4's way of mixing documentation and code
(before the invention of POD) was based on a
trick to mix nroff and perl code. The trick was
built upon these three nroff macros being used in
void context. The pink camel has the details in
the script wrapman near page 319. */
const char * const maybe_macro = SvPVX_const(sv);
if (strnEQ(maybe_macro, "di", 2) ||
strnEQ(maybe_macro, "ds", 2) ||
strnEQ(maybe_macro, "ig", 2))
useless = NULL;
}
}
}
op_null(o); /* don't execute or even remember it */
break;
#ifndef PERL_MAD
case OP_POSTINC:
o->op_type = OP_PREINC; /* pre-increment is faster */
o->op_ppaddr = PL_ppaddr[OP_PREINC];
break;
case OP_POSTDEC:
o->op_type = OP_PREDEC; /* pre-decrement is faster */
o->op_ppaddr = PL_ppaddr[OP_PREDEC];
break;
case OP_I_POSTINC:
o->op_type = OP_I_PREINC; /* pre-increment is faster */
o->op_ppaddr = PL_ppaddr[OP_I_PREINC];
break;
case OP_I_POSTDEC:
o->op_type = OP_I_PREDEC; /* pre-decrement is faster */
o->op_ppaddr = PL_ppaddr[OP_I_PREDEC];
break;
#endif /* MAD */
case OP_OR:
case OP_AND:
case OP_DOR:
case OP_COND_EXPR:
for (kid = cUNOPo->op_first->op_sibling; kid; kid = kid->op_sibling)
scalarvoid(kid);
break;
case OP_NULL:
if (o->op_flags & OPf_STACKED)
break;
/* FALL THROUGH */
case OP_NEXTSTATE:
case OP_DBSTATE:
case OP_ENTERTRY:
case OP_ENTER:
if (!(o->op_flags & OPf_KIDS))
break;
/* FALL THROUGH */
case OP_SCOPE:
case OP_LEAVE:
case OP_LEAVETRY:
case OP_LEAVELOOP:
case OP_LINESEQ:
case OP_LIST:
case OP_LISTLAST:
case OP_LISTFIRST:
for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling)
scalarvoid(kid);
break;
case OP_SASSIGN:
scalarvoid(cBINOPo->op_last);
break;
case OP_ENTEREVAL:
scalarkids(o);
break;
case OP_REQUIRE:
/* all requires must return a boolean value */
o->op_flags &= ~OPf_WANT;
/* FALL THROUGH */
case OP_SCALAR:
return scalar(o);
case OP_SPLIT:
if ((kid = cLISTOPo->op_first) && kid->op_type == OP_PUSHRE) {
if (!kPMOP->op_pmreplrootu.op_pmreplroot)
deprecate_old("implicit split to @_");
}
break;
}
if (useless && !(o->op_flags & OPf_ASSIGN)
&& ckWARN(WARN_VOID))
Perl_warner_at(aTHX_ o->op_location, packWARN(WARN_VOID), "Useless use of %s in void context", useless);
return o;
}
static int sigar_common_fs_type_get(sigar_file_system_t *fsp)
{
char *type = fsp->sys_type_name;
switch (*type) {
case 'n':
if (strnEQ(type, "nfs", 3)) {
fsp->type = SIGAR_FSTYPE_NETWORK;
}
break;
case 's':
if (strEQ(type, "smbfs")) { /* samba */
fsp->type = SIGAR_FSTYPE_NETWORK;
}
else if (strEQ(type, "swap")) {
fsp->type = SIGAR_FSTYPE_SWAP;
}
break;
case 'a':
if (strEQ(type, "afs")) {
fsp->type = SIGAR_FSTYPE_NETWORK;
}
break;
case 'i':
if (strEQ(type, "iso9660")) {
fsp->type = SIGAR_FSTYPE_CDROM;
}
break;
case 'c':
if (strEQ(type, "cvfs")) {
fsp->type = SIGAR_FSTYPE_LOCAL_DISK;
}
else if (strEQ(type, "cifs")) {
fsp->type = SIGAR_FSTYPE_NETWORK;
}
break;
case 'm':
if (strEQ(type, "msdos") || strEQ(type, "minix")) {
fsp->type = SIGAR_FSTYPE_LOCAL_DISK;
}
break;
case 'h':
if (strEQ(type, "hpfs")) {
fsp->type = SIGAR_FSTYPE_LOCAL_DISK;
}
break;
case 'v':
if (strEQ(type, "vxfs")) {
fsp->type = SIGAR_FSTYPE_LOCAL_DISK;
}
else if (strEQ(type, "vfat")) {
fsp->type = SIGAR_FSTYPE_LOCAL_DISK;
}
break;
case 'z':
if (strEQ(type, "zfs")) {
fsp->type = SIGAR_FSTYPE_LOCAL_DISK;
}
break;
}
return fsp->type;
}
static int
intuit_diff_type(void)
{
long this_line = 0, previous_line;
long first_command_line = -1;
LINENUM fcl_line = -1;
bool last_line_was_command = false, this_is_a_command = false;
bool stars_last_line = false, stars_this_line = false;
char *s, *t;
int indent, retval;
struct file_name names[MAX_FILE];
memset(names, 0, sizeof(names));
ok_to_create_file = false;
fseek(pfp, p_base, SEEK_SET);
p_input_line = p_bline - 1;
for (;;) {
previous_line = this_line;
last_line_was_command = this_is_a_command;
stars_last_line = stars_this_line;
this_line = ftell(pfp);
indent = 0;
p_input_line++;
if (pgets(false) == 0) {
if (first_command_line >= 0L) {
/* nothing but deletes!? */
p_start = first_command_line;
p_sline = fcl_line;
retval = ED_DIFF;
goto scan_exit;
} else {
p_start = this_line;
p_sline = p_input_line;
retval = 0;
goto scan_exit;
}
}
for (s = buf; *s == ' ' || *s == '\t' || *s == 'X'; s++) {
if (*s == '\t')
indent += 8 - (indent % 8);
else
indent++;
}
for (t = s; isdigit((unsigned char)*t) || *t == ','; t++)
;
this_is_a_command = (isdigit((unsigned char)*s) &&
(*t == 'd' || *t == 'c' || *t == 'a'));
if (first_command_line < 0L && this_is_a_command) {
first_command_line = this_line;
fcl_line = p_input_line;
p_indent = indent; /* assume this for now */
}
if (!stars_last_line && strnEQ(s, "*** ", 4))
names[OLD_FILE].path = fetchname(s + 4,
&names[OLD_FILE].exists, strippath);
else if (strnEQ(s, "--- ", 4))
names[NEW_FILE].path = fetchname(s + 4,
&names[NEW_FILE].exists, strippath);
else if (strnEQ(s, "+++ ", 4))
/* pretend it is the old name */
names[OLD_FILE].path = fetchname(s + 4,
&names[OLD_FILE].exists, strippath);
else if (strnEQ(s, "Index:", 6))
names[INDEX_FILE].path = fetchname(s + 6,
&names[INDEX_FILE].exists, strippath);
else if (strnEQ(s, "Prereq:", 7)) {
for (t = s + 7; isspace((unsigned char)*t); t++)
;
revision = savestr(t);
for (t = revision; *t && !isspace((unsigned char)*t); t++)
;
*t = '\0';
if (*revision == '\0') {
free(revision);
revision = NULL;
}
} else if (strnEQ(s, "==== ", 5)) {
/* Perforce-style diffs. */
if ((t = strstr(s + 5, " - ")) != NULL)
p4_fetchname(&names[NEW_FILE], t + 3);
p4_fetchname(&names[OLD_FILE], s + 5);
}
if ((!diff_type || diff_type == ED_DIFF) &&
first_command_line >= 0L &&
strEQ(s, ".\n")) {
p_indent = indent;
p_start = first_command_line;
p_sline = fcl_line;
retval = ED_DIFF;
goto scan_exit;
}
if ((!diff_type || diff_type == UNI_DIFF) && strnEQ(s, "@@ -", 4)) {
if (strnEQ(s + 4, "0,0", 3))
ok_to_create_file = true;
p_indent = indent;
p_start = this_line;
p_sline = p_input_line;
retval = UNI_DIFF;
goto scan_exit;
}
stars_this_line = strnEQ(s, "********", 8);
if ((!diff_type || diff_type == CONTEXT_DIFF) && stars_last_line &&
strnEQ(s, "*** ", 4)) {
if (atol(s + 4) == 0)
ok_to_create_file = true;
/*
* If this is a new context diff the character just
* before the newline is a '*'.
*/
while (*s != '\n')
s++;
p_indent = indent;
p_start = previous_line;
p_sline = p_input_line - 1;
retval = (*(s - 1) == '*' ? NEW_CONTEXT_DIFF : CONTEXT_DIFF);
goto scan_exit;
}
if ((!diff_type || diff_type == NORMAL_DIFF) &&
last_line_was_command &&
(strnEQ(s, "< ", 2) || strnEQ(s, "> ", 2))) {
p_start = previous_line;
p_sline = p_input_line - 1;
p_indent = indent;
retval = NORMAL_DIFF;
goto scan_exit;
}
}
scan_exit:
if (retval == UNI_DIFF) {
/* unswap old and new */
struct file_name tmp = names[OLD_FILE];
names[OLD_FILE] = names[NEW_FILE];
names[NEW_FILE] = tmp;
}
if (filearg[0] == NULL) {
if (posix)
filearg[0] = posix_name(names, ok_to_create_file);
else {
/* Ignore the Index: name for context diffs, like GNU */
if (names[OLD_FILE].path != NULL ||
names[NEW_FILE].path != NULL) {
free(names[INDEX_FILE].path);
names[INDEX_FILE].path = NULL;
}
filearg[0] = best_name(names, ok_to_create_file);
}
}
free(bestguess);
bestguess = NULL;
if (filearg[0] != NULL)
bestguess = savestr(filearg[0]);
else if (!ok_to_create_file) {
/*
* We don't want to create a new file but we need a
* filename to set bestguess. Avoid setting filearg[0]
* so the file is not created automatically.
*/
if (posix)
bestguess = posix_name(names, true);
else
bestguess = best_name(names, true);
}
free(names[OLD_FILE].path);
free(names[NEW_FILE].path);
free(names[INDEX_FILE].path);
return retval;
}
/*
* Function to do a complete selection screen
*/
int iSelect_Browser(int wYSize, int wXSize, int wYPos, int wXPos, int selectpos, int multiselect,
int sYSize, int sXSize, int sYPos, int sXPos, char *title, char *name,
int mYSize, int mXSize, int mYPos, int mXPos,
char **keystr, char *tagbegin, char *tagend)
{
WINDOW *wField;
WINDOW *sField;
WINDOW *mField;
WINDOW *hField;
int i;
int nFirstLine, nLastLine; /* first & last line in buffer */
int nAbsFirstLine, nAbsLastLine; /* first & last line of output buffer */
int nRelMarked; /* relative line inside output buffer of marked line */
int nRelFirstDraw, nRelLastDraw; /* relative first & last line inside output buffer */
int c;
int bEOI;
int bQuit = FALSE;
int y;
int x;
char msg[1024];
char ca[1024];
char ca3[1024];
char *cp;
char *cp2;
char *cp3;
char **cpp;
int ok;
int bAllowEmpty;
/*
* Browser field
*/
wField = newwin(wYSize, wXSize, wYPos, wXPos);
werase(wField);
crmode();
noecho();
keypad(wField, TRUE);
scrollok(wField, FALSE);
/*
* Status field
*/
sField = newwin(sYSize, sXSize, sYPos, sXPos);
werase(sField);
strcpy(msg, "");
/*
* Message field
*/
mField = newwin(mYSize, mXSize, mYPos, mXPos);
werase(mField);
/* dimension of file */
nFirstLine = 0;
nLastLine = nLines-1;
/* determine curses select position */
if (selectpos < -1)
selectpos = -1;
if (selectpos > nLastLine)
selectpos = nLastLine;
if (selectpos == -1) {
selectpos = 0;
/* search for first selectable line */
for (i = nFirstLine; i < nLastLine; i++) {
if (spaLines[i]->fSelectable) {
selectpos = i;
break;
}
}
}
/* calculate browser view borders */
if (nLastLine < (wYSize-1)) {
/* buffer has fewer lines then our browser window */
nAbsFirstLine = nFirstLine;
nAbsLastLine = nLastLine;
nRelFirstDraw = 0;
nRelLastDraw = nLastLine-nFirstLine;
nRelMarked = selectpos;
}
else {
/* browser window is smaller then file */
/* find top view position, so adjust the
cursor into the middle of the browser window */
y = selectpos - (int)((wYSize-1)/2);
if (y <= 0)
y = 0;
if (y+(wYSize-1) > nLastLine)
y = nLastLine-(wYSize-1);
nAbsFirstLine = y;
nAbsLastLine = y+(wYSize-1);
nRelFirstDraw = 0;
nRelLastDraw = (wYSize-1);
nRelMarked = selectpos-y;
}
ok = FALSE;
for (i = nFirstLine; i < nLastLine; i++) {
if (spaLines[i]->fSelectable) {
ok = TRUE;
break;
}
}
if (!ok)
strcpy(msg, "WARNING! No lines selectable.");
bEOI = FALSE;
while (bEOI == FALSE) {
iSelect_Draw(wField,
wYSize, wXSize, wYPos, wXPos,
nAbsFirstLine, nAbsLastLine,
nRelMarked,
nRelFirstDraw, nRelLastDraw,
nLines,
sField, title, name,
mField, msg,
tagbegin, tagend);
wrefresh(wField);
strcpy(msg, "");
c = wgetch(wField);
*keystr = key2asc(c);
c = do_custom_key(c);
if (c == KEY_LEFT)
c = 'q';
if (c == KEY_RIGHT)
c = '\n';
if (c >= KEY_MIN && c <= KEY_MAX) {
/*
* a curses special function key
*/
if (c == KEY_DOWN) {
if (nAbsFirstLine+nRelMarked < nAbsLastLine) {
nRelMarked++;
/* nRelFirstDraw=nRelMarked-1; !!OPTIMIZE!! */
/* nRelLastDraw=nRelMarked; !!OPTIMIZE!! */
}
else {
if (nAbsLastLine < nLastLine) {
wscrl(wField, 1);
nAbsFirstLine++;
nAbsLastLine++;
/* nRelFirstDraw=(wYSize-1); !!OPTIMIZE!! */
/* nRelLastDraw=(wYSize-1); !!OPTIMIZE!!*/
}
else {
strcpy(msg, "Already at End.");
}
}
}
else if (c == KEY_UP) {
if (nRelMarked > 0) {
nRelMarked--;
/* nRelLastDraw=nRelMarked; !!OPTIMIZE!! */
/* nRelFirstDraw=nRelMarked+1; !!OPTIMIZE!! */
}
else {
if (nAbsFirstLine > nFirstLine) {
wscrl(wField, -1);
nAbsFirstLine--;
nAbsLastLine--;
/* nRelFirstDraw=0 !!OPTIMIZE!! */
/* nRelLastDraw=0; !!OPTIMIZE!! */
}
else {
strcpy(msg, "Already at Begin.");
}
}
}
else if (c == KEY_NPAGE) {
if (nAbsFirstLine+nRelMarked == nLastLine) {
strcpy(msg, "Already at End.");
}
else {
for (i = 0; i < (wYSize-1); i++) {
if (nAbsFirstLine+nRelMarked < nAbsLastLine)
nRelMarked++;
else {
if (nAbsLastLine < nLastLine) {
wscrl(wField, 1);
nAbsFirstLine++;
nAbsLastLine++;
}
}
}
}
}
else if (c == KEY_PPAGE) {
if (nAbsFirstLine+nRelMarked == nFirstLine) {
strcpy(msg, "Already at Begin.");
}
else {
for (i = 0; i < (wYSize-1); i++) {
if (nRelMarked > 0)
nRelMarked--;
else {
if (nAbsFirstLine > nFirstLine) {
wscrl(wField, -1);
nAbsFirstLine--;
nAbsLastLine--;
}
}
}
}
}
else {
strcpy(msg, "Invalid special key. Press 'h' for Help Page!");
}
}
else {
c = c & 0xff; /* strip down to 8bit */
if (c < 32 || c > 126) {
/*
* a control code
*/
if (c == '\n' || c == '\r') { /* RETURN */
if (spaLines[nAbsFirstLine+nRelMarked]->fSelectable) {
spaLines[nAbsFirstLine+nRelMarked]->fSelected = TRUE;
bEOI = TRUE;
}
else {
if (multiselect) {
for (i = 0; i < nLines; i++) {
if (spaLines[i]->fSelected) {
bEOI = TRUE;
break;
}
}
if (!bEOI)
strcpy(msg, "Line not selectable and still no others selected.");
}
else {
strcpy(msg, "Line not selectable.");
}
}
/* additionally ask for query strings */
if (bEOI == TRUE) {
cp = spaLines[nAbsFirstLine+nRelMarked]->cpResult;
cp2 = ca;
while (bEOI == TRUE && *cp != NUL) {
if (strnEQ(cp, "%[", 2)) {
cp += 2;
for (cp3 = cp; !strniEQ(cp3, "]s", 2); cp3++)
;
strncpy(ca3, cp, cp3-cp);
ca3[cp3-cp] = NUL;
cp = cp3+1;
if (*cp == 's')
bAllowEmpty = TRUE;
else
bAllowEmpty = FALSE;
cp++;
sprintf(msg, "%s: ", ca3);
iSelect_Draw(wField, wYSize, wXSize, wYPos, wXPos, nAbsFirstLine, nAbsLastLine, -1, nRelFirstDraw, nRelLastDraw, nLines, sField, title, name, mField, msg, tagbegin, tagend);
wrefresh(wField);
cp3 = iSelect_InputField(mYSize, mXSize-strlen(msg), mYPos, mXPos+strlen(msg), bAllowEmpty);
if (strEQ(cp3, "ESC")) {
bEOI = FALSE;
spaLines[nAbsFirstLine+nRelMarked]->fSelected = FALSE;
strcpy(msg, "Selection cancelled.");
continue;
}
strcpy(msg, "");
strcpy(cp2, cp3);
cp2 += strlen(cp3);
}
else {
*cp2++ = *cp++;
}
}
if (bEOI == TRUE) {
*cp2 = NUL;
if (strNE(spaLines[nAbsFirstLine+nRelMarked]->cpResult, ca))
spaLines[nAbsFirstLine+nRelMarked]->cpResult = strdup(ca);
}
}
}
}
if (c >= 32 && c <= 126) {
/*
* a printable character
*/
if (c == ' ') {
if (multiselect) {
if (spaLines[nAbsFirstLine+nRelMarked]->fSelectable) {
if (spaLines[nAbsFirstLine+nRelMarked]->fSelected == FALSE)
spaLines[nAbsFirstLine+nRelMarked]->fSelected = TRUE;
else
spaLines[nAbsFirstLine+nRelMarked]->fSelected = FALSE;
}
else {
strcpy(msg, "Line not selectable.");
}
}
else {
strcpy(msg, "No multi-line selection allowed.");
}
}
else if (c == 'q') {
bEOI = TRUE;
bQuit = TRUE;
}
else if (c == 'g') {
if (nAbsFirstLine+nRelMarked == nFirstLine) {
strcpy(msg, "Already at Begin.");
}
else {
if (nLastLine < (wYSize-1)) {
nAbsFirstLine = nFirstLine;
nAbsLastLine = nLastLine;
nRelFirstDraw = 0;
nRelLastDraw = nLastLine-nFirstLine;
nRelMarked = 0;
}
else {
nAbsFirstLine = nFirstLine;
nAbsLastLine = nFirstLine+(wYSize-1);
nRelFirstDraw = 0;
nRelLastDraw = (wYSize-1);
nRelMarked = 0;
}
}
}
else if (c == 'G') {
if (nAbsFirstLine+nRelMarked == nLastLine) {
strcpy(msg, "Already at End.");
}
else {
if (nLastLine < (wYSize-1)) {
nAbsFirstLine = nFirstLine;
nAbsLastLine = nLastLine;
nRelFirstDraw = 0;
nRelLastDraw = nLastLine-nFirstLine;
nRelMarked = nLastLine-nFirstLine;
}
else {
nAbsFirstLine = nLastLine-(wYSize-1);
nAbsLastLine = nLastLine;
nRelFirstDraw = 0;
nRelLastDraw = (wYSize-1);
nRelMarked = (wYSize-1);
}
}
}
else if (c == 'h' || c == 'v') {
if (c == 'h')
strcpy(msg, "Help Page: Press 'q' to exit");
else
strcpy(msg, "Version Page: Press 'q' to exit");
iSelect_Draw(wField, wYSize, wXSize, wYPos, wXPos, nAbsFirstLine, nAbsLastLine, nRelMarked, nRelFirstDraw, nRelLastDraw, nLines, sField, title, name, mField, msg, tagbegin, tagend);
wrefresh(wField);
hField = newwin(wYSize, wXSize, wYPos, wXPos);
werase(hField);
if (c == 'h')
cpp = iSelect_Help;
else
cpp = iSelect_README;
for (y = 0; y < wYSize && cpp[y] != NULL; y++) {
sprintf(ca, cpp[y]);
cp = ca;
x = 0;
while (1) {
if ((cp2 = strstr(cp, "<b>")) != NULL) {
*cp2 = NUL;
wmove(hField, y, x); waddstr(hField, cp); x += strlen(cp);
wattrset(hField, A_NORMAL|A_BOLD);
cp = cp2+3;
cp2 = strstr(cp, "</b>");
*cp2 = NUL;
wmove(hField, y, x); waddstr(hField, cp); x += strlen(cp);
wattrset(hField, A_NORMAL);
cp = cp2+4;
}
else {
wmove(hField, y, x); waddstr(hField, cp);
break;
}
}
}
wrefresh(hField);
while (1) {
c = wgetch(wField);
c = c & 0xff; /* strip down to 8bit */
if (c == 'q')
break;
}
delwin(hField);
nRelFirstDraw = 0;
nRelLastDraw = nAbsLastLine-nAbsFirstLine;
strcpy(msg, "");
iSelect_Draw(wField, wYSize, wXSize, wYPos, wXPos, nAbsFirstLine, nAbsLastLine, nRelMarked, nRelFirstDraw, nRelLastDraw, nLines, sField, title, name, mField, msg, tagbegin, tagend);
#ifndef USE_SLCURSES
redrawwin(wField);
#endif
wrefresh(wField);
}
else {
strcpy(msg, "Invalid key. Press 'h' for Help Page!");
}
}
}
}
fflush(stdin);
echo();
#ifndef USE_SLCURSES
nocrmode();
#endif
delwin(wField);
if (bQuit)
return(-1);
else
return(nAbsFirstLine+nRelMarked);
}
GV *
Perl_gv_fetchmethod_autoload(pTHX_ HV *stash, const char *name, I32 autoload)
{
register const char *nend;
const char *nsplit = 0;
GV* gv;
HV* ostash = stash;
if (stash && SvTYPE(stash) < SVt_PVHV)
stash = Nullhv;
for (nend = name; *nend; nend++) {
if (*nend == '\'')
nsplit = nend;
else if (*nend == ':' && *(nend + 1) == ':')
nsplit = ++nend;
}
if (nsplit) {
const char *origname = name;
name = nsplit + 1;
if (*nsplit == ':')
--nsplit;
if ((nsplit - origname) == 5 && strnEQ(origname, "SUPER", 5)) {
/* ->SUPER::method should really be looked up in original stash */
SV *tmpstr = sv_2mortal(Perl_newSVpvf(aTHX_ "%s::SUPER",
CopSTASHPV(PL_curcop)));
/* __PACKAGE__::SUPER stash should be autovivified */
stash = gv_stashpvn(SvPVX(tmpstr), SvCUR(tmpstr), TRUE);
DEBUG_o( Perl_deb(aTHX_ "Treating %s as %s::%s\n",
origname, HvNAME(stash), name) );
}
else {
/* don't autovifify if ->NoSuchStash::method */
stash = gv_stashpvn(origname, nsplit - origname, FALSE);
/* however, explicit calls to Pkg::SUPER::method may
happen, and may require autovivification to work */
if (!stash && (nsplit - origname) >= 7 &&
strnEQ(nsplit - 7, "::SUPER", 7) &&
gv_stashpvn(origname, nsplit - origname - 7, FALSE))
stash = gv_stashpvn(origname, nsplit - origname, TRUE);
}
ostash = stash;
}
gv = gv_fetchmeth(stash, name, nend - name, 0);
if (!gv) {
if (strEQ(name,"import") || strEQ(name,"unimport"))
gv = (GV*)&PL_sv_yes;
else if (autoload)
gv = gv_autoload4(ostash, name, nend - name, TRUE);
}
else if (autoload) {
CV* cv = GvCV(gv);
if (!CvROOT(cv) && !CvXSUB(cv)) {
GV* stubgv;
GV* autogv;
if (CvANON(cv))
stubgv = gv;
else {
stubgv = CvGV(cv);
if (GvCV(stubgv) != cv) /* orphaned import */
stubgv = gv;
}
autogv = gv_autoload4(GvSTASH(stubgv),
GvNAME(stubgv), GvNAMELEN(stubgv), TRUE);
if (autogv)
gv = autogv;
}
}
return gv;
}
/*
=for apidoc mro_package_moved
Call this function to signal to a stash that it has been assigned to
another spot in the stash hierarchy. C<stash> is the stash that has been
assigned. C<oldstash> is the stash it replaces, if any. C<gv> is the glob
that is actually being assigned to.
This can also be called with a null first argument to
indicate that C<oldstash> has been deleted.
This function invalidates isa caches on the old stash, on all subpackages
nested inside it, and on the subclasses of all those, including
non-existent packages that have corresponding entries in C<stash>.
It also sets the effective names (C<HvENAME>) on all the stashes as
appropriate.
If the C<gv> is present and is not in the symbol table, then this function
simply returns. This checked will be skipped if C<flags & 1>.
=cut
*/
void
Perl_mro_package_moved(pTHX_ HV * const stash, HV * const oldstash,
const GV * const gv, U32 flags)
{
SV *namesv;
HEK **namep;
I32 name_count;
HV *stashes;
HE* iter;
PERL_ARGS_ASSERT_MRO_PACKAGE_MOVED;
assert(stash || oldstash);
/* Determine the name(s) of the location that stash was assigned to
* or from which oldstash was removed.
*
* We cannot reliably use the name in oldstash, because it may have
* been deleted from the location in the symbol table that its name
* suggests, as in this case:
*
* $globref = \*foo::bar::;
* Symbol::delete_package("foo");
* *$globref = \%baz::;
* *$globref = *frelp::;
* # calls mro_package_moved(%frelp::, %baz::, *$globref, NULL, 0)
*
* So we get it from the gv. But, since the gv may no longer be in the
* symbol table, we check that first. The only reliable way to tell is
* to see whether its stash has an effective name and whether the gv
* resides in that stash under its name. That effective name may be
* different from what gv_fullname4 would use.
* If flags & 1, the caller has asked us to skip the check.
*/
if(!(flags & 1)) {
SV **svp;
if(
!GvSTASH(gv) || !HvENAME(GvSTASH(gv)) ||
!(svp = hv_fetchhek(GvSTASH(gv), GvNAME_HEK(gv), 0)) ||
*svp != (SV *)gv
) return;
}
assert(SvOOK(GvSTASH(gv)));
assert(GvNAMELEN(gv));
assert(GvNAME(gv)[GvNAMELEN(gv) - 1] == ':');
assert(GvNAMELEN(gv) == 1 || GvNAME(gv)[GvNAMELEN(gv) - 2] == ':');
name_count = HvAUX(GvSTASH(gv))->xhv_name_count;
if (!name_count) {
name_count = 1;
namep = &HvAUX(GvSTASH(gv))->xhv_name_u.xhvnameu_name;
}
else {
namep = HvAUX(GvSTASH(gv))->xhv_name_u.xhvnameu_names;
if (name_count < 0) ++namep, name_count = -name_count - 1;
}
if (name_count == 1) {
if (HEK_LEN(*namep) == 4 && strnEQ(HEK_KEY(*namep), "main", 4)) {
namesv = GvNAMELEN(gv) == 1
? newSVpvs_flags(":", SVs_TEMP)
: newSVpvs_flags("", SVs_TEMP);
}
else {
namesv = sv_2mortal(newSVhek(*namep));
if (GvNAMELEN(gv) == 1) sv_catpvs(namesv, ":");
else sv_catpvs(namesv, "::");
}
if (GvNAMELEN(gv) != 1) {
sv_catpvn_flags(
namesv, GvNAME(gv), GvNAMELEN(gv) - 2,
/* skip trailing :: */
GvNAMEUTF8(gv) ? SV_CATUTF8 : SV_CATBYTES
);
}
}
else {
SV *aname;
namesv = sv_2mortal((SV *)newAV());
while (name_count--) {
if(HEK_LEN(*namep) == 4 && strnEQ(HEK_KEY(*namep), "main", 4)) {
aname = GvNAMELEN(gv) == 1
? newSVpvs(":")
: newSVpvs("");
namep++;
}
else {
aname = newSVhek(*namep++);
if (GvNAMELEN(gv) == 1) sv_catpvs(aname, ":");
else sv_catpvs(aname, "::");
}
if (GvNAMELEN(gv) != 1) {
sv_catpvn_flags(
aname, GvNAME(gv), GvNAMELEN(gv) - 2,
/* skip trailing :: */
GvNAMEUTF8(gv) ? SV_CATUTF8 : SV_CATBYTES
);
}
av_push((AV *)namesv, aname);
}
}
/* Get a list of all the affected classes. */
/* We cannot simply pass them all to mro_isa_changed_in to avoid
the list, as that function assumes that only one package has
changed. It does not work with:
@foo::ISA = qw( B B::B );
*B:: = delete $::{"A::"};
as neither B nor B::B can be updated before the other, since they
will reset caches on foo, which will see either B or B::B with the
wrong name. The names must be set on *all* affected stashes before
we do anything else. (And linearisations must be cleared, too.)
*/
stashes = (HV *) sv_2mortal((SV *)newHV());
mro_gather_and_rename(
stashes, (HV *) sv_2mortal((SV *)newHV()),
stash, oldstash, namesv
);
/* Once the caches have been wiped on all the classes, call
mro_isa_changed_in on each. */
hv_iterinit(stashes);
while((iter = hv_iternext(stashes))) {
HV * const stash = *(HV **)HEK_KEY(HeKEY_hek(iter));
if(HvENAME(stash)) {
/* We have to restore the original meta->isa (that
mro_gather_and_rename set aside for us) this way, in case
one class in this list is a superclass of a another class
that we have already encountered. In such a case, meta->isa
from PL_isarev. */
struct mro_meta * const meta = HvMROMETA(stash);
if(meta->isa != (HV *)HeVAL(iter)) {
SvREFCNT_dec(meta->isa);
meta->isa
= HeVAL(iter) == &PL_sv_yes
? NULL
: (HV *)HeVAL(iter);
HeVAL(iter) = NULL; /* We donated our reference count. */
}
mro_isa_changed_in(stash);
}
}
}
static bool
plan_a(const char *filename)
{
int ifd, statfailed;
char *p, *s, lbuf[MAXLINELEN];
struct stat filestat;
off_t i;
ptrdiff_t sz;
size_t iline, lines_allocated;
#ifdef DEBUGGING
if (debug & 8)
return false;
#endif
if (filename == NULL || *filename == '\0')
return false;
statfailed = stat(filename, &filestat);
if (statfailed && ok_to_create_file) {
if (verbose)
say("(Creating file %s...)\n", filename);
/*
* in check_patch case, we still display `Creating file' even
* though we're not. The rule is that -C should be as similar
* to normal patch behavior as possible
*/
if (check_only)
return true;
makedirs(filename, true);
close(creat(filename, 0666));
statfailed = stat(filename, &filestat);
}
if (statfailed && check_only)
fatal("%s not found, -C mode, can't probe further\n", filename);
/* For nonexistent or read-only files, look for RCS or SCCS versions. */
if (statfailed ||
/* No one can write to it. */
(filestat.st_mode & 0222) == 0 ||
/* I can't write to it. */
((filestat.st_mode & 0022) == 0 && filestat.st_uid != getuid())) {
const char *cs = NULL, *filebase, *filedir;
struct stat cstat;
char *tmp_filename1, *tmp_filename2;
tmp_filename1 = strdup(filename);
tmp_filename2 = strdup(filename);
if (tmp_filename1 == NULL || tmp_filename2 == NULL)
fatal("strdupping filename");
filebase = basename(tmp_filename1);
filedir = dirname(tmp_filename2);
/* Leave room in lbuf for the diff command. */
s = lbuf + 20;
#define try(f, a1, a2, a3) \
(snprintf(s, sizeof lbuf - 20, f, a1, a2, a3), stat(s, &cstat) == 0)
if (try("%s/RCS/%s%s", filedir, filebase, RCSSUFFIX) ||
try("%s/RCS/%s%s", filedir, filebase, "") ||
try("%s/%s%s", filedir, filebase, RCSSUFFIX)) {
snprintf(buf, buf_len, CHECKOUT, filename);
snprintf(lbuf, sizeof lbuf, RCSDIFF, filename);
cs = "RCS";
} else if (try("%s/SCCS/%s%s", filedir, SCCSPREFIX, filebase) ||
try("%s/%s%s", filedir, SCCSPREFIX, filebase)) {
snprintf(buf, buf_len, GET, s);
snprintf(lbuf, sizeof lbuf, SCCSDIFF, s, filename);
cs = "SCCS";
} else if (statfailed)
fatal("can't find %s\n", filename);
free(tmp_filename1);
free(tmp_filename2);
/*
* else we can't write to it but it's not under a version
* control system, so just proceed.
*/
if (cs) {
if (!statfailed) {
if ((filestat.st_mode & 0222) != 0)
/* The owner can write to it. */
fatal("file %s seems to be locked "
"by somebody else under %s\n",
filename, cs);
/*
* It might be checked out unlocked. See if
* it's safe to check out the default version
* locked.
*/
if (verbose)
say("Comparing file %s to default "
"%s version...\n",
filename, cs);
if (system(lbuf))
fatal("can't check out file %s: "
"differs from default %s version\n",
filename, cs);
}
if (verbose)
say("Checking out file %s from %s...\n",
filename, cs);
if (system(buf) || stat(filename, &filestat))
fatal("can't check out file %s from %s\n",
filename, cs);
}
}
filemode = filestat.st_mode;
if (!S_ISREG(filemode))
fatal("%s is not a normal file--can't patch\n", filename);
i_size = filestat.st_size;
if (out_of_mem) {
set_hunkmax(); /* make sure dynamic arrays are allocated */
out_of_mem = false;
return false; /* force plan b because plan a bombed */
}
if ((uintmax_t)i_size > (uintmax_t)SIZE_MAX) {
say("block too large to mmap\n");
return false;
}
if ((ifd = open(filename, O_RDONLY)) < 0)
pfatal("can't open file %s", filename);
if (i_size) {
i_womp = mmap(NULL, i_size, PROT_READ, MAP_PRIVATE, ifd, 0);
if (i_womp == MAP_FAILED) {
perror("mmap failed");
i_womp = NULL;
close(ifd);
return false;
}
} else {
i_womp = NULL;
}
close(ifd);
#if !defined(__minix)
if (i_size)
madvise(i_womp, i_size, MADV_SEQUENTIAL);
#endif /* !defined(__minix) */
/* estimate the number of lines */
lines_allocated = i_size / 25;
if (lines_allocated < 100)
lines_allocated = 100;
if (!reallocate_lines(&lines_allocated))
return false;
/* now scan the buffer and build pointer array */
iline = 1;
i_ptr[iline] = i_womp;
/* test for NUL too, to maintain the behavior of the original code */
for (s = i_womp, i = 0; i < i_size && *s != '\0'; s++, i++) {
if (*s == '\n') {
if (iline == lines_allocated) {
if (!reallocate_lines(&lines_allocated))
return false;
}
/* these are NOT NUL terminated */
i_ptr[++iline] = s + 1;
}
}
/* if the last line contains no EOL, append one */
if (i_size > 0 && i_womp[i_size - 1] != '\n') {
last_line_missing_eol = true;
/* fix last line */
sz = s - i_ptr[iline];
p = malloc(sz + 1);
if (p == NULL) {
free(i_ptr);
i_ptr = NULL;
munmap(i_womp, i_size);
i_womp = NULL;
return false;
}
memcpy(p, i_ptr[iline], sz);
p[sz] = '\n';
i_ptr[iline] = p;
/* count the extra line and make it point to some valid mem */
i_ptr[++iline] = empty_line;
} else
last_line_missing_eol = false;
input_lines = iline - 1;
/* now check for revision, if any */
if (revision != NULL) {
if (!rev_in_string(i_womp)) {
if (force) {
if (verbose)
say("Warning: this file doesn't appear "
"to be the %s version--patching anyway.\n",
revision);
} else if (batch) {
fatal("this file doesn't appear to be the "
"%s version--aborting.\n",
revision);
} else {
ask("This file doesn't appear to be the "
"%s version--patch anyway? [n] ",
revision);
if (*buf != 'y')
fatal("aborted\n");
}
} else if (verbose)
say("Good. This file appears to be the %s version.\n",
revision);
}
return true; /* plan a will work */
}
/* Keep (virtually) nothing in memory. */
static void
plan_b(const char *filename)
{
FILE *ifp;
size_t i = 0, j, maxlen = 1;
char *p;
bool found_revision = (revision == NULL);
using_plan_a = false;
if ((ifp = fopen(filename, "r")) == NULL)
pfatal("can't open file %s", filename);
unlink(TMPINNAME);
if ((tifd = open(TMPINNAME, O_EXCL | O_CREAT | O_WRONLY, 0666)) < 0)
pfatal("can't open file %s", TMPINNAME);
while (fgets(buf, buf_len, ifp) != NULL) {
if (revision != NULL && !found_revision && rev_in_string(buf))
found_revision = true;
if ((i = strlen(buf)) > maxlen)
maxlen = i; /* find longest line */
}
last_line_missing_eol = i > 0 && buf[i - 1] != '\n';
if (last_line_missing_eol && maxlen == i)
maxlen++;
if (revision != NULL) {
if (!found_revision) {
if (force) {
if (verbose)
say("Warning: this file doesn't appear "
"to be the %s version--patching anyway.\n",
revision);
} else if (batch) {
fatal("this file doesn't appear to be the "
"%s version--aborting.\n",
revision);
} else {
ask("This file doesn't appear to be the %s "
"version--patch anyway? [n] ",
revision);
if (*buf != 'y')
fatal("aborted\n");
}
} else if (verbose)
say("Good. This file appears to be the %s version.\n",
revision);
}
fseek(ifp, 0L, SEEK_SET); /* rewind file */
lines_per_buf = BUFFERSIZE / maxlen;
tireclen = maxlen;
tibuf[0] = malloc(BUFFERSIZE + 1);
if (tibuf[0] == NULL)
fatal("out of memory\n");
tibuf[1] = malloc(BUFFERSIZE + 1);
if (tibuf[1] == NULL)
fatal("out of memory\n");
for (i = 1;; i++) {
p = tibuf[0] + maxlen * (i % lines_per_buf);
if (i % lines_per_buf == 0) /* new block */
if (write(tifd, tibuf[0], BUFFERSIZE) < BUFFERSIZE)
pfatal("can't write temp file");
if (fgets(p, maxlen + 1, ifp) == NULL) {
input_lines = i - 1;
if (i % lines_per_buf != 0)
if (write(tifd, tibuf[0], BUFFERSIZE) < BUFFERSIZE)
pfatal("can't write temp file");
break;
}
j = strlen(p);
/* These are '\n' terminated strings, so no need to add a NUL */
if (j == 0 || p[j - 1] != '\n')
p[j] = '\n';
}
fclose(ifp);
close(tifd);
if ((tifd = open(TMPINNAME, O_RDONLY)) < 0)
pfatal("can't reopen file %s", TMPINNAME);
}
/*
* Fetch a line from the input file, \n terminated, not necessarily \0.
*/
char *
ifetch(LINENUM line, int whichbuf)
{
if (line < 1 || line > input_lines) {
if (warn_on_invalid_line) {
say("No such line %ld in input file, ignoring\n", line);
warn_on_invalid_line = false;
}
return NULL;
}
if (using_plan_a)
return i_ptr[line];
else {
LINENUM offline = line % lines_per_buf;
LINENUM baseline = line - offline;
if (tiline[0] == baseline)
whichbuf = 0;
else if (tiline[1] == baseline)
whichbuf = 1;
else {
tiline[whichbuf] = baseline;
if (lseek(tifd, (off_t) (baseline / lines_per_buf *
BUFFERSIZE), SEEK_SET) < 0)
pfatal("cannot seek in the temporary input file");
if (read(tifd, tibuf[whichbuf], BUFFERSIZE) < 0)
pfatal("error reading tmp file %s", TMPINNAME);
}
return tibuf[whichbuf] + (tireclen * offline);
}
}
/*
* True if the string argument contains the revision number we want.
*/
static bool
rev_in_string(const char *string)
{
const char *s;
size_t patlen;
if (revision == NULL)
return true;
patlen = strlen(revision);
if (strnEQ(string, revision, patlen) && isspace((unsigned char)string[patlen]))
return true;
for (s = string; *s; s++) {
if (isspace((unsigned char)*s) && strnEQ(s + 1, revision, patlen) &&
isspace((unsigned char)s[patlen + 1])) {
return true;
}
}
return false;
}
/*
* The iSelect function...
*/
int iSelect(char *caBuf, int pos, char *title, char *name,
char *tagbegin, char *tagend, int stripco, int stripws,
int browsealways, int allselectable,
int multiselect, int exitnoselect,
char **keystr)
{
WINDOW *wMain;
int i, j, k;
char ca[MAXLINELEN], ca2[MAXLINELEN];
char ca3[MAXLINELEN];
char *cp, *cps, *cpe;
struct Line *spLine;
int rc;
int ok;
/*
* convert input buffer caBuf into
* spaLines array of browsable strings
*/
j = 0;
nLines = 0;
for (i = 0; caBuf[i] != NUL; i++) {
if (caBuf[i] != NL) {
/* line accumulation */
ca[j++] = caBuf[i];
}
else {
/* end of line accumulation reached, now convert it */
ca[j++] = NUL;
j = 0;
/* skip comment lines */
if (stripco) {
if (strnEQ(ca, "#", 1))
continue;
}
spLine = (struct Line *)malloc(sizeof(struct Line));
sprintf(ca2, "%ss", tagbegin);
sprintf(ca3, "%sS", tagbegin);
if ( (cp = strstr(ca, ca2)) != NULL
|| (cp = strstr(ca, ca3)) != NULL) {
/* is a selectable line */
cps = cp;
cp += strlen(tagbegin)+1;
if (strnEQ(cp, ":", 1)) {
cp++;
for (k = 0; !strnEQ(cp, tagend, strlen(tagend)); k++)
ca2[k] = *cp++;
ca2[k] = NUL;
cpe = cp+strlen(tagend);
for (; *cpe != NUL; )
*cps++ = *cpe++;
*cps = NUL;
}
else if (strnEQ(cp, tagend, strlen(tagend))) {
cpe = cp+strlen(tagend);
for (; *cpe != NUL; )
*cps++ = *cpe++;
*cps = NUL;
strcpy(ca2, ca);
}
else {
CU(EX_FAIL);
}
spLine->cpLine = strdup(ca);
spLine->fSelectable = TRUE;
spLine->cpResult = strdup(ca2);
}
else {
/* is normal plain text line */
spLine->cpLine = strdup(ca);
if (allselectable)
spLine->fSelectable = TRUE;
else
spLine->fSelectable = FALSE;
spLine->cpResult = strdup(ca);
}
spLine->fSelected = FALSE;
if (stripws)
strip(spLine->cpResult);
spaLines[nLines++] = spLine;
}
}
#ifdef DEBUG
for (i = 0; i < nLines; i++) {
printf("spaLines[%d] = {\n", i);
printf(" cpLine = \"%s\"\n", spaLines[i]->cpLine);
printf(" fSelectable = %d\n", spaLines[i]->fSelectable);
printf(" cpResult = \"%s\"\n", spaLines[i]->cpResult);
printf("}\n");
}
#endif
if (!browsealways && nLines == 0)
CU(-1);
if (!browsealways && nLines == 1) {
spaLines[0]->fSelected = TRUE;
CU(0);
}
if (exitnoselect) {
ok = FALSE;
for (i = 0; i < nLines; i++) {
if (spaLines[i]->fSelectable) {
ok = TRUE;
break;
}
}
if (!ok)
CU(-1);
}
/*
* setup Curses package and
* open our own first window which holds the complete screen
*/
setup();
wMain = newwin(LINES, COLS, 0, 0);
werase(wMain);
wrefresh(wMain);
/*
* Now run the browser...
*/
rc = iSelect_Browser(/* Browser: */ LINES-2, COLS-2, 0, 1, pos, multiselect,
/* Status: */ 1, COLS, LINES-2, 0, title, name,
/* Message: */ 1, COLS-1, LINES-1, 0,
/* Result: */ keystr,
/* Tags: */ tagbegin, tagend);
/*
* delete the main window and
* close Curses package
*/
werase(wMain);
wrefresh(wMain);
delwin(wMain);
diesoft();
CUS:
return rc;
}
GV*
Perl_gv_autoload4(pTHX_ HV *stash, const char *name, STRLEN len, I32 method)
{
char autoload[] = "AUTOLOAD";
STRLEN autolen = sizeof(autoload)-1;
GV* gv;
CV* cv;
HV* varstash;
GV* vargv;
SV* varsv;
char *packname = "";
if (len == autolen && strnEQ(name, autoload, autolen))
return Nullgv;
if (stash) {
if (SvTYPE(stash) < SVt_PVHV) {
packname = SvPV_nolen((SV*)stash);
stash = Nullhv;
}
else {
packname = HvNAME(stash);
}
}
if (!(gv = gv_fetchmeth(stash, autoload, autolen, FALSE)))
return Nullgv;
cv = GvCV(gv);
if (!(CvROOT(cv) || CvXSUB(cv)))
return Nullgv;
/*
* Inheriting AUTOLOAD for non-methods works ... for now.
*/
if (ckWARN2(WARN_DEPRECATED, WARN_SYNTAX) && !method &&
(GvCVGEN(gv) || GvSTASH(gv) != stash))
Perl_warner(aTHX_ packWARN2(WARN_DEPRECATED, WARN_SYNTAX),
"Use of inherited AUTOLOAD for non-method %s::%.*s() is deprecated",
packname, (int)len, name);
if (CvXSUB(cv)) {
/* rather than lookup/init $AUTOLOAD here
* only to have the XSUB do another lookup for $AUTOLOAD
* and split that value on the last '::',
* pass along the same data via some unused fields in the CV
*/
CvSTASH(cv) = stash;
SvPVX(cv) = (char *)name; /* cast to lose constness warning */
SvCUR(cv) = len;
return gv;
}
/*
* Given &FOO::AUTOLOAD, set $FOO::AUTOLOAD to desired function name.
* The subroutine's original name may not be "AUTOLOAD", so we don't
* use that, but for lack of anything better we will use the sub's
* original package to look up $AUTOLOAD.
*/
varstash = GvSTASH(CvGV(cv));
vargv = *(GV**)hv_fetch(varstash, autoload, autolen, TRUE);
ENTER;
if (!isGV(vargv))
gv_init(vargv, varstash, autoload, autolen, FALSE);
LEAVE;
varsv = GvSV(vargv);
sv_setpv(varsv, packname);
sv_catpvn(varsv, "::", 2);
sv_catpvn(varsv, name, len);
SvTAINTED_off(varsv);
return gv;
}
/*
* True if there is more of the current diff listing to process.
*/
bool
another_hunk(void)
{
long line_beginning; /* file pos of the current line */
LINENUM repl_beginning; /* index of --- line */
LINENUM fillcnt; /* #lines of missing ptrn or repl */
LINENUM fillsrc; /* index of first line to copy */
LINENUM filldst; /* index of first missing line */
bool ptrn_spaces_eaten; /* ptrn was slightly misformed */
bool repl_could_be_missing; /* no + or ! lines in this hunk */
bool repl_missing; /* we are now backtracking */
long repl_backtrack_position; /* file pos of first repl line */
LINENUM repl_patch_line; /* input line number for same */
LINENUM ptrn_copiable; /* # of copiable lines in ptrn */
char *s;
size_t len;
int context = 0;
while (p_end >= 0) {
if (p_end == p_efake)
p_end = p_bfake; /* don't free twice */
else
free(p_line[p_end]);
p_end--;
}
p_efake = -1;
p_max = hunkmax; /* gets reduced when --- found */
if (diff_type == CONTEXT_DIFF || diff_type == NEW_CONTEXT_DIFF) {
line_beginning = ftell(pfp);
repl_beginning = 0;
fillcnt = 0;
fillsrc = 0;
filldst = 0;
ptrn_spaces_eaten = false;
repl_could_be_missing = true;
repl_missing = false;
repl_backtrack_position = 0;
repl_patch_line = 0;
ptrn_copiable = 0;
len = pgets(true);
p_input_line++;
if (len == 0 || strnNE(buf, "********", 8)) {
next_intuit_at(line_beginning, p_input_line);
return false;
}
p_context = 100;
p_hunk_beg = p_input_line + 1;
while (p_end < p_max) {
line_beginning = ftell(pfp);
len = pgets(true);
p_input_line++;
if (len == 0) {
if (p_max - p_end < 4) {
/* assume blank lines got chopped */
strlcpy(buf, " \n", buf_size);
} else {
if (repl_beginning && repl_could_be_missing) {
repl_missing = true;
goto hunk_done;
}
fatal("unexpected end of file in patch\n");
}
}
p_end++;
if (p_end >= hunkmax)
fatal("Internal error: hunk larger than hunk "
"buffer size");
p_char[p_end] = *buf;
p_line[p_end] = NULL;
switch (*buf) {
case '*':
if (strnEQ(buf, "********", 8)) {
if (repl_beginning && repl_could_be_missing) {
repl_missing = true;
goto hunk_done;
} else
fatal("unexpected end of hunk "
"at line %ld\n",
p_input_line);
}
if (p_end != 0) {
if (repl_beginning && repl_could_be_missing) {
repl_missing = true;
goto hunk_done;
}
fatal("unexpected *** at line %ld: %s",
p_input_line, buf);
}
context = 0;
p_line[p_end] = savestr(buf);
if (out_of_mem) {
p_end--;
return false;
}
for (s = buf; *s && !isdigit((unsigned char)*s); s++)
;
if (!*s)
malformed();
if (strnEQ(s, "0,0", 3))
memmove(s, s + 2, strlen(s + 2) + 1);
p_first = (LINENUM) atol(s);
while (isdigit((unsigned char)*s))
s++;
if (*s == ',') {
for (; *s && !isdigit((unsigned char)*s); s++)
;
if (!*s)
malformed();
p_ptrn_lines = ((LINENUM) atol(s)) - p_first + 1;
} else if (p_first)
p_ptrn_lines = 1;
else {
p_ptrn_lines = 0;
p_first = 1;
}
/* we need this much at least */
p_max = p_ptrn_lines + 6;
while (p_max >= hunkmax)
grow_hunkmax();
p_max = hunkmax;
break;
case '-':
if (buf[1] == '-') {
if (repl_beginning ||
(p_end != p_ptrn_lines + 1 +
(p_char[p_end - 1] == '\n'))) {
if (p_end == 1) {
/*
* `old' lines were omitted;
* set up to fill them in
* from 'new' context lines.
*/
p_end = p_ptrn_lines + 1;
fillsrc = p_end + 1;
filldst = 1;
fillcnt = p_ptrn_lines;
} else {
if (repl_beginning) {
if (repl_could_be_missing) {
repl_missing = true;
goto hunk_done;
}
fatal("duplicate \"---\" at line %ld--check line numbers at line %ld\n",
p_input_line, p_hunk_beg + repl_beginning);
} else {
fatal("%s \"---\" at line %ld--check line numbers at line %ld\n",
(p_end <= p_ptrn_lines
? "Premature"
: "Overdue"),
p_input_line, p_hunk_beg);
}
}
}
repl_beginning = p_end;
repl_backtrack_position = ftell(pfp);
repl_patch_line = p_input_line;
p_line[p_end] = savestr(buf);
if (out_of_mem) {
p_end--;
return false;
}
p_char[p_end] = '=';
for (s = buf; *s && !isdigit((unsigned char)*s); s++)
;
if (!*s)
malformed();
p_newfirst = (LINENUM) atol(s);
while (isdigit((unsigned char)*s))
s++;
if (*s == ',') {
for (; *s && !isdigit((unsigned char)*s); s++)
;
if (!*s)
malformed();
p_repl_lines = ((LINENUM) atol(s)) -
p_newfirst + 1;
} else if (p_newfirst)
p_repl_lines = 1;
else {
p_repl_lines = 0;
p_newfirst = 1;
}
p_max = p_repl_lines + p_end;
if (p_max > MAXHUNKSIZE)
fatal("hunk too large (%ld lines) at line %ld: %s",
p_max, p_input_line, buf);
while (p_max >= hunkmax)
grow_hunkmax();
if (p_repl_lines != ptrn_copiable &&
(p_context != 0 || p_repl_lines != 1))
repl_could_be_missing = false;
break;
}
goto change_line;
case '+':
case '!':
repl_could_be_missing = false;
change_line:
if (buf[1] == '\n' && canonicalize)
strlcpy(buf + 1, " \n", buf_size - 1);
if (!isspace((unsigned char)buf[1]) && buf[1] != '>' &&
buf[1] != '<' &&
repl_beginning && repl_could_be_missing) {
repl_missing = true;
goto hunk_done;
}
if (context >= 0) {
if (context < p_context)
p_context = context;
context = -1000;
}
p_line[p_end] = savestr(buf + 2);
if (out_of_mem) {
p_end--;
return false;
}
if (p_end == p_ptrn_lines) {
if (remove_special_line()) {
int l;
l = strlen(p_line[p_end]) - 1;
(p_line[p_end])[l] = 0;
}
}
break;
case '\t':
case '\n': /* assume the 2 spaces got eaten */
if (repl_beginning && repl_could_be_missing &&
(!ptrn_spaces_eaten ||
diff_type == NEW_CONTEXT_DIFF)) {
repl_missing = true;
goto hunk_done;
}
p_line[p_end] = savestr(buf);
if (out_of_mem) {
p_end--;
return false;
}
if (p_end != p_ptrn_lines + 1) {
ptrn_spaces_eaten |= (repl_beginning != 0);
context++;
if (!repl_beginning)
ptrn_copiable++;
p_char[p_end] = ' ';
}
break;
case ' ':
if (!isspace((unsigned char)buf[1]) &&
repl_beginning && repl_could_be_missing) {
repl_missing = true;
goto hunk_done;
}
context++;
if (!repl_beginning)
ptrn_copiable++;
p_line[p_end] = savestr(buf + 2);
if (out_of_mem) {
p_end--;
return false;
}
break;
default:
if (repl_beginning && repl_could_be_missing) {
repl_missing = true;
goto hunk_done;
}
malformed();
}
/* set up p_len for strncmp() so we don't have to */
/* assume null termination */
if (p_line[p_end])
p_len[p_end] = strlen(p_line[p_end]);
else
p_len[p_end] = 0;
}
hunk_done:
if (p_end >= 0 && !repl_beginning)
fatal("no --- found in patch at line %ld\n", pch_hunk_beg());
if (repl_missing) {
/* reset state back to just after --- */
p_input_line = repl_patch_line;
for (p_end--; p_end > repl_beginning; p_end--)
free(p_line[p_end]);
fseek(pfp, repl_backtrack_position, SEEK_SET);
/* redundant 'new' context lines were omitted - set */
/* up to fill them in from the old file context */
if (!p_context && p_repl_lines == 1) {
p_repl_lines = 0;
p_max--;
}
fillsrc = 1;
filldst = repl_beginning + 1;
fillcnt = p_repl_lines;
p_end = p_max;
} else if (!p_context && fillcnt == 1) {
/* the first hunk was a null hunk with no context */
/* and we were expecting one line -- fix it up. */
while (filldst < p_end) {
p_line[filldst] = p_line[filldst + 1];
p_char[filldst] = p_char[filldst + 1];
p_len[filldst] = p_len[filldst + 1];
filldst++;
}
#if 0
repl_beginning--; /* this doesn't need to be fixed */
#endif
p_end--;
p_first++; /* do append rather than insert */
fillcnt = 0;
p_ptrn_lines = 0;
}
if (diff_type == CONTEXT_DIFF &&
(fillcnt || (p_first > 1 && ptrn_copiable > 2 * p_context))) {
if (verbose)
say("%s\n%s\n%s\n",
"(Fascinating--this is really a new-style context diff but without",
"the telltale extra asterisks on the *** line that usually indicate",
"the new style...)");
diff_type = NEW_CONTEXT_DIFF;
}
/* if there were omitted context lines, fill them in now */
if (fillcnt) {
p_bfake = filldst; /* remember where not to free() */
p_efake = filldst + fillcnt - 1;
while (fillcnt-- > 0) {
while (fillsrc <= p_end && p_char[fillsrc] != ' ')
fillsrc++;
if (fillsrc > p_end)
fatal("replacement text or line numbers mangled in hunk at line %ld\n",
p_hunk_beg);
p_line[filldst] = p_line[fillsrc];
p_char[filldst] = p_char[fillsrc];
p_len[filldst] = p_len[fillsrc];
fillsrc++;
filldst++;
}
while (fillsrc <= p_end && fillsrc != repl_beginning &&
p_char[fillsrc] != ' ')
fillsrc++;
#ifdef DEBUGGING
if (debug & 64)
printf("fillsrc %ld, filldst %ld, rb %ld, e+1 %ld\n",
fillsrc, filldst, repl_beginning, p_end + 1);
#endif
if (fillsrc != p_end + 1 && fillsrc != repl_beginning)
malformed();
if (filldst != p_end + 1 && filldst != repl_beginning)
malformed();
}
if (p_line[p_end] != NULL) {
if (remove_special_line()) {
p_len[p_end] -= 1;
(p_line[p_end])[p_len[p_end]] = 0;
}
}
} else if (diff_type == UNI_DIFF) {
LINENUM fillold; /* index of old lines */
LINENUM fillnew; /* index of new lines */
char ch;
line_beginning = ftell(pfp); /* file pos of the current line */
len = pgets(true);
p_input_line++;
if (len == 0 || strnNE(buf, "@@ -", 4)) {
next_intuit_at(line_beginning, p_input_line);
return false;
}
s = buf + 4;
if (!*s)
malformed();
p_first = (LINENUM) atol(s);
while (isdigit((unsigned char)*s))
s++;
if (*s == ',') {
p_ptrn_lines = (LINENUM) atol(++s);
while (isdigit((unsigned char)*s))
s++;
} else
p_ptrn_lines = 1;
if (*s == ' ')
s++;
if (*s != '+' || !*++s)
malformed();
p_newfirst = (LINENUM) atol(s);
while (isdigit((unsigned char)*s))
s++;
if (*s == ',') {
p_repl_lines = (LINENUM) atol(++s);
while (isdigit((unsigned char)*s))
s++;
} else
p_repl_lines = 1;
if (*s == ' ')
s++;
if (*s != '@')
malformed();
if (!p_ptrn_lines)
p_first++; /* do append rather than insert */
p_max = p_ptrn_lines + p_repl_lines + 1;
while (p_max >= hunkmax)
grow_hunkmax();
fillold = 1;
fillnew = fillold + p_ptrn_lines;
p_end = fillnew + p_repl_lines;
snprintf(buf, buf_size, "*** %ld,%ld ****\n", p_first,
p_first + p_ptrn_lines - 1);
p_line[0] = savestr(buf);
if (out_of_mem) {
p_end = -1;
return false;
}
p_char[0] = '*';
snprintf(buf, buf_size, "--- %ld,%ld ----\n", p_newfirst,
p_newfirst + p_repl_lines - 1);
p_line[fillnew] = savestr(buf);
if (out_of_mem) {
p_end = 0;
return false;
}
p_char[fillnew++] = '=';
p_context = 100;
context = 0;
p_hunk_beg = p_input_line + 1;
while (fillold <= p_ptrn_lines || fillnew <= p_end) {
line_beginning = ftell(pfp);
len = pgets(true);
p_input_line++;
if (len == 0) {
if (p_max - fillnew < 3) {
/* assume blank lines got chopped */
strlcpy(buf, " \n", buf_size);
} else {
fatal("unexpected end of file in patch\n");
}
}
if (*buf == '\t' || *buf == '\n') {
ch = ' '; /* assume the space got eaten */
s = savestr(buf);
} else {
ch = *buf;
s = savestr(buf + 1);
}
if (out_of_mem) {
while (--fillnew > p_ptrn_lines)
free(p_line[fillnew]);
p_end = fillold - 1;
return false;
}
switch (ch) {
case '-':
if (fillold > p_ptrn_lines) {
free(s);
p_end = fillnew - 1;
malformed();
}
p_char[fillold] = ch;
p_line[fillold] = s;
p_len[fillold++] = strlen(s);
if (fillold > p_ptrn_lines) {
if (remove_special_line()) {
p_len[fillold - 1] -= 1;
s[p_len[fillold - 1]] = 0;
}
}
break;
case '=':
ch = ' ';
/* FALL THROUGH */
case ' ':
if (fillold > p_ptrn_lines) {
free(s);
while (--fillnew > p_ptrn_lines)
free(p_line[fillnew]);
p_end = fillold - 1;
malformed();
}
context++;
p_char[fillold] = ch;
p_line[fillold] = s;
p_len[fillold++] = strlen(s);
s = savestr(s);
if (out_of_mem) {
while (--fillnew > p_ptrn_lines)
free(p_line[fillnew]);
p_end = fillold - 1;
return false;
}
if (fillold > p_ptrn_lines) {
if (remove_special_line()) {
p_len[fillold - 1] -= 1;
s[p_len[fillold - 1]] = 0;
}
}
/* FALL THROUGH */
case '+':
if (fillnew > p_end) {
free(s);
while (--fillnew > p_ptrn_lines)
free(p_line[fillnew]);
p_end = fillold - 1;
malformed();
}
p_char[fillnew] = ch;
p_line[fillnew] = s;
p_len[fillnew++] = strlen(s);
if (fillold > p_ptrn_lines) {
if (remove_special_line()) {
p_len[fillnew - 1] -= 1;
s[p_len[fillnew - 1]] = 0;
}
}
break;
default:
p_end = fillnew;
malformed();
}
if (ch != ' ' && context > 0) {
if (context < p_context)
p_context = context;
context = -1000;
}
} /* while */
} else { /* normal diff--fake it up */
char hunk_type;
int i;
LINENUM min, max;
line_beginning = ftell(pfp);
p_context = 0;
len = pgets(true);
p_input_line++;
if (len == 0 || !isdigit((unsigned char)*buf)) {
next_intuit_at(line_beginning, p_input_line);
return false;
}
p_first = (LINENUM) atol(buf);
for (s = buf; isdigit((unsigned char)*s); s++)
;
if (*s == ',') {
p_ptrn_lines = (LINENUM) atol(++s) - p_first + 1;
while (isdigit((unsigned char)*s))
s++;
} else
p_ptrn_lines = (*s != 'a');
hunk_type = *s;
if (hunk_type == 'a')
p_first++; /* do append rather than insert */
min = (LINENUM) atol(++s);
for (; isdigit((unsigned char)*s); s++)
;
if (*s == ',')
max = (LINENUM) atol(++s);
else
max = min;
if (hunk_type == 'd')
min++;
p_end = p_ptrn_lines + 1 + max - min + 1;
if (p_end > MAXHUNKSIZE)
fatal("hunk too large (%ld lines) at line %ld: %s",
p_end, p_input_line, buf);
while (p_end >= hunkmax)
grow_hunkmax();
p_newfirst = min;
p_repl_lines = max - min + 1;
snprintf(buf, buf_size, "*** %ld,%ld\n", p_first,
p_first + p_ptrn_lines - 1);
p_line[0] = savestr(buf);
if (out_of_mem) {
p_end = -1;
return false;
}
p_char[0] = '*';
for (i = 1; i <= p_ptrn_lines; i++) {
len = pgets(true);
p_input_line++;
if (len == 0)
fatal("unexpected end of file in patch at line %ld\n",
p_input_line);
if (*buf != '<')
fatal("< expected at line %ld of patch\n",
p_input_line);
p_line[i] = savestr(buf + 2);
if (out_of_mem) {
p_end = i - 1;
return false;
}
p_len[i] = strlen(p_line[i]);
p_char[i] = '-';
}
if (remove_special_line()) {
p_len[i - 1] -= 1;
(p_line[i - 1])[p_len[i - 1]] = 0;
}
if (hunk_type == 'c') {
len = pgets(true);
p_input_line++;
if (len == 0)
fatal("unexpected end of file in patch at line %ld\n",
p_input_line);
if (*buf != '-')
fatal("--- expected at line %ld of patch\n",
p_input_line);
}
snprintf(buf, buf_size, "--- %ld,%ld\n", min, max);
p_line[i] = savestr(buf);
if (out_of_mem) {
p_end = i - 1;
return false;
}
p_char[i] = '=';
for (i++; i <= p_end; i++) {
len = pgets(true);
p_input_line++;
if (len == 0)
fatal("unexpected end of file in patch at line %ld\n",
p_input_line);
if (*buf != '>')
fatal("> expected at line %ld of patch\n",
p_input_line);
p_line[i] = savestr(buf + 2);
if (out_of_mem) {
p_end = i - 1;
return false;
}
p_len[i] = strlen(p_line[i]);
p_char[i] = '+';
}
if (remove_special_line()) {
p_len[i - 1] -= 1;
(p_line[i - 1])[p_len[i - 1]] = 0;
}
}
if (reverse) /* backwards patch? */
if (!pch_swap())
say("Not enough memory to swap next hunk!\n");
#ifdef DEBUGGING
if (debug & 2) {
int i;
char special;
for (i = 0; i <= p_end; i++) {
if (i == p_ptrn_lines)
special = '^';
else
special = ' ';
fprintf(stderr, "%3d %c %c %s", i, p_char[i],
special, p_line[i]);
fflush(stderr);
}
}
#endif
if (p_end + 1 < hunkmax)/* paranoia reigns supreme... */
p_char[p_end + 1] = '^'; /* add a stopper for apply_hunk */
return true;
}
