Add mksh from CVS 2010/08/24 as system/core/mksh module
Both shells (ash from system/core/sh, and mksh) are built by
default but only the one where $(TARGET_SHELL) is set to is
actually installed (the shell and the mkshrc configuration
file are tagged shell_mksh for this to work).
Signed-off-by: Thorsten Glaser <tg@mirbsd.org>
diff --git a/mksh/src/expr.c b/mksh/src/expr.c
new file mode 100644
index 0000000..6c5710c
--- /dev/null
+++ b/mksh/src/expr.c
@@ -0,0 +1,895 @@
+/* $OpenBSD: expr.c,v 1.21 2009/06/01 19:00:57 deraadt Exp $ */
+
+/*-
+ * Copyright (c) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
+ * Thorsten Glaser <tg@mirbsd.org>
+ *
+ * Provided that these terms and disclaimer and all copyright notices
+ * are retained or reproduced in an accompanying document, permission
+ * is granted to deal in this work without restriction, including un-
+ * limited rights to use, publicly perform, distribute, sell, modify,
+ * merge, give away, or sublicence.
+ *
+ * This work is provided "AS IS" and WITHOUT WARRANTY of any kind, to
+ * the utmost extent permitted by applicable law, neither express nor
+ * implied; without malicious intent or gross negligence. In no event
+ * may a licensor, author or contributor be held liable for indirect,
+ * direct, other damage, loss, or other issues arising in any way out
+ * of dealing in the work, even if advised of the possibility of such
+ * damage or existence of a defect, except proven that it results out
+ * of said person's immediate fault when using the work as intended.
+ */
+
+#include "sh.h"
+
+__RCSID("$MirOS: src/bin/mksh/expr.c,v 1.44 2010/08/14 21:35:13 tg Exp $");
+
+/* The order of these enums is constrained by the order of opinfo[] */
+enum token {
+ /* some (long) unary operators */
+ O_PLUSPLUS = 0, O_MINUSMINUS,
+ /* binary operators */
+ O_EQ, O_NE,
+ /* assignments are assumed to be in range O_ASN .. O_BORASN */
+ O_ASN, O_TIMESASN, O_DIVASN, O_MODASN, O_PLUSASN, O_MINUSASN,
+ O_LSHIFTASN, O_RSHIFTASN, O_BANDASN, O_BXORASN, O_BORASN,
+ O_LSHIFT, O_RSHIFT,
+ O_LE, O_GE, O_LT, O_GT,
+ O_LAND,
+ O_LOR,
+ O_TIMES, O_DIV, O_MOD,
+ O_PLUS, O_MINUS,
+ O_BAND,
+ O_BXOR,
+ O_BOR,
+ O_TERN,
+ O_COMMA,
+ /* things after this aren't used as binary operators */
+ /* unary that are not also binaries */
+ O_BNOT, O_LNOT,
+ /* misc */
+ OPEN_PAREN, CLOSE_PAREN, CTERN,
+ /* things that don't appear in the opinfo[] table */
+ VAR, LIT, END, BAD
+};
+#define IS_BINOP(op) (((int)op) >= (int)O_EQ && ((int)op) <= (int)O_COMMA)
+#define IS_ASSIGNOP(op) ((int)(op) >= (int)O_ASN && (int)(op) <= (int)O_BORASN)
+
+/* precisions; used to be enum prec but we do arithmetics on it */
+#define P_PRIMARY 0 /* VAR, LIT, (), ~ ! - + */
+#define P_MULT 1 /* * / % */
+#define P_ADD 2 /* + - */
+#define P_SHIFT 3 /* << >> */
+#define P_RELATION 4 /* < <= > >= */
+#define P_EQUALITY 5 /* == != */
+#define P_BAND 6 /* & */
+#define P_BXOR 7 /* ^ */
+#define P_BOR 8 /* | */
+#define P_LAND 9 /* && */
+#define P_LOR 10 /* || */
+#define P_TERN 11 /* ?: */
+#define P_ASSIGN 12 /* = *= /= %= += -= <<= >>= &= ^= |= */
+#define P_COMMA 13 /* , */
+#define MAX_PREC P_COMMA
+
+struct opinfo {
+ char name[4];
+ int len; /* name length */
+ int prec; /* precedence: lower is higher */
+};
+
+/* Tokens in this table must be ordered so the longest are first
+ * (eg, += before +). If you change something, change the order
+ * of enum token too.
+ */
+static const struct opinfo opinfo[] = {
+ { "++", 2, P_PRIMARY }, /* before + */
+ { "--", 2, P_PRIMARY }, /* before - */
+ { "==", 2, P_EQUALITY }, /* before = */
+ { "!=", 2, P_EQUALITY }, /* before ! */
+ { "=", 1, P_ASSIGN }, /* keep assigns in a block */
+ { "*=", 2, P_ASSIGN },
+ { "/=", 2, P_ASSIGN },
+ { "%=", 2, P_ASSIGN },
+ { "+=", 2, P_ASSIGN },
+ { "-=", 2, P_ASSIGN },
+ { "<<=", 3, P_ASSIGN },
+ { ">>=", 3, P_ASSIGN },
+ { "&=", 2, P_ASSIGN },
+ { "^=", 2, P_ASSIGN },
+ { "|=", 2, P_ASSIGN },
+ { "<<", 2, P_SHIFT },
+ { ">>", 2, P_SHIFT },
+ { "<=", 2, P_RELATION },
+ { ">=", 2, P_RELATION },
+ { "<", 1, P_RELATION },
+ { ">", 1, P_RELATION },
+ { "&&", 2, P_LAND },
+ { "||", 2, P_LOR },
+ { "*", 1, P_MULT },
+ { "/", 1, P_MULT },
+ { "%", 1, P_MULT },
+ { "+", 1, P_ADD },
+ { "-", 1, P_ADD },
+ { "&", 1, P_BAND },
+ { "^", 1, P_BXOR },
+ { "|", 1, P_BOR },
+ { "?", 1, P_TERN },
+ { ",", 1, P_COMMA },
+ { "~", 1, P_PRIMARY },
+ { "!", 1, P_PRIMARY },
+ { "(", 1, P_PRIMARY },
+ { ")", 1, P_PRIMARY },
+ { ":", 1, P_PRIMARY },
+ { "", 0, P_PRIMARY }
+};
+
+typedef struct expr_state Expr_state;
+struct expr_state {
+ const char *expression; /* expression being evaluated */
+ const char *tokp; /* lexical position */
+ struct tbl *val; /* value from token() */
+ struct tbl *evaling; /* variable that is being recursively
+ * expanded (EXPRINEVAL flag set) */
+ int noassign; /* don't do assigns (for ?:,&&,||) */
+ enum token tok; /* token from token() */
+ bool arith; /* evaluating an $(()) expression? */
+ bool natural; /* unsigned arithmetic calculation */
+};
+
+#define bivui(x, op, y) (es->natural ? \
+ (mksh_ari_t)((x)->val.u op (y)->val.u) : \
+ (mksh_ari_t)((x)->val.i op (y)->val.i) \
+)
+#define chvui(x, op) do { \
+ if (es->natural) \
+ (x)->val.u = op (x)->val.u; \
+ else \
+ (x)->val.i = op (x)->val.i; \
+} while (/* CONSTCOND */ 0)
+#define stvui(x, n) do { \
+ if (es->natural) \
+ (x)->val.u = (n); \
+ else \
+ (x)->val.i = (n); \
+} while (/* CONSTCOND */ 0)
+
+enum error_type {
+ ET_UNEXPECTED, ET_BADLIT, ET_RECURSIVE,
+ ET_LVALUE, ET_RDONLY, ET_STR
+};
+
+static void evalerr(Expr_state *, enum error_type, const char *)
+ MKSH_A_NORETURN;
+static struct tbl *evalexpr(Expr_state *, int);
+static void exprtoken(Expr_state *);
+static struct tbl *do_ppmm(Expr_state *, enum token, struct tbl *, bool);
+static void assign_check(Expr_state *, enum token, struct tbl *);
+static struct tbl *tempvar(void);
+static struct tbl *intvar(Expr_state *, struct tbl *);
+
+/*
+ * parse and evaluate expression
+ */
+int
+evaluate(const char *expr, mksh_ari_t *rval, int error_ok, bool arith)
+{
+ struct tbl v;
+ int ret;
+
+ v.flag = DEFINED|INTEGER;
+ v.type = 0;
+ ret = v_evaluate(&v, expr, error_ok, arith);
+ *rval = v.val.i;
+ return (ret);
+}
+
+/*
+ * parse and evaluate expression, storing result in vp.
+ */
+int
+v_evaluate(struct tbl *vp, const char *expr, volatile int error_ok,
+ bool arith)
+{
+ struct tbl *v;
+ Expr_state curstate;
+ Expr_state * const es = &curstate;
+ int i;
+
+ /* save state to allow recursive calls */
+ curstate.expression = curstate.tokp = expr;
+ curstate.noassign = 0;
+ curstate.arith = arith;
+ curstate.evaling = NULL;
+ curstate.natural = false;
+
+ newenv(E_ERRH);
+ i = sigsetjmp(e->jbuf, 0);
+ if (i) {
+ /* Clear EXPRINEVAL in of any variables we were playing with */
+ if (curstate.evaling)
+ curstate.evaling->flag &= ~EXPRINEVAL;
+ quitenv(NULL);
+ if (i == LAEXPR) {
+ if (error_ok == KSH_RETURN_ERROR)
+ return (0);
+ errorfz();
+ }
+ unwind(i);
+ /* NOTREACHED */
+ }
+
+ exprtoken(es);
+ if (es->tok == END) {
+ es->tok = LIT;
+ es->val = tempvar();
+ }
+ v = intvar(es, evalexpr(es, MAX_PREC));
+
+ if (es->tok != END)
+ evalerr(es, ET_UNEXPECTED, NULL);
+
+ if (es->arith && es->natural)
+ vp->flag |= INT_U;
+ if (vp->flag & INTEGER)
+ setint_v(vp, v, es->arith);
+ else
+ /* can fail if readonly */
+ setstr(vp, str_val(v), error_ok);
+
+ quitenv(NULL);
+
+ return (1);
+}
+
+static void
+evalerr(Expr_state *es, enum error_type type, const char *str)
+{
+ char tbuf[2];
+ const char *s;
+
+ es->arith = false;
+ switch (type) {
+ case ET_UNEXPECTED:
+ switch (es->tok) {
+ case VAR:
+ s = es->val->name;
+ break;
+ case LIT:
+ s = str_val(es->val);
+ break;
+ case END:
+ s = "end of expression";
+ break;
+ case BAD:
+ tbuf[0] = *es->tokp;
+ tbuf[1] = '\0';
+ s = tbuf;
+ break;
+ default:
+ s = opinfo[(int)es->tok].name;
+ }
+ warningf(true, "%s: unexpected '%s'", es->expression, s);
+ break;
+
+ case ET_BADLIT:
+ warningf(true, "%s: bad number '%s'", es->expression, str);
+ break;
+
+ case ET_RECURSIVE:
+ warningf(true, "%s: expression recurses on parameter '%s'",
+ es->expression, str);
+ break;
+
+ case ET_LVALUE:
+ warningf(true, "%s: %s requires lvalue",
+ es->expression, str);
+ break;
+
+ case ET_RDONLY:
+ warningf(true, "%s: %s applied to read only variable",
+ es->expression, str);
+ break;
+
+ default: /* keep gcc happy */
+ case ET_STR:
+ warningf(true, "%s: %s", es->expression, str);
+ break;
+ }
+ unwind(LAEXPR);
+}
+
+static struct tbl *
+evalexpr(Expr_state *es, int prec)
+{
+ struct tbl *vl, *vr = NULL, *vasn;
+ enum token op;
+ mksh_ari_t res = 0;
+
+ if (prec == P_PRIMARY) {
+ op = es->tok;
+ if (op == O_BNOT || op == O_LNOT || op == O_MINUS ||
+ op == O_PLUS) {
+ exprtoken(es);
+ vl = intvar(es, evalexpr(es, P_PRIMARY));
+ if (op == O_BNOT)
+ chvui(vl, ~);
+ else if (op == O_LNOT)
+ chvui(vl, !);
+ else if (op == O_MINUS)
+ chvui(vl, -);
+ /* op == O_PLUS is a no-op */
+ } else if (op == OPEN_PAREN) {
+ exprtoken(es);
+ vl = evalexpr(es, MAX_PREC);
+ if (es->tok != CLOSE_PAREN)
+ evalerr(es, ET_STR, "missing )");
+ exprtoken(es);
+ } else if (op == O_PLUSPLUS || op == O_MINUSMINUS) {
+ exprtoken(es);
+ vl = do_ppmm(es, op, es->val, true);
+ exprtoken(es);
+ } else if (op == VAR || op == LIT) {
+ vl = es->val;
+ exprtoken(es);
+ } else {
+ evalerr(es, ET_UNEXPECTED, NULL);
+ /* NOTREACHED */
+ }
+ if (es->tok == O_PLUSPLUS || es->tok == O_MINUSMINUS) {
+ vl = do_ppmm(es, es->tok, vl, false);
+ exprtoken(es);
+ }
+ return (vl);
+ }
+ vl = evalexpr(es, prec - 1);
+ for (op = es->tok; IS_BINOP(op) && opinfo[(int)op].prec == prec;
+ op = es->tok) {
+ exprtoken(es);
+ vasn = vl;
+ if (op != O_ASN) /* vl may not have a value yet */
+ vl = intvar(es, vl);
+ if (IS_ASSIGNOP(op)) {
+ assign_check(es, op, vasn);
+ vr = intvar(es, evalexpr(es, P_ASSIGN));
+ } else if (op != O_TERN && op != O_LAND && op != O_LOR)
+ vr = intvar(es, evalexpr(es, prec - 1));
+ if ((op == O_DIV || op == O_MOD || op == O_DIVASN ||
+ op == O_MODASN) && vr->val.i == 0) {
+ if (es->noassign)
+ vr->val.i = 1;
+ else
+ evalerr(es, ET_STR, "zero divisor");
+ }
+ switch ((int)op) {
+ case O_TIMES:
+ case O_TIMESASN:
+ res = bivui(vl, *, vr);
+ break;
+ case O_DIV:
+ case O_DIVASN:
+ res = bivui(vl, /, vr);
+ break;
+ case O_MOD:
+ case O_MODASN:
+ res = bivui(vl, %, vr);
+ break;
+ case O_PLUS:
+ case O_PLUSASN:
+ res = bivui(vl, +, vr);
+ break;
+ case O_MINUS:
+ case O_MINUSASN:
+ res = bivui(vl, -, vr);
+ break;
+ case O_LSHIFT:
+ case O_LSHIFTASN:
+ res = bivui(vl, <<, vr);
+ break;
+ case O_RSHIFT:
+ case O_RSHIFTASN:
+ res = bivui(vl, >>, vr);
+ break;
+ case O_LT:
+ res = bivui(vl, <, vr);
+ break;
+ case O_LE:
+ res = bivui(vl, <=, vr);
+ break;
+ case O_GT:
+ res = bivui(vl, >, vr);
+ break;
+ case O_GE:
+ res = bivui(vl, >=, vr);
+ break;
+ case O_EQ:
+ res = bivui(vl, ==, vr);
+ break;
+ case O_NE:
+ res = bivui(vl, !=, vr);
+ break;
+ case O_BAND:
+ case O_BANDASN:
+ res = bivui(vl, &, vr);
+ break;
+ case O_BXOR:
+ case O_BXORASN:
+ res = bivui(vl, ^, vr);
+ break;
+ case O_BOR:
+ case O_BORASN:
+ res = bivui(vl, |, vr);
+ break;
+ case O_LAND:
+ if (!vl->val.i)
+ es->noassign++;
+ vr = intvar(es, evalexpr(es, prec - 1));
+ res = bivui(vl, &&, vr);
+ if (!vl->val.i)
+ es->noassign--;
+ break;
+ case O_LOR:
+ if (vl->val.i)
+ es->noassign++;
+ vr = intvar(es, evalexpr(es, prec - 1));
+ res = bivui(vl, ||, vr);
+ if (vl->val.i)
+ es->noassign--;
+ break;
+ case O_TERN:
+ {
+ bool ev = vl->val.i != 0;
+
+ if (!ev)
+ es->noassign++;
+ vl = evalexpr(es, MAX_PREC);
+ if (!ev)
+ es->noassign--;
+ if (es->tok != CTERN)
+ evalerr(es, ET_STR, "missing :");
+ exprtoken(es);
+ if (ev)
+ es->noassign++;
+ vr = evalexpr(es, P_TERN);
+ if (ev)
+ es->noassign--;
+ vl = ev ? vl : vr;
+ }
+ break;
+ case O_ASN:
+ res = vr->val.i;
+ break;
+ case O_COMMA:
+ res = vr->val.i;
+ break;
+ }
+ if (IS_ASSIGNOP(op)) {
+ stvui(vr, res);
+ if (!es->noassign) {
+ if (vasn->flag & INTEGER)
+ setint_v(vasn, vr, es->arith);
+ else
+ setint(vasn, res);
+ }
+ vl = vr;
+ } else if (op != O_TERN)
+ stvui(vl, res);
+ }
+ return (vl);
+}
+
+static void
+exprtoken(Expr_state *es)
+{
+ const char *cp = es->tokp;
+ int c;
+ char *tvar;
+
+ /* skip white space */
+ skip_spaces:
+ while ((c = *cp), ksh_isspace(c))
+ ++cp;
+ if (es->tokp == es->expression && c == '#') {
+ /* expression begins with # */
+ es->natural = true; /* switch to unsigned */
+ ++cp;
+ goto skip_spaces;
+ }
+ es->tokp = cp;
+
+ if (c == '\0')
+ es->tok = END;
+ else if (ksh_isalphx(c)) {
+ for (; ksh_isalnux(c); c = *cp)
+ cp++;
+ if (c == '[') {
+ int len;
+
+ len = array_ref_len(cp);
+ if (len == 0)
+ evalerr(es, ET_STR, "missing ]");
+ cp += len;
+ } else if (c == '(' /*)*/ ) {
+ /* todo: add math functions (all take single argument):
+ * abs acos asin atan cos cosh exp int log sin sinh sqrt
+ * tan tanh
+ */
+ ;
+ }
+ if (es->noassign) {
+ es->val = tempvar();
+ es->val->flag |= EXPRLVALUE;
+ } else {
+ strndupx(tvar, es->tokp, cp - es->tokp, ATEMP);
+ es->val = global(tvar);
+ afree(tvar, ATEMP);
+ }
+ es->tok = VAR;
+ } else if (c == '1' && cp[1] == '#') {
+ cp += 2;
+ cp += utf_ptradj(cp);
+ strndupx(tvar, es->tokp, cp - es->tokp, ATEMP);
+ goto process_tvar;
+#ifndef MKSH_SMALL
+ } else if (c == '\'') {
+ ++cp;
+ cp += utf_ptradj(cp);
+ if (*cp++ != '\'')
+ evalerr(es, ET_STR,
+ "multi-character character constant");
+ /* 'x' -> 1#x (x = one multibyte character) */
+ c = cp - es->tokp;
+ tvar = alloc(c + /* NUL */ 1, ATEMP);
+ tvar[0] = '1';
+ tvar[1] = '#';
+ memcpy(tvar + 2, es->tokp + 1, c - 2);
+ tvar[c] = '\0';
+ goto process_tvar;
+#endif
+ } else if (ksh_isdigit(c)) {
+ while (c != '_' && (ksh_isalnux(c) || c == '#'))
+ c = *cp++;
+ strndupx(tvar, es->tokp, --cp - es->tokp, ATEMP);
+ process_tvar:
+ es->val = tempvar();
+ es->val->flag &= ~INTEGER;
+ es->val->type = 0;
+ es->val->val.s = tvar;
+ if (setint_v(es->val, es->val, es->arith) == NULL)
+ evalerr(es, ET_BADLIT, tvar);
+ afree(tvar, ATEMP);
+ es->tok = LIT;
+ } else {
+ int i, n0;
+
+ for (i = 0; (n0 = opinfo[i].name[0]); i++)
+ if (c == n0 && strncmp(cp, opinfo[i].name,
+ (size_t)opinfo[i].len) == 0) {
+ es->tok = (enum token)i;
+ cp += opinfo[i].len;
+ break;
+ }
+ if (!n0)
+ es->tok = BAD;
+ }
+ es->tokp = cp;
+}
+
+/* Do a ++ or -- operation */
+static struct tbl *
+do_ppmm(Expr_state *es, enum token op, struct tbl *vasn, bool is_prefix)
+{
+ struct tbl *vl;
+ mksh_ari_t oval;
+
+ assign_check(es, op, vasn);
+
+ vl = intvar(es, vasn);
+ oval = vl->val.i;
+ if (op == O_PLUSPLUS) {
+ if (es->natural)
+ ++vl->val.u;
+ else
+ ++vl->val.i;
+ } else {
+ if (es->natural)
+ --vl->val.u;
+ else
+ --vl->val.i;
+ }
+ if (vasn->flag & INTEGER)
+ setint_v(vasn, vl, es->arith);
+ else
+ setint(vasn, vl->val.i);
+ if (!is_prefix) /* undo the inc/dec */
+ vl->val.i = oval;
+
+ return (vl);
+}
+
+static void
+assign_check(Expr_state *es, enum token op, struct tbl *vasn)
+{
+ if (es->tok == END ||
+ (vasn->name[0] == '\0' && !(vasn->flag & EXPRLVALUE)))
+ evalerr(es, ET_LVALUE, opinfo[(int)op].name);
+ else if (vasn->flag & RDONLY)
+ evalerr(es, ET_RDONLY, opinfo[(int)op].name);
+}
+
+static struct tbl *
+tempvar(void)
+{
+ struct tbl *vp;
+
+ vp = alloc(sizeof(struct tbl), ATEMP);
+ vp->flag = ISSET|INTEGER;
+ vp->type = 0;
+ vp->areap = ATEMP;
+ vp->ua.hval = 0;
+ vp->val.i = 0;
+ vp->name[0] = '\0';
+ return (vp);
+}
+
+/* cast (string) variable to temporary integer variable */
+static struct tbl *
+intvar(Expr_state *es, struct tbl *vp)
+{
+ struct tbl *vq;
+
+ /* try to avoid replacing a temp var with another temp var */
+ if (vp->name[0] == '\0' &&
+ (vp->flag & (ISSET|INTEGER|EXPRLVALUE)) == (ISSET|INTEGER))
+ return (vp);
+
+ vq = tempvar();
+ if (setint_v(vq, vp, es->arith) == NULL) {
+ if (vp->flag & EXPRINEVAL)
+ evalerr(es, ET_RECURSIVE, vp->name);
+ es->evaling = vp;
+ vp->flag |= EXPRINEVAL;
+ v_evaluate(vq, str_val(vp), KSH_UNWIND_ERROR, es->arith);
+ vp->flag &= ~EXPRINEVAL;
+ es->evaling = NULL;
+ }
+ return (vq);
+}
+
+
+/*
+ * UTF-8 support code: high-level functions
+ */
+
+int
+utf_widthadj(const char *src, const char **dst)
+{
+ size_t len;
+ unsigned int wc;
+ int width;
+
+ if (!UTFMODE || (len = utf_mbtowc(&wc, src)) == (size_t)-1 ||
+ wc == 0)
+ len = width = 1;
+ else if ((width = utf_wcwidth(wc)) < 0)
+ /* XXX use 2 for x_zotc3 here? */
+ width = 1;
+
+ if (dst)
+ *dst = src + len;
+ return (width);
+}
+
+int
+utf_mbswidth(const char *s)
+{
+ size_t len;
+ unsigned int wc;
+ int width = 0, cw;
+
+ if (!UTFMODE)
+ return (strlen(s));
+
+ while (*s)
+ if (((len = utf_mbtowc(&wc, s)) == (size_t)-1) ||
+ ((cw = utf_wcwidth(wc)) == -1)) {
+ s++;
+ width += 1;
+ } else {
+ s += len;
+ width += cw;
+ }
+ return (width);
+}
+
+const char *
+utf_skipcols(const char *p, int cols)
+{
+ int c = 0;
+
+ while (c < cols) {
+ if (!*p)
+ return (p + cols - c);
+ c += utf_widthadj(p, &p);
+ }
+ return (p);
+}
+
+size_t
+utf_ptradj(const char *src)
+{
+ register size_t n;
+
+ if (!UTFMODE ||
+ *(const unsigned char *)(src) < 0xC2 ||
+ (n = utf_mbtowc(NULL, src)) == (size_t)-1)
+ n = 1;
+ return (n);
+}
+
+/*
+ * UTF-8 support code: low-level functions
+ */
+
+/* CESU-8 multibyte and wide character conversion crafted for mksh */
+
+size_t
+utf_mbtowc(unsigned int *dst, const char *src)
+{
+ const unsigned char *s = (const unsigned char *)src;
+ unsigned int c, wc;
+
+ if ((wc = *s++) < 0x80) {
+ out:
+ if (dst != NULL)
+ *dst = wc;
+ return (wc ? ((const char *)s - src) : 0);
+ }
+ if (wc < 0xC2 || wc >= 0xF0)
+ /* < 0xC0: spurious second byte */
+ /* < 0xC2: non-minimalistic mapping error in 2-byte seqs */
+ /* > 0xEF: beyond BMP */
+ goto ilseq;
+
+ if (wc < 0xE0) {
+ wc = (wc & 0x1F) << 6;
+ if (((c = *s++) & 0xC0) != 0x80)
+ goto ilseq;
+ wc |= c & 0x3F;
+ goto out;
+ }
+
+ wc = (wc & 0x0F) << 12;
+
+ if (((c = *s++) & 0xC0) != 0x80)
+ goto ilseq;
+ wc |= (c & 0x3F) << 6;
+
+ if (((c = *s++) & 0xC0) != 0x80)
+ goto ilseq;
+ wc |= c & 0x3F;
+
+ /* Check for non-minimalistic mapping error in 3-byte seqs */
+ if (wc >= 0x0800 && wc <= 0xFFFD)
+ goto out;
+ ilseq:
+ return ((size_t)(-1));
+}
+
+size_t
+utf_wctomb(char *dst, unsigned int wc)
+{
+ unsigned char *d;
+
+ if (wc < 0x80) {
+ *dst = wc;
+ return (1);
+ }
+
+ d = (unsigned char *)dst;
+ if (wc < 0x0800)
+ *d++ = (wc >> 6) | 0xC0;
+ else {
+ *d++ = ((wc = wc > 0xFFFD ? 0xFFFD : wc) >> 12) | 0xE0;
+ *d++ = ((wc >> 6) & 0x3F) | 0x80;
+ }
+ *d++ = (wc & 0x3F) | 0x80;
+ return ((char *)d - dst);
+}
+
+
+#ifndef MKSH_mirbsd_wcwidth
+/* --- begin of wcwidth.c excerpt --- */
+/*-
+ * Markus Kuhn -- 2007-05-26 (Unicode 5.0)
+ *
+ * Permission to use, copy, modify, and distribute this software
+ * for any purpose and without fee is hereby granted. The author
+ * disclaims all warranties with regard to this software.
+ */
+
+__RCSID("$miros: src/lib/libc/i18n/wcwidth.c,v 1.8 2008/09/20 12:01:18 tg Exp $");
+
+int
+utf_wcwidth(unsigned int c)
+{
+ static const struct cbset {
+ unsigned short first;
+ unsigned short last;
+ } comb[] = {
+ { 0x0300, 0x036F }, { 0x0483, 0x0486 }, { 0x0488, 0x0489 },
+ { 0x0591, 0x05BD }, { 0x05BF, 0x05BF }, { 0x05C1, 0x05C2 },
+ { 0x05C4, 0x05C5 }, { 0x05C7, 0x05C7 }, { 0x0600, 0x0603 },
+ { 0x0610, 0x0615 }, { 0x064B, 0x065E }, { 0x0670, 0x0670 },
+ { 0x06D6, 0x06E4 }, { 0x06E7, 0x06E8 }, { 0x06EA, 0x06ED },
+ { 0x070F, 0x070F }, { 0x0711, 0x0711 }, { 0x0730, 0x074A },
+ { 0x07A6, 0x07B0 }, { 0x07EB, 0x07F3 }, { 0x0901, 0x0902 },
+ { 0x093C, 0x093C }, { 0x0941, 0x0948 }, { 0x094D, 0x094D },
+ { 0x0951, 0x0954 }, { 0x0962, 0x0963 }, { 0x0981, 0x0981 },
+ { 0x09BC, 0x09BC }, { 0x09C1, 0x09C4 }, { 0x09CD, 0x09CD },
+ { 0x09E2, 0x09E3 }, { 0x0A01, 0x0A02 }, { 0x0A3C, 0x0A3C },
+ { 0x0A41, 0x0A42 }, { 0x0A47, 0x0A48 }, { 0x0A4B, 0x0A4D },
+ { 0x0A70, 0x0A71 }, { 0x0A81, 0x0A82 }, { 0x0ABC, 0x0ABC },
+ { 0x0AC1, 0x0AC5 }, { 0x0AC7, 0x0AC8 }, { 0x0ACD, 0x0ACD },
+ { 0x0AE2, 0x0AE3 }, { 0x0B01, 0x0B01 }, { 0x0B3C, 0x0B3C },
+ { 0x0B3F, 0x0B3F }, { 0x0B41, 0x0B43 }, { 0x0B4D, 0x0B4D },
+ { 0x0B56, 0x0B56 }, { 0x0B82, 0x0B82 }, { 0x0BC0, 0x0BC0 },
+ { 0x0BCD, 0x0BCD }, { 0x0C3E, 0x0C40 }, { 0x0C46, 0x0C48 },
+ { 0x0C4A, 0x0C4D }, { 0x0C55, 0x0C56 }, { 0x0CBC, 0x0CBC },
+ { 0x0CBF, 0x0CBF }, { 0x0CC6, 0x0CC6 }, { 0x0CCC, 0x0CCD },
+ { 0x0CE2, 0x0CE3 }, { 0x0D41, 0x0D43 }, { 0x0D4D, 0x0D4D },
+ { 0x0DCA, 0x0DCA }, { 0x0DD2, 0x0DD4 }, { 0x0DD6, 0x0DD6 },
+ { 0x0E31, 0x0E31 }, { 0x0E34, 0x0E3A }, { 0x0E47, 0x0E4E },
+ { 0x0EB1, 0x0EB1 }, { 0x0EB4, 0x0EB9 }, { 0x0EBB, 0x0EBC },
+ { 0x0EC8, 0x0ECD }, { 0x0F18, 0x0F19 }, { 0x0F35, 0x0F35 },
+ { 0x0F37, 0x0F37 }, { 0x0F39, 0x0F39 }, { 0x0F71, 0x0F7E },
+ { 0x0F80, 0x0F84 }, { 0x0F86, 0x0F87 }, { 0x0F90, 0x0F97 },
+ { 0x0F99, 0x0FBC }, { 0x0FC6, 0x0FC6 }, { 0x102D, 0x1030 },
+ { 0x1032, 0x1032 }, { 0x1036, 0x1037 }, { 0x1039, 0x1039 },
+ { 0x1058, 0x1059 }, { 0x1160, 0x11FF }, { 0x135F, 0x135F },
+ { 0x1712, 0x1714 }, { 0x1732, 0x1734 }, { 0x1752, 0x1753 },
+ { 0x1772, 0x1773 }, { 0x17B4, 0x17B5 }, { 0x17B7, 0x17BD },
+ { 0x17C6, 0x17C6 }, { 0x17C9, 0x17D3 }, { 0x17DD, 0x17DD },
+ { 0x180B, 0x180D }, { 0x18A9, 0x18A9 }, { 0x1920, 0x1922 },
+ { 0x1927, 0x1928 }, { 0x1932, 0x1932 }, { 0x1939, 0x193B },
+ { 0x1A17, 0x1A18 }, { 0x1B00, 0x1B03 }, { 0x1B34, 0x1B34 },
+ { 0x1B36, 0x1B3A }, { 0x1B3C, 0x1B3C }, { 0x1B42, 0x1B42 },
+ { 0x1B6B, 0x1B73 }, { 0x1DC0, 0x1DCA }, { 0x1DFE, 0x1DFF },
+ { 0x200B, 0x200F }, { 0x202A, 0x202E }, { 0x2060, 0x2063 },
+ { 0x206A, 0x206F }, { 0x20D0, 0x20EF }, { 0x302A, 0x302F },
+ { 0x3099, 0x309A }, { 0xA806, 0xA806 }, { 0xA80B, 0xA80B },
+ { 0xA825, 0xA826 }, { 0xFB1E, 0xFB1E }, { 0xFE00, 0xFE0F },
+ { 0xFE20, 0xFE23 }, { 0xFEFF, 0xFEFF }, { 0xFFF9, 0xFFFB }
+ };
+ size_t min = 0, mid, max = NELEM(comb) - 1;
+
+ /* test for 8-bit control characters */
+ if (c < 32 || (c >= 0x7f && c < 0xa0))
+ return (c ? -1 : 0);
+
+ /* binary search in table of non-spacing characters */
+ if (c >= comb[0].first && c <= comb[max].last)
+ while (max >= min) {
+ mid = (min + max) / 2;
+ if (c > comb[mid].last)
+ min = mid + 1;
+ else if (c < comb[mid].first)
+ max = mid - 1;
+ else
+ return (0);
+ }
+
+ /* if we arrive here, c is not a combining or C0/C1 control char */
+ return ((c >= 0x1100 && (
+ c <= 0x115f || /* Hangul Jamo init. consonants */
+ c == 0x2329 || c == 0x232a ||
+ (c >= 0x2e80 && c <= 0xa4cf && c != 0x303f) || /* CJK ... Yi */
+ (c >= 0xac00 && c <= 0xd7a3) || /* Hangul Syllables */
+ (c >= 0xf900 && c <= 0xfaff) || /* CJK Compatibility Ideographs */
+ (c >= 0xfe10 && c <= 0xfe19) || /* Vertical forms */
+ (c >= 0xfe30 && c <= 0xfe6f) || /* CJK Compatibility Forms */
+ (c >= 0xff00 && c <= 0xff60) || /* Fullwidth Forms */
+ (c >= 0xffe0 && c <= 0xffe6))) ? 2 : 1);
+}
+/* --- end of wcwidth.c excerpt --- */
+#endif