/* $OpenBSD: expr.c,v 1.24 2014/12/08 14:26:31 otto Exp $ */

/*-

* Copyright (c) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,

* 2011, 2012, 2013, 2014, 2016, 2017, 2018, 2019,

* 2021, 2022, 2023

* mirabilos <m$(date +%Y)@mirbsd.de>

*

* 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.

*/

#define MKSH_DO_MBI_CTAS

#include "sh.h"

__RCSID("$MirOS: src/bin/mksh/expr.c,v 1.129 2025/12/24 04:51:52 tg Exp $");

#define EXPRTOK_DEFNS

#include "exprtok.h"

/* 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

enum token {

#define EXPRTOK_ENUM

#include "exprtok.h"

};

static const char opname[][4] = {

#define EXPRTOK_NAME

#include "exprtok.h"

};

static const kby oplen[] = {

#define EXPRTOK_LEN

#include "exprtok.h"

};

static const kby opprec[] = {

#define EXPRTOK_PREC

#include "exprtok.h"

};

typedef struct expr_state {

/* expression being evaluated */

const char *expression;

/* lexical position */

const char *tokp;

/* value from token() */

struct tbl *val;

/* variable that is being recursively expanded (EXPRINEVAL flag set) */

struct tbl *evaling;

/* token from token() */

enum token tok;

/* don't do assignments (for ?:, &&, ||) */

kby noassign;

/* evaluating an $(()) expression? */

Wahr arith;

/* unsigned arithmetic calculation */

Wahr natural;

} Expr_state;

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 *, unsigned int);

static void exprtoken(Expr_state *);

static struct tbl *do_ppmm(Expr_state *, enum token, struct tbl *, Wahr);

static void assign_check(Expr_state *, enum token, struct tbl *);

static struct tbl *intvar(Expr_state *, struct tbl *);

/*

* parse and evaluate expression

*/

int

evaluate(const char *expr, mksh_ari_t *rval, int error_ok, Wahr arith)

{

union tbl_static v;

int ret;

v.tbl.flag = DEFINED | INTEGER;

v.tbl.type = 0;

ret = v_evaluate((struct tbl *)&v, expr, error_ok, arith);

*rval = v.tbl.val.i;

return (ret);

}

/*

* parse and evaluate expression, storing result in vp.

*/

int

v_evaluate(struct tbl *vp, const char *expr, int error_ok, Wahr arith)

{

struct tbl *v;

Expr_state curstate;

Expr_state * const es = &curstate;

int i;

/* save state to allow recursive calls */

memset(&curstate, 0, sizeof(curstate));

curstate.expression = curstate.tokp = expr;

curstate.tok = BAD;

curstate.arith = arith;

newenv(E_ERRH);

if ((i = kshsetjmp(e->jbuf))) {

/* 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);

/* error already printed */

/* (cf. syn.c for why) */

exstat = 1;

shl_stdout_ok = Nee;

i = LERROR;

}

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 read-only */

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 = Nee;

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 = opname[(int)es->tok];

}

kwarnf0(KWF_ERR(1) | KWF_PREFIX | KWF_FILELINE | KWF_NOERRNO,

Tf_sD_s_qs, es->expression, Tunexpected, s);

break;

case ET_BADLIT:

if (!strcmp(es->expression, str))

kwarnf0(KWF_ERR(1) | KWF_PREFIX | KWF_FILELINE |

KWF_TWOMSG, es->expression, Tbadnum);

else

kwarnf0(KWF_ERR(1) | KWF_PREFIX | KWF_FILELINE,

Tf_sD_s_qs, es->expression, Tbadnum, str);

break;

case ET_RECURSIVE:

kwarnf0(KWF_ERR(1) | KWF_PREFIX | KWF_FILELINE | KWF_NOERRNO,

Tf_sD_s_qs,

es->expression, "expression recurses on parameter", str);

break;

case ET_LVALUE:

kwarnf0(KWF_ERR(1) | KWF_PREFIX | KWF_FILELINE | KWF_NOERRNO,

Tf_sD_s_s,

es->expression, str, "requires lvalue");

break;

case ET_RDONLY:

kwarnf0(KWF_ERR(1) | KWF_PREFIX | KWF_FILELINE | KWF_NOERRNO,

Tf_sD_s_s,

es->expression, str, "applied to read-only variable");

break;

default: /* keep gcc happy */

case ET_STR:

kwarnf(KWF_ERR(1) | KWF_PREFIX | KWF_FILELINE | KWF_NOERRNO |

KWF_TWOMSG, es->expression, str);

break;

}

unwind(LAEXPR);

}

/* do a ++ or -- operation */

static struct tbl *

do_ppmm(Expr_state *es, enum token op, struct tbl *vasn, Wahr is_prefix)

{

struct tbl *vl;

mksh_uari_t oval;

assign_check(es, op, vasn);

vl = intvar(es, vasn);

oval = vl->val.u;

if (op == O_PLUSPLUS)

++vl->val.u;

else

--vl->val.u;

if (!es->noassign) {

if (vasn->flag & INTEGER)

setint_v(vasn, vl, es->arith);

else

setint(vasn, vl->val.i);

}

if (!is_prefix)

/* undo the increment/decrement */

vl->val.u = oval;

return (vl);

}

static struct tbl *

evalexpr(Expr_state *es, unsigned int prec)

{

struct tbl *vl, *vr = NULL, *vasn;

enum token op;

mksh_uari_t res = 0;

if (prec == P_PRIMARY) {

switch ((int)(op = es->tok)) {

case O_BNOT:

case O_LNOT:

case O_MINUS:

case O_PLUS:

exprtoken(es);

vl = intvar(es, evalexpr(es, P_PRIMARY));

switch ((int)op) {

case O_BNOT:

vl->val.u = ~vl->val.u;

break;

case O_LNOT:

vl->val.u = !vl->val.u;

break;

case O_MINUS:

vl->val.u = -vl->val.u;

break;

case O_PLUS:

/* nop */

break;

}

break;

case OPEN_PAREN:

exprtoken(es);

vl = evalexpr(es, MAX_PREC);

if (es->tok != CLOSE_PAREN)

evalerr(es, ET_STR, "missing )");

exprtoken(es);

break;

case O_PLUSPLUS:

case O_MINUSMINUS:

exprtoken(es);

vl = do_ppmm(es, op, es->val, Ja);

exprtoken(es);

break;

case VAR:

case LIT:

vl = es->val;

exprtoken(es);

break;

default:

evalerr(es, ET_UNEXPECTED, NULL);

/* NOTREACHED */

}

if (es->tok == O_PLUSPLUS || es->tok == O_MINUSMINUS) {

vl = do_ppmm(es, es->tok, vl, Nee);

exprtoken(es);

}

return (vl);

/* prec == P_PRIMARY */

}

vl = evalexpr(es, prec - 1);

while ((int)(op = es->tok) >= (int)O_EQ && (int)op <= (int)O_COMMA &&

opprec[(int)op] == prec) {

switch ((int)op) {

case O_TERN:

case O_LAND:

case O_LOR:

break;

default:

exprtoken(es);

}

vasn = vl;

if (op != O_ASN)

/* vl may not have a value yet */

vl = intvar(es, vl);

if (IS_ASSIGNOP(op)) {

if (!es->noassign)

assign_check(es, op, vasn);

vr = intvar(es, evalexpr(es, P_ASSIGN));

} else if (op == O_TERN) {

Wahr ev = vl->val.u != 0;

if (!ev)

es->noassign++;

exprtoken(es);

vl = evalexpr(es, MAX_PREC);

if (!ev)

es->noassign--;

if (es->tok != CTERN)

evalerr(es, ET_STR, "missing :");

if (ev)

es->noassign++;

exprtoken(es);

vr = evalexpr(es, P_TERN);

if (ev)

es->noassign--;

vl = ev ? vl : vr;

continue;

} else if (op != O_LAND && op != O_LOR)

vr = intvar(es, evalexpr(es, prec - 1));

/* op calculation */

#ifndef MKSH_LEGACY_MODE

#define ariop(op) (vl->val.u op vr->val.u)

#define cmpop(op) (es->natural ? \

(mksh_uari_t)(vl->val.u op vr->val.u) : \

(mksh_uari_t)mbiKcmp(mksh_uari_t, KUA_HM, \

vl->val.u, op, vr->val.u))

#else

#define ariop(op) (es->natural ? \

(mksh_uari_t)(vl->val.u op vr->val.u) : \

(mksh_uari_t)(vl->val.i op vr->val.i))

#define cmpop(op) ariop(op)

#endif

switch ((int)op) {

case O_PLUS:

case O_PLUSASN:

res = ariop(+);

break;

case O_MINUS:

case O_MINUSASN:

res = ariop(-);

break;

case O_TIMES:

case O_TIMESASN:

res = ariop(*);

break;

case O_DIV:

case O_DIVASN:

if (vr->val.i == 0) {

if (!es->noassign)

evalerr(es, ET_STR, "zero divisor");

res = vl->val.u; /* dummy value, could be 1 */

break;

}

#ifndef MKSH_LEGACY_MODE

if (!es->natural)

res = mbiKdiv(mksh_uari_t, KUA_HM,

vl->val.u, vr->val.u);

else

#endif

res = ariop(/);

break;

case O_MOD:

case O_MODASN:

if (vr->val.i == 0) {

if (!es->noassign)

evalerr(es, ET_STR, "zero divisor");

res = vl->val.u; /* dummy value, could be 1 */

break;

}

#ifndef MKSH_LEGACY_MODE

if (!es->natural)

res = mbiKrem(mksh_uari_t, KUA_HM,

vl->val.u, vr->val.u);

else

#endif

res = ariop(%);

break;

#ifndef MKSH_LEGACY_MODE

case O_ROL:

case O_ROLASN:

res = mbiKrol(mksh_uari_t, vl->val.u, vr->val.u);

break;

case O_ROR:

case O_RORASN:

res = mbiKror(mksh_uari_t, vl->val.u, vr->val.u);

break;

#endif

case O_LSHIFT:

case O_LSHIFTASN:

#ifndef MKSH_LEGACY_MODE

res = mbiKshl(mksh_uari_t, vl->val.u, vr->val.u);

#else

res = ariop(<<);

#endif

break;

case O_RSHIFT:

case O_RSHIFTASN:

#ifndef MKSH_LEGACY_MODE

res = mbiKsar(mksh_uari_t,

!es->natural && vl->val.i < 0,

vl->val.u, vr->val.u);

#else

res = ariop(>>);

#endif

break;

case O_LT:

res = cmpop(<);

break;

case O_LE:

res = cmpop(<=);

break;

case O_GT:

res = cmpop(>);

break;

case O_GE:

res = cmpop(>=);

break;

case O_EQ:

res = ariop(==);

break;

case O_NE:

res = ariop(!=);

break;

case O_BAND:

case O_BANDASN:

res = ariop(&);

break;

case O_BXOR:

case O_BXORASN:

res = ariop(^);

break;

case O_BOR:

case O_BORASN:

res = ariop(|);

break;

case O_LAND:

if (!vl->val.u)

es->noassign++;

exprtoken(es);

vr = intvar(es, evalexpr(es, prec - 1));

res = vl->val.u && vr->val.u;

if (!vl->val.u)

es->noassign--;

break;

case O_LOR:

if (vl->val.u)

es->noassign++;

exprtoken(es);

vr = intvar(es, evalexpr(es, prec - 1));

res = vl->val.u || vr->val.u;

if (vl->val.u)

es->noassign--;

break;

case O_ASN:

case O_COMMA:

res = vr->val.u;

break;

}

#undef ariop

#undef cmpop

if (IS_ASSIGNOP(op)) {

vr->val.u = res;

if (!es->noassign) {

if (vasn->flag & INTEGER)

setint_v(vasn, vr, es->arith);

else

setint(vasn, vr->val.i);

}

vl = vr;

} else

vl->val.u = res;

}

return (vl);

}

static void

exprtoken(Expr_state *es)

{

const char *cp = es->tokp;

int c;

char *tvar;

/* skip whitespace */

skip_spaces:

--cp;

do {

c = ord(*++cp);

} while (ctype(c, C_SPACE));

if (es->tokp == es->expression && (unsigned int)c == ORD('#')) {

/* expression begins with # */

/* switch to unsigned */

es->natural = Ja;

++cp;

goto skip_spaces;

}

es->tokp = cp;

if (c == '\0')

es->tok = END;

else if (ctype(c, C_ALPHX)) {

do {

c = ord(*++cp);

} while (ctype(c, C_ALNUX));

if ((unsigned int)c == ORD('[')) {

size_t len;

len = array_ref_len(cp);

if (len == 0)

evalerr(es, ET_STR, "missing ]");

cp += len;

}

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;

if (*cp)

cp += ez_mbtoc(NULL, cp);

strndupx(tvar, es->tokp, cp - es->tokp, ATEMP);

goto process_tvar;

#ifndef MKSH_SMALL

} else if (c == '\'') {

if (*++cp == '\0') {

es->tok = END;

evalerr(es, ET_UNEXPECTED, NULL);

}

cp += ez_mbtoc(NULL, 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 (ctype(c, C_DIGIT)) {

while (ctype(c, C_ALNUM | C_HASH))

c = ord(*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 = ord(opname[i][0])); i++)

if (c == n0 && strncmp(cp, opname[i],

(size_t)oplen[i]) == 0) {

es->tok = (enum token)i;

cp += oplen[i];

break;

}

if (!n0)

es->tok = BAD;

}

es->tokp = cp;

}

static void

assign_check(Expr_state *es, enum token op, struct tbl *vasn)

{

if (es->tok == END || !vasn ||

(vasn->name[0] == '\0' && !(vasn->flag & EXPRLVALUE)))

evalerr(es, ET_LVALUE, opname[(int)op]);

else if (vasn->flag & RDONLY)

evalerr(es, ET_RDONLY, opname[(int)op]);

}

struct tbl *

tempvar(const char *vname)

{

struct tbl *vp;

size_t vsize;

/* vname is either "" or vtemp->name which maxes at 12 */

vsize = strlen(vname) + 1U;

vp = alloc(mbccFAMsz(struct tbl, name, vsize), ATEMP);

memcpy(vp->name, vname, vsize);

vp->flag = ISSET|INTEGER;

vp->type = 0;

vp->areap = ATEMP;

vp->ua.hval = 0;

vp->val.i = 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

*/

char *

ez_bs(char *cp, char *lower_bound)

{

if (UTFMODE) {

char *bp = cp;

size_t n;

/* skip backwards knowing the UTF-8 encoding */

while (bp > lower_bound && (rtt2asc(*bp) & 0xC0U) == 0x80U)

--bp;

/* ensure we arrive back at the original point */

n = ez_mbtoc(NULL, bp);

/* back where we started? if so, this was indeed UTF-8 */

if (bp + n - 1 == cp)

return (bp);

/* no so some raw octet is at *cp */

}

return (cp);

}

int

utf_widthadj(const char *src, const char **dst)

{

size_t len;

unsigned int wc;

int width;

if (!UTFMODE || !*src || (len = utf_mbtowc(&wc, src)) == (size_t)-1)

len = width = 1;

else if ((width = utf_wcwidth(wc)) < 0)

width = 1;

*dst = src + len;

return (width);

}

size_t

utf_mbswidth(const char *s)

{

size_t len, width = 0;

unsigned int wc;

int 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);

}

/*

* 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 = ord(rtt2asc(*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 = ord(rtt2asc(*s++))) & 0xC0) != 0x80)

goto ilseq;

wc |= c & 0x3F;

goto out;

}

wc = (wc & 0x0F) << 12;

if (((c = ord(rtt2asc(*s++))) & 0xC0) != 0x80)

goto ilseq;

wc |= (c & 0x3F) << 6;

if (((c = ord(rtt2asc(*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 = asc2rtt(wc);

return (1);

}

d = (unsigned char *)dst;

if (wc < 0x0800)

*d++ = asc2rtt((wc >> 6) | 0xC0);

else {

*d++ = asc2rtt(((wc = wc > 0xFFFD ? 0xFFFD : wc) >> 12) | 0xE0);

*d++ = asc2rtt(((wc >> 6) & 0x3F) | 0x80);

}

*d++ = asc2rtt((wc & 0x3F) | 0x80);

return ((char *)d - dst);

}

/* “give me that character right now” */

#if defined(MKSH_EBCDIC) || defined(MKSH_FAUX_EBCDIC)

/* as UCS codepoint; dst must not be NULL */

size_t

ez_mbtowc(unsigned int *dst, const char *src)

{

size_t n;

if (UTFMODE) {

if ((n = utf_mbtowc(dst, src)) != (size_t)-1)

return (n);

*dst = OPTUMKRAW(rtt2asc(*src));

} else

*dst = ord(rtt2asc(*src));

return (*src ? 1 : 0);

}

/* identical to ez_mbtoc, unless EBCDIC… */

#endif

/* as kby if !UTFMODE, UCS codepoint or OPTURAW otherwise */

size_t

ez_mbtoc(unsigned int *dst, const char *src)

{

size_t n;

if (UTFMODE) {

if ((n = utf_mbtowc(dst, src)) != (size_t)-1)

return (n);

if (dst)

*dst = OPTUMKRAW(rtt2asc(*src));

} else if (dst)

*dst = ord(*src);

return (*src ? 1 : 0);

}

size_t

ez_ctomb(char *dst, unsigned int wc)

{

if (!UTFMODE)

*dst = (kby)wc;

else if (OPTUISRAW(wc))

*dst = asc2rtt((kby)wc);

else

return (utf_wctomb(dst, wc));

return (1);

}

/*

* Wrapper around access(2) because it says root can execute everything

* on some operating systems. Does not set errno, no user needs it. Use

* this iff mode can have the X_OK bit set, access otherwise.

*/

int

ksh_access(const char *fn, int mode)

{

#ifdef __OS2__

return (access_ex(access, fn, mode));

#else

int rv;

struct stat sb;

if ((rv = access(fn, mode)) == 0 && (mode & X_OK) &&

(kshuid == 0 || ksheuid == 0) &&

(rv = stat(fn, &sb)) == 0 && !S_ISDIR(sb.st_mode) &&

(sb.st_mode & (S_IXUSR|S_IXGRP|S_IXOTH)) == 0)

rv = -1;

return (rv);

#endif

}

#ifndef MIRBSD_BOOTFLOPPY

/* From: X11/xc/programs/xterm/wcwidth.c,v 1.17 */

struct mb_ucsrange {

unsigned short beg;

unsigned short end;

};

static int mb_ucsbsearch(const struct mb_ucsrange arr[], size_t elems,

unsigned int val);

/*

* Generated from the UCD 15.0.0 - see /usr/share/doc/legal/LICENCE-BSD - by

* MirOS: contrib/code/Snippets/eawparse,v 1.15 2020/06/15 20:31:13 tg Exp $

*/

/*-

* Parts Copyright © 1991–2022 Unicode, Inc. All rights reserved.

* Distributed under the Terms of Use in:

* https://www.unicode.org/copyright.html

*

* Permission is hereby granted, free of charge, to any person obtaining

* a copy of the Unicode data files and any associated documentation

* (the "Data Files") or Unicode software and any associated documentation

* (the "Software") to deal in the Data Files or Software

* without restriction, including without limitation the rights to use,

* copy, modify, merge, publish, distribute, and/or sell copies of

* the Data Files or Software, and to permit persons to whom the Data Files

* or Software are furnished to do so, provided that either

* (a) this copyright and permission notice appear with all copies

* of the Data Files or Software, or

* (b) this copyright and permission notice appear in associated

* Documentation.

*

* THE DATA FILES AND SOFTWARE ARE PROVIDED "AS IS", WITHOUT WARRANTY OF

* ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE

* WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

* NONINFRINGEMENT OF THIRD PARTY RIGHTS.

* IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN THIS

* NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL

* DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,

* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER

* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR

* PERFORMANCE OF THE DATA FILES OR SOFTWARE.

*

* Except as contained in this notice, the name of a copyright holder

* shall not be used in advertising or otherwise to promote the sale,

* use or other dealings in these Data Files or Software without prior

* written authorization of the copyright holder.

*/

static const struct mb_ucsrange mb_ucs_combining[] = {

{ 0x0300, 0x036F },

{ 0x0483, 0x0489 },

{ 0x0591, 0x05BD },

{ 0x05BF, 0x05BF },

{ 0x05C1, 0x05C2 },

{ 0x05C4, 0x05C5 },

{ 0x05C7, 0x05C7 },

{ 0x0610, 0x061A },

{ 0x061C, 0x061C },

{ 0x064B, 0x065F },

{ 0x0670, 0x0670 },

{ 0x06D6, 0x06DC },

{ 0x06DF, 0x06E4 },

{ 0x06E7, 0x06E8 },

{ 0x06EA, 0x06ED },

{ 0x0711, 0x0711 },

{ 0x0730, 0x074A },

{ 0x07A6, 0x07B0 },

{ 0x07EB, 0x07F3 },

{ 0x07FD, 0x07FD },

{ 0x0816, 0x0819 },

{ 0x081B, 0x0823 },

{ 0x0825, 0x0827 },

{ 0x0829, 0x082D },

{ 0x0859, 0x085B },

{ 0x0898, 0x089F },

{ 0x08CA, 0x08E1 },

{ 0x08E3, 0x0902 },

{ 0x093A, 0x093A },

{ 0x093C, 0x093C },

{ 0x0941, 0x0948 },

{ 0x094D, 0x094D },

{ 0x0951, 0x0957 },

{ 0x0962, 0x0963 },

{ 0x0981, 0x0981 },

{ 0x09BC, 0x09BC },

{ 0x09C1, 0x09C4 },

{ 0x09CD, 0x09CD },

{ 0x09E2, 0x09E3 },

{ 0x09FE, 0x09FE },

{ 0x0A01, 0x0A02 },

{ 0x0A3C, 0x0A3C },

{ 0x0A41, 0x0A42 },

{ 0x0A47, 0x0A48 },

{ 0x0A4B, 0x0A4D },

{ 0x0A51, 0x0A51 },

{ 0x0A70, 0x0A71 },

{ 0x0A75, 0x0A75 },

{ 0x0A81, 0x0A82 },

{ 0x0ABC, 0x0ABC },

{ 0x0AC1, 0x0AC5 },

{ 0x0AC7, 0x0AC8 },

{ 0x0ACD, 0x0ACD },

{ 0x0AE2, 0x0AE3 },

{ 0x0AFA, 0x0AFF },

{ 0x0B01, 0x0B01 },