mirrors/zsh
1
0
Fork 0
mirror of git://git.code.sf.net/p/zsh/code synced 2025-08-11 02:51:07 +02:00
Code Releases Activity

Wayne: pattern.c unitialised var

Browse source 
Zero-length arrays now possible with $array[1,0]
This commit is contained in:
Peter Stephenson 2000-05-31 08:56:23 +00:00
parent d5b6d1f40c
commit 7bf294f2b8
10 changed files with 190 additions and 170 deletions

13
ChangeLog
View file

@ -1,3 +1,16 @@
2000-05-31 Peter Stephenson <pws@cambridgesiliconradio.com>
* Wayne Davison: 11680: Src/params.c: subscript too small/big
error messages.
* Wayne Davison: 11677, 11681: Src/glob.c, Src/params.c, Src/subst.c,
Src/zsh.h, Src/Modules/mapfile.c, Src/Modules/parameter.c,
Src/Zle/complete.c: make $array[1,0] return a zero-length array.
* Wayne Davison: 11676: Src/pattern.c: uninitialised variable.
* Wayne Davison: 11675: Test/07cond.ztst: apparent race condition.
2000-05-31 Sven Wischnowsky <wischnow@zsh.org> 2000-05-31 Sven Wischnowsky <wischnow@zsh.org>
* 11682: Src/Zle/compresult.c: move to last cursor after not * 11682: Src/Zle/compresult.c: move to last cursor after not

66
Src/Modules/mapfile.c
View file

@ -86,7 +86,8 @@ createmapfilehash()
unsetparam(mapfile_nam); unsetparam(mapfile_nam);
mapfile_pm = NULL; mapfile_pm = NULL;
if (!(pm = createparam(mapfile_nam, PM_SPECIAL|PM_REMOVABLE|PM_HASHED))) if (!(pm = createparam(mapfile_nam,
PM_SPECIAL|PM_HIDE|PM_REMOVABLE|PM_HASHED)))
return NULL; return NULL;
pm->level = pm->old ? locallevel : 0; pm->level = pm->old ? locallevel : 0;
@ -143,12 +144,16 @@ setpmmapfile(Param pm, char *value)
*/ */
ftruncate(fd, len); ftruncate(fd, len);
memcpy(mmptr, value, len); memcpy(mmptr, value, len);
#ifndef MS_SYNC
#define MS_SYNC 0
#endif
msync(mmptr, len, MS_SYNC); msync(mmptr, len, MS_SYNC);
/* /*
* Then we need to truncate again, since mmap() always maps complete * Then we need to truncate again, since mmap() always maps complete
* pages. Honestly, I tried it without, and you need both. * pages. Honestly, I tried it without, and you need both.
*/ */
ftruncate(fd, len); ftruncate(fd, len);
munmap(mmptr, len);
} }
#else /* don't USE_MMAP */ #else /* don't USE_MMAP */
/* can't be bothered to do anything too clever here */ /* can't be bothered to do anything too clever here */
@ -197,8 +202,8 @@ setpmmapfiles(Param pm, HashTable ht)
for (hn = ht->nodes[i]; hn; hn = hn->next) { for (hn = ht->nodes[i]; hn; hn = hn->next) {
struct value v; struct value v;
v.isarr = v.inv = v.a = 0; v.isarr = v.inv = v.start = 0;
v.b = -1; v.len = -1;
v.arr = NULL; v.arr = NULL;
v.pm = (Param) hn; v.pm = (Param) hn;
@ -243,7 +248,7 @@ get_contents(char *fname)
val = NULL; val = NULL;
if ((fd = open(fname, O_RDONLY | O_NOCTTY)) >= 0) { if ((fd = open(fname, O_RDONLY | O_NOCTTY)) >= 0) {
LinkList ll; LinkList ll;
MUSTUSEHEAP("mapfile:get_contents");
if ((ll = readoutput(fd, 1))) if ((ll = readoutput(fd, 1)))
val = peekfirst(ll); val = peekfirst(ll);
} }
@ -259,30 +264,27 @@ getpmmapfile(HashTable ht, char *name)
char *contents; char *contents;
Param pm = NULL; Param pm = NULL;
HEAPALLOC { pm = (Param) zhalloc(sizeof(struct param));
pm = (Param) zhalloc(sizeof(struct param)); pm->nam = dupstring(name);
pm->nam = dupstring(name); pm->flags = PM_SCALAR;
pm->flags = PM_SCALAR; pm->sets.cfn = setpmmapfile;
pm->sets.cfn = setpmmapfile; pm->gets.cfn = strgetfn;
pm->gets.cfn = strgetfn; pm->unsetfn = unsetpmmapfile;
pm->unsetfn = unsetpmmapfile; pm->ct = 0;
pm->ct = 0; pm->env = NULL;
pm->env = NULL; pm->ename = NULL;
pm->ename = NULL; pm->old = NULL;
pm->old = NULL; pm->level = 0;
pm->level = 0;
pm->flags |= (mapfile_pm->flags & PM_READONLY); pm->flags |= (mapfile_pm->flags & PM_READONLY);
/* Set u.str to contents of file given by name */
if ((contents = get_contents(pm->nam)))
pm->u.str = contents;
else {
pm->u.str = "";
pm->flags |= PM_UNSET;
}
} LASTALLOC;
/* Set u.str to contents of file given by name */
if ((contents = get_contents(pm->nam)))
pm->u.str = contents;
else {
pm->u.str = "";
pm->flags |= PM_UNSET;
}
return (HashNode) pm; return (HashNode) pm;
} }
@ -324,14 +326,14 @@ scanpmmapfile(HashTable ht, ScanFunc func, int flags)
/**/ /**/
int int
setup_mapfile(Module m) setup_(Module m)
{ {
return 0; return 0;
} }
/**/ /**/
int int
boot_mapfile(Module m) boot_(Module m)
{ {
/* Create the special associative array. */ /* Create the special associative array. */
@ -341,11 +343,9 @@ boot_mapfile(Module m)
return 0; return 0;
} }
#ifdef MODULE
/**/ /**/
int int
cleanup_mapfile(Module m) cleanup_(Module m)
{ {
Param pm; Param pm;
@ -361,9 +361,7 @@ cleanup_mapfile(Module m)
/**/ /**/
int int
finish_mapfile(Module m) finish_(Module m)
{ {
return 0; return 0;
} }
#endif

20
Src/Modules/parameter.c
View file

@ -229,8 +229,8 @@ setpmcommands(Param pm, HashTable ht)
Cmdnam cn = zcalloc(sizeof(*cn)); Cmdnam cn = zcalloc(sizeof(*cn));
struct value v; struct value v;
v.isarr = v.inv = v.a = 0; v.isarr = v.inv = v.start = 0;
v.b = -1; v.len = -1;
v.arr = NULL; v.arr = NULL;
v.pm = (Param) hn; v.pm = (Param) hn;
@ -400,8 +400,8 @@ setfunctions(Param pm, HashTable ht, int dis)
for (hn = ht->nodes[i]; hn; hn = hn->next) { for (hn = ht->nodes[i]; hn; hn = hn->next) {
struct value v; struct value v;
v.isarr = v.inv = v.a = 0; v.isarr = v.inv = v.start = 0;
v.b = -1; v.len = -1;
v.arr = NULL; v.arr = NULL;
v.pm = (Param) hn; v.pm = (Param) hn;
@ -754,8 +754,8 @@ setpmoptions(Param pm, HashTable ht)
struct value v; struct value v;
char *val; char *val;
v.isarr = v.inv = v.a = 0; v.isarr = v.inv = v.start = 0;
v.b = -1; v.len = -1;
v.arr = NULL; v.arr = NULL;
v.pm = (Param) hn; v.pm = (Param) hn;
@ -1433,8 +1433,8 @@ setpmnameddirs(Param pm, HashTable ht)
struct value v; struct value v;
char *val; char *val;
v.isarr = v.inv = v.a = 0; v.isarr = v.inv = v.start = 0;
v.b = -1; v.len = -1;
v.arr = NULL; v.arr = NULL;
v.pm = (Param) hn; v.pm = (Param) hn;
@ -1659,8 +1659,8 @@ setaliases(Param pm, HashTable ht, int global, int dis)
struct value v; struct value v;
char *val; char *val;
v.isarr = v.inv = v.a = 0; v.isarr = v.inv = v.start = 0;
v.b = -1; v.len = -1;
v.arr = NULL; v.arr = NULL;
v.pm = (Param) hn; v.pm = (Param) hn;

4
Src/Zle/complete.c
View file

@ -1033,8 +1033,8 @@ set_compstate(Param pm, HashTable ht)
for (cp = compkparams, for (cp = compkparams,
pp = compkpms; cp->name; cp++, pp++) pp = compkpms; cp->name; cp++, pp++)
if (!strcmp(hn->nam, cp->name)) { if (!strcmp(hn->nam, cp->name)) {
v.isarr = v.inv = v.a = 0; v.isarr = v.inv = v.start = 0;
v.b = -1; v.len = -1;
v.arr = NULL; v.arr = NULL;
v.pm = (Param) hn; v.pm = (Param) hn;
if (cp->type == PM_INTEGER) if (cp->type == PM_INTEGER)

25
Src/glob.c
View file

@ -921,8 +921,8 @@ glob(LinkList list, LinkNode np, int nountok)
Complist q; /* pattern after parsing */ Complist q; /* pattern after parsing */
char *ostr = (char *)getdata(np); /* the pattern before the parser */ char *ostr = (char *)getdata(np); /* the pattern before the parser */
/* chops it up */ /* chops it up */
int first = 0, last = -1; /* index of first/last match to */ int first = 0, count = -1; /* index of first match to return */
/* return */ /* plus number of items */
struct globdata saved; /* saved glob state */ struct globdata saved; /* saved glob state */
if (unset(GLOBOPT) || !haswilds(ostr)) { if (unset(GLOBOPT) || !haswilds(ostr)) {
@ -1334,15 +1334,15 @@ glob(LinkList list, LinkNode np, int nountok)
v.isarr = SCANPM_WANTVALS; v.isarr = SCANPM_WANTVALS;
v.pm = NULL; v.pm = NULL;
v.b = -1; v.len = -1;
v.inv = 0; v.inv = 0;
if (getindex(&s, &v) || s == os) { if (getindex(&s, &v) || s == os) {
zerr("invalid subscript", NULL, 0); zerr("invalid subscript", NULL, 0);
restore_globstate(saved); restore_globstate(saved);
return; return;
} }
first = v.a; first = v.start;
last = v.b; count = v.len;
break; break;
} }
default: default:
@ -1428,16 +1428,15 @@ glob(LinkList list, LinkNode np, int nountok)
if (first < 0) if (first < 0)
first += matchct; first += matchct;
if (last < 0) if (count < 0)
last += matchct; count += matchct + 1;
if (first < 0) if (first < 0)
first = 0; first = 0;
if (last >= matchct) if (count > matchct - first)
last = matchct - 1; count = matchct - first;
if (first <= last) { if (count > 0) {
matchptr = matchbuf + matchct - 1 - last; matchptr = matchbuf + matchct - first - count;
last -= first; while (count-- > 0) { /* insert matches in the arg list */
while (last-- >= 0) { /* insert matches in the arg list */
insertlinknode(list, node, matchptr->name); insertlinknode(list, node, matchptr->name);
matchptr++; matchptr++;
} }

216
Src/params.c
View file

@ -394,8 +394,8 @@ scanparamvals(HashNode hn, int flags)
} }
v.isarr = (PM_TYPE(v.pm->flags) & (PM_ARRAY|PM_HASHED)); v.isarr = (PM_TYPE(v.pm->flags) & (PM_ARRAY|PM_HASHED));
v.inv = 0; v.inv = 0;
v.a = 0; v.start = 0;
v.b = -1; v.len = -1;
paramvals[numparamvals] = getstrvalue(&v); paramvals[numparamvals] = getstrvalue(&v);
if (flags & SCANPM_MATCHVAL) { if (flags & SCANPM_MATCHVAL) {
if (pattry(scanprog, paramvals[numparamvals])) { if (pattry(scanprog, paramvals[numparamvals])) {
@ -437,8 +437,8 @@ getvaluearr(Value v)
else if (PM_TYPE(v->pm->flags) == PM_HASHED) { else if (PM_TYPE(v->pm->flags) == PM_HASHED) {
v->arr = paramvalarr(v->pm->gets.hfn(v->pm), v->isarr); v->arr = paramvalarr(v->pm->gets.hfn(v->pm), v->isarr);
/* Can't take numeric slices of associative arrays */ /* Can't take numeric slices of associative arrays */
v->a = 0; v->start = 0;
v->b = numparamvals; v->len = numparamvals + 1;
return v->arr; return v->arr;
} else } else
return NULL; return NULL;
@ -932,13 +932,15 @@ getarg(char **str, int *inv, Value v, int a2, zlong *w)
paramtab = tht; paramtab = tht;
} }
v->isarr = (*inv ? SCANPM_WANTINDEX : 0); v->isarr = (*inv ? SCANPM_WANTINDEX : 0);
v->a = 0; v->start = 0;
*inv = 0; /* We've already obtained the "index" (key) */ *inv = 0; /* We've already obtained the "index" (key) */
*w = v->b = -1; *w = v->len = -1;
r = isset(KSHARRAYS) ? 1 : 0; r = isset(KSHARRAYS) ? 1 : 0;
} else } else {
if (!(r = mathevalarg(s, &s)) || (isset(KSHARRAYS) && r >= 0)) r = mathevalarg(s, &s);
r++; if ((!r && !a2) || (isset(KSHARRAYS) && r >= 0))
r++;
}
if (word && !v->isarr) { if (word && !v->isarr) {
s = t = getstrvalue(v); s = t = getstrvalue(v);
i = wordcount(s, sep, 0); i = wordcount(s, sep, 0);
@ -955,7 +957,7 @@ getarg(char **str, int *inv, Value v, int a2, zlong *w)
return 0; return 0;
if (!a2 && *tt != ',') if (!a2 && *tt != ',')
*w = (zlong)(s - t) - 1; *w = (zlong)(s - d) - 1;
return (a2 ? s : d + 1) - t; return (a2 ? s : d + 1) - t;
} else if (!v->isarr && !word) { } else if (!v->isarr && !word) {
@ -1014,7 +1016,7 @@ getarg(char **str, int *inv, Value v, int a2, zlong *w)
(v->isarr & (SCANPM_MATCHKEY | SCANPM_MATCHVAL | (v->isarr & (SCANPM_MATCHKEY | SCANPM_MATCHVAL |
SCANPM_KEYMATCH))))) { SCANPM_KEYMATCH))))) {
*inv = v->inv; *inv = v->inv;
*w = v->b; *w = v->len;
return 1; return 1;
} }
} else } else
@ -1065,7 +1067,7 @@ getarg(char **str, int *inv, Value v, int a2, zlong *w)
if (!--r) { if (!--r) {
r = (zlong)(t - s + (a2 ? -1 : 1)); r = (zlong)(t - s + (a2 ? -1 : 1));
if (!a2 && *tt != ',') if (!a2 && *tt != ',')
*w = r + strlen(ta[i]) - 2; *w = strlen(ta[i]) - 1;
return r; return r;
} }
return a2 ? -1 : 0; return a2 ? -1 : 0;
@ -1129,7 +1131,7 @@ getarg(char **str, int *inv, Value v, int a2, zlong *w)
int int
getindex(char **pptr, Value v) getindex(char **pptr, Value v)
{ {
int a, b, inv = 0; int start, len, inv = 0;
char *s = *pptr, *tbrack; char *s = *pptr, *tbrack;
*s++ = '['; *s++ = '[';
@ -1141,31 +1143,32 @@ getindex(char **pptr, Value v)
if ((s[0] == '*' || s[0] == '@') && s[1] == ']') { if ((s[0] == '*' || s[0] == '@') && s[1] == ']') {
if ((v->isarr || IS_UNSET_VALUE(v)) && s[0] == '@') if ((v->isarr || IS_UNSET_VALUE(v)) && s[0] == '@')
v->isarr |= SCANPM_ISVAR_AT; v->isarr |= SCANPM_ISVAR_AT;
v->a = 0; v->start = 0;
v->b = -1; v->len = -1;
s += 2; s += 2;
} else { } else {
zlong we = 0, dummy; zlong wlen = 0, dummy;
a = getarg(&s, &inv, v, 0, &we); start = getarg(&s, &inv, v, 0, &wlen);
if (inv) { if (inv) {
if (!v->isarr && a != 0) { if (!v->isarr && start != 0) {
char *t, *p; char *t, *p;
t = getstrvalue(v); t = getstrvalue(v);
if (a > 0) { if (start > 0) {
for (p = t + a - 1; p-- > t; ) for (p = t + start - 1; p-- > t; )
if (*p == Meta) if (*p == Meta)
a--; start--;
} else } else
a = -ztrlen(t + a + strlen(t)); start = -ztrlen(t + start + strlen(t));
} }
if (a > 0 && (isset(KSHARRAYS) || (v->pm->flags & PM_HASHED))) if (start > 0 && (isset(KSHARRAYS) || (v->pm->flags & PM_HASHED)))
a--; start--;
if (v->isarr != SCANPM_WANTINDEX) { if (v->isarr != SCANPM_WANTINDEX) {
v->inv = 1; v->inv = 1;
v->isarr = 0; v->isarr = 0;
v->a = v->b = a; v->start = start;
v->len = 1;
} }
if (*s == ',') { if (*s == ',') {
zerr("invalid subscript", NULL, 0); zerr("invalid subscript", NULL, 0);
@ -1179,25 +1182,28 @@ getindex(char **pptr, Value v)
} else { } else {
int com; int com;
if (a > 0) if (start > 0)
a--; start--;
if ((com = (*s == ','))) { if ((com = (*s == ','))) {
s++; s++;
b = getarg(&s, &inv, v, 1, &dummy); len = getarg(&s, &inv, v, 1, &dummy);
if (b > 0) if (len > 0) {
b--; len -= start;
if (len < 0)
len = 0;
}
} else { } else {
b = we ? we : a; len = wlen ? wlen : 1;
} }
if (*s == ']' || *s == Outbrack) { if (*s == ']' || *s == Outbrack) {
s++; s++;
if (v->isarr && a == b && !com && if (v->isarr && len == 1 && !com &&
(!(v->isarr & SCANPM_MATCHMANY) || (!(v->isarr & SCANPM_MATCHMANY) ||
!(v->isarr & (SCANPM_MATCHKEY | SCANPM_MATCHVAL | !(v->isarr & (SCANPM_MATCHKEY | SCANPM_MATCHVAL |
SCANPM_KEYMATCH)))) SCANPM_KEYMATCH))))
v->isarr = 0; v->isarr = 0;
v->a = a; v->start = start;
v->b = b; v->len = len;
} else } else
s = *pptr; s = *pptr;
} }
@ -1258,7 +1264,8 @@ fetchvalue(Value v, char **pptr, int bracks, int flags)
v = (Value) hcalloc(sizeof *v); v = (Value) hcalloc(sizeof *v);
v->pm = argvparam; v->pm = argvparam;
v->inv = 0; v->inv = 0;
v->a = v->b = ppar - 1; v->start = ppar - 1;
v->len = 1;
if (sav) if (sav)
*s = sav; *s = sav;
} else { } else {
@ -1288,8 +1295,8 @@ fetchvalue(Value v, char **pptr, int bracks, int flags)
} }
v->pm = pm; v->pm = pm;
v->inv = 0; v->inv = 0;
v->a = 0; v->start = 0;
v->b = -1; v->len = -1;
if (bracks > 0 && (*s == '[' || *s == Inbrack)) { if (bracks > 0 && (*s == '[' || *s == Inbrack)) {
if (getindex(&s, v)) { if (getindex(&s, v)) {
*pptr = s; *pptr = s;
@ -1297,19 +1304,21 @@ fetchvalue(Value v, char **pptr, int bracks, int flags)
} }
} else if (!(flags & SCANPM_ASSIGNING) && v->isarr && } else if (!(flags & SCANPM_ASSIGNING) && v->isarr &&
iident(*t) && isset(KSHARRAYS)) iident(*t) && isset(KSHARRAYS))
v->b = 0, v->isarr = 0; v->len = 1, v->isarr = 0;
} }
if (!bracks && *s) if (!bracks && *s)
return NULL; return NULL;
*pptr = s; *pptr = s;
if (v->a > MAX_ARRLEN || if (v->start > MAX_ARRLEN ||
v->a < -MAX_ARRLEN) { v->start < -MAX_ARRLEN) {
zerr("subscript too %s: %d", (v->a < 0) ? "small" : "big", v->a); zerr("subscript too %s: %d", (v->start < 0) ? "small" : "big",
v->start + !isset(KSHARRAYS));
return NULL; return NULL;
} }
if (v->b > MAX_ARRLEN || if (v->start + v->len > MAX_ARRLEN ||
v->b < -MAX_ARRLEN) { v->start + v->len < -MAX_ARRLEN) {
zerr("subscript too %s: %d", (v->b < 0) ? "small" : "big", v->b); zerr("subscript too %s: %d", (v->len < 0) ? "small" : "big",
v->start + v->len - !!isset(KSHARRAYS));
return NULL; return NULL;
} }
return v; return v;
@ -1326,7 +1335,7 @@ getstrvalue(Value v)
return hcalloc(1); return hcalloc(1);
if (v->inv && !(v->pm->flags & PM_HASHED)) { if (v->inv && !(v->pm->flags & PM_HASHED)) {
sprintf(buf, "%d", v->a); sprintf(buf, "%d", v->start);
s = dupstring(buf); s = dupstring(buf);
return s; return s;
} }
@ -1345,9 +1354,10 @@ getstrvalue(Value v)
if (v->isarr) if (v->isarr)
s = sepjoin(ss, NULL, 1); s = sepjoin(ss, NULL, 1);
else { else {
if (v->a < 0) if (v->start < 0)
v->a += arrlen(ss); v->start += arrlen(ss);
s = (v->a >= arrlen(ss) || v->a < 0) ? (char *) hcalloc(1) : ss[v->a]; s = (v->start >= arrlen(ss) || v->start < 0) ?
(char *) hcalloc(1) : ss[v->start];
} }
return s; return s;
case PM_INTEGER: case PM_INTEGER:
@ -1367,18 +1377,18 @@ getstrvalue(Value v)
break; break;
} }
if (v->a == 0 && v->b == -1) if (v->start == 0 && v->len == -1)
return s; return s;
if (v->a < 0) if (v->start < 0)
v->a += strlen(s); v->start += strlen(s);
if (v->b < 0) if (v->len < 0)
v->b += strlen(s); v->len += strlen(s) - v->start + 1;
s = (v->a > (int)strlen(s)) ? dupstring("") : dupstring(s + v->a); s = (v->start > (int)strlen(s)) ? dupstring("") : dupstring(s + v->start);
if (v->b < v->a) if (v->len <= 0)
s[0] = '\0'; s[0] = '\0';
else if (v->b - v->a < (int)strlen(s)) else if (v->len <= (int)strlen(s))
s[v->b - v->a + 1 + (s[v->b - v->a] == Meta)] = '\0'; s[v->len + (s[v->len - 1] == Meta)] = '\0';
return s; return s;
} }
@ -1399,25 +1409,25 @@ getarrvalue(Value v)
char buf[DIGBUFSIZE]; char buf[DIGBUFSIZE];
s = arrdup(nular); s = arrdup(nular);
sprintf(buf, "%d", v->a); sprintf(buf, "%d", v->start);
s[0] = dupstring(buf); s[0] = dupstring(buf);
return s; return s;
} }
s = getvaluearr(v); s = getvaluearr(v);
if (v->a == 0 && v->b == -1) if (v->start == 0 && v->len == -1)
return s; return s;
if (v->a < 0) if (v->start < 0)
v->a += arrlen(s); v->start += arrlen(s);
if (v->b < 0) if (v->len < 0)
v->b += arrlen(s); v->len += arrlen(s) - v->start + 1;
if (v->a > arrlen(s) || v->a < 0) if (v->start > arrlen(s) || v->start < 0)
s = arrdup(nular); s = arrdup(nular);
else else
s = arrdup(s + v->a); s = arrdup(s + v->start);
if (v->b < v->a) if (v->len <= 0)
s[0] = NULL; s[0] = NULL;
else if (v->b - v->a < arrlen(s)) else if (v->len <= arrlen(s))
s[v->b - v->a + 1] = NULL; s[v->len] = NULL;
return s; return s;
} }
@ -1428,7 +1438,7 @@ getintvalue(Value v)
if (!v || v->isarr) if (!v || v->isarr)
return 0; return 0;
if (v->inv) if (v->inv)
return v->a; return v->start;
if (PM_TYPE(v->pm->flags) == PM_INTEGER) if (PM_TYPE(v->pm->flags) == PM_INTEGER)
return v->pm->gets.ifn(v->pm); return v->pm->gets.ifn(v->pm);
if (v->pm->flags & (PM_EFLOAT|PM_FFLOAT)) if (v->pm->flags & (PM_EFLOAT|PM_FFLOAT))
@ -1446,7 +1456,7 @@ getnumvalue(Value v)
if (!v || v->isarr) { if (!v || v->isarr) {
mn.u.l = 0; mn.u.l = 0;
} else if (v->inv) { } else if (v->inv) {
mn.u.l = v->a; mn.u.l = v->start;
} else if (PM_TYPE(v->pm->flags) == PM_INTEGER) { } else if (PM_TYPE(v->pm->flags) == PM_INTEGER) {
mn.u.l = v->pm->gets.ifn(v->pm); mn.u.l = v->pm->gets.ifn(v->pm);
} else if (v->pm->flags & (PM_EFLOAT|PM_FFLOAT)) { } else if (v->pm->flags & (PM_EFLOAT|PM_FFLOAT)) {
@ -1495,7 +1505,7 @@ setstrvalue(Value v, char *val)
v->pm->flags &= ~PM_UNSET; v->pm->flags &= ~PM_UNSET;
switch (PM_TYPE(v->pm->flags)) { switch (PM_TYPE(v->pm->flags)) {
case PM_SCALAR: case PM_SCALAR:
if (v->a == 0 && v->b == -1) { if (v->start == 0 && v->len == -1) {
(v->pm->sets.cfn) (v->pm, val); (v->pm->sets.cfn) (v->pm, val);
if (v->pm->flags & (PM_LEFT | PM_RIGHT_B | PM_RIGHT_Z) && !v->pm->ct) if (v->pm->flags & (PM_LEFT | PM_RIGHT_B | PM_RIGHT_Z) && !v->pm->ct)
v->pm->ct = strlen(val); v->pm->ct = strlen(val);
@ -1506,22 +1516,22 @@ setstrvalue(Value v, char *val)
z = dupstring((v->pm->gets.cfn) (v->pm)); z = dupstring((v->pm->gets.cfn) (v->pm));
zlen = strlen(z); zlen = strlen(z);
if (v->inv && unset(KSHARRAYS)) if (v->inv && unset(KSHARRAYS))
v->a--, v->b--; v->start--;
if (v->a < 0) { if (v->start < 0) {
v->a += zlen; v->start += zlen;
if (v->a < 0) if (v->start < 0)
v->a = 0; v->start = 0;
} }
if (v->a > zlen) if (v->start > zlen)
v->a = zlen; v->start = zlen;
if (v->b < 0) if (v->len < 0)
v->b += zlen; v->len += zlen - v->start + 1;
if (v->b > zlen - 1) if (v->len > zlen - v->start)
v->b = zlen - 1; v->len = zlen - v->start;
x = (char *) zalloc(v->a + strlen(val) + zlen - v->b); x = (char *) zalloc(strlen(val) + zlen - v->len + 1);
strncpy(x, z, v->a); strncpy(x, z, v->start);
strcpy(x + v->a, val); strcpy(x + v->start, val);
strcat(x + v->a, z + v->b + 1); strcat(x + v->start, z + v->start + v->len);
(v->pm->sets.cfn) (v->pm, x); (v->pm->sets.cfn) (v->pm, x);
zsfree(val); zsfree(val);
} }
@ -1618,7 +1628,7 @@ setarrvalue(Value v, char **val)
zerr("attempt to assign array value to non-array", NULL, 0); zerr("attempt to assign array value to non-array", NULL, 0);
return; return;
} }
if (v->a == 0 && v->b == -1) { if (v->start == 0 && v->len == -1) {
if (PM_TYPE(v->pm->flags) == PM_HASHED) if (PM_TYPE(v->pm->flags) == PM_HASHED)
arrhashsetfn(v->pm, val); arrhashsetfn(v->pm, val);
else else
@ -1633,30 +1643,30 @@ setarrvalue(Value v, char **val)
return; return;
} }
if (v->inv && unset(KSHARRAYS)) if (v->inv && unset(KSHARRAYS))
v->a--, v->b--; v->start--;
q = old = v->pm->gets.afn(v->pm); q = old = v->pm->gets.afn(v->pm);
n = arrlen(old); n = arrlen(old);
if (v->a < 0) if (v->start < 0)
v->a += n; v->start += n;
if (v->b < 0) if (v->len < 0)
v->b += n; v->len += n - v->start + 1;
if (v->a < 0) if (v->start < 0)
v->a = 0; v->start = 0;
if (v->b < 0) if (v->len < 0)
v->b = 0; v->len = 0;
ll = v->a + arrlen(val); ll = v->start + arrlen(val);
if (v->b < n) if (v->start + v->len - 1 < n)
ll += n - v->b; ll += n - (v->start + v->len - 1);
p = new = (char **) zcalloc(sizeof(char *) * (ll + 1)); p = new = (char **) zcalloc(sizeof(char *) * (ll + 1));
for (i = 0; i < v->a; i++) for (i = 0; i < v->start; i++)
*p++ = i < n ? ztrdup(*q++) : ztrdup(""); *p++ = i < n ? ztrdup(*q++) : ztrdup("");
for (r = val; *r;) for (r = val; *r;)
*p++ = ztrdup(*r++); *p++ = ztrdup(*r++);
if (v->b + 1 < n) if (v->start + v->len < n)
for (q = old + v->b + 1; *q;) for (q = old + v->start + v->len; *q;)
*p++ = ztrdup(*q++); *p++ = ztrdup(*q++);
*p = NULL; *p = NULL;
@ -2151,7 +2161,7 @@ arrhashsetfn(Param pm, char **val)
HashTable opmtab = paramtab, ht = 0; HashTable opmtab = paramtab, ht = 0;
char **aptr = val; char **aptr = val;
Value v = (Value) hcalloc(sizeof *v); Value v = (Value) hcalloc(sizeof *v);
v->b = -1; v->len = -1;
if (alen % 2) { if (alen % 2) {
freearray(val); freearray(val);

3
Src/pattern.c
View file

@ -807,7 +807,7 @@ patgetglobflags(char **strp, long *assertp)
static long static long
patcomppiece(int *flagp) patcomppiece(int *flagp)
{ {
long starter, next, pound, op; long starter = 0, next, pound, op;
int flags, flags2, kshchar, len, ch, patch; int flags, flags2, kshchar, len, ch, patch;
union upat up; union upat up;
char *nptr, *str0, cbuf[2]; char *nptr, *str0, cbuf[2];
@ -1025,7 +1025,6 @@ patcomppiece(int *flagp)
if (*patparse != Outang) if (*patparse != Outang)
return 0; return 0;
patparse++; patparse++;
starter = 0; /* shut compiler up */
switch(len) { switch(len) {
case 3: case 3:
starter = patnode(P_NUMRNG); starter = patnode(P_NUMRNG);

8
Src/subst.c
View file

@ -1138,7 +1138,7 @@ paramsubst(LinkList l, LinkNode n, char **str, int qt, int ssub)
v = (Value) hcalloc(sizeof *v); v = (Value) hcalloc(sizeof *v);
v->isarr = isarr; v->isarr = isarr;
v->pm = pm; v->pm = pm;
v->b = -1; v->len = -1;
if (getindex(&s, v) || s == os) if (getindex(&s, v) || s == os)
break; break;
} }
@ -1154,9 +1154,9 @@ paramsubst(LinkList l, LinkNode n, char **str, int qt, int ssub)
if (v->pm->flags & PM_ARRAY) { if (v->pm->flags & PM_ARRAY) {
int tmplen = arrlen(v->pm->gets.afn(v->pm)); int tmplen = arrlen(v->pm->gets.afn(v->pm));
if (v->a < 0) if (v->start < 0)
v->a += tmplen + v->inv; v->start += tmplen + v->inv;
if (!v->inv && (v->a >= tmplen || v->a < 0)) if (!v->inv && (v->start >= tmplen || v->start < 0))
vunset = 1; vunset = 1;
} }
if (!vunset) { if (!vunset) {

4
Src/zsh.h
View file

@ -467,8 +467,8 @@ struct value {
int isarr; int isarr;
Param pm; /* parameter node */ Param pm; /* parameter node */
int inv; /* should we return the index ? */ int inv; /* should we return the index ? */
int a; /* first element of array slice, or -1 */ int start; /* first element of array slice, or -1 */
int b; /* last element of array slice, or -1 */ int len; /* length of array slice, or -1 */
char **arr; /* cache for hash turned into array */ char **arr; /* cache for hash turned into array */
}; };

1
Test/07cond.ztst
View file

@ -99,6 +99,7 @@
# can't be bothered with -S # can't be bothered with -S
sleep 1
cat unmodified cat unmodified
touch newnewnew touch newnewnew
[[ -N newnewnew && ! -N unmodified ]] [[ -N newnewnew && ! -N unmodified ]]