external/cde
1
0
Fork 0
mirror of git://git.code.sf.net/p/cdesktopenv/code synced 2025-03-09 15:50:02 +00:00
Code Issues Releases Wiki Activity

libast/regex: full revert (re: 38aab428, 1aa8f771)

Browse source 
In another branch, this is causing a mysterious test failure in
types.sh. So this is not ready for 1.0.
This commit is contained in:
Martijn Dekker 2021-12-16 19:06:33 +01:00
parent 3779d84220
commit 4856847631
8 changed files with 35 additions and 61 deletions
Download patch file Download diff file Expand all files Collapse all files

1
src/lib/libast/regex/regcoll.c
View file

@ -56,7 +56,6 @@ regcollate(register const char* s, char** e, char* buf, size_t size, wchar_t* wc
if (size < 2 || (term = *s) != '.' && term != '=' || !*++s || *s == term && *(s + 1) == ']') if (size < 2 || (term = *s) != '.' && term != '=' || !*++s || *s == term && *(s + 1) == ']')
goto nope; goto nope;
t = s; t = s;
mbinit();
w = mbchar(s); w = mbchar(s);
if ((r = (s - t)) > 1) if ((r = (s - t)) > 1)
{ {

17
src/lib/libast/regex/regcomp.c
View file

@ -1,7 +1,7 @@
/*********************************************************************** /***********************************************************************
* * * *
* This software is part of the ast package * * This software is part of the ast package *
* Copyright (c) 1985-2013 AT&T Intellectual Property * * Copyright (c) 1985-2012 AT&T Intellectual Property *
* Copyright (c) 2020-2021 Contributors to ksh 93u+m * * Copyright (c) 2020-2021 Contributors to ksh 93u+m *
* and is licensed under the * * and is licensed under the *
* Eclipse Public License, Version 1.0 * * Eclipse Public License, Version 1.0 *
@ -1083,7 +1083,6 @@ col(Celt_t* ce, int ic, unsigned char* bp, int bw, int bc, unsigned char* ep, in
if (cc > 0) if (cc > 0)
{ {
cc = -1; cc = -1;
mbinit();
k += mbconv((char*)k, c); k += mbconv((char*)k, c);
} }
else else
@ -1094,7 +1093,6 @@ col(Celt_t* ce, int ic, unsigned char* bp, int bw, int bc, unsigned char* ep, in
if (ep) if (ep)
{ {
k = key; k = key;
mbinit();
c = mbchar(k); c = mbchar(k);
if (iswupper(c)) if (iswupper(c))
bt = COLL_range_uc; bt = COLL_range_uc;
@ -1126,7 +1124,6 @@ col(Celt_t* ce, int ic, unsigned char* bp, int bw, int bc, unsigned char* ep, in
s = (char*)ep; s = (char*)ep;
if (ic) if (ic)
{ {
mbinit();
c = mbchar(s); c = mbchar(s);
if (iswupper(c)) if (iswupper(c))
{ {
@ -1142,7 +1139,6 @@ col(Celt_t* ce, int ic, unsigned char* bp, int bw, int bc, unsigned char* ep, in
if (cc > 0) if (cc > 0)
{ {
cc = -1; cc = -1;
mbinit();
k += mbconv((char*)k, c); k += mbconv((char*)k, c);
} }
else else
@ -1151,7 +1147,6 @@ col(Celt_t* ce, int ic, unsigned char* bp, int bw, int bc, unsigned char* ep, in
*k = 0; *k = 0;
mbxfrm(ce->end, key, COLL_KEY_MAX); mbxfrm(ce->end, key, COLL_KEY_MAX);
k = key; k = key;
mbinit();
c = mbchar(k); c = mbchar(k);
if (iswupper(c)) if (iswupper(c))
et = COLL_range_uc; et = COLL_range_uc;
@ -1521,7 +1516,6 @@ bra(Cenv_t* env)
if (env->token.len > 1 || w >= 0 && w < T_META) if (env->token.len > 1 || w >= 0 && w < T_META)
{ {
c = w; c = w;
mbinit();
w = mbconv(mbc, c); w = mbconv(mbc, c);
pp = (unsigned char*)mbc; pp = (unsigned char*)mbc;
env->cursor += env->token.len; env->cursor += env->token.len;
@ -1620,7 +1614,6 @@ bra(Cenv_t* env)
if (iswupper(wc)) if (iswupper(wc))
{ {
wc = towlower(wc); wc = towlower(wc);
mbinit();
rw = mbconv((char*)pp, wc); rw = mbconv((char*)pp, wc);
c = 'u'; c = 'u';
} }
@ -1674,7 +1667,6 @@ bra(Cenv_t* env)
wc = towupper(wc); wc = towupper(wc);
c = 'U'; c = 'U';
} }
mbinit();
rw = mbconv((char*)pp, wc); rw = mbconv((char*)pp, wc);
i = 0; i = 0;
} }
@ -2106,7 +2098,7 @@ grp(Cenv_t* env, int parno)
switch (c) switch (c)
{ {
case ')': case ')':
if (!(env->flags & (REG_LITERAL|REG_SHELL))) if (!(env->flags & REG_LITERAL))
{ {
env->error = REG_BADRPT; env->error = REG_BADRPT;
return 0; return 0;
@ -2539,7 +2531,7 @@ grp(Cenv_t* env, int parno)
} }
c = token(env); c = token(env);
env->parnest--; env->parnest--;
if (c != T_CLOSE && (c != ')' || !(env->flags & (REG_LITERAL|REG_SHELL)))) if (c != T_CLOSE && (!(env->flags & REG_LITERAL) || c != ')'))
{ {
env->error = REG_EPAREN; env->error = REG_EPAREN;
goto nope; goto nope;
@ -2625,7 +2617,6 @@ seq(Cenv_t* env)
c = towupper(c); c = towupper(c);
if ((&buf[sizeof(buf)] - s) < MB_CUR_MAX) if ((&buf[sizeof(buf)] - s) < MB_CUR_MAX)
break; break;
mbinit();
if ((n = mbconv((char*)s, c)) < 0) if ((n = mbconv((char*)s, c)) < 0)
*s++ = c; *s++ = c;
else if (n) else if (n)
@ -3401,7 +3392,7 @@ regcomp(regex_t* p, const char* pattern, regflags_t flags)
p->re_nsub /= 2; p->re_nsub /= 2;
if (env.flags & REG_DELIMITED) if (env.flags & REG_DELIMITED)
{ {
p->re_npat = env.cursor - (unsigned char*)pattern + 1; p->re_npat = env.cursor - env.pattern + 1;
if (*env.cursor == env.delimiter) if (*env.cursor == env.delimiter)
p->re_npat++; p->re_npat++;
else if (env.flags & REG_MUSTDELIM) else if (env.flags & REG_MUSTDELIM)

34
src/lib/libast/regex/regdecomp.c
View file

@ -1,7 +1,7 @@
/*********************************************************************** /***********************************************************************
* * * *
* This software is part of the ast package * * This software is part of the ast package *
* Copyright (c) 1985-2013 AT&T Intellectual Property * * Copyright (c) 1985-2011 AT&T Intellectual Property *
* Copyright (c) 2020-2021 Contributors to ksh 93u+m * * Copyright (c) 2020-2021 Contributors to ksh 93u+m *
* and is licensed under the * * and is licensed under the *
* Eclipse Public License, Version 1.0 * * Eclipse Public License, Version 1.0 *
@ -70,7 +70,7 @@ detrie(Trie_node_t* x, Sfio_t* sp, char* b, char* p, char* e, int delimiter)
} }
static int static int
decomp(register Rex_t* e, Rex_t* parent, Sfio_t* sp, int type, int delimiter, regflags_t flags) decomp(register Rex_t* e, Sfio_t* sp, int type, int delimiter, regflags_t flags)
{ {
Rex_t* q; Rex_t* q;
unsigned char* s; unsigned char* s;
@ -92,10 +92,10 @@ decomp(register Rex_t* e, Rex_t* parent, Sfio_t* sp, int type, int delimiter, re
switch (e->type) switch (e->type)
{ {
case REX_ALT: case REX_ALT:
if (decomp(e->re.group.expr.binary.left, e, sp, type, delimiter, flags)) if (decomp(e->re.group.expr.binary.left, sp, type, delimiter, flags))
return 1; return 1;
sfputc(sp, '|'); sfputc(sp, '|');
if (e->re.group.expr.binary.right && decomp(e->re.group.expr.binary.right, e, sp, type, delimiter, flags)) if (e->re.group.expr.binary.right && decomp(e->re.group.expr.binary.right, sp, type, delimiter, flags))
return 1; return 1;
break; break;
case REX_BACK: case REX_BACK:
@ -141,13 +141,11 @@ decomp(register Rex_t* e, Rex_t* parent, Sfio_t* sp, int type, int delimiter, re
sfputc(sp, '?'); sfputc(sp, '?');
else else
c = 0; c = 0;
if (e->re.group.expr.rex && e->re.group.expr.rex->type == REX_GROUP)
c = 0;
} }
switch (e->type) switch (e->type)
{ {
case REX_REP: case REX_REP:
if (decomp(e->re.group.expr.rex, e, sp, type, delimiter, flags)) if (decomp(e->re.group.expr.rex, sp, type, delimiter, flags))
return 1; return 1;
break; break;
case REX_CLASS: case REX_CLASS:
@ -324,7 +322,7 @@ decomp(register Rex_t* e, Rex_t* parent, Sfio_t* sp, int type, int delimiter, re
case REX_NEG: case REX_NEG:
if (type >= SRE) if (type >= SRE)
sfprintf(sp, "!("); sfprintf(sp, "!(");
if (decomp(e->re.group.expr.rex, e, sp, type, delimiter, flags)) if (decomp(e->re.group.expr.rex, sp, type, delimiter, flags))
return 1; return 1;
if (type >= SRE) if (type >= SRE)
sfputc(sp, ')'); sfputc(sp, ')');
@ -332,17 +330,17 @@ decomp(register Rex_t* e, Rex_t* parent, Sfio_t* sp, int type, int delimiter, re
sfputc(sp, '!'); sfputc(sp, '!');
break; break;
case REX_CONJ: case REX_CONJ:
if (decomp(e->re.group.expr.binary.left, e, sp, type, delimiter, flags)) if (decomp(e->re.group.expr.binary.left, sp, type, delimiter, flags))
return 1; return 1;
sfputc(sp, '&'); sfputc(sp, '&');
if (decomp(e->re.group.expr.binary.right, e, sp, type, delimiter, flags)) if (decomp(e->re.group.expr.binary.right, sp, type, delimiter, flags))
return 1; return 1;
break; break;
case REX_GROUP: case REX_GROUP:
if (type >= SRE && parent->type != REX_REP) if (type >= SRE)
sfputc(sp, '@'); sfputc(sp, '@');
meta(sp, '(', type, 1, delimiter); meta(sp, '(', type, 1, delimiter);
if (decomp(e->re.group.expr.rex, e, sp, type, delimiter, flags)) if (decomp(e->re.group.expr.rex, sp, type, delimiter, flags))
return 1; return 1;
meta(sp, ')', type, 1, delimiter); meta(sp, ')', type, 1, delimiter);
break; break;
@ -352,22 +350,22 @@ decomp(register Rex_t* e, Rex_t* parent, Sfio_t* sp, int type, int delimiter, re
case REX_GROUP_BEHIND_NOT: case REX_GROUP_BEHIND_NOT:
meta(sp, '(', type, 1, delimiter); meta(sp, '(', type, 1, delimiter);
sfputc(sp, '?'); sfputc(sp, '?');
if (decomp(e->re.group.expr.rex, e, sp, type, delimiter, flags)) if (decomp(e->re.group.expr.rex, sp, type, delimiter, flags))
return 1; return 1;
meta(sp, ')', type, 1, delimiter); meta(sp, ')', type, 1, delimiter);
break; break;
case REX_GROUP_COND: case REX_GROUP_COND:
meta(sp, '(', type, 1, delimiter); meta(sp, '(', type, 1, delimiter);
sfputc(sp, '?'); sfputc(sp, '?');
if (e->re.group.expr.binary.left && decomp(e->re.group.expr.binary.left, e, sp, type, delimiter, flags)) if (e->re.group.expr.binary.left && decomp(e->re.group.expr.binary.left, sp, type, delimiter, flags))
return 1; return 1;
if (q = e->re.group.expr.binary.right) if (q = e->re.group.expr.binary.right)
{ {
sfputc(sp, ':'); sfputc(sp, ':');
if (q->re.group.expr.binary.left && decomp(q->re.group.expr.binary.left, q, sp, type, delimiter, flags)) if (q->re.group.expr.binary.left && decomp(q->re.group.expr.binary.left, sp, type, delimiter, flags))
return 1; return 1;
sfputc(sp, ':'); sfputc(sp, ':');
if (q->re.group.expr.binary.right && decomp(q->re.group.expr.binary.right, q, sp, type, delimiter, flags)) if (q->re.group.expr.binary.right && decomp(q->re.group.expr.binary.right, sp, type, delimiter, flags))
return 1; return 1;
} }
meta(sp, ')', type, 1, delimiter); meta(sp, ')', type, 1, delimiter);
@ -375,7 +373,7 @@ decomp(register Rex_t* e, Rex_t* parent, Sfio_t* sp, int type, int delimiter, re
case REX_GROUP_CUT: case REX_GROUP_CUT:
meta(sp, '(', type, 1, delimiter); meta(sp, '(', type, 1, delimiter);
sfputc(sp, '?'); sfputc(sp, '?');
if (decomp(e->re.group.expr.rex, e, sp, type, delimiter, flags)) if (decomp(e->re.group.expr.rex, sp, type, delimiter, flags))
return 1; return 1;
meta(sp, ')', type, 1, delimiter); meta(sp, ')', type, 1, delimiter);
break; break;
@ -432,7 +430,7 @@ regdecomp(regex_t* p, regflags_t flags, char* buf, size_t n)
} }
else else
delimiter = -1; delimiter = -1;
if (decomp(p->env->rex, p->env->rex, sp, type, delimiter, flags)) if (decomp(p->env->rex, sp, type, delimiter, flags))
r = 0; r = 0;
else else
{ {

2
src/lib/libast/regex/regerror.c
View file

@ -26,7 +26,7 @@
* POSIX regex error message handler * POSIX regex error message handler
*/ */
static const char id[] = "\n@(#)$Id: regex (AT&T Research) 2012-09-27 $\0\n"; static const char id[] = "\n@(#)$Id: regex (AT&T Research) 2012-05-31 $\0\n";
#include "reglib.h" #include "reglib.h"

2
src/lib/libast/regex/regexec.c
View file

@ -34,7 +34,7 @@
*/ */
int int
regexec_20120528(const regex_t* p, const char* s, size_t nmatch, regmatch_t* match, regflags_t flags) regexec(const regex_t* p, const char* s, size_t nmatch, regmatch_t* match, regflags_t flags)
{ {
if (flags & REG_STARTEND) if (flags & REG_STARTEND)
{ {

8
src/lib/libast/regex/reglib.h
View file

@ -1,7 +1,7 @@
/*********************************************************************** /***********************************************************************
* * * *
* This software is part of the ast package * * This software is part of the ast package *
* Copyright (c) 1985-2013 AT&T Intellectual Property * * Copyright (c) 1985-2012 AT&T Intellectual Property *
* Copyright (c) 2020-2021 Contributors to ksh 93u+m * * Copyright (c) 2020-2021 Contributors to ksh 93u+m *
* and is licensed under the * * and is licensed under the *
* Eclipse Public License, Version 1.0 * * Eclipse Public License, Version 1.0 *
@ -173,9 +173,9 @@ typedef struct regsubop_s
#define HIT SSIZE_MAX #define HIT SSIZE_MAX
#define bitclr(p,c) ((p)[(c)>>3]&=(~(1<<((c)&07)))) #define bitclr(p,c) ((p)[((c)>>3)&037]&=(~(1<<((c)&07))))
#define bitset(p,c) ((p)[(c)>>3]|=(1<<((c)&07))) #define bitset(p,c) ((p)[((c)>>3)&037]|=(1<<((c)&07)))
#define bittst(p,c) ((p)[(c)>>3]&(1<<((c)&07))) #define bittst(p,c) ((p)[((c)>>3)&037]&(1<<((c)&07)))
#define setadd(p,c) bitset((p)->bits,c) #define setadd(p,c) bitset((p)->bits,c)
#define setclr(p,c) bitclr((p)->bits,c) #define setclr(p,c) bitclr((p)->bits,c)

23
src/lib/libast/regex/regnexec.c
View file

@ -1,7 +1,7 @@
/*********************************************************************** /***********************************************************************
* * * *
* This software is part of the ast package * * This software is part of the ast package *
* Copyright (c) 1985-2013 AT&T Intellectual Property * * Copyright (c) 1985-2012 AT&T Intellectual Property *
* Copyright (c) 2020-2021 Contributors to ksh 93u+m * * Copyright (c) 2020-2021 Contributors to ksh 93u+m *
* and is licensed under the * * and is licensed under the *
* Eclipse Public License, Version 1.0 * * Eclipse Public License, Version 1.0 *
@ -628,7 +628,6 @@ collic(register Celt_t* ce, char* key, register char* nxt, int c, int x)
c = towlower(c); c = towlower(c);
else else
return 0; return 0;
mbinit();
x = mbconv(key, c); x = mbconv(key, c);
key[x] = 0; key[x] = 0;
return collelt(ce, key, c, 0); return collelt(ce, key, c, 0);
@ -881,7 +880,6 @@ DEBUG_TEST(0x0008,(sfprintf(sfstdout, "AHA#%04d 0x%04x parse %s `%-.*s'\n", __LI
} }
else else
{ {
mbinit();
while (s < e) while (s < e)
{ {
c = mbchar(s); c = mbchar(s);
@ -1532,7 +1530,6 @@ DEBUG_TEST(0x0200,(sfprintf(sfstdout,"AHA#%04d 0x%04x parse %s=>%s `%-.*s'\n", _
for (i = 0; s < e && i < n; i++, s = t) for (i = 0; s < e && i < n; i++, s = t)
{ {
t = s; t = s;
mbinit();
if (mbchar(t) != c) if (mbchar(t) != c)
break; break;
b[i] = t - s; b[i] = t - s;
@ -1543,7 +1540,6 @@ DEBUG_TEST(0x0200,(sfprintf(sfstdout,"AHA#%04d 0x%04x parse %s=>%s `%-.*s'\n", _
for (i = 0; s < e && i < n; i++, s = t) for (i = 0; s < e && i < n; i++, s = t)
{ {
t = s; t = s;
mbinit();
if (towupper(mbchar(t)) != c) if (towupper(mbchar(t)) != c)
break; break;
b[i] = t - s; b[i] = t - s;
@ -1626,7 +1622,6 @@ DEBUG_TEST(0x0200,(sfprintf(sfstdout,"AHA#%04d 0x%04x parse %s=>%s `%-.*s'\n", _
for (i = 0; i < m && s < e; i++, s = t) for (i = 0; i < m && s < e; i++, s = t)
{ {
t = s; t = s;
mbinit();
if (mbchar(t) != c) if (mbchar(t) != c)
return r; return r;
} }
@ -1642,10 +1637,7 @@ DEBUG_TEST(0x0200,(sfprintf(sfstdout,"AHA#%04d 0x%04x parse %s=>%s `%-.*s'\n", _
case GOOD: case GOOD:
return BEST; return BEST;
} }
if (s >= e) if (s >= e || mbchar(s) != c)
break;
mbinit();
if (mbchar(s) != c)
break; break;
} }
} }
@ -1654,7 +1646,6 @@ DEBUG_TEST(0x0200,(sfprintf(sfstdout,"AHA#%04d 0x%04x parse %s=>%s `%-.*s'\n", _
for (i = 0; i < m && s < e; i++, s = t) for (i = 0; i < m && s < e; i++, s = t)
{ {
t = s; t = s;
mbinit();
if (towupper(mbchar(t)) != c) if (towupper(mbchar(t)) != c)
return r; return r;
} }
@ -1670,10 +1661,7 @@ DEBUG_TEST(0x0200,(sfprintf(sfstdout,"AHA#%04d 0x%04x parse %s=>%s `%-.*s'\n", _
case GOOD: case GOOD:
return BEST; return BEST;
} }
if (s >= e) if (s >= e || towupper(mbchar(s)) != c)
break;
mbinit();
if (towupper(mbchar(s)) != c)
break; break;
} }
} }
@ -1856,7 +1844,7 @@ list(Env_t* env, Rex_t* rex)
*/ */
int int
regnexec_20120528(const regex_t* p, const char* s, size_t len, size_t nmatch, regmatch_t* match, regflags_t flags) regnexec(const regex_t* p, const char* s, size_t len, size_t nmatch, regmatch_t* match, regflags_t flags)
{ {
register ssize_t n; register ssize_t n;
register int i; register int i;
@ -1928,8 +1916,7 @@ regnexec_20120528(const regex_t* p, const char* s, size_t len, size_t nmatch, re
DEBUG_TEST(0x0080,(sfprintf(sfstdout, "AHA#%04d REX_BM len=%d right=%d left=%d size=%d %d %d\n", __LINE__, len, e->re.bm.right, e->re.bm.left, e->re.bm.size, index, mid)),(0)); DEBUG_TEST(0x0080,(sfprintf(sfstdout, "AHA#%04d REX_BM len=%d right=%d left=%d size=%d %d %d\n", __LINE__, len, e->re.bm.right, e->re.bm.left, e->re.bm.size, index, mid)),(0));
for (;;) for (;;)
{ {
while (index < mid) while ((index += skip[buf[index]]) < mid);
index += skip[buf[index]];
if (index < HIT) if (index < HIT)
{ {
DEBUG_TEST(0x0080,(sfprintf(sfstdout, "AHA#%04d REG_NOMATCH %d %d\n", __LINE__, index, HIT)),(0)); DEBUG_TEST(0x0080,(sfprintf(sfstdout, "AHA#%04d REG_NOMATCH %d %d\n", __LINE__, index, HIT)),(0));

9
src/lib/libast/regex/regrexec.c
View file

@ -1,7 +1,7 @@
/*********************************************************************** /***********************************************************************
* * * *
* This software is part of the ast package * * This software is part of the ast package *
* Copyright (c) 1985-2013 AT&T Intellectual Property * * Copyright (c) 1985-2012 AT&T Intellectual Property *
* Copyright (c) 2020-2021 Contributors to ksh 93u+m * * Copyright (c) 2020-2021 Contributors to ksh 93u+m *
* and is licensed under the * * and is licensed under the *
* Eclipse Public License, Version 1.0 * * Eclipse Public License, Version 1.0 *
@ -34,9 +34,9 @@
*/ */
int int
regrexec_20120528(const regex_t* p, const char* s, size_t len, size_t nmatch, regmatch_t* match, regflags_t flags, int sep, void* handle, regrecord_t record) regrexec(const regex_t* p, const char* s, size_t len, size_t nmatch, regmatch_t* match, regflags_t flags, int sep, void* handle, regrecord_t record)
{ {
register unsigned char* buf; register unsigned char* buf = (unsigned char*)s;
register unsigned char* beg; register unsigned char* beg;
register unsigned char* l; register unsigned char* l;
register unsigned char* r; register unsigned char* r;
@ -73,8 +73,7 @@ regrexec_20120528(const regex_t* p, const char* s, size_t len, size_t nmatch, re
index = leftlen++; index = leftlen++;
for (;;) for (;;)
{ {
while (index < mid) while ((index += skip[buf[index]]) < mid);
index += skip[buf[index]];
if (index < HIT) if (index < HIT)
goto impossible; goto impossible;
index -= HIT; index -= HIT;