* [v5 PATCH 01/13] shell: Call setlocale
2024-06-02 1:28 [v5 PATCH 00/13] Add multi-byte supportAdd multi-byte support Herbert Xu
@ 2024-06-02 1:28 ` Herbert Xu
2024-06-02 1:28 ` [v5 PATCH 02/13] shell: Use strcoll instead of strcmp where applicable Herbert Xu
` (11 subsequent siblings)
12 siblings, 0 replies; 14+ messages in thread
From: Herbert Xu @ 2024-06-02 1:28 UTC (permalink / raw)
To: DASH Mailing List
Call setlocale to initialise locale settings for libc.
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
---
src/main.c | 4 ++++
1 file changed, 4 insertions(+)
diff --git a/src/main.c b/src/main.c
index 7beb280..1e192f8 100644
--- a/src/main.c
+++ b/src/main.c
@@ -32,6 +32,7 @@
* SUCH DAMAGE.
*/
+#include <locale.h>
#include <stdio.h>
#include <signal.h>
#include <sys/stat.h>
@@ -101,6 +102,9 @@ main(int argc, char **argv)
#if PROFILE
monitor(4, etext, profile_buf, sizeof profile_buf, 50);
#endif
+
+ setlocale(LC_ALL, "");
+
state = 0;
if (unlikely(setjmp(main_handler.loc))) {
int e;
--
2.39.2
^ permalink raw reply related [flat|nested] 14+ messages in thread* [v5 PATCH 02/13] shell: Use strcoll instead of strcmp where applicable
2024-06-02 1:28 [v5 PATCH 00/13] Add multi-byte supportAdd multi-byte support Herbert Xu
2024-06-02 1:28 ` [v5 PATCH 01/13] shell: Call setlocale Herbert Xu
@ 2024-06-02 1:28 ` Herbert Xu
2024-06-02 1:28 ` [v5 PATCH 03/13] expand: Count multi-byte characters for VSLENGTH Herbert Xu
` (10 subsequent siblings)
12 siblings, 0 replies; 14+ messages in thread
From: Herbert Xu @ 2024-06-02 1:28 UTC (permalink / raw)
To: DASH Mailing List
Use strcoll instead of strcmp so that the locale is taken into
account when sorting strings during pathname expansion, and for
the built-in test(1) string comparison operators.
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
---
src/bltin/test.c | 8 ++++----
src/expand.c | 2 +-
2 files changed, 5 insertions(+), 5 deletions(-)
diff --git a/src/bltin/test.c b/src/bltin/test.c
index fd8a43b..2db4d0f 100644
--- a/src/bltin/test.c
+++ b/src/bltin/test.c
@@ -353,13 +353,13 @@ binop(void)
/* NOTREACHED */
#endif
case STREQ:
- return strcmp(opnd1, opnd2) == 0;
+ return strcoll(opnd1, opnd2) == 0;
case STRNE:
- return strcmp(opnd1, opnd2) != 0;
+ return strcoll(opnd1, opnd2) != 0;
case STRLT:
- return strcmp(opnd1, opnd2) < 0;
+ return strcoll(opnd1, opnd2) < 0;
case STRGT:
- return strcmp(opnd1, opnd2) > 0;
+ return strcoll(opnd1, opnd2) > 0;
case INTEQ:
return getn(opnd1) == getn(opnd2);
case INTNE:
diff --git a/src/expand.c b/src/expand.c
index ce245e4..db46cf4 100644
--- a/src/expand.c
+++ b/src/expand.c
@@ -1481,7 +1481,7 @@ msort(struct strlist *list, int len)
p = msort(p, len - half); /* sort second half */
lpp = &list;
for (;;) {
- if (strcmp(p->text, q->text) < 0) {
+ if (strcoll(p->text, q->text) < 0) {
*lpp = p;
lpp = &p->next;
if ((p = *lpp) == NULL) {
--
2.39.2
^ permalink raw reply related [flat|nested] 14+ messages in thread* [v5 PATCH 03/13] expand: Count multi-byte characters for VSLENGTH
2024-06-02 1:28 [v5 PATCH 00/13] Add multi-byte supportAdd multi-byte support Herbert Xu
2024-06-02 1:28 ` [v5 PATCH 01/13] shell: Call setlocale Herbert Xu
2024-06-02 1:28 ` [v5 PATCH 02/13] shell: Use strcoll instead of strcmp where applicable Herbert Xu
@ 2024-06-02 1:28 ` Herbert Xu
2024-06-02 1:28 ` [v5 PATCH 04/13] expand: Process multi-byte characters in subevalvar Herbert Xu
` (9 subsequent siblings)
12 siblings, 0 replies; 14+ messages in thread
From: Herbert Xu @ 2024-06-02 1:28 UTC (permalink / raw)
To: DASH Mailing List
Count multi-byte characters in variables and rather than bytes
and return that as the length expansion.
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
---
src/expand.c | 107 ++++++++++++++++++++++++++++++++++++++++---------
src/memalloc.h | 10 ++---
2 files changed, 94 insertions(+), 23 deletions(-)
diff --git a/src/expand.c b/src/expand.c
index db46cf4..0a868d5 100644
--- a/src/expand.c
+++ b/src/expand.c
@@ -54,6 +54,7 @@
#include <sys/time.h>
#include <sys/stat.h>
#include <unistd.h>
+#include <wchar.h>
/*
* Routines to expand arguments to commands. We have to deal with
@@ -790,6 +791,41 @@ really_record:
return p;
}
+static char *chtodest(int c, const char *syntax, char *out)
+{
+ if (syntax[c] == CCTL)
+ USTPUTC(CTLESC, out);
+ USTPUTC(c, out);
+
+ return out;
+}
+
+struct mbpair {
+ unsigned ml;
+ unsigned ql;
+};
+
+static struct mbpair mbtodest(const char *p, char *q, const char *syntax,
+ size_t len)
+{
+ mbstate_t mbs = {};
+ struct mbpair mbp;
+ char *q0 = q;
+ size_t ml;
+
+ ml = mbrlen(--p, len, &mbs);
+ if (ml == -2 || ml == -1 || ml < 2)
+ ml = 1;
+
+ len = ml;
+ do {
+ q = chtodest((signed char)*p++, syntax, q);
+ } while (--len);
+
+ mbp.ml = ml - 1;
+ mbp.ql = q - q0;
+ return mbp;
+}
/*
* Put a string on the stack.
@@ -797,38 +833,72 @@ really_record:
static size_t memtodest(const char *p, size_t len, int flags)
{
- const char *syntax = flags & EXP_QUOTED ? DQSYNTAX : BASESYNTAX;
+ const char *syntax;
+ size_t count = 0;
+ int expq;
char *q;
- char *s;
if (unlikely(!len))
return 0;
q = makestrspace(len * 2, expdest);
- s = q;
- do {
+#if QUOTES_ESC != 0x11 || EXP_QUOTED != 0x100
+#error QUOTES_ESC != 0x11 || EXP_QUOTED != 0x100
+#endif
+ expq = flags & EXP_QUOTED;
+ if (likely(!(flags & (expq >> 4 | expq >> 8) & QUOTES_ESC))) {
+ while (len >= 8) {
+ uint64_t x = *(uint64_t *)(p + count);
+
+ if ((x | (x - 0x0101010101010101)) &
+ 0x8080808080808080)
+ break;
+
+ *(uint64_t *)(q + count) = x;
+
+ count += 8;
+ len -= 8;
+ }
+
+ q += count;
+ p += count;
+
+ syntax = flags & QUOTES_ESC ? BASESYNTAX : is_type;
+ } else
+ syntax = SQSYNTAX;
+
+ for (; len; len--) {
int c = (signed char)*p++;
- if (c) {
- if ((flags & QUOTES_ESC) &&
- ((syntax[c] == CCTL) ||
- (flags & EXP_QUOTED && syntax[c] == CBACK)))
- USTPUTC(CTLESC, q);
- } else if (!(flags & EXP_KEEPNUL))
+
+ if (unlikely(!c && !(flags & EXP_KEEPNUL)))
continue;
- USTPUTC(c, q);
- } while (--len);
+
+ count++;
+
+ if (unlikely(c < 0)) {
+ struct mbpair mbp = mbtodest(p, q, syntax, len);
+ unsigned mlm;
+
+ q += mbp.ql;
+ mlm = mbp.ml;
+ p += mlm;
+ len -= mlm;
+ continue;
+ }
+
+ q = chtodest(c, syntax, q);
+ }
expdest = q;
- return q - s;
+ return count;
}
static size_t strtodest(const char *p, int flags)
{
size_t len = strlen(p);
- memtodest(p, len, flags);
- return len;
+ return memtodest(p, len, flags);
}
@@ -850,6 +920,7 @@ varvalue(char *name, int varflags, int flags, int quoted)
int discard = (subtype == VSPLUS || subtype == VSLENGTH) |
(flags & EXP_DISCARD);
ssize_t len = 0;
+ size_t start;
char c;
if (!subtype) {
@@ -859,9 +930,9 @@ varvalue(char *name, int varflags, int flags, int quoted)
sh_error("Bad substitution");
}
- flags |= EXP_KEEPNUL;
flags &= discard ? ~QUOTES_ESC : ~0;
sep = (flags & EXP_FULL) << CHAR_BIT;
+ start = expdest - (char *)stackblock();
switch (*name) {
case '$':
@@ -921,7 +992,7 @@ param:
if (*ap && sep) {
len++;
- memtodest(&sepc, 1, flags);
+ memtodest(&sepc, 1, flags | EXP_KEEPNUL);
}
}
break;
@@ -951,7 +1022,7 @@ value:
}
if (discard)
- STADJUST(-len, expdest);
+ expdest = (char *)stackblock() + start;
return len;
}
diff --git a/src/memalloc.h b/src/memalloc.h
index a7f7996..1895c1e 100644
--- a/src/memalloc.h
+++ b/src/memalloc.h
@@ -81,11 +81,11 @@ static inline char *_STPUTC(int c, char *p) {
#define STPUTC(c, p) ((p) = _STPUTC((c), (p)))
#define CHECKSTRSPACE(n, p) \
({ \
- char *q = (p); \
- size_t l = (n); \
- size_t m = sstrend - q; \
- if (l > m) \
- (p) = makestrspace(l, q); \
+ char *_q = (p); \
+ size_t _l = (n); \
+ size_t _m = sstrend - _q; \
+ if (_l > _m) \
+ (p) = makestrspace(_l, _q); \
0; \
})
#define USTPUTC(c, p) (*p++ = (c))
--
2.39.2
^ permalink raw reply related [flat|nested] 14+ messages in thread* [v5 PATCH 04/13] expand: Process multi-byte characters in subevalvar
2024-06-02 1:28 [v5 PATCH 00/13] Add multi-byte supportAdd multi-byte support Herbert Xu
` (2 preceding siblings ...)
2024-06-02 1:28 ` [v5 PATCH 03/13] expand: Count multi-byte characters for VSLENGTH Herbert Xu
@ 2024-06-02 1:28 ` Herbert Xu
2024-06-02 1:28 ` [v5 PATCH 05/13] expand: Process multi-byte characters in expmeta Herbert Xu
` (8 subsequent siblings)
12 siblings, 0 replies; 14+ messages in thread
From: Herbert Xu @ 2024-06-02 1:28 UTC (permalink / raw)
To: DASH Mailing List
When trimming variables in subevalvar, process multi-byte characters
as one unit instead of their constituent bytes.
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
---
src/expand.c | 170 +++++++++++++++++++++++++++++++++++--------------
src/expand.h | 1 +
src/mystring.c | 2 +-
src/parser.h | 1 +
4 files changed, 125 insertions(+), 49 deletions(-)
diff --git a/src/expand.c b/src/expand.c
index 0a868d5..5d73f8e 100644
--- a/src/expand.c
+++ b/src/expand.c
@@ -544,8 +544,10 @@ static char *scanleft(char *startp, char *endp, char *rmesc, char *rmescend,
loc = startp;
loc2 = rmesc;
do {
- int match;
const char *s = loc2;
+ unsigned ml;
+ int match;
+
c = *loc2;
if (zero) {
*loc2 = '\0';
@@ -554,12 +556,26 @@ static char *scanleft(char *startp, char *endp, char *rmesc, char *rmescend,
match = pmatch(str, s);
*loc2 = c;
if (match)
- return loc;
- if (quotes && *loc == (char)CTLESC)
+ return quotes ? loc : loc2;
+
+ if (!c)
+ break;
+
+ if (*loc != (char)CTLMBCHAR) {
+ if (*loc == (char)CTLESC)
+ loc++;
loc++;
- loc++;
- loc2++;
- } while (c);
+ loc2++;
+ continue;
+ }
+
+ if (*++loc == (char)CTLESC)
+ loc++;
+
+ ml = (unsigned char)*loc;
+ loc += ml + 3;
+ loc2 += ml;
+ } while (1);
return 0;
}
@@ -567,14 +583,16 @@ static char *scanleft(char *startp, char *endp, char *rmesc, char *rmescend,
static char *scanright(char *startp, char *endp, char *rmesc, char *rmescend,
char *str, int quotes, int zero
) {
- int esc = 0;
+ size_t esc = 0;
char *loc;
char *loc2;
for (loc = endp, loc2 = rmescend; loc >= startp; loc2--) {
- int match;
- char c = *loc2;
const char *s = loc2;
+ char c = *loc2;
+ unsigned ml;
+ int match;
+
if (zero) {
*loc2 = '\0';
s = rmesc;
@@ -582,17 +600,23 @@ static char *scanright(char *startp, char *endp, char *rmesc, char *rmescend,
match = pmatch(str, s);
*loc2 = c;
if (match)
- return loc;
+ return quotes ? loc : loc2;
loc--;
- if (quotes) {
- if (--esc < 0) {
- esc = esclen(startp, loc);
- }
- if (esc % 2) {
- esc--;
- loc--;
- }
+ if (!esc--)
+ esc = esclen(startp, loc);
+ if (esc % 2) {
+ esc--;
+ loc--;
+ continue;
}
+ if (*loc != (char)CTLMBCHAR)
+ continue;
+
+ ml = (unsigned char)*--loc;
+ loc -= ml + 2;
+ if (*loc == (char)CTLESC)
+ loc--;
+ loc2 -= ml - 1;
}
return 0;
}
@@ -646,14 +670,11 @@ static char *subevalvar(char *start, char *str, int strloc, int startloc,
nstrloc = str - (char *)stackblock();
}
- rmesc = startp;
- if (quotes) {
- rmesc = _rmescapes(startp, RMESCAPE_ALLOC | RMESCAPE_GROW);
- if (rmesc != startp)
- rmescend = expdest;
- startp = stackblock() + startloc;
- str = stackblock() + nstrloc;
- }
+ rmesc = _rmescapes(startp, RMESCAPE_ALLOC | RMESCAPE_GROW);
+ if (rmesc != startp)
+ rmescend = expdest;
+ startp = stackblock() + startloc;
+ str = stackblock() + nstrloc;
rmescend--;
/* zero = subtype == VSTRIMLEFT || subtype == VSTRIMLEFTMAX */
@@ -663,16 +684,29 @@ static char *subevalvar(char *start, char *str, int strloc, int startloc,
endp = stackblock() + strloc - 1;
loc = scan(startp, endp, rmesc, rmescend, str, quotes, zero);
- if (loc) {
- if (zero) {
- memmove(startp, loc, endp - loc);
- loc = startp + (endp - loc);
+ if (!loc) {
+ if (quotes) {
+ rmesc = startp;
+ rmescend = endp;
}
- *loc = '\0';
- } else
- loc = endp;
+ } else if (!quotes) {
+ if (zero)
+ rmesc = loc;
+ else
+ rmescend = loc;
+ } else if (zero) {
+ rmesc = loc;
+ rmescend = endp;
+ } else {
+ rmesc = startp;
+ rmescend = loc;
+ }
+
+ memmove(startp, rmesc, rmescend - rmesc);
+ loc = startp + (rmescend - rmesc);
out:
+ *loc = '\0';
amount = loc - expdest;
STADJUST(amount, expdest);
@@ -698,6 +732,7 @@ evalvar(char *p, int flag)
ssize_t varlen;
int discard;
int quoted;
+ int mbchar;
varflags = *p++ & ~VSBIT;
subtype = varflags & VSTYPE;
@@ -707,8 +742,18 @@ evalvar(char *p, int flag)
startloc = expdest - (char *)stackblock();
p = strchr(p, '=') + 1;
+ mbchar = 0;
+ switch (subtype) {
+ case VSTRIMLEFT:
+ case VSTRIMLEFTMAX:
+ case VSTRIMRIGHT:
+ case VSTRIMRIGHTMAX:
+ mbchar = EXP_MBCHAR;
+ break;
+ }
+
again:
- varlen = varvalue(var, varflags, flag, quoted);
+ varlen = varvalue(var, varflags, flag | mbchar, quoted);
if (varflags & VSNUL)
varlen--;
@@ -814,14 +859,31 @@ static struct mbpair mbtodest(const char *p, char *q, const char *syntax,
size_t ml;
ml = mbrlen(--p, len, &mbs);
- if (ml == -2 || ml == -1 || ml < 2)
+ if (ml == -2 || ml == -1 || ml < 2) {
+ q = chtodest((signed char)*p, syntax, q);
ml = 1;
+ goto out;
+ }
len = ml;
do {
q = chtodest((signed char)*p++, syntax, q);
} while (--len);
+ goto out;
+ if (syntax[CTLMBCHAR] == CCTL) {
+ USTPUTC(CTLMBCHAR, q);
+ USTPUTC(ml, q);
+ }
+
+ q = mempcpy(q, p, ml);
+
+ if (syntax[CTLMBCHAR] == CCTL) {
+ USTPUTC(ml, q);
+ USTPUTC(CTLMBCHAR, q);
+ }
+
+out:
mbp.ml = ml - 1;
mbp.ql = q - q0;
return mbp;
@@ -841,13 +903,15 @@ static size_t memtodest(const char *p, size_t len, int flags)
if (unlikely(!len))
return 0;
- q = makestrspace(len * 2, expdest);
+ /* CTLMBCHAR, 2, c, c, 2, CTLMBCHAR */
+ q = makestrspace(len * 3, expdest);
-#if QUOTES_ESC != 0x11 || EXP_QUOTED != 0x100
-#error QUOTES_ESC != 0x11 || EXP_QUOTED != 0x100
+#if QUOTES_ESC != 0x11 || EXP_MBCHAR != 0x20 || EXP_QUOTED != 0x100
+#error QUOTES_ESC != 0x11 || EXP_MBCHAR != 0x20 || EXP_QUOTED != 0x100
#endif
expq = flags & EXP_QUOTED;
- if (likely(!(flags & (expq >> 4 | expq >> 8) & QUOTES_ESC))) {
+ if (likely(!(flags & (expq >> 3 | expq >> 4 | expq >> 8) &
+ (QUOTES_ESC | EXP_MBCHAR)))) {
while (len >= 8) {
uint64_t x = *(uint64_t *)(p + count);
@@ -864,7 +928,8 @@ static size_t memtodest(const char *p, size_t len, int flags)
q += count;
p += count;
- syntax = flags & QUOTES_ESC ? BASESYNTAX : is_type;
+ syntax = flags & (QUOTES_ESC | EXP_MBCHAR) ?
+ BASESYNTAX : is_type;
} else
syntax = SQSYNTAX;
@@ -1772,17 +1837,25 @@ _rmescapes(char *str, int flag)
inquotes = 0;
notescaped = globbing;
while (*p) {
+ unsigned ml;
+ int newnesc = globbing;
+
if (*p == (char)CTLQUOTEMARK) {
p++;
inquotes ^= globbing;
continue;
- }
- if (*p == '\\') {
+ } else if (*p == '\\') {
/* naked back slash */
- notescaped ^= globbing;
- goto copy;
- }
- if (*p == (char)CTLESC) {
+ newnesc ^= notescaped;
+ } else if (*p == (char)CTLMBCHAR) {
+ if (*++p == (char)CTLESC)
+ p++;
+
+ ml = (unsigned char)*p++;
+ q = mempcpy(q, p, ml);
+ p += ml + 2;
+ goto setnesc;
+ } else if (*p == (char)CTLESC) {
p++;
if (notescaped)
*q++ = '\\';
@@ -1791,9 +1864,10 @@ _rmescapes(char *str, int flag)
*q++ = '\\';
}
}
- notescaped = globbing;
-copy:
+
*q++ = *p++;
+setnesc:
+ notescaped = newnesc;
}
*q = '\0';
if (flag & RMESCAPE_GROW) {
diff --git a/src/expand.h b/src/expand.h
index 49a18f9..a78564f 100644
--- a/src/expand.h
+++ b/src/expand.h
@@ -55,6 +55,7 @@ struct arglist {
#define EXP_VARTILDE 0x4 /* expand tildes in an assignment */
#define EXP_REDIR 0x8 /* file glob for a redirection (1 match only) */
#define EXP_CASE 0x10 /* keeps quotes around for CASE pattern */
+#define EXP_MBCHAR 0x20 /* mark multi-byte characters */
#define EXP_VARTILDE2 0x40 /* expand tildes after colons only */
#define EXP_WORD 0x80 /* expand word in parameter expansion */
#define EXP_QUOTED 0x100 /* expand word in double quotes */
diff --git a/src/mystring.c b/src/mystring.c
index 7bf61e3..ca0cd39 100644
--- a/src/mystring.c
+++ b/src/mystring.c
@@ -64,7 +64,7 @@ const char dolatstr[] = { CTLQUOTEMARK, CTLVAR, VSNORMAL | VSBIT, '@', '=',
CTLQUOTEMARK, '\0' };
const char cqchars[] = {
'\\',
- CTLESC, CTLQUOTEMARK, 0
+ CTLESC, CTLMBCHAR, CTLQUOTEMARK, 0
};
const char illnum[] = "Illegal number: %s";
const char homestr[] = "HOME";
diff --git a/src/parser.h b/src/parser.h
index 433573d..14bfc4f 100644
--- a/src/parser.h
+++ b/src/parser.h
@@ -44,6 +44,7 @@ union node;
#define CTLVAR -126 /* variable defn */
#define CTLENDVAR -125
#define CTLBACKQ -124
+#define CTLMBCHAR -123
#define CTLARI -122 /* arithmetic expression */
#define CTLENDARI -121
#define CTLQUOTEMARK -120
--
2.39.2
^ permalink raw reply related [flat|nested] 14+ messages in thread* [v5 PATCH 05/13] expand: Process multi-byte characters in expmeta
2024-06-02 1:28 [v5 PATCH 00/13] Add multi-byte supportAdd multi-byte support Herbert Xu
` (3 preceding siblings ...)
2024-06-02 1:28 ` [v5 PATCH 04/13] expand: Process multi-byte characters in subevalvar Herbert Xu
@ 2024-06-02 1:28 ` Herbert Xu
2024-06-02 1:28 ` [v5 PATCH 06/13] expand: Support multi-byte characters during field splitting Herbert Xu
` (7 subsequent siblings)
12 siblings, 0 replies; 14+ messages in thread
From: Herbert Xu @ 2024-06-02 1:28 UTC (permalink / raw)
To: DASH Mailing List
When glob(3) is not in use, make sure that expmeta processes
multi-byte characters correctly.
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
---
src/expand.c | 105 +++++++++++++++++++++++++++++++++++----------------
1 file changed, 72 insertions(+), 33 deletions(-)
diff --git a/src/expand.c b/src/expand.c
index 5d73f8e..03eafc2 100644
--- a/src/expand.c
+++ b/src/expand.c
@@ -85,6 +85,7 @@
#define RMESCAPE_GLOB 0x2 /* Add backslashes for glob */
#define RMESCAPE_GROW 0x8 /* Grow strings instead of stalloc */
#define RMESCAPE_HEAP 0x10 /* Malloc strings instead of stalloc */
+#define RMESCAPE_EMETA 0x20 /* Remove backslashes too */
/* Add CTLESC when necessary. */
#define QUOTES_ESC (EXP_FULL | EXP_CASE)
@@ -1386,12 +1387,10 @@ expandmeta(struct strlist *str)
savelastp = exparg.lastp;
INTOFF;
- p = preglob(str->text, RMESCAPE_ALLOC | RMESCAPE_HEAP);
+ p = str->text;
len = strlen(p);
expmeta(p, len, 0);
- if (p != str->text)
- ckfree(p);
INTON;
if (exparg.lastp == savelastp) {
/*
@@ -1433,6 +1432,41 @@ static char *addfnamealt(char *enddir, size_t expdir_len)
return stnputs(name, expdir_len, enddir) - expdir_len;
}
+static void expmeta_rmescapes(char *enddir, char *name)
+{
+ preglob(strcpy(enddir, name), RMESCAPE_EMETA);
+}
+
+static unsigned mbcharlen(char *p)
+{
+ int esc = 0;
+
+ if (*++p == (char)CTLESC)
+ esc++;
+
+ return esc + 3 + (unsigned char)p[esc];
+}
+
+static size_t skipesc(char *p)
+{
+ size_t esc = 0;
+
+ if (p[esc] == (char)CTLMBCHAR)
+ esc += mbcharlen(p);
+ else if (p[esc] == (char)CTLESC)
+ esc++;
+ else if (p[esc] == '\\' && p[esc + 1]) {
+ while (p[++esc] == (char)CTLQUOTEMARK)
+ ;
+ if (p[esc] == (char)CTLMBCHAR)
+ esc += mbcharlen(p + esc);
+ else if (p[esc] == (char)CTLESC)
+ esc++;
+ }
+
+ return esc;
+}
+
/*
* Do metacharacter (i.e. *, ?, [...]) expansion.
*/
@@ -1451,12 +1485,14 @@ static char *expmeta(char *name, unsigned name_len, size_t expdir_len)
char *start;
size_t len;
DIR *dirp;
- int atend;
+ char *pat;
char *cp;
char *p;
int esc;
+ int c;
*(DIR *volatile *)&dirp = NULL;
+ *(char *volatile *)&pat = NULL;
savehandler = handler;
if (unlikely(err = setjmp(jmploc.loc)))
goto out;
@@ -1472,11 +1508,8 @@ static char *expmeta(char *name, unsigned name_len, size_t expdir_len)
metaflag = 1;
else if (*p == '[') {
char *q = p + 1;
- if (*q == '!')
- q++;
for (;;) {
- if (*q == '\\')
- q++;
+ q += skipesc(q);
if (*q == '/' || *q == '\0')
break;
if (*++q == ']') {
@@ -1485,8 +1518,7 @@ static char *expmeta(char *name, unsigned name_len, size_t expdir_len)
}
}
} else {
- if (*p == '\\' && p[1])
- esc++;
+ esc = skipesc(p);
if (p[esc] == '/') {
if (metaflag)
break;
@@ -1497,24 +1529,18 @@ static char *expmeta(char *name, unsigned name_len, size_t expdir_len)
if (metaflag == 0) { /* we've reached the end of the file name */
if (!expdir_len)
goto out_opendir;
- p = name;
- do {
- if (*p == '\\' && p[1])
- p++;
- *enddir++ = *p;
- } while (*p++);
+ expmeta_rmescapes(enddir, name);
if (lstat64(cp, &statb) >= 0)
- cp = addfnamealt(enddir, expdir_len);
+ cp = addfnamealt(strchrnul(enddir, 0), expdir_len);
goto out_opendir;
}
endname = p;
if (name < start) {
- p = name;
- do {
- if (*p == '\\' && p[1])
- p++;
- *enddir++ = *p++;
- } while (p < start);
+ c = *start;
+ *start = 0;
+ expmeta_rmescapes(enddir, name);
+ *start = c;
+ enddir += strlen(enddir);
}
*enddir = 0;
expdir_len = enddir - cp;
@@ -1522,16 +1548,16 @@ static char *expmeta(char *name, unsigned name_len, size_t expdir_len)
*(DIR *volatile *)&dirp = opendir(expdir_len ? cp : dotdir);
if (!dirp)
goto out_opendir;
- if (*endname == 0) {
- atend = 1;
- } else {
- atend = 0;
+ c = *endname;
+ if (c) {
*endname = '\0';
endname += esc + 1;
}
name_len -= endname - name;
matchdot = 0;
- p = start;
+ *(char *volatile *)&pat =
+ preglob(start, RMESCAPE_ALLOC | RMESCAPE_HEAP);
+ p = pat;
if (*p == '\\')
p++;
if (*p == '.')
@@ -1539,12 +1565,12 @@ static char *expmeta(char *name, unsigned name_len, size_t expdir_len)
while (! int_pending() && (dp = readdir64(dirp)) != NULL) {
if (dp->d_name[0] == '.' && ! matchdot)
continue;
- if (pmatch(start, dp->d_name)) {
+ if (pmatch(pat, dp->d_name)) {
len = strlen(dp->d_name) + 1;
enddir = cp + expdir_len;
enddir = stnputs(dp->d_name, len, enddir);
- if (atend)
+ if (!c)
cp = addfnamealt(enddir, expdir_len);
else {
enddir[-1] = '/';
@@ -1553,10 +1579,13 @@ static char *expmeta(char *name, unsigned name_len, size_t expdir_len)
}
}
}
- if (! atend)
- endname[-esc - 1] = esc ? '\\' : '/';
+ if (c)
+ endname[-esc - 1] = c;
out:
+ pat = *(char *volatile *)&pat;
+ if (pat != start)
+ ckfree(pat);
closedir(*(DIR *volatile *)&dirp);
out_opendir:
handler = savehandler;
@@ -1800,6 +1829,7 @@ _rmescapes(char *str, int flag)
int notescaped;
int globbing;
int inquotes;
+ int expmeta;
p = strpbrk(str, cqchars);
if (!p) {
@@ -1808,6 +1838,7 @@ _rmescapes(char *str, int flag)
q = p;
r = str;
globbing = flag & RMESCAPE_GLOB;
+ expmeta = (flag & RMESCAPE_EMETA) ? RMESCAPE_GLOB : 0;
if (flag & RMESCAPE_ALLOC) {
size_t len = p - str;
@@ -1847,6 +1878,12 @@ _rmescapes(char *str, int flag)
} else if (*p == '\\') {
/* naked back slash */
newnesc ^= notescaped;
+ /* naked backslashes can only occur outside quotes */
+ inquotes = 0;
+ if (expmeta & ~newnesc) {
+ p++;
+ goto setnesc;
+ }
} else if (*p == (char)CTLMBCHAR) {
if (*++p == (char)CTLESC)
p++;
@@ -1857,7 +1894,9 @@ _rmescapes(char *str, int flag)
goto setnesc;
} else if (*p == (char)CTLESC) {
p++;
- if (notescaped)
+ if (expmeta)
+ ;
+ else if (notescaped)
*q++ = '\\';
else if (inquotes) {
*q++ = '\\';
--
2.39.2
^ permalink raw reply related [flat|nested] 14+ messages in thread* [v5 PATCH 06/13] expand: Support multi-byte characters during field splitting
2024-06-02 1:28 [v5 PATCH 00/13] Add multi-byte supportAdd multi-byte support Herbert Xu
` (4 preceding siblings ...)
2024-06-02 1:28 ` [v5 PATCH 05/13] expand: Process multi-byte characters in expmeta Herbert Xu
@ 2024-06-02 1:28 ` Herbert Xu
2024-06-02 1:28 ` [v5 PATCH 07/13] expand: Add multi-byte support to pmatch Herbert Xu
` (6 subsequent siblings)
12 siblings, 0 replies; 14+ messages in thread
From: Herbert Xu @ 2024-06-02 1:28 UTC (permalink / raw)
To: DASH Mailing List
When multi-byte characters are used in IFS, they will be used
for field splitting.
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
---
src/expand.c | 455 ++++++++++++++++++++++++++++++++++-----------------
src/expand.h | 1 +
src/var.c | 12 +-
3 files changed, 309 insertions(+), 159 deletions(-)
diff --git a/src/expand.c b/src/expand.c
index 03eafc2..2223045 100644
--- a/src/expand.c
+++ b/src/expand.c
@@ -55,6 +55,7 @@
#include <sys/stat.h>
#include <unistd.h>
#include <wchar.h>
+#include <wctype.h>
/*
* Routines to expand arguments to commands. We have to deal with
@@ -102,6 +103,14 @@ struct ifsregion {
int nulonly; /* search for nul bytes only */
};
+struct ifs_state {
+ const char *ifs;
+ char *start;
+ char *r;
+ int maxargs;
+ int ifsspc;
+};
+
/* output of current string */
static char *expdest;
/* list of back quote expressions */
@@ -113,6 +122,11 @@ static struct ifsregion *ifslastp;
/* holds expanded arg list */
static struct arglist exparg;
+static char ifsmap[128];
+static const char *ncifs;
+static size_t ifsmb0len;
+static wchar_t *wcifs;
+
static char *argstr(char *p, int flag);
static char *exptilde(char *startp, int flag);
static char *expari(char *start, int flag);
@@ -120,7 +134,7 @@ STATIC void expbackq(union node *, int);
STATIC char *evalvar(char *, int);
static size_t strtodest(const char *p, int flags);
static size_t memtodest(const char *p, size_t len, int flags);
-STATIC ssize_t varvalue(char *, int, int, int);
+STATIC ssize_t varvalue(char *, int, unsigned);
STATIC void expandmeta(struct strlist *);
static void addglob(const glob64_t *);
static char *expmeta(char *, unsigned, size_t);
@@ -158,6 +172,30 @@ esclen(const char *start, const char *p) {
return esc;
}
+static __attribute__((noinline)) unsigned mbnext(const char *p)
+{
+ unsigned start = 0;
+ unsigned end = 0;
+ unsigned ml;
+ int c;
+
+ c = (signed char)p[end++];
+
+ switch (__builtin_expect(c, 0)) {
+ case CTLMBCHAR:
+ if ((signed char)p[end] == CTLESC)
+ end++;
+ ml = (unsigned char)p[end++];
+ start = end;
+ end = ml + 2;
+ break;
+ case CTLESC:
+ start++;
+ break;
+ }
+
+ return start | end << 8;
+}
static inline const char *getpwhome(const char *name)
{
@@ -546,6 +584,7 @@ static char *scanleft(char *startp, char *endp, char *rmesc, char *rmescend,
loc2 = rmesc;
do {
const char *s = loc2;
+ unsigned mb;
unsigned ml;
int match;
@@ -562,19 +601,9 @@ static char *scanleft(char *startp, char *endp, char *rmesc, char *rmescend,
if (!c)
break;
- if (*loc != (char)CTLMBCHAR) {
- if (*loc == (char)CTLESC)
- loc++;
- loc++;
- loc2++;
- continue;
- }
-
- if (*++loc == (char)CTLESC)
- loc++;
-
- ml = (unsigned char)*loc;
- loc += ml + 3;
+ mb = mbnext(loc);
+ loc += (mb & 0xff) + (mb >> 8);
+ ml = (mb >> 8) > 3 ? (mb >> 8) - 2 : 1;
loc2 += ml;
} while (1);
return 0;
@@ -754,7 +783,7 @@ evalvar(char *p, int flag)
}
again:
- varlen = varvalue(var, varflags, flag | mbchar, quoted);
+ varlen = varvalue(var, varflags, flag | mbchar);
if (varflags & VSNUL)
varlen--;
@@ -973,23 +1002,23 @@ static size_t strtodest(const char *p, int flags)
* Add the value of a specialized variable to the stack string.
*/
-STATIC ssize_t
-varvalue(char *name, int varflags, int flags, int quoted)
+static ssize_t varvalue(char *name, int varflags, unsigned flags)
{
+ int subtype = varflags & VSTYPE;
+ unsigned long seplen;
+ const char *seps;
+ ssize_t len = 0;
+ size_t start;
+ int discard;
+ char **ap;
int num;
char *p;
int i;
- int sep;
- char sepc;
- char **ap;
- int subtype = varflags & VSTYPE;
- int discard = (subtype == VSPLUS || subtype == VSLENGTH) |
- (flags & EXP_DISCARD);
- ssize_t len = 0;
- size_t start;
- char c;
- if (!subtype) {
+ discard = (subtype == VSPLUS || subtype == VSLENGTH) |
+ (flags & EXP_DISCARD);
+
+ if (unlikely(!subtype)) {
if (discard)
return -1;
@@ -997,7 +1026,8 @@ varvalue(char *name, int varflags, int flags, int quoted)
}
flags &= discard ? ~QUOTES_ESC : ~0;
- sep = (flags & EXP_FULL) << CHAR_BIT;
+ seps = nullstr;
+ seplen = flags & EXP_FULL;
start = expdest - (char *)stackblock();
switch (*name) {
@@ -1028,13 +1058,14 @@ numvar:
expdest = p;
break;
case '@':
- if (quoted && sep)
+ if ((flags & (EXP_QUOTED | EXP_FULL)) ==
+ (EXP_QUOTED | EXP_FULL))
goto param;
/* fall through */
case '*':
- /* We will set c to 0 or ~0 depending on whether
+ /* We will set seplen to 0 or !0 depending on whether
* we're doing field splitting. We won't do field
- * splitting if either we're quoted or sep is zero.
+ * splitting if either we're quoted or seplen is zero.
*
* Instead of testing (quoted || !sep) the following
* trick optimises away any branches by using the
@@ -1046,20 +1077,22 @@ numvar:
#if EXP_QUOTED >> CHAR_BIT != EXP_FULL
#error The following two lines expect EXP_QUOTED == EXP_FULL << CHAR_BIT
#endif
- c = !((quoted | ~sep) & EXP_QUOTED) - 1;
- sep &= ~quoted;
- sep |= ifsset() ? (unsigned char)(c & ifsval()[0]) : ' ';
+ seplen &= ~(flags >> CHAR_BIT);
+ if (!seplen)
+ seps = ncifs;
+ seplen = ((seplen - 1) & (ifsmb0len - 1)) + 1;
param:
- sepc = sep;
if (!(ap = shellparam.p))
return -1;
- while ((p = *ap++)) {
+ if (!(p = *ap))
+ break;
+ for (;;) {
len += strtodest(p, flags);
- if (*ap && sep) {
- len++;
- memtodest(&sepc, 1, flags | EXP_KEEPNUL);
- }
+ if (!(p = *++ap))
+ break;
+
+ len += memtodest(seps, seplen, flags | EXP_KEEPNUL);
}
break;
case '0':
@@ -1120,7 +1153,126 @@ recordregion(int start, int end, int nulonly)
ifslastp->nulonly = nulonly;
}
+static unsigned ifsisifs(const char *p, unsigned ml, const char *ifs)
+{
+ bool isdefifs = false;
+ bool isifs = false;
+ wchar_t wc = *p;
+ wchar_t ifs0;
+ if (likely(ifs[0]) && unlikely(wcifs)) {
+ if (wc & 0x80) {
+ mbstate_t mbst = {};
+ wchar_t wc2;
+
+ if (mbrtowc(&wc2, p, ml, &mbst) != ml)
+ goto out;
+ wc = wc2;
+ }
+
+ isifs = wcschr(wcifs, wc);
+ ifs0 = wcifs[0];
+ } else if (likely(!ml)) {
+ isifs = strchr(ifs, wc);
+ ifs0 = ifs[0];
+ }
+
+ if (isifs)
+ isdefifs = iswspace(wc ?: ifs0);
+
+out:
+ return isifs << 1 | isdefifs;
+}
+
+static char *ifsbreakup_slow(struct ifs_state *ifst, struct arglist *arglist,
+ int nulonly, char *p)
+{
+ struct strlist *sp;
+ unsigned ifschar;
+ unsigned sisifs;
+ bool isdefifs;
+ unsigned ml;
+ bool isifs;
+ char *q;
+
+ q = p;
+
+ ifschar = mbnext(p);
+ p += ifschar & 0xff;
+ ml = (ifschar >> 8) > 3 ?
+ (ifschar >> 8) - 2 : 0;
+
+ sisifs = ifsisifs(p, ml, ifst->ifs);
+ p += ifschar >> 8;
+
+ isifs = sisifs >> 1;
+ isdefifs = sisifs & 1;
+
+ /* If only reading one more argument:
+ * If we have exactly one field,
+ * read that field without its terminator.
+ * If we have more than one field,
+ * read all fields including their terminators,
+ * except for trailing IFS whitespace.
+ *
+ * This means that if we have only IFS
+ * characters left, and at most one
+ * of them is non-whitespace, we stop
+ * reading here.
+ * Otherwise, we read all the remaining
+ * characters except for trailing
+ * IFS whitespace.
+ *
+ * In any case, r indicates the start
+ * of the characters to remove, or NULL
+ * if no characters should be removed.
+ */
+ if (!ifst->maxargs) {
+ if (isdefifs) {
+ if (!ifst->r)
+ ifst->r = q;
+ return p;
+ }
+
+ if (!(isifs && ifst->ifsspc))
+ ifst->r = NULL;
+ } else if (ifst->ifsspc) {
+ if (isifs)
+ q = p;
+
+ ifst->start = q;
+
+ if (isdefifs)
+ return p;
+ } else if (isifs) {
+ int ifsspc = ifst->ifsspc;
+
+ if (!nulonly) {
+ ifsspc = isdefifs;
+ ifst->ifsspc = ifsspc;
+ }
+
+ /* Ignore IFS whitespace at start */
+ if (q == ifst->start && ifsspc) {
+ ifst->start = p;
+ return p;
+ }
+ if (ifst->maxargs > 0 && !--ifst->maxargs) {
+ ifst->r = q;
+ return p;
+ }
+ *q = '\0';
+ sp = (struct strlist *)stalloc(sizeof *sp);
+ sp->text = ifst->start;
+ *arglist->lastp = sp;
+ arglist->lastp = &sp->next;
+ ifst->start = p;
+ return p;
+ }
+
+ ifst->ifsspc = 0;
+ return p;
+}
/*
* Break the argument string into pieces based upon IFS and add the
@@ -1133,21 +1285,19 @@ void
ifsbreakup(char *string, int maxargs, struct arglist *arglist)
{
struct ifsregion *ifsp;
+ struct ifs_state ifst;
+ const char *realifs;
struct strlist *sp;
- char *start;
- char *p;
- char *q;
- char *r = NULL;
- const char *ifs, *realifs;
- int ifsspc;
int nulonly;
+ char *p;
-
- start = string;
+ ifst.r = NULL;
+ ifst.start = string;
+ ifst.maxargs = maxargs;
if (ifslastp != NULL) {
- ifsspc = 0;
+ ifst.ifsspc = 0;
nulonly = 0;
- realifs = ifsset() ? ifsval() : defifs;
+ realifs = ncifs;
ifsp = &ifsfirst;
do {
int afternul;
@@ -1155,106 +1305,60 @@ ifsbreakup(char *string, int maxargs, struct arglist *arglist)
p = string + ifsp->begoff;
afternul = nulonly;
nulonly = ifsp->nulonly;
- ifs = nulonly ? nullstr : realifs;
- ifsspc = 0;
- while (p < string + ifsp->endoff) {
- int c;
- bool isifs;
- bool isdefifs;
+ ifst.ifs = nulonly ? nullstr : realifs;
+ ifst.ifsspc = 0;
+ for (;;) {
+ char *p0 = p;
- q = p;
- c = *p++;
- if (c == (char)CTLESC)
- c = *p++;
+ while (string + ifsp->endoff - p >= 8) {
+ union {
+ uint64_t qw;
+ unsigned char b[8];
+ } x;
- isifs = strchr(ifs, c);
- isdefifs = false;
- if (isifs)
- isdefifs = strchr(defifs, c);
+ x.qw = *(uint64_t *)p;
- /* If only reading one more argument:
- * If we have exactly one field,
- * read that field without its terminator.
- * If we have more than one field,
- * read all fields including their terminators,
- * except for trailing IFS whitespace.
- *
- * This means that if we have only IFS
- * characters left, and at most one
- * of them is non-whitespace, we stop
- * reading here.
- * Otherwise, we read all the remaining
- * characters except for trailing
- * IFS whitespace.
- *
- * In any case, r indicates the start
- * of the characters to remove, or NULL
- * if no characters should be removed.
- */
- if (!maxargs) {
- if (isdefifs) {
- if (!r)
- r = q;
- continue;
- }
-
- if (!(isifs && ifsspc))
- r = NULL;
-
- ifsspc = 0;
- continue;
+ if ((x.qw & 0x8080808080808080))
+ break;
+ if (ifsmap[x.b[0]] |
+ ifsmap[x.b[1]] |
+ ifsmap[x.b[2]] |
+ ifsmap[x.b[3]] |
+ ifsmap[x.b[4]] |
+ ifsmap[x.b[5]] |
+ ifsmap[x.b[6]] |
+ ifsmap[x.b[7]])
+ break;
+ p += 8;
}
- if (ifsspc) {
- if (isifs)
- q = p;
-
- start = q;
-
- if (isdefifs)
- continue;
-
- isifs = false;
+ if (p != p0) {
+ if (!ifst.maxargs)
+ ifst.r = NULL;
+ else if (ifst.ifsspc)
+ ifst.start = p0;
+ ifst.ifsspc = 0;
}
- if (isifs) {
- if (!(afternul || nulonly))
- ifsspc = isdefifs;
- /* Ignore IFS whitespace at start */
- if (q == start && ifsspc) {
- start = p;
- ifsspc = 0;
- continue;
- }
- if (maxargs > 0 && !--maxargs) {
- r = q;
- continue;
- }
- *q = '\0';
- sp = (struct strlist *)stalloc(sizeof *sp);
- sp->text = start;
- *arglist->lastp = sp;
- arglist->lastp = &sp->next;
- start = p;
- continue;
- }
+ if (p >= string + ifsp->endoff)
+ break;
- ifsspc = 0;
+ p = ifsbreakup_slow(&ifst, arglist,
+ afternul | nulonly, p);
}
} while ((ifsp = ifsp->next) != NULL);
if (nulonly)
goto add;
+ if (ifst.r)
+ *ifst.r = '\0';
}
- if (r)
- *r = '\0';
-
- if (!*start)
+ if (!*ifst.start)
return;
add:
sp = (struct strlist *)stalloc(sizeof *sp);
- sp->text = start;
+ sp->text = ifst.start;
*arglist->lastp = sp;
arglist->lastp = &sp->next;
}
@@ -1280,7 +1384,56 @@ out:
ifslastp = NULL;
}
+void changeifs(const char *ifs)
+{
+ mbstate_t mbs = {};
+ wchar_t *nwcifs;
+ unsigned mb = 0;
+ size_t len = 0;
+ const char *p;
+ size_t ml;
+ if (!ifsset())
+ ifs = defifs;
+ ncifs = ifs;
+
+ memset(ifsmap, 0, sizeof(ifsmap));
+
+ for (p = ifs;; p++) {
+ unsigned c = (unsigned char)*p;
+
+ mb |= c >> 7;
+ if (!(c >> 7))
+ ifsmap[c] = 1;
+
+ if (c == 0)
+ break;
+
+ len++;
+ }
+
+ nwcifs = NULL;
+
+ ifsmb0len = !!len;
+
+ if (!mb)
+ goto out;
+
+ ml = mbrlen(ifs, len, &mbs);
+ if (ml == -2 || ml == -1)
+ ml = 1;
+ ifsmb0len = ml;
+
+ nwcifs = ckmalloc((len + 1) * sizeof(*wcifs));
+ memset(nwcifs, 0, (len + 1) * sizeof(*wcifs));
+
+ p = ifs;
+ mbsrtowcs(nwcifs, &p, len + 1, &mbs);
+
+out:
+ ckfree(wcifs);
+ wcifs = nwcifs;
+}
/*
* Expand shell metacharacters. At this point, the only control characters
@@ -1437,31 +1590,25 @@ static void expmeta_rmescapes(char *enddir, char *name)
preglob(strcpy(enddir, name), RMESCAPE_EMETA);
}
-static unsigned mbcharlen(char *p)
+static int skipesc(char *p)
{
+ unsigned short mb;
int esc = 0;
- if (*++p == (char)CTLESC)
- esc++;
+ mb = mbnext(p);
+ if ((mb >> 8) > 3)
+ return (mb & 0xff) + (mb >> 8) - 1;
- return esc + 3 + (unsigned char)p[esc];
-}
+ esc = mb & 0xff;
-static size_t skipesc(char *p)
-{
- size_t esc = 0;
-
- if (p[esc] == (char)CTLMBCHAR)
- esc += mbcharlen(p);
- else if (p[esc] == (char)CTLESC)
- esc++;
- else if (p[esc] == '\\' && p[esc + 1]) {
+ if (!esc && p[esc] == '\\' && p[esc + 1]) {
while (p[++esc] == (char)CTLQUOTEMARK)
;
- if (p[esc] == (char)CTLMBCHAR)
- esc += mbcharlen(p + esc);
- else if (p[esc] == (char)CTLESC)
- esc++;
+ mb = mbnext(p + esc);
+ esc += mb & 0xff;
+
+ if ((mb >> 8) > 3)
+ esc += (mb >> 8) - 1;
}
return esc;
@@ -1868,6 +2015,7 @@ _rmescapes(char *str, int flag)
inquotes = 0;
notescaped = globbing;
while (*p) {
+ unsigned mb;
unsigned ml;
int newnesc = globbing;
@@ -1885,10 +2033,11 @@ _rmescapes(char *str, int flag)
goto setnesc;
}
} else if (*p == (char)CTLMBCHAR) {
- if (*++p == (char)CTLESC)
- p++;
+ mb = mbnext(p);
+ ml = mb >> 8;
- ml = (unsigned char)*p++;
+ ml -= 2;
+ p += mb & 0xff;
q = mempcpy(q, p, ml);
p += ml + 2;
goto setnesc;
diff --git a/src/expand.h b/src/expand.h
index a78564f..7bcff75 100644
--- a/src/expand.h
+++ b/src/expand.h
@@ -75,6 +75,7 @@ void removerecordregions(int);
void ifsbreakup(char *, int, struct arglist *);
void ifsfree(void);
void restore_handler_expandarg(struct jmploc *savehandler, int err);
+void changeifs(const char *);
/* From arith.y */
intmax_t arith(const char *);
diff --git a/src/var.c b/src/var.c
index e2102c3..eb4075f 100644
--- a/src/var.c
+++ b/src/var.c
@@ -86,7 +86,7 @@ struct var varinit[] = {
#if ATTY
{ 0, VSTRFIXED|VTEXTFIXED|VUNSET, "ATTY\0", 0 },
#endif
- { 0, VSTRFIXED|VTEXTFIXED, defifsvar, 0 },
+ { 0, VSTRFIXED|VTEXTFIXED, defifsvar, changeifs },
{ 0, VSTRFIXED|VTEXTFIXED|VUNSET, "MAIL\0", changemail },
{ 0, VSTRFIXED|VTEXTFIXED|VUNSET, "MAILPATH\0", changemail },
{ 0, VSTRFIXED|VTEXTFIXED, defpathvar, changepath },
@@ -267,9 +267,6 @@ struct var *setvareq(char *s, int flags)
n);
}
- if (vp->func && (flags & VNOFUNC) == 0)
- (*vp->func)(varnull(s));
-
if ((vp->flags & (VTEXTFIXED|VSTACK)) == 0)
ckfree(vp->text);
@@ -301,6 +298,9 @@ out_free:
vp->text = s;
vp->flags = flags;
+ if (vp->func && (flags & VNOFUNC) == 0)
+ (*vp->func)(varnull(s));
+
out:
return vp;
}
@@ -531,12 +531,12 @@ poplocalvars(void)
vp->flags &= ~(VSTRFIXED|VREADONLY);
unsetvar(vp->text);
} else {
- if (vp->func && !(vp->flags & VNOFUNC))
- (*vp->func)(varnull(lvp->text));
if ((vp->flags & (VTEXTFIXED|VSTACK)) == 0)
ckfree(vp->text);
vp->flags = lvp->flags;
vp->text = lvp->text;
+ if (vp->func && !(vp->flags & VNOFUNC))
+ (*vp->func)(varnull(vp->text));
}
ckfree(lvp);
}
--
2.39.2
^ permalink raw reply related [flat|nested] 14+ messages in thread* [v5 PATCH 07/13] expand: Add multi-byte support to pmatch
2024-06-02 1:28 [v5 PATCH 00/13] Add multi-byte supportAdd multi-byte support Herbert Xu
` (5 preceding siblings ...)
2024-06-02 1:28 ` [v5 PATCH 06/13] expand: Support multi-byte characters during field splitting Herbert Xu
@ 2024-06-02 1:28 ` Herbert Xu
2024-06-02 1:29 ` [v5 PATCH 08/13] input: Allow MB_LEN_MAX calls to pungetc Herbert Xu
` (5 subsequent siblings)
12 siblings, 0 replies; 14+ messages in thread
From: Herbert Xu @ 2024-06-02 1:28 UTC (permalink / raw)
To: DASH Mailing List
Add CTLMBCHAR support to pmatch.
POSIX equivalence classes and collating symbols are not unsupported.
Enable CTLMBCHAR generation in mbtodest.
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
---
src/eval.c | 3 +-
src/expand.c | 371 +++++++++++++++++++++++++++++++--------------------
2 files changed, 227 insertions(+), 147 deletions(-)
diff --git a/src/eval.c b/src/eval.c
index 1839623..140a734 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -457,7 +457,8 @@ evalcase(union node *n, int flags)
lineno -= funcline - 1;
arglist.lastp = &arglist.list;
- expandarg(n->ncase.expr, &arglist, EXP_TILDE);
+ expandarg(n->ncase.expr, &arglist, FNMATCH_IS_ENABLED ? EXP_TILDE :
+ EXP_TILDE | EXP_MBCHAR);
for (cp = n->ncase.cases ; cp && evalskip == 0 ; cp = cp->nclist.next) {
for (patp = cp->nclist.pattern ; patp ; patp = patp->narg.next) {
if (casematch(patp, arglist.list->text)) {
diff --git a/src/expand.c b/src/expand.c
index 2223045..ec408fd 100644
--- a/src/expand.c
+++ b/src/expand.c
@@ -86,7 +86,6 @@
#define RMESCAPE_GLOB 0x2 /* Add backslashes for glob */
#define RMESCAPE_GROW 0x8 /* Grow strings instead of stalloc */
#define RMESCAPE_HEAP 0x10 /* Malloc strings instead of stalloc */
-#define RMESCAPE_EMETA 0x20 /* Remove backslashes too */
/* Add CTLESC when necessary. */
#define QUOTES_ESC (EXP_FULL | EXP_CASE)
@@ -142,7 +141,7 @@ STATIC struct strlist *expsort(struct strlist *);
STATIC struct strlist *msort(struct strlist *, int);
STATIC void addfname(char *);
STATIC int patmatch(char *, const char *);
-STATIC int pmatch(const char *, const char *);
+STATIC int pmatch(char *, const char *);
static size_t cvtnum(intmax_t num, int flags);
STATIC size_t esclen(const char *, const char *);
STATIC void varunset(const char *, const char *, const char *, int)
@@ -157,6 +156,11 @@ STATIC void varunset(const char *, const char *, const char *, int)
STATIC inline char *
preglob(const char *pattern, int flag) {
+ if (FNMATCH_IS_ENABLED) {
+ if (!flag)
+ flag = RMESCAPE_GROW;
+ flag |= RMESCAPE_ALLOC;
+ }
flag |= RMESCAPE_GLOB;
return _rmescapes((char *)pattern, flag);
}
@@ -583,28 +587,31 @@ static char *scanleft(char *startp, char *endp, char *rmesc, char *rmescend,
loc = startp;
loc2 = rmesc;
do {
- const char *s = loc2;
+ char *s = FNMATCH_IS_ENABLED ? loc2 : loc;
unsigned mb;
unsigned ml;
int match;
- c = *loc2;
+ c = *s;
if (zero) {
- *loc2 = '\0';
- s = rmesc;
+ *s = '\0';
+ s = FNMATCH_IS_ENABLED ? rmesc : startp;
}
match = pmatch(str, s);
- *loc2 = c;
+ *(FNMATCH_IS_ENABLED ? loc2 : loc) = c;
if (match)
- return quotes ? loc : loc2;
+ return FNMATCH_IS_ENABLED && quotes ? loc : loc2;
if (!c)
break;
mb = mbnext(loc);
loc += (mb & 0xff) + (mb >> 8);
- ml = (mb >> 8) > 3 ? (mb >> 8) - 2 : 1;
- loc2 += ml;
+ if (unlikely(FNMATCH_IS_ENABLED || !quotes)) {
+ ml = (mb >> 8) > 3 ? (mb >> 8) - 2 : 1;
+ loc2 += ml;
+ } else
+ loc2 = loc;
} while (1);
return 0;
}
@@ -617,21 +624,23 @@ static char *scanright(char *startp, char *endp, char *rmesc, char *rmescend,
char *loc;
char *loc2;
- for (loc = endp, loc2 = rmescend; loc >= startp; loc2--) {
- const char *s = loc2;
- char c = *loc2;
+ for (loc = endp, loc2 = rmescend;;
+ FNMATCH_IS_ENABLED ? loc2-- : (loc2 = loc)) {
+ char *s = FNMATCH_IS_ENABLED ? loc2 : loc;
+ char c = *s;
unsigned ml;
int match;
if (zero) {
- *loc2 = '\0';
+ *s = '\0';
s = rmesc;
}
match = pmatch(str, s);
- *loc2 = c;
+ *(FNMATCH_IS_ENABLED ? loc2 : loc) = c;
if (match)
- return quotes ? loc : loc2;
- loc--;
+ return FNMATCH_IS_ENABLED && quotes ? loc : loc2;
+ if (--loc < startp)
+ break;
if (!esc--)
esc = esclen(startp, loc);
if (esc % 2) {
@@ -646,7 +655,8 @@ static char *scanright(char *startp, char *endp, char *rmesc, char *rmescend,
loc -= ml + 2;
if (*loc == (char)CTLESC)
loc--;
- loc2 -= ml - 1;
+ if (FNMATCH_IS_ENABLED)
+ loc2 -= ml - 1;
}
return 0;
}
@@ -692,19 +702,21 @@ static char *subevalvar(char *start, char *str, int strloc, int startloc,
#endif
rmescend = stackblock() + strloc;
- str = preglob(rmescend, FNMATCH_IS_ENABLED ?
- RMESCAPE_ALLOC | RMESCAPE_GROW : 0);
+ str = preglob(rmescend, 0);
if (FNMATCH_IS_ENABLED) {
startp = stackblock() + startloc;
rmescend = stackblock() + strloc;
nstrloc = str - (char *)stackblock();
}
- rmesc = _rmescapes(startp, RMESCAPE_ALLOC | RMESCAPE_GROW);
- if (rmesc != startp)
- rmescend = expdest;
- startp = stackblock() + startloc;
- str = stackblock() + nstrloc;
+ rmesc = startp;
+ if (FNMATCH_IS_ENABLED || !quotes) {
+ rmesc = _rmescapes(startp, RMESCAPE_ALLOC | RMESCAPE_GROW);
+ if (rmesc != startp)
+ rmescend = expdest;
+ startp = stackblock() + startloc;
+ str = stackblock() + nstrloc;
+ }
rmescend--;
/* zero = subtype == VSTRIMLEFT || subtype == VSTRIMLEFTMAX */
@@ -895,12 +907,6 @@ static struct mbpair mbtodest(const char *p, char *q, const char *syntax,
goto out;
}
- len = ml;
- do {
- q = chtodest((signed char)*p++, syntax, q);
- } while (--len);
- goto out;
-
if (syntax[CTLMBCHAR] == CCTL) {
USTPUTC(CTLMBCHAR, q);
USTPUTC(ml, q);
@@ -1473,7 +1479,7 @@ static void expandmeta_glob(struct strlist *str)
#endif
INTOFF;
- p = preglob(str->text, RMESCAPE_ALLOC | RMESCAPE_HEAP);
+ p = preglob(str->text, RMESCAPE_HEAP);
i = glob64(p, GLOB_ALTDIRFUNC | GLOB_NOMAGIC, 0, &pglob);
if (p != str->text)
ckfree(p);
@@ -1540,10 +1546,12 @@ expandmeta(struct strlist *str)
savelastp = exparg.lastp;
INTOFF;
- p = str->text;
+ p = preglob(str->text, RMESCAPE_ALLOC | RMESCAPE_HEAP);
len = strlen(p);
expmeta(p, len, 0);
+ if (p != str->text)
+ ckfree(p);
INTON;
if (exparg.lastp == savelastp) {
/*
@@ -1585,9 +1593,26 @@ static char *addfnamealt(char *enddir, size_t expdir_len)
return stnputs(name, expdir_len, enddir) - expdir_len;
}
-static void expmeta_rmescapes(char *enddir, char *name)
+static char *expmeta_rmescapes(char *enddir, const char *name)
{
- preglob(strcpy(enddir, name), RMESCAPE_EMETA);
+ const char *p;
+
+ if (!FNMATCH_IS_ENABLED)
+ return strchrnul(rmescapes(strcpy(enddir, name)), 0);
+
+ p = name;
+ do {
+ char *q = strchrnul(p, '\\');
+
+ enddir = mempcpy(enddir, p, q - p + 1);
+ p = q;
+ if (!*p)
+ break;
+ if (*++p)
+ enddir[-1] = *p++;
+ } while (1);
+
+ return enddir - 1;
}
static int skipesc(char *p)
@@ -1602,8 +1627,7 @@ static int skipesc(char *p)
esc = mb & 0xff;
if (!esc && p[esc] == '\\' && p[esc + 1]) {
- while (p[++esc] == (char)CTLQUOTEMARK)
- ;
+ esc++;
mb = mbnext(p + esc);
esc += mb & 0xff;
@@ -1639,7 +1663,6 @@ static char *expmeta(char *name, unsigned name_len, size_t expdir_len)
int c;
*(DIR *volatile *)&dirp = NULL;
- *(char *volatile *)&pat = NULL;
savehandler = handler;
if (unlikely(err = setjmp(jmploc.loc)))
goto out;
@@ -1676,18 +1699,17 @@ static char *expmeta(char *name, unsigned name_len, size_t expdir_len)
if (metaflag == 0) { /* we've reached the end of the file name */
if (!expdir_len)
goto out_opendir;
- expmeta_rmescapes(enddir, name);
+ enddir = expmeta_rmescapes(enddir, name);
if (lstat64(cp, &statb) >= 0)
- cp = addfnamealt(strchrnul(enddir, 0), expdir_len);
+ cp = addfnamealt(enddir, expdir_len);
goto out_opendir;
}
endname = p;
if (name < start) {
c = *start;
*start = 0;
- expmeta_rmescapes(enddir, name);
+ enddir = expmeta_rmescapes(enddir, name);
*start = c;
- enddir += strlen(enddir);
}
*enddir = 0;
expdir_len = enddir - cp;
@@ -1702,21 +1724,28 @@ static char *expmeta(char *name, unsigned name_len, size_t expdir_len)
}
name_len -= endname - name;
matchdot = 0;
- *(char *volatile *)&pat =
- preglob(start, RMESCAPE_ALLOC | RMESCAPE_HEAP);
+ pat = start;
p = pat;
- if (*p == '\\')
+ if (*p == (FNMATCH_IS_ENABLED ? '\\' : (char)CTLESC))
p++;
if (*p == '.')
matchdot++;
while (! int_pending() && (dp = readdir64(dirp)) != NULL) {
- if (dp->d_name[0] == '.' && ! matchdot)
- continue;
- if (pmatch(pat, dp->d_name)) {
- len = strlen(dp->d_name) + 1;
+ char *dname = dp->d_name;
+ if (*dname == '.' && !matchdot)
+ continue;
+ len = strlen(dname) + 1;
+ p = dname;
+ if (!FNMATCH_IS_ENABLED) {
+ expdest = enddir;
+ memtodest(p, len, EXP_MBCHAR | EXP_KEEPNUL);
+ cp = stackblock();
enddir = cp + expdir_len;
- enddir = stnputs(dp->d_name, len, enddir);
+ p = enddir;
+ }
+ if (pmatch(pat, p)) {
+ enddir = stnputs(dname, len, enddir);
if (!c)
cp = addfnamealt(enddir, expdir_len);
else {
@@ -1724,15 +1753,13 @@ static char *expmeta(char *name, unsigned name_len, size_t expdir_len)
len += expdir_len;
cp = expmeta(endname, name_len, len);
}
+ enddir = cp + expdir_len;
}
}
if (c)
endname[-esc - 1] = c;
out:
- pat = *(char *volatile *)&pat;
- if (pat != start)
- ckfree(pat);
closedir(*(DIR *volatile *)&dirp);
out_opendir:
handler = savehandler;
@@ -1820,52 +1847,48 @@ msort(struct strlist *list, int len)
STATIC inline int
patmatch(char *pattern, const char *string)
{
- return pmatch(preglob(pattern, FNMATCH_IS_ENABLED ?
- RMESCAPE_ALLOC | RMESCAPE_GROW : 0),
- string);
+ return pmatch(preglob(pattern, 0), string);
}
-STATIC int ccmatch(const char *p, int chr, const char **r)
+static __attribute__((noinline)) int ccmatch(char *p, const char *mbc, int ml,
+ char **r)
{
- static const struct class {
- char name[10];
- int (*fn)(int);
- } classes[] = {
- { .name = ":alnum:]", .fn = isalnum },
- { .name = ":cntrl:]", .fn = iscntrl },
- { .name = ":lower:]", .fn = islower },
- { .name = ":space:]", .fn = isspace },
- { .name = ":alpha:]", .fn = isalpha },
- { .name = ":digit:]", .fn = isdigit },
- { .name = ":print:]", .fn = isprint },
- { .name = ":upper:]", .fn = isupper },
- { .name = ":blank:]", .fn = isblank },
- { .name = ":graph:]", .fn = isgraph },
- { .name = ":punct:]", .fn = ispunct },
- { .name = ":xdigit:]", .fn = isxdigit },
- };
- const struct class *class, *end;
-
- end = classes + sizeof(classes) / sizeof(classes[0]);
- for (class = classes; class < end; class++) {
- const char *q;
-
- q = prefix(p, class->name);
- if (!q)
- continue;
- *r = q;
- return class->fn(chr);
- }
+ mbstate_t mbst = {};
+ wctype_t type;
+ wchar_t wc;
+ char *q;
*r = 0;
- return 0;
+
+ if (*p++ != ':')
+ return 0;
+
+ q = strstr(p, ":]");
+ if (!q)
+ return 0;
+
+ *q = 0;
+ type = wctype(p);
+ *q = ':';
+
+ if (!type)
+ return 0;
+
+ *r = q + 2;
+
+ if (mbrtowc(&wc, mbc, ml, &mbst) != ml)
+ return 0;
+
+ return iswctype(wc, type);
}
-STATIC int
-pmatch(const char *pattern, const char *string)
+static int pmatch(char *pattern, const char *string)
{
- const char *p, *q;
+ char stop[] = { 0, CTLESC, CTLMBCHAR };
+ const char *q;
+ unsigned mb;
+ char *p;
char c;
if (FNMATCH_IS_ENABLED)
@@ -1874,36 +1897,43 @@ pmatch(const char *pattern, const char *string)
p = pattern;
q = string;
for (;;) {
- switch (c = *p++) {
+ switch ((signed char)(c = *p++)) {
case '\0':
goto breakloop;
- case '\\':
- if (*p) {
- c = *p++;
- }
- goto dft;
- case '?':
- if (*q++ == '\0')
- return 0;
+ case CTLESC:
+ c = *p++;
break;
+ case '?':
+ if (*q == '\0')
+ return 0;
+ mb = mbnext(q);
+ q += (mb >> 8) + (mb & 0xff);
+ continue;
case '*':
c = *p;
while (c == '*')
c = *++p;
- if (c != '\\' && c != '?' && c != '*' && c != '[') {
- while (*q != c) {
- if (*q == '\0')
+ if (!c)
+ return 1;
+ stop[0] = CTLESC;
+ if (c != '?' && c != '[')
+ stop[0] = c;
+ for (;;) {
+ if (stop[0] != (char)CTLESC) {
+ q = strpbrk(q, stop);
+ if (!q)
return 0;
- q++;
}
- }
- do {
if (pmatch(p, q))
return 1;
- } while (*q++ != '\0');
+ if (!*q)
+ break;
+ mb = mbnext(q);
+ q += (mb >> 8) + (mb & 0xff);
+ }
return 0;
case '[': {
- const char *startp;
+ char *startp;
int invert, found;
char chr;
@@ -1914,48 +1944,85 @@ pmatch(const char *pattern, const char *string)
p++;
}
found = 0;
+ mb = mbnext(q);
+ q += mb & 0xff;
+ mb >>= 8;
chr = *q;
if (chr == '\0')
return 0;
c = *p++;
do {
+ unsigned mbp = 0;
+ const char *mbs = &c;
+
if (!c) {
p = startp;
c = '[';
goto dft;
}
if (c == '[') {
- const char *r;
+ char *r;
- found |= !!ccmatch(p, chr, &r);
+ found |= !!ccmatch(p, q, mb > 1 ?
+ mb - 2 : mb,
+ &r);
if (r) {
p = r;
continue;
}
- } else if (c == '\\')
+ } else if (c == (char)CTLESC)
c = *p++;
+ else if (c == (char)CTLMBCHAR) {
+ mbp = mbnext(--p);
+ p += mbp & 0xff;
+ mbs = p;
+ mbp >>= 8;
+ p += mbp;
+ }
if (*p == '-' && p[1] != ']') {
p++;
- if (*p == '\\')
+ if (*p == (char)CTLESC)
p++;
- if (chr >= c && chr <= *p)
+ else if (*p == CTLMBCHAR) {
+ mbp = mbnext(p);
+ p += mbp & 0xff;
+ p += mbp >> 8;
+ continue;
+ }
+ if (!(mbp | (mb - 1)) &&
+ chr >= c && chr <= *p)
found = 1;
p++;
- } else {
- if (chr == c)
- found = 1;
- }
+ } else if (!memcmp(mbs, q, mb))
+ found = 1;
} while ((c = *p++) != ']');
if (found == invert)
return 0;
- q++;
- break;
+ q += mb;
+ continue;
}
-dft: default:
- if (*q++ != c)
+ case CTLMBCHAR:
+ mb = mbnext(--p);
+ p += mb & 0xff;
+ mb = mbnext(q);
+ q += mb & 0xff;
+ mb >>= 8;
+
+ if (memcmp(p - 1, q - 1, mb + 1))
return 0;
- break;
+
+ p += mb;
+ q += mb;
+ continue;
}
+dft:
+ mb = mbnext(q);
+ if ((mb >> 8) > 1)
+ return 0;
+ q += mb & 0xff;
+ if (*q != c)
+ return 0;
+ q += mb >> 8;
}
breakloop:
if (*q != '\0')
@@ -1976,7 +2043,6 @@ _rmescapes(char *str, int flag)
int notescaped;
int globbing;
int inquotes;
- int expmeta;
p = strpbrk(str, cqchars);
if (!p) {
@@ -1985,7 +2051,6 @@ _rmescapes(char *str, int flag)
q = p;
r = str;
globbing = flag & RMESCAPE_GLOB;
- expmeta = (flag & RMESCAPE_EMETA) ? RMESCAPE_GLOB : 0;
if (flag & RMESCAPE_ALLOC) {
size_t len = p - str;
@@ -2015,50 +2080,64 @@ _rmescapes(char *str, int flag)
inquotes = 0;
notescaped = globbing;
while (*p) {
+ int c = (signed char)*p;
+ int newnesc = globbing;
unsigned mb;
unsigned ml;
- int newnesc = globbing;
- if (*p == (char)CTLQUOTEMARK) {
+ if (c == CTLQUOTEMARK) {
p++;
inquotes ^= globbing;
continue;
- } else if (*p == '\\') {
+ } else if (c == '\\') {
/* naked back slash */
newnesc ^= notescaped;
/* naked backslashes can only occur outside quotes */
inquotes = 0;
- if (expmeta & ~newnesc) {
- p++;
- goto setnesc;
+ if (!FNMATCH_IS_ENABLED && notescaped)
+ c = CTLESC;
+ } else if (c == CTLESC) {
+ if ((notescaped ^ inquotes) & inquotes) {
+ if (FNMATCH_IS_ENABLED)
+ *q++ = '\\';
+ else
+ q[-1] = '\\';
}
- } else if (*p == (char)CTLMBCHAR) {
+ if (globbing)
+ *q++ = FNMATCH_IS_ENABLED ? '\\' : CTLESC;
+
+ c = *++p;
+ } else if (c == CTLMBCHAR) {
+ unsigned tail = 2;
+
+ if (!FNMATCH_IS_ENABLED && (globbing ^ notescaped))
+ q--;
+
mb = mbnext(p);
ml = mb >> 8;
- ml -= 2;
- p += mb & 0xff;
- q = mempcpy(q, p, ml);
- p += ml + 2;
- goto setnesc;
- } else if (*p == (char)CTLESC) {
- p++;
- if (expmeta)
- ;
- else if (notescaped)
- *q++ = '\\';
- else if (inquotes) {
- *q++ = '\\';
- *q++ = '\\';
+ if (!globbing || FNMATCH_IS_ENABLED) {
+ p += mb & 0xff;
+ ml -= 2;
+ } else {
+ ml += mb & 0xff;
+ tail = 0;
}
+
+ q = mempcpy(q, p, ml);
+ p += ml + tail;
+ goto setnesc;
}
- *q++ = *p++;
+ *q++ = c;
+ p++;
setnesc:
notescaped = newnesc;
}
+ if (!FNMATCH_IS_ENABLED && (globbing ^ notescaped))
+ q[-1] = '\\';
*q = '\0';
- if (flag & RMESCAPE_GROW) {
+ if (flag & (RMESCAPE_ALLOC | RMESCAPE_GROW)) {
expdest = r;
STADJUST(q - r + 1, expdest);
}
--
2.39.2
^ permalink raw reply related [flat|nested] 14+ messages in thread* [v5 PATCH 08/13] input: Allow MB_LEN_MAX calls to pungetc
2024-06-02 1:28 [v5 PATCH 00/13] Add multi-byte supportAdd multi-byte support Herbert Xu
` (6 preceding siblings ...)
2024-06-02 1:28 ` [v5 PATCH 07/13] expand: Add multi-byte support to pmatch Herbert Xu
@ 2024-06-02 1:29 ` Herbert Xu
2024-06-02 1:29 ` [v5 PATCH 09/13] input: Add pgetc_eoa Herbert Xu
` (4 subsequent siblings)
12 siblings, 0 replies; 14+ messages in thread
From: Herbert Xu @ 2024-06-02 1:29 UTC (permalink / raw)
To: DASH Mailing List
In order to parse multi-byte characters which may be up to MB_LEN_MAX
bytes long, allow enough calls to pungetc to undo a single multi-byte
character.
Also add a function pungetn to do multiple pungetc calls in a row.
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
---
src/input.c | 58 ++++++++++++++++++++++++++++++++++-------------------
src/input.h | 11 +++++-----
2 files changed, 42 insertions(+), 27 deletions(-)
diff --git a/src/input.c b/src/input.c
index 1c598b2..e17e067 100644
--- a/src/input.c
+++ b/src/input.c
@@ -56,7 +56,7 @@
#include "main.h"
#include "myhistedit.h"
-#define IBUFSIZ (BUFSIZ + 1)
+#define IBUFSIZ (BUFSIZ + PUNGETC_MAX + 1)
MKINIT struct parsefile basepf; /* top level input file */
@@ -83,13 +83,16 @@ INIT {
}
RESET {
+ int c;
+
/* clear input buffer */
popallfiles();
- basepf.unget = 0;
- while (basepf.lastc[0] != '\n' &&
- basepf.lastc[0] != PEOF &&
- !int_pending())
- pgetc();
+
+ c = PEOF;
+ if (basepf.nextc - basebuf > basepf.unget)
+ c = basepf.nextc[-basepf.unget - 1];
+ while (c != '\n' && c != PEOF && !int_pending())
+ c = pgetc();
}
FORKRESET {
@@ -131,17 +134,20 @@ static int __pgetc(void)
{
int c;
- if (parsefile->unget)
- return parsefile->lastc[--parsefile->unget];
+ if (parsefile->unget) {
+ long unget = -(long)(unsigned)parsefile->unget--;
+
+ if (parsefile->nleft < 0)
+ return preadbuffer();
+
+ return parsefile->nextc[unget];
+ }
if (--parsefile->nleft >= 0)
c = (signed char)*parsefile->nextc++;
else
c = preadbuffer();
- parsefile->lastc[1] = parsefile->lastc[0];
- parsefile->lastc[0] = c;
-
return c;
}
@@ -176,9 +182,16 @@ static int stdin_clear_nonblock(void)
static int
preadfd(void)
{
+ char *buf = parsefile->buf;
+ int unget;
int nr;
- char *buf = parsefile->buf;
- parsefile->nextc = buf;
+
+ unget = parsefile->nextc - buf;
+ if (unget > PUNGETC_MAX)
+ unget = PUNGETC_MAX;
+
+ memmove(buf, parsefile->nextc - unget, unget);
+ parsefile->nextc = buf += unget;
retry:
#ifndef SMALL
@@ -196,8 +209,8 @@ retry:
nr = 0;
else {
nr = el_len;
- if (nr > IBUFSIZ - 1)
- nr = IBUFSIZ - 1;
+ if (nr > BUFSIZ)
+ nr = BUFSIZ;
memcpy(buf, rl_cp, nr);
if (nr != el_len) {
el_len -= nr;
@@ -209,9 +222,9 @@ retry:
} else
#endif
if (parsefile->fd)
- nr = read(parsefile->fd, buf, IBUFSIZ - 1);
+ nr = read(parsefile->fd, buf, BUFSIZ);
else {
- unsigned len = IBUFSIZ - 1;
+ unsigned len = BUFSIZ;
nr = 0;
@@ -348,6 +361,11 @@ done:
return (signed char)*parsefile->nextc++;
}
+void pungetn(int n)
+{
+ parsefile->unget += n;
+}
+
/*
* Undo a call to pgetc. Only two characters may be pushed back.
* PEOF may be pushed back.
@@ -356,7 +374,7 @@ done:
void
pungetc(void)
{
- parsefile->unget++;
+ pungetn(1);
}
/*
@@ -383,7 +401,6 @@ pushstring(char *s, void *ap)
sp->prevnleft = parsefile->nleft;
sp->unget = parsefile->unget;
sp->spfree = parsefile->spfree;
- memcpy(sp->lastc, parsefile->lastc, sizeof(sp->lastc));
sp->ap = (struct alias *)ap;
if (ap) {
((struct alias *)ap)->flag |= ALIASINUSE;
@@ -413,7 +430,6 @@ static void popstring(void)
parsefile->nextc = sp->prevstring;
parsefile->nleft = sp->prevnleft;
parsefile->unget = sp->unget;
- memcpy(parsefile->lastc, sp->lastc, sizeof(sp->lastc));
/*dprintf("*** calling popstring: restoring to '%s'\n", parsenextc);*/
parsefile->strpush = sp->prev;
parsefile->spfree = sp;
@@ -457,7 +473,7 @@ setinputfd(int fd, int push)
}
parsefile->fd = fd;
if (parsefile->buf == NULL)
- parsefile->buf = ckmalloc(IBUFSIZ);
+ parsefile->nextc = parsefile->buf = ckmalloc(IBUFSIZ);
input_set_lleft(parsefile, parsefile->nleft = 0);
plinno = 1;
}
diff --git a/src/input.h b/src/input.h
index 1ff5773..5b4a045 100644
--- a/src/input.h
+++ b/src/input.h
@@ -34,12 +34,16 @@
* @(#)input.h 8.2 (Berkeley) 5/4/95
*/
+#include <limits.h>
+
#ifdef SMALL
#define IS_DEFINED_SMALL 1
#else
#define IS_DEFINED_SMALL 0
#endif
+#define PUNGETC_MAX (MB_LEN_MAX > 16 ? MB_LEN_MAX : 16)
+
/* PEOF (the end of file marker) is defined in syntax.h */
enum {
@@ -59,9 +63,6 @@ struct strpush {
/* Delay freeing so we can stop nested aliases. */
struct strpush *spfree;
- /* Remember last two characters for pungetc. */
- int lastc[2];
-
/* Number of outstanding calls to pungetc. */
int unget;
};
@@ -87,9 +88,6 @@ struct parsefile {
/* Delay freeing so we can stop nested aliases. */
struct strpush *spfree;
- /* Remember last two characters for pungetc. */
- int lastc[2];
-
/* Number of outstanding calls to pungetc. */
int unget;
};
@@ -106,6 +104,7 @@ extern struct parsefile *parsefile;
int pgetc(void);
int pgetc2(void);
void pungetc(void);
+void pungetn(int);
void pushstring(char *, void *);
int setinputfile(const char *, int);
void setinputstring(char *);
--
2.39.2
^ permalink raw reply related [flat|nested] 14+ messages in thread* [v5 PATCH 09/13] input: Add pgetc_eoa
2024-06-02 1:28 [v5 PATCH 00/13] Add multi-byte supportAdd multi-byte support Herbert Xu
` (7 preceding siblings ...)
2024-06-02 1:29 ` [v5 PATCH 08/13] input: Allow MB_LEN_MAX calls to pungetc Herbert Xu
@ 2024-06-02 1:29 ` Herbert Xu
2024-06-02 1:29 ` [v5 PATCH 10/13] parser: Add support for multi-byte characters Herbert Xu
` (3 subsequent siblings)
12 siblings, 0 replies; 14+ messages in thread
From: Herbert Xu @ 2024-06-02 1:29 UTC (permalink / raw)
To: DASH Mailing List
This reintroduces PEOA in a limited way. Instead of allowing pgetc
to return it, limit it to a new function pgetc_eoa so only specific
callers need to deal with PEOA.
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
---
src/input.c | 8 +++++++-
src/input.h | 3 ++-
2 files changed, 9 insertions(+), 2 deletions(-)
diff --git a/src/input.c b/src/input.c
index e17e067..bedc581 100644
--- a/src/input.c
+++ b/src/input.c
@@ -157,7 +157,7 @@ static int __pgetc(void)
* Nul characters in the input are silently discarded.
*/
-int pgetc(void)
+int __attribute__((noinline)) pgetc(void)
{
struct strpush *sp = parsefile->spfree;
@@ -167,6 +167,12 @@ int pgetc(void)
return __pgetc();
}
+int pgetc_eoa(void)
+{
+ return parsefile->strpush && parsefile->nleft == -1 &&
+ parsefile->strpush->ap ? PEOA : pgetc();
+}
+
static int stdin_clear_nonblock(void)
{
int flags = fcntl(0, F_GETFL, 0);
diff --git a/src/input.h b/src/input.h
index 5b4a045..151b1c6 100644
--- a/src/input.h
+++ b/src/input.h
@@ -45,6 +45,7 @@
#define PUNGETC_MAX (MB_LEN_MAX > 16 ? MB_LEN_MAX : 16)
/* PEOF (the end of file marker) is defined in syntax.h */
+#define PEOA ((PEOF) - 1)
enum {
INPUT_PUSH_FILE = 1,
@@ -102,7 +103,7 @@ extern struct parsefile *parsefile;
#define plinno (parsefile->linno)
int pgetc(void);
-int pgetc2(void);
+int pgetc_eoa(void);
void pungetc(void);
void pungetn(int);
void pushstring(char *, void *);
--
2.39.2
^ permalink raw reply related [flat|nested] 14+ messages in thread* [v5 PATCH 10/13] parser: Add support for multi-byte characters
2024-06-02 1:28 [v5 PATCH 00/13] Add multi-byte supportAdd multi-byte support Herbert Xu
` (8 preceding siblings ...)
2024-06-02 1:29 ` [v5 PATCH 09/13] input: Add pgetc_eoa Herbert Xu
@ 2024-06-02 1:29 ` Herbert Xu
2024-06-02 1:29 ` [v5 PATCH 11/13] input: Always push in setinputfile Herbert Xu
` (2 subsequent siblings)
12 siblings, 0 replies; 14+ messages in thread
From: Herbert Xu @ 2024-06-02 1:29 UTC (permalink / raw)
To: DASH Mailing List
Add the requisite markers for multi-byte characters so that the
expansion code can recognise them. Also allow wide blank characters
to terminate words.
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
---
src/expand.c | 19 +++++++
src/mktokens | 1 +
src/parser.c | 136 +++++++++++++++++++++++++++++++++++++++++----------
3 files changed, 129 insertions(+), 27 deletions(-)
diff --git a/src/expand.c b/src/expand.c
index ec408fd..cb579df 100644
--- a/src/expand.c
+++ b/src/expand.c
@@ -276,6 +276,7 @@ static char *argstr(char *p, int flag)
CTLESC,
CTLVAR,
CTLBACKQ,
+ CTLMBCHAR,
CTLARI,
CTLENDARI,
0
@@ -300,6 +301,8 @@ tilde:
start:
startloc = expdest - (char *)stackblock();
for (;;) {
+ unsigned ml;
+ unsigned mb;
int end;
length += strcspn(p + length, reject);
@@ -362,6 +365,22 @@ addquote:
startloc++;
}
break;
+ case CTLMBCHAR:
+ c = (signed char)*p--;
+ mb = mbnext(p);
+ ml = (mb >> 8) - 2;
+ if (flag & QUOTES_ESC) {
+ length = (mb >> 8) + (mb & 0xff);
+ if (c == (char)CTLESC)
+ startloc += length;
+ break;
+ }
+ if (c == CTLESC)
+ startloc += ml;
+ p += mb & 0xff;
+ expdest = stnputs(p, ml, expdest);
+ p += mb >> 8;
+ break;
case CTLESC:
startloc++;
length++;
diff --git a/src/mktokens b/src/mktokens
index 78055be..dcef676 100644
--- a/src/mktokens
+++ b/src/mktokens
@@ -41,6 +41,7 @@
cat > "${TMPDIR}"/ka$$ <<\!
TEOF 1 end of file
+TBLANK 0 blank
TNL 0 newline
TSEMI 0 ";"
TBACKGND 0 "&"
diff --git a/src/parser.c b/src/parser.c
index 09b1cb8..1a2f5df 100644
--- a/src/parser.c
+++ b/src/parser.c
@@ -36,7 +36,11 @@
#include <alloca.h>
#endif
+#include <limits.h>
+#include <stdbool.h>
#include <stdlib.h>
+#include <wchar.h>
+#include <wctype.h>
#include "shell.h"
#include "parser.h"
@@ -801,6 +805,8 @@ xxreadtoken(void)
setprompt(2);
}
for (;;) { /* until token or start of word found */
+ int tok;
+
c = pgetc_eatbnl();
switch (c) {
case ' ': case '\t':
@@ -834,9 +840,10 @@ xxreadtoken(void)
case ')':
RETURN(TRP);
}
- break;
+ tok = readtoken1(c, BASESYNTAX, (char *)NULL, 0);
+ if (tok != TBLANK)
+ return tok;
}
- return readtoken1(c, BASESYNTAX, (char *)NULL, 0);
#undef RETURN
}
@@ -876,7 +883,53 @@ static void synstack_pop(struct synstack **stack)
*stack = (*stack)->next;
}
+static unsigned getmbc(int c, char *out, int mode)
+{
+ char *const start = out;
+ mbstate_t mbst = {};
+ unsigned ml = 0;
+ size_t ml2;
+ wchar_t wc;
+ char *mbc;
+ if (likely(c >= 0))
+ return 0;
+
+ mbc = (mode & 3) < 2 ? out + 2 + (mode == 1) : out;
+ mbc[ml] = c;
+ while ((ml2 = mbrtowc(&wc, mbc + ml++, 1, &mbst)) == -2) {
+ if (ml >= MB_LEN_MAX)
+ break;
+ c = pgetc_eoa();
+ if (c == PEOA || c == PEOF)
+ break;
+ mbc[ml] = c;
+ }
+
+ if (ml2 == 1 && ml > 1) {
+ if (mode == 4 && iswblank(wc))
+ return 1;
+
+ if ((mode & 3) < 2) {
+ USTPUTC(CTLMBCHAR, out);
+ if (mode == 1)
+ USTPUTC(CTLESC, out);
+ USTPUTC(ml, out);
+ }
+ STADJUST(ml, out);
+ if ((mode & 3) < 2) {
+ USTPUTC(ml, out);
+ USTPUTC(CTLMBCHAR, out);
+ }
+
+ return out - start;
+ }
+
+ if (ml > 1)
+ pungetn(ml - 1);
+
+ return 0;
+}
/*
* If eofmark is NULL, read a word or a redirection symbol. If eofmark
@@ -929,12 +982,29 @@ readtoken1(int firstc, char const *syntax, char *eofmark, int striptabs)
}
#endif
CHECKEND(); /* set c to PEOF if at end of here document */
- for (;;) { /* until end of line or end of word */
- CHECKSTRSPACE(4, out); /* permit 4 calls to USTPUTC */
+ /* Until end of line or end of word */
+ for (;; c = pgetc_top(synstack)) {
+ int fieldsplitting;
+ unsigned ml;
+
+ /* Permit max(MB_LEN_MAX, 23) calls to USTPUTC. */
+ CHECKSTRSPACE((MB_LEN_MAX > 16 ? MB_LEN_MAX : 16) + 7,
+ out);
+ fieldsplitting = synstack->syntax == BASESYNTAX &&
+ !synstack->varnest ? 4 : 0;
+ ml = getmbc(c, out, fieldsplitting);
+ if (ml == 1) {
+ if (out == stackblock())
+ return TBLANK;
+ c = pgetc();
+ break;
+ }
+ out += ml;
+ if (ml)
+ continue;
switch(synstack->syntax[c]) {
case CNL: /* '\n' */
- if (synstack->syntax == BASESYNTAX &&
- !synstack->varnest)
+ if (fieldsplitting)
goto endword; /* exit outer loop */
USTPUTC(c, out);
nlprompt();
@@ -956,26 +1026,33 @@ readtoken1(int firstc, char const *syntax, char *eofmark, int striptabs)
USTPUTC(CTLESC, out);
USTPUTC('\\', out);
pungetc();
- } else {
- if (
- synstack->dblquote &&
- c != '\\' && c != '`' &&
- c != '$' && (
- c != '"' ||
- (eofmark != NULL &&
- !synstack->varnest)
- ) && (
- c != '}' ||
- !synstack->varnest
- )
- ) {
- USTPUTC(CTLESC, out);
- USTPUTC('\\', out);
- }
- USTPUTC(CTLESC, out);
- USTPUTC(c, out);
- quotef++;
+ break;
}
+
+ if (
+ synstack->dblquote &&
+ c != '\\' && c != '`' &&
+ c != '$' && (
+ c != '"' ||
+ (eofmark != NULL &&
+ !synstack->varnest)
+ ) && (
+ c != '}' ||
+ !synstack->varnest
+ )
+ ) {
+ USTPUTC(CTLESC, out);
+ USTPUTC('\\', out);
+ }
+ quotef++;
+
+ ml = getmbc(c, out, 1);
+ out += ml;
+ if (ml)
+ break;
+
+ USTPUTC(CTLESC, out);
+ USTPUTC(c, out);
break;
case CSQUOTE:
synstack->syntax = SQSYNTAX;
@@ -1053,11 +1130,10 @@ toggledq:
case CEOF:
goto endword; /* exit outer loop */
default:
- if (synstack->varnest == 0)
+ if (fieldsplitting)
goto endword; /* exit outer loop */
USTPUTC(c, out);
}
- c = pgetc_top(synstack);
}
}
endword:
@@ -1384,6 +1460,7 @@ parsebackq: {
size_t psavelen;
size_t savelen;
union node *n;
+ unsigned ml;
char *pstr;
char *str;
@@ -1415,6 +1492,11 @@ parsebackq: {
if (pc != '\\' && pc != '`' && pc != '$'
&& (!synstack->dblquote || pc != '"'))
STPUTC('\\', pout);
+ CHECKSTRSPACE(MB_LEN_MAX, pout);
+ ml = getmbc(pc, pout, 2);
+ pout += ml;
+ if (ml)
+ continue;
break;
case PEOF:
--
2.39.2
^ permalink raw reply related [flat|nested] 14+ messages in thread* [v5 PATCH 11/13] input: Always push in setinputfile
2024-06-02 1:28 [v5 PATCH 00/13] Add multi-byte supportAdd multi-byte support Herbert Xu
` (9 preceding siblings ...)
2024-06-02 1:29 ` [v5 PATCH 10/13] parser: Add support for multi-byte characters Herbert Xu
@ 2024-06-02 1:29 ` Herbert Xu
2024-06-02 1:29 ` [v5 PATCH 12/13] builtin: Use pgetc in read(1) Herbert Xu
2024-06-02 1:29 ` [v5 PATCH 13/13] builtin: Process multi-byte characters " Herbert Xu
12 siblings, 0 replies; 14+ messages in thread
From: Herbert Xu @ 2024-06-02 1:29 UTC (permalink / raw)
To: DASH Mailing List
Push the input file even in the case of "sh file". This is because
the base parsefile will be used for read(1).
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
---
src/input.c | 17 ++++++++---------
1 file changed, 8 insertions(+), 9 deletions(-)
diff --git a/src/input.c b/src/input.c
index bedc581..1712e5f 100644
--- a/src/input.c
+++ b/src/input.c
@@ -61,6 +61,7 @@
MKINIT struct parsefile basepf; /* top level input file */
MKINIT char basebuf[IBUFSIZ]; /* buffer for top level input file */
+MKINIT struct parsefile *toppf = &basepf;
struct parsefile *parsefile = &basepf; /* current input file */
int whichprompt; /* 1 == PS1, 2 == PS2 */
@@ -89,8 +90,8 @@ RESET {
popallfiles();
c = PEOF;
- if (basepf.nextc - basebuf > basepf.unget)
- c = basepf.nextc[-basepf.unget - 1];
+ if (toppf->nextc - toppf->buf > toppf->unget)
+ c = toppf->nextc[-toppf->unget - 1];
while (c != '\n' && c != PEOF && !int_pending())
c = pgetc();
}
@@ -473,13 +474,11 @@ out:
static void
setinputfd(int fd, int push)
{
- if (push) {
- pushfile();
- parsefile->buf = 0;
- }
+ pushfile();
+ if (!push)
+ toppf = parsefile;
parsefile->fd = fd;
- if (parsefile->buf == NULL)
- parsefile->nextc = parsefile->buf = ckmalloc(IBUFSIZ);
+ parsefile->nextc = parsefile->buf = ckmalloc(IBUFSIZ);
input_set_lleft(parsefile, parsefile->nleft = 0);
plinno = 1;
}
@@ -560,5 +559,5 @@ void unwindfiles(struct parsefile *stop)
void
popallfiles(void)
{
- unwindfiles(&basepf);
+ unwindfiles(toppf);
}
--
2.39.2
^ permalink raw reply related [flat|nested] 14+ messages in thread* [v5 PATCH 12/13] builtin: Use pgetc in read(1)
2024-06-02 1:28 [v5 PATCH 00/13] Add multi-byte supportAdd multi-byte support Herbert Xu
` (10 preceding siblings ...)
2024-06-02 1:29 ` [v5 PATCH 11/13] input: Always push in setinputfile Herbert Xu
@ 2024-06-02 1:29 ` Herbert Xu
2024-06-02 1:29 ` [v5 PATCH 13/13] builtin: Process multi-byte characters " Herbert Xu
12 siblings, 0 replies; 14+ messages in thread
From: Herbert Xu @ 2024-06-02 1:29 UTC (permalink / raw)
To: DASH Mailing List
Use pgetc instead of read(2) in read(1). This allows any future
buffering in the input layer to be used by read(1). This also
allows read(1) to call helpers in the parser that may use the
input layer.
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
---
src/input.c | 42 ++++++++++++++++++++++++++++--------------
src/input.h | 1 +
src/miscbltin.c | 39 +++++++++++++++++++--------------------
3 files changed, 48 insertions(+), 34 deletions(-)
diff --git a/src/input.c b/src/input.c
index 1712e5f..6779069 100644
--- a/src/input.c
+++ b/src/input.c
@@ -42,19 +42,20 @@
* This file implements the input routines used by the parser.
*/
-#include "eval.h"
-#include "shell.h"
-#include "redir.h"
-#include "syntax.h"
-#include "input.h"
-#include "output.h"
-#include "options.h"
-#include "memalloc.h"
-#include "error.h"
#include "alias.h"
-#include "parser.h"
+#include "error.h"
+#include "eval.h"
+#include "input.h"
#include "main.h"
+#include "memalloc.h"
#include "myhistedit.h"
+#include "options.h"
+#include "output.h"
+#include "parser.h"
+#include "redir.h"
+#include "shell.h"
+#include "syntax.h"
+#include "trap.h"
#define IBUFSIZ (BUFSIZ + PUNGETC_MAX + 1)
@@ -258,7 +259,7 @@ retry:
}
if (nr < 0) {
- if (errno == EINTR)
+ if (errno == EINTR && !(basepf.prev && pending_sig))
goto retry;
}
return nr;
@@ -522,6 +523,13 @@ pushfile(void)
parsefile = pf;
}
+void pushstdin(void)
+{
+ INTOFF;
+ basepf.prev = parsefile;
+ parsefile = &basepf;
+ INTON;
+}
void
popfile(void)
@@ -529,6 +537,11 @@ popfile(void)
struct parsefile *pf = parsefile;
INTOFF;
+ parsefile = pf->prev;
+ pf->prev = NULL;
+ if (pf == &basepf)
+ goto out;
+
if (pf->fd >= 0)
close(pf->fd);
if (pf->buf)
@@ -539,15 +552,16 @@ popfile(void)
popstring();
freestrings(parsefile->spfree);
}
- parsefile = pf->prev;
ckfree(pf);
+
+out:
INTON;
}
-void unwindfiles(struct parsefile *stop)
+void __attribute__((noinline)) unwindfiles(struct parsefile *stop)
{
- while (parsefile != stop)
+ while (basepf.prev || parsefile != stop)
popfile();
}
diff --git a/src/input.h b/src/input.h
index 151b1c6..c59d784 100644
--- a/src/input.h
+++ b/src/input.h
@@ -109,6 +109,7 @@ void pungetn(int);
void pushstring(char *, void *);
int setinputfile(const char *, int);
void setinputstring(char *);
+void pushstdin(void);
void popfile(void);
void unwindfiles(struct parsefile *);
void popallfiles(void);
diff --git a/src/miscbltin.c b/src/miscbltin.c
index 8a0ddf4..10d256e 100644
--- a/src/miscbltin.c
+++ b/src/miscbltin.c
@@ -46,18 +46,20 @@
#include <ctype.h>
#include <inttypes.h>
-#include "shell.h"
-#include "options.h"
-#include "var.h"
-#include "output.h"
-#include "memalloc.h"
#include "error.h"
+#include "expand.h"
+#include "input.h"
+#include "memalloc.h"
#include "miscbltin.h"
#include "mystring.h"
#include "main.h"
-#include "expand.h"
+#include "options.h"
+#include "output.h"
#include "parser.h"
+#include "shell.h"
+#include "syntax.h"
#include "trap.h"
+#include "var.h"
#undef rflag
@@ -115,14 +117,13 @@ readcmd_handle_line(char *s, int ac, char **ap)
int
readcmd(int argc, char **argv)
{
- char **ap;
- char c;
- int rflag;
char *prompt;
- char *p;
int startloc;
int newloc;
int status;
+ char **ap;
+ int rflag;
+ char *p;
int i;
rflag = 0;
@@ -145,19 +146,17 @@ readcmd(int argc, char **argv)
status = 0;
STARTSTACKSTR(p);
+ pushstdin();
+
goto start;
for (;;) {
- switch (read(0, &c, 1)) {
- case 1:
- break;
- default:
- if (errno == EINTR && !pending_sig)
- continue;
- /* fall through */
- case 0:
+ int c;
+
+ c = pgetc();
+ if (c == PEOF) {
status = 1;
- goto out;
+ break;
}
if (c == '\0')
continue;
@@ -186,7 +185,7 @@ start:
newloc = startloc - 1;
}
}
-out:
+ popfile();
recordregion(startloc, p - (char *)stackblock(), 0);
STACKSTRNUL(p);
readcmd_handle_line(p + 1, argc - (ap - argv), ap);
--
2.39.2
^ permalink raw reply related [flat|nested] 14+ messages in thread* [v5 PATCH 13/13] builtin: Process multi-byte characters in read(1)
2024-06-02 1:28 [v5 PATCH 00/13] Add multi-byte supportAdd multi-byte support Herbert Xu
` (11 preceding siblings ...)
2024-06-02 1:29 ` [v5 PATCH 12/13] builtin: Use pgetc in read(1) Herbert Xu
@ 2024-06-02 1:29 ` Herbert Xu
12 siblings, 0 replies; 14+ messages in thread
From: Herbert Xu @ 2024-06-02 1:29 UTC (permalink / raw)
To: DASH Mailing List
Add support for multi-byte characters in read(1) by using getmbc
from the parser.
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
---
src/miscbltin.c | 19 +++++++++++++------
src/parser.c | 2 +-
src/parser.h | 1 +
3 files changed, 15 insertions(+), 7 deletions(-)
diff --git a/src/miscbltin.c b/src/miscbltin.c
index 10d256e..5aa2b24 100644
--- a/src/miscbltin.c
+++ b/src/miscbltin.c
@@ -36,15 +36,16 @@
* Miscelaneous builtins.
*/
+#include <ctype.h>
+#include <inttypes.h>
+#include <limits.h>
+#include <stdlib.h>
#include <sys/types.h> /* quad_t */
#include <sys/param.h> /* BSD4_4 */
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/resource.h>
#include <unistd.h>
-#include <stdlib.h>
-#include <ctype.h>
-#include <inttypes.h>
#include "error.h"
#include "expand.h"
@@ -151,8 +152,10 @@ readcmd(int argc, char **argv)
goto start;
for (;;) {
+ unsigned ml;
int c;
+ CHECKSTRSPACE((MB_LEN_MAX > 16 ? MB_LEN_MAX : 16) + 4, p);
c = pgetc();
if (c == PEOF) {
status = 1;
@@ -160,9 +163,14 @@ readcmd(int argc, char **argv)
}
if (c == '\0')
continue;
+ ml = getmbc(c, p, 0);
+ if (ml) {
+ p += ml;
+ goto record;
+ }
if (newloc >= startloc) {
if (c == '\n')
- goto resetbs;
+ goto record;
goto put;
}
if (!rflag && c == '\\') {
@@ -172,13 +180,12 @@ readcmd(int argc, char **argv)
if (c == '\n')
break;
put:
- CHECKSTRSPACE(2, p);
if (strchr(qchars, c))
USTPUTC(CTLESC, p);
USTPUTC(c, p);
+record:
if (newloc >= startloc) {
-resetbs:
recordregion(startloc, newloc, 0);
start:
startloc = p - (char *)stackblock();
diff --git a/src/parser.c b/src/parser.c
index 1a2f5df..a4d3291 100644
--- a/src/parser.c
+++ b/src/parser.c
@@ -883,7 +883,7 @@ static void synstack_pop(struct synstack **stack)
*stack = (*stack)->next;
}
-static unsigned getmbc(int c, char *out, int mode)
+unsigned getmbc(int c, char *out, int mode)
{
char *const start = out;
mbstate_t mbst = {};
diff --git a/src/parser.h b/src/parser.h
index 14bfc4f..7a9605b 100644
--- a/src/parser.h
+++ b/src/parser.h
@@ -95,6 +95,7 @@ const char *getprompt(void *);
const char *const *findkwd(const char *);
char *endofname(const char *);
const char *expandstr(const char *);
+unsigned getmbc(int c, char *out, int mode);
static inline int
goodname(const char *p)
--
2.39.2
^ permalink raw reply related [flat|nested] 14+ messages in thread