1 /* $OpenBSD: expr.c,v 1.21 2009/06/01 19:00:57 deraadt Exp $ */ 2 3 /*- 4 * Copyright (c) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 5 * Thorsten Glaser <tg (at) mirbsd.org> 6 * 7 * Provided that these terms and disclaimer and all copyright notices 8 * are retained or reproduced in an accompanying document, permission 9 * is granted to deal in this work without restriction, including un- 10 * limited rights to use, publicly perform, distribute, sell, modify, 11 * merge, give away, or sublicence. 12 * 13 * This work is provided "AS IS" and WITHOUT WARRANTY of any kind, to 14 * the utmost extent permitted by applicable law, neither express nor 15 * implied; without malicious intent or gross negligence. In no event 16 * may a licensor, author or contributor be held liable for indirect, 17 * direct, other damage, loss, or other issues arising in any way out 18 * of dealing in the work, even if advised of the possibility of such 19 * damage or existence of a defect, except proven that it results out 20 * of said person's immediate fault when using the work as intended. 21 */ 22 23 #include "sh.h" 24 25 __RCSID("$MirOS: src/bin/mksh/expr.c,v 1.49 2011/09/07 15:24:14 tg Exp $"); 26 27 /* The order of these enums is constrained by the order of opinfo[] */ 28 enum token { 29 /* some (long) unary operators */ 30 O_PLUSPLUS = 0, O_MINUSMINUS, 31 /* binary operators */ 32 O_EQ, O_NE, 33 /* assignments are assumed to be in range O_ASN .. O_BORASN */ 34 O_ASN, O_TIMESASN, O_DIVASN, O_MODASN, O_PLUSASN, O_MINUSASN, 35 O_LSHIFTASN, O_RSHIFTASN, O_BANDASN, O_BXORASN, O_BORASN, 36 O_LSHIFT, O_RSHIFT, 37 O_LE, O_GE, O_LT, O_GT, 38 O_LAND, 39 O_LOR, 40 O_TIMES, O_DIV, O_MOD, 41 O_PLUS, O_MINUS, 42 O_BAND, 43 O_BXOR, 44 O_BOR, 45 O_TERN, 46 O_COMMA, 47 /* things after this aren't used as binary operators */ 48 /* unary that are not also binaries */ 49 O_BNOT, O_LNOT, 50 /* misc */ 51 OPEN_PAREN, CLOSE_PAREN, CTERN, 52 /* things that don't appear in the opinfo[] table */ 53 VAR, LIT, END, BAD 54 }; 55 #define IS_BINOP(op) (((int)op) >= (int)O_EQ && ((int)op) <= (int)O_COMMA) 56 #define IS_ASSIGNOP(op) ((int)(op) >= (int)O_ASN && (int)(op) <= (int)O_BORASN) 57 58 /* precisions; used to be enum prec but we do arithmetics on it */ 59 #define P_PRIMARY 0 /* VAR, LIT, (), ~ ! - + */ 60 #define P_MULT 1 /* * / % */ 61 #define P_ADD 2 /* + - */ 62 #define P_SHIFT 3 /* << >> */ 63 #define P_RELATION 4 /* < <= > >= */ 64 #define P_EQUALITY 5 /* == != */ 65 #define P_BAND 6 /* & */ 66 #define P_BXOR 7 /* ^ */ 67 #define P_BOR 8 /* | */ 68 #define P_LAND 9 /* && */ 69 #define P_LOR 10 /* || */ 70 #define P_TERN 11 /* ?: */ 71 #define P_ASSIGN 12 /* = *= /= %= += -= <<= >>= &= ^= |= */ 72 #define P_COMMA 13 /* , */ 73 #define MAX_PREC P_COMMA 74 75 struct opinfo { 76 char name[4]; 77 int len; /* name length */ 78 int prec; /* precedence: lower is higher */ 79 }; 80 81 /* Tokens in this table must be ordered so the longest are first 82 * (eg, += before +). If you change something, change the order 83 * of enum token too. 84 */ 85 static const struct opinfo opinfo[] = { 86 { "++", 2, P_PRIMARY }, /* before + */ 87 { "--", 2, P_PRIMARY }, /* before - */ 88 { "==", 2, P_EQUALITY }, /* before = */ 89 { "!=", 2, P_EQUALITY }, /* before ! */ 90 { "=", 1, P_ASSIGN }, /* keep assigns in a block */ 91 { "*=", 2, P_ASSIGN }, 92 { "/=", 2, P_ASSIGN }, 93 { "%=", 2, P_ASSIGN }, 94 { "+=", 2, P_ASSIGN }, 95 { "-=", 2, P_ASSIGN }, 96 { "<<=", 3, P_ASSIGN }, 97 { ">>=", 3, P_ASSIGN }, 98 { "&=", 2, P_ASSIGN }, 99 { "^=", 2, P_ASSIGN }, 100 { "|=", 2, P_ASSIGN }, 101 { "<<", 2, P_SHIFT }, 102 { ">>", 2, P_SHIFT }, 103 { "<=", 2, P_RELATION }, 104 { ">=", 2, P_RELATION }, 105 { "<", 1, P_RELATION }, 106 { ">", 1, P_RELATION }, 107 { "&&", 2, P_LAND }, 108 { "||", 2, P_LOR }, 109 { "*", 1, P_MULT }, 110 { "/", 1, P_MULT }, 111 { "%", 1, P_MULT }, 112 { "+", 1, P_ADD }, 113 { "-", 1, P_ADD }, 114 { "&", 1, P_BAND }, 115 { "^", 1, P_BXOR }, 116 { "|", 1, P_BOR }, 117 { "?", 1, P_TERN }, 118 { ",", 1, P_COMMA }, 119 { "~", 1, P_PRIMARY }, 120 { "!", 1, P_PRIMARY }, 121 { "(", 1, P_PRIMARY }, 122 { ")", 1, P_PRIMARY }, 123 { ":", 1, P_PRIMARY }, 124 { "", 0, P_PRIMARY } 125 }; 126 127 typedef struct expr_state Expr_state; 128 struct expr_state { 129 const char *expression; /* expression being evaluated */ 130 const char *tokp; /* lexical position */ 131 struct tbl *val; /* value from token() */ 132 struct tbl *evaling; /* variable that is being recursively 133 * expanded (EXPRINEVAL flag set) */ 134 int noassign; /* don't do assigns (for ?:,&&,||) */ 135 enum token tok; /* token from token() */ 136 bool arith; /* evaluating an $(()) expression? */ 137 bool natural; /* unsigned arithmetic calculation */ 138 }; 139 140 #define bivui(x, op, y) (es->natural ? \ 141 (mksh_ari_t)((x)->val.u op (y)->val.u) : \ 142 (mksh_ari_t)((x)->val.i op (y)->val.i) \ 143 ) 144 #define stvui(x, n) do { \ 145 if (es->natural) \ 146 (x)->val.u = (n); \ 147 else \ 148 (x)->val.i = (n); \ 149 } while (/* CONSTCOND */ 0) 150 151 enum error_type { 152 ET_UNEXPECTED, ET_BADLIT, ET_RECURSIVE, 153 ET_LVALUE, ET_RDONLY, ET_STR 154 }; 155 156 static void evalerr(Expr_state *, enum error_type, const char *) 157 MKSH_A_NORETURN; 158 static struct tbl *evalexpr(Expr_state *, int); 159 static void exprtoken(Expr_state *); 160 static struct tbl *do_ppmm(Expr_state *, enum token, struct tbl *, bool); 161 static void assign_check(Expr_state *, enum token, struct tbl *); 162 static struct tbl *tempvar(void); 163 static struct tbl *intvar(Expr_state *, struct tbl *); 164 165 /* 166 * parse and evaluate expression 167 */ 168 int 169 evaluate(const char *expr, mksh_ari_t *rval, int error_ok, bool arith) 170 { 171 struct tbl v; 172 int ret; 173 174 v.flag = DEFINED|INTEGER; 175 v.type = 0; 176 ret = v_evaluate(&v, expr, error_ok, arith); 177 *rval = v.val.i; 178 return (ret); 179 } 180 181 /* 182 * parse and evaluate expression, storing result in vp. 183 */ 184 int 185 v_evaluate(struct tbl *vp, const char *expr, volatile int error_ok, 186 bool arith) 187 { 188 struct tbl *v; 189 Expr_state curstate; 190 Expr_state * const es = &curstate; 191 int i; 192 193 /* save state to allow recursive calls */ 194 curstate.expression = curstate.tokp = expr; 195 curstate.noassign = 0; 196 curstate.arith = arith; 197 curstate.evaling = NULL; 198 curstate.natural = false; 199 200 newenv(E_ERRH); 201 i = sigsetjmp(e->jbuf, 0); 202 if (i) { 203 /* Clear EXPRINEVAL in of any variables we were playing with */ 204 if (curstate.evaling) 205 curstate.evaling->flag &= ~EXPRINEVAL; 206 quitenv(NULL); 207 if (i == LAEXPR) { 208 if (error_ok == KSH_RETURN_ERROR) 209 return (0); 210 errorfz(); 211 } 212 unwind(i); 213 /* NOTREACHED */ 214 } 215 216 exprtoken(es); 217 if (es->tok == END) { 218 es->tok = LIT; 219 es->val = tempvar(); 220 } 221 v = intvar(es, evalexpr(es, MAX_PREC)); 222 223 if (es->tok != END) 224 evalerr(es, ET_UNEXPECTED, NULL); 225 226 if (es->arith && es->natural) 227 vp->flag |= INT_U; 228 if (vp->flag & INTEGER) 229 setint_v(vp, v, es->arith); 230 else 231 /* can fail if readonly */ 232 setstr(vp, str_val(v), error_ok); 233 234 quitenv(NULL); 235 236 return (1); 237 } 238 239 static void 240 evalerr(Expr_state *es, enum error_type type, const char *str) 241 { 242 char tbuf[2]; 243 const char *s; 244 245 es->arith = false; 246 switch (type) { 247 case ET_UNEXPECTED: 248 switch (es->tok) { 249 case VAR: 250 s = es->val->name; 251 break; 252 case LIT: 253 s = str_val(es->val); 254 break; 255 case END: 256 s = "end of expression"; 257 break; 258 case BAD: 259 tbuf[0] = *es->tokp; 260 tbuf[1] = '\0'; 261 s = tbuf; 262 break; 263 default: 264 s = opinfo[(int)es->tok].name; 265 } 266 warningf(true, "%s: %s '%s'", es->expression, 267 "unexpected", s); 268 break; 269 270 case ET_BADLIT: 271 warningf(true, "%s: %s '%s'", es->expression, 272 "bad number", str); 273 break; 274 275 case ET_RECURSIVE: 276 warningf(true, "%s: %s '%s'", es->expression, 277 "expression recurses on parameter", str); 278 break; 279 280 case ET_LVALUE: 281 warningf(true, "%s: %s %s", 282 es->expression, str, "requires lvalue"); 283 break; 284 285 case ET_RDONLY: 286 warningf(true, "%s: %s %s", 287 es->expression, str, "applied to read only variable"); 288 break; 289 290 default: /* keep gcc happy */ 291 case ET_STR: 292 warningf(true, "%s: %s", es->expression, str); 293 break; 294 } 295 unwind(LAEXPR); 296 } 297 298 static struct tbl * 299 evalexpr(Expr_state *es, int prec) 300 { 301 struct tbl *vl, *vr = NULL, *vasn; 302 enum token op; 303 mksh_ari_t res = 0; 304 305 if (prec == P_PRIMARY) { 306 op = es->tok; 307 if (op == O_BNOT || op == O_LNOT || op == O_MINUS || 308 op == O_PLUS) { 309 exprtoken(es); 310 vl = intvar(es, evalexpr(es, P_PRIMARY)); 311 if (op == O_BNOT) 312 vl->val.i = ~vl->val.i; 313 else if (op == O_LNOT) 314 vl->val.i = !vl->val.i; 315 else if (op == O_MINUS) 316 vl->val.i = -vl->val.i; 317 /* op == O_PLUS is a no-op */ 318 } else if (op == OPEN_PAREN) { 319 exprtoken(es); 320 vl = evalexpr(es, MAX_PREC); 321 if (es->tok != CLOSE_PAREN) 322 evalerr(es, ET_STR, "missing )"); 323 exprtoken(es); 324 } else if (op == O_PLUSPLUS || op == O_MINUSMINUS) { 325 exprtoken(es); 326 vl = do_ppmm(es, op, es->val, true); 327 exprtoken(es); 328 } else if (op == VAR || op == LIT) { 329 vl = es->val; 330 exprtoken(es); 331 } else { 332 evalerr(es, ET_UNEXPECTED, NULL); 333 /* NOTREACHED */ 334 } 335 if (es->tok == O_PLUSPLUS || es->tok == O_MINUSMINUS) { 336 vl = do_ppmm(es, es->tok, vl, false); 337 exprtoken(es); 338 } 339 return (vl); 340 } 341 vl = evalexpr(es, prec - 1); 342 for (op = es->tok; IS_BINOP(op) && opinfo[(int)op].prec == prec; 343 op = es->tok) { 344 exprtoken(es); 345 vasn = vl; 346 if (op != O_ASN) /* vl may not have a value yet */ 347 vl = intvar(es, vl); 348 if (IS_ASSIGNOP(op)) { 349 assign_check(es, op, vasn); 350 vr = intvar(es, evalexpr(es, P_ASSIGN)); 351 } else if (op != O_TERN && op != O_LAND && op != O_LOR) 352 vr = intvar(es, evalexpr(es, prec - 1)); 353 if ((op == O_DIV || op == O_MOD || op == O_DIVASN || 354 op == O_MODASN) && vr->val.i == 0) { 355 if (es->noassign) 356 vr->val.i = 1; 357 else 358 evalerr(es, ET_STR, "zero divisor"); 359 } 360 switch ((int)op) { 361 case O_TIMES: 362 case O_TIMESASN: 363 res = bivui(vl, *, vr); 364 break; 365 case O_DIV: 366 case O_DIVASN: 367 res = bivui(vl, /, vr); 368 break; 369 case O_MOD: 370 case O_MODASN: 371 res = bivui(vl, %, vr); 372 break; 373 case O_PLUS: 374 case O_PLUSASN: 375 res = bivui(vl, +, vr); 376 break; 377 case O_MINUS: 378 case O_MINUSASN: 379 res = bivui(vl, -, vr); 380 break; 381 case O_LSHIFT: 382 case O_LSHIFTASN: 383 res = bivui(vl, <<, vr); 384 break; 385 case O_RSHIFT: 386 case O_RSHIFTASN: 387 res = bivui(vl, >>, vr); 388 break; 389 case O_LT: 390 res = bivui(vl, <, vr); 391 break; 392 case O_LE: 393 res = bivui(vl, <=, vr); 394 break; 395 case O_GT: 396 res = bivui(vl, >, vr); 397 break; 398 case O_GE: 399 res = bivui(vl, >=, vr); 400 break; 401 case O_EQ: 402 res = bivui(vl, ==, vr); 403 break; 404 case O_NE: 405 res = bivui(vl, !=, vr); 406 break; 407 case O_BAND: 408 case O_BANDASN: 409 res = bivui(vl, &, vr); 410 break; 411 case O_BXOR: 412 case O_BXORASN: 413 res = bivui(vl, ^, vr); 414 break; 415 case O_BOR: 416 case O_BORASN: 417 res = bivui(vl, |, vr); 418 break; 419 case O_LAND: 420 if (!vl->val.i) 421 es->noassign++; 422 vr = intvar(es, evalexpr(es, prec - 1)); 423 res = bivui(vl, &&, vr); 424 if (!vl->val.i) 425 es->noassign--; 426 break; 427 case O_LOR: 428 if (vl->val.i) 429 es->noassign++; 430 vr = intvar(es, evalexpr(es, prec - 1)); 431 res = bivui(vl, ||, vr); 432 if (vl->val.i) 433 es->noassign--; 434 break; 435 case O_TERN: 436 { 437 bool ev = vl->val.i != 0; 438 439 if (!ev) 440 es->noassign++; 441 vl = evalexpr(es, MAX_PREC); 442 if (!ev) 443 es->noassign--; 444 if (es->tok != CTERN) 445 evalerr(es, ET_STR, "missing :"); 446 exprtoken(es); 447 if (ev) 448 es->noassign++; 449 vr = evalexpr(es, P_TERN); 450 if (ev) 451 es->noassign--; 452 vl = ev ? vl : vr; 453 } 454 break; 455 case O_ASN: 456 res = vr->val.i; 457 break; 458 case O_COMMA: 459 res = vr->val.i; 460 break; 461 } 462 if (IS_ASSIGNOP(op)) { 463 stvui(vr, res); 464 if (!es->noassign) { 465 if (vasn->flag & INTEGER) 466 setint_v(vasn, vr, es->arith); 467 else 468 setint(vasn, res); 469 } 470 vl = vr; 471 } else if (op != O_TERN) 472 stvui(vl, res); 473 } 474 return (vl); 475 } 476 477 static void 478 exprtoken(Expr_state *es) 479 { 480 const char *cp = es->tokp; 481 int c; 482 char *tvar; 483 484 /* skip white space */ 485 skip_spaces: 486 while ((c = *cp), ksh_isspace(c)) 487 ++cp; 488 if (es->tokp == es->expression && c == '#') { 489 /* expression begins with # */ 490 es->natural = true; /* switch to unsigned */ 491 ++cp; 492 goto skip_spaces; 493 } 494 es->tokp = cp; 495 496 if (c == '\0') 497 es->tok = END; 498 else if (ksh_isalphx(c)) { 499 for (; ksh_isalnux(c); c = *cp) 500 cp++; 501 if (c == '[') { 502 size_t len; 503 504 len = array_ref_len(cp); 505 if (len == 0) 506 evalerr(es, ET_STR, "missing ]"); 507 cp += len; 508 } else if (c == '(' /*)*/ ) { 509 /* todo: add math functions (all take single argument): 510 * abs acos asin atan cos cosh exp int log sin sinh sqrt 511 * tan tanh 512 */ 513 ; 514 } 515 if (es->noassign) { 516 es->val = tempvar(); 517 es->val->flag |= EXPRLVALUE; 518 } else { 519 strndupx(tvar, es->tokp, cp - es->tokp, ATEMP); 520 es->val = global(tvar); 521 afree(tvar, ATEMP); 522 } 523 es->tok = VAR; 524 } else if (c == '1' && cp[1] == '#') { 525 cp += 2; 526 cp += utf_ptradj(cp); 527 strndupx(tvar, es->tokp, cp - es->tokp, ATEMP); 528 goto process_tvar; 529 #ifndef MKSH_SMALL 530 } else if (c == '\'') { 531 ++cp; 532 cp += utf_ptradj(cp); 533 if (*cp++ != '\'') 534 evalerr(es, ET_STR, 535 "multi-character character constant"); 536 /* 'x' -> 1#x (x = one multibyte character) */ 537 c = cp - es->tokp; 538 tvar = alloc(c + /* NUL */ 1, ATEMP); 539 tvar[0] = '1'; 540 tvar[1] = '#'; 541 memcpy(tvar + 2, es->tokp + 1, c - 2); 542 tvar[c] = '\0'; 543 goto process_tvar; 544 #endif 545 } else if (ksh_isdigit(c)) { 546 while (c != '_' && (ksh_isalnux(c) || c == '#')) 547 c = *cp++; 548 strndupx(tvar, es->tokp, --cp - es->tokp, ATEMP); 549 process_tvar: 550 es->val = tempvar(); 551 es->val->flag &= ~INTEGER; 552 es->val->type = 0; 553 es->val->val.s = tvar; 554 if (setint_v(es->val, es->val, es->arith) == NULL) 555 evalerr(es, ET_BADLIT, tvar); 556 afree(tvar, ATEMP); 557 es->tok = LIT; 558 } else { 559 int i, n0; 560 561 for (i = 0; (n0 = opinfo[i].name[0]); i++) 562 if (c == n0 && strncmp(cp, opinfo[i].name, 563 (size_t)opinfo[i].len) == 0) { 564 es->tok = (enum token)i; 565 cp += opinfo[i].len; 566 break; 567 } 568 if (!n0) 569 es->tok = BAD; 570 } 571 es->tokp = cp; 572 } 573 574 /* Do a ++ or -- operation */ 575 static struct tbl * 576 do_ppmm(Expr_state *es, enum token op, struct tbl *vasn, bool is_prefix) 577 { 578 struct tbl *vl; 579 mksh_ari_t oval; 580 581 assign_check(es, op, vasn); 582 583 vl = intvar(es, vasn); 584 oval = vl->val.i; 585 if (op == O_PLUSPLUS) { 586 if (es->natural) 587 ++vl->val.u; 588 else 589 ++vl->val.i; 590 } else { 591 if (es->natural) 592 --vl->val.u; 593 else 594 --vl->val.i; 595 } 596 if (vasn->flag & INTEGER) 597 setint_v(vasn, vl, es->arith); 598 else 599 setint(vasn, vl->val.i); 600 if (!is_prefix) /* undo the inc/dec */ 601 vl->val.i = oval; 602 603 return (vl); 604 } 605 606 static void 607 assign_check(Expr_state *es, enum token op, struct tbl *vasn) 608 { 609 if (es->tok == END || 610 (vasn->name[0] == '\0' && !(vasn->flag & EXPRLVALUE))) 611 evalerr(es, ET_LVALUE, opinfo[(int)op].name); 612 else if (vasn->flag & RDONLY) 613 evalerr(es, ET_RDONLY, opinfo[(int)op].name); 614 } 615 616 static struct tbl * 617 tempvar(void) 618 { 619 struct tbl *vp; 620 621 vp = alloc(sizeof(struct tbl), ATEMP); 622 vp->flag = ISSET|INTEGER; 623 vp->type = 0; 624 vp->areap = ATEMP; 625 vp->ua.hval = 0; 626 vp->val.i = 0; 627 vp->name[0] = '\0'; 628 return (vp); 629 } 630 631 /* cast (string) variable to temporary integer variable */ 632 static struct tbl * 633 intvar(Expr_state *es, struct tbl *vp) 634 { 635 struct tbl *vq; 636 637 /* try to avoid replacing a temp var with another temp var */ 638 if (vp->name[0] == '\0' && 639 (vp->flag & (ISSET|INTEGER|EXPRLVALUE)) == (ISSET|INTEGER)) 640 return (vp); 641 642 vq = tempvar(); 643 if (setint_v(vq, vp, es->arith) == NULL) { 644 if (vp->flag & EXPRINEVAL) 645 evalerr(es, ET_RECURSIVE, vp->name); 646 es->evaling = vp; 647 vp->flag |= EXPRINEVAL; 648 v_evaluate(vq, str_val(vp), KSH_UNWIND_ERROR, es->arith); 649 vp->flag &= ~EXPRINEVAL; 650 es->evaling = NULL; 651 } 652 return (vq); 653 } 654 655 656 /* 657 * UTF-8 support code: high-level functions 658 */ 659 660 int 661 utf_widthadj(const char *src, const char **dst) 662 { 663 size_t len; 664 unsigned int wc; 665 int width; 666 667 if (!UTFMODE || (len = utf_mbtowc(&wc, src)) == (size_t)-1 || 668 wc == 0) 669 len = width = 1; 670 else if ((width = utf_wcwidth(wc)) < 0) 671 /* XXX use 2 for x_zotc3 here? */ 672 width = 1; 673 674 if (dst) 675 *dst = src + len; 676 return (width); 677 } 678 679 size_t 680 utf_mbswidth(const char *s) 681 { 682 size_t len, width = 0; 683 unsigned int wc; 684 int cw; 685 686 if (!UTFMODE) 687 return (strlen(s)); 688 689 while (*s) 690 if (((len = utf_mbtowc(&wc, s)) == (size_t)-1) || 691 ((cw = utf_wcwidth(wc)) == -1)) { 692 s++; 693 width += 1; 694 } else { 695 s += len; 696 width += cw; 697 } 698 return (width); 699 } 700 701 const char * 702 utf_skipcols(const char *p, int cols) 703 { 704 int c = 0; 705 706 while (c < cols) { 707 if (!*p) 708 return (p + cols - c); 709 c += utf_widthadj(p, &p); 710 } 711 return (p); 712 } 713 714 size_t 715 utf_ptradj(const char *src) 716 { 717 register size_t n; 718 719 if (!UTFMODE || 720 *(const unsigned char *)(src) < 0xC2 || 721 (n = utf_mbtowc(NULL, src)) == (size_t)-1) 722 n = 1; 723 return (n); 724 } 725 726 /* 727 * UTF-8 support code: low-level functions 728 */ 729 730 /* CESU-8 multibyte and wide character conversion crafted for mksh */ 731 732 size_t 733 utf_mbtowc(unsigned int *dst, const char *src) 734 { 735 const unsigned char *s = (const unsigned char *)src; 736 unsigned int c, wc; 737 738 if ((wc = *s++) < 0x80) { 739 out: 740 if (dst != NULL) 741 *dst = wc; 742 return (wc ? ((const char *)s - src) : 0); 743 } 744 if (wc < 0xC2 || wc >= 0xF0) 745 /* < 0xC0: spurious second byte */ 746 /* < 0xC2: non-minimalistic mapping error in 2-byte seqs */ 747 /* > 0xEF: beyond BMP */ 748 goto ilseq; 749 750 if (wc < 0xE0) { 751 wc = (wc & 0x1F) << 6; 752 if (((c = *s++) & 0xC0) != 0x80) 753 goto ilseq; 754 wc |= c & 0x3F; 755 goto out; 756 } 757 758 wc = (wc & 0x0F) << 12; 759 760 if (((c = *s++) & 0xC0) != 0x80) 761 goto ilseq; 762 wc |= (c & 0x3F) << 6; 763 764 if (((c = *s++) & 0xC0) != 0x80) 765 goto ilseq; 766 wc |= c & 0x3F; 767 768 /* Check for non-minimalistic mapping error in 3-byte seqs */ 769 if (wc >= 0x0800 && wc <= 0xFFFD) 770 goto out; 771 ilseq: 772 return ((size_t)(-1)); 773 } 774 775 size_t 776 utf_wctomb(char *dst, unsigned int wc) 777 { 778 unsigned char *d; 779 780 if (wc < 0x80) { 781 *dst = wc; 782 return (1); 783 } 784 785 d = (unsigned char *)dst; 786 if (wc < 0x0800) 787 *d++ = (wc >> 6) | 0xC0; 788 else { 789 *d++ = ((wc = wc > 0xFFFD ? 0xFFFD : wc) >> 12) | 0xE0; 790 *d++ = ((wc >> 6) & 0x3F) | 0x80; 791 } 792 *d++ = (wc & 0x3F) | 0x80; 793 return ((char *)d - dst); 794 } 795 796 797 #ifndef MKSH_mirbsd_wcwidth 798 /* --- begin of wcwidth.c excerpt --- */ 799 /*- 800 * Markus Kuhn -- 2007-05-26 (Unicode 5.0) 801 * 802 * Permission to use, copy, modify, and distribute this software 803 * for any purpose and without fee is hereby granted. The author 804 * disclaims all warranties with regard to this software. 805 */ 806 807 __RCSID("$miros: src/lib/libc/i18n/wcwidth.c,v 1.10 2010/12/11 16:05:03 tg Exp $"); 808 809 int 810 utf_wcwidth(unsigned int c) 811 { 812 static const struct cbset { 813 unsigned short first; 814 unsigned short last; 815 } comb[] = { 816 /* Unicode 6.0.0 BMP */ 817 { 0x0300, 0x036F }, { 0x0483, 0x0489 }, { 0x0591, 0x05BD }, 818 { 0x05BF, 0x05BF }, { 0x05C1, 0x05C2 }, { 0x05C4, 0x05C5 }, 819 { 0x05C7, 0x05C7 }, { 0x0600, 0x0603 }, { 0x0610, 0x061A }, 820 { 0x064B, 0x065F }, { 0x0670, 0x0670 }, { 0x06D6, 0x06DD }, 821 { 0x06DF, 0x06E4 }, { 0x06E7, 0x06E8 }, { 0x06EA, 0x06ED }, 822 { 0x070F, 0x070F }, { 0x0711, 0x0711 }, { 0x0730, 0x074A }, 823 { 0x07A6, 0x07B0 }, { 0x07EB, 0x07F3 }, { 0x0816, 0x0819 }, 824 { 0x081B, 0x0823 }, { 0x0825, 0x0827 }, { 0x0829, 0x082D }, 825 { 0x0859, 0x085B }, { 0x0900, 0x0902 }, { 0x093A, 0x093A }, 826 { 0x093C, 0x093C }, { 0x0941, 0x0948 }, { 0x094D, 0x094D }, 827 { 0x0951, 0x0957 }, { 0x0962, 0x0963 }, { 0x0981, 0x0981 }, 828 { 0x09BC, 0x09BC }, { 0x09C1, 0x09C4 }, { 0x09CD, 0x09CD }, 829 { 0x09E2, 0x09E3 }, { 0x0A01, 0x0A02 }, { 0x0A3C, 0x0A3C }, 830 { 0x0A41, 0x0A42 }, { 0x0A47, 0x0A48 }, { 0x0A4B, 0x0A4D }, 831 { 0x0A51, 0x0A51 }, { 0x0A70, 0x0A71 }, { 0x0A75, 0x0A75 }, 832 { 0x0A81, 0x0A82 }, { 0x0ABC, 0x0ABC }, { 0x0AC1, 0x0AC5 }, 833 { 0x0AC7, 0x0AC8 }, { 0x0ACD, 0x0ACD }, { 0x0AE2, 0x0AE3 }, 834 { 0x0B01, 0x0B01 }, { 0x0B3C, 0x0B3C }, { 0x0B3F, 0x0B3F }, 835 { 0x0B41, 0x0B44 }, { 0x0B4D, 0x0B4D }, { 0x0B56, 0x0B56 }, 836 { 0x0B62, 0x0B63 }, { 0x0B82, 0x0B82 }, { 0x0BC0, 0x0BC0 }, 837 { 0x0BCD, 0x0BCD }, { 0x0C3E, 0x0C40 }, { 0x0C46, 0x0C48 }, 838 { 0x0C4A, 0x0C4D }, { 0x0C55, 0x0C56 }, { 0x0C62, 0x0C63 }, 839 { 0x0CBC, 0x0CBC }, { 0x0CBF, 0x0CBF }, { 0x0CC6, 0x0CC6 }, 840 { 0x0CCC, 0x0CCD }, { 0x0CE2, 0x0CE3 }, { 0x0D41, 0x0D44 }, 841 { 0x0D4D, 0x0D4D }, { 0x0D62, 0x0D63 }, { 0x0DCA, 0x0DCA }, 842 { 0x0DD2, 0x0DD4 }, { 0x0DD6, 0x0DD6 }, { 0x0E31, 0x0E31 }, 843 { 0x0E34, 0x0E3A }, { 0x0E47, 0x0E4E }, { 0x0EB1, 0x0EB1 }, 844 { 0x0EB4, 0x0EB9 }, { 0x0EBB, 0x0EBC }, { 0x0EC8, 0x0ECD }, 845 { 0x0F18, 0x0F19 }, { 0x0F35, 0x0F35 }, { 0x0F37, 0x0F37 }, 846 { 0x0F39, 0x0F39 }, { 0x0F71, 0x0F7E }, { 0x0F80, 0x0F84 }, 847 { 0x0F86, 0x0F87 }, { 0x0F8D, 0x0F97 }, { 0x0F99, 0x0FBC }, 848 { 0x0FC6, 0x0FC6 }, { 0x102D, 0x1030 }, { 0x1032, 0x1037 }, 849 { 0x1039, 0x103A }, { 0x103D, 0x103E }, { 0x1058, 0x1059 }, 850 { 0x105E, 0x1060 }, { 0x1071, 0x1074 }, { 0x1082, 0x1082 }, 851 { 0x1085, 0x1086 }, { 0x108D, 0x108D }, { 0x109D, 0x109D }, 852 { 0x1160, 0x11FF }, { 0x135D, 0x135F }, { 0x1712, 0x1714 }, 853 { 0x1732, 0x1734 }, { 0x1752, 0x1753 }, { 0x1772, 0x1773 }, 854 { 0x17B4, 0x17B5 }, { 0x17B7, 0x17BD }, { 0x17C6, 0x17C6 }, 855 { 0x17C9, 0x17D3 }, { 0x17DD, 0x17DD }, { 0x180B, 0x180D }, 856 { 0x18A9, 0x18A9 }, { 0x1920, 0x1922 }, { 0x1927, 0x1928 }, 857 { 0x1932, 0x1932 }, { 0x1939, 0x193B }, { 0x1A17, 0x1A18 }, 858 { 0x1A56, 0x1A56 }, { 0x1A58, 0x1A5E }, { 0x1A60, 0x1A60 }, 859 { 0x1A62, 0x1A62 }, { 0x1A65, 0x1A6C }, { 0x1A73, 0x1A7C }, 860 { 0x1A7F, 0x1A7F }, { 0x1B00, 0x1B03 }, { 0x1B34, 0x1B34 }, 861 { 0x1B36, 0x1B3A }, { 0x1B3C, 0x1B3C }, { 0x1B42, 0x1B42 }, 862 { 0x1B6B, 0x1B73 }, { 0x1B80, 0x1B81 }, { 0x1BA2, 0x1BA5 }, 863 { 0x1BA8, 0x1BA9 }, { 0x1BE6, 0x1BE6 }, { 0x1BE8, 0x1BE9 }, 864 { 0x1BED, 0x1BED }, { 0x1BEF, 0x1BF1 }, { 0x1C2C, 0x1C33 }, 865 { 0x1C36, 0x1C37 }, { 0x1CD0, 0x1CD2 }, { 0x1CD4, 0x1CE0 }, 866 { 0x1CE2, 0x1CE8 }, { 0x1CED, 0x1CED }, { 0x1DC0, 0x1DE6 }, 867 { 0x1DFC, 0x1DFF }, { 0x200B, 0x200F }, { 0x202A, 0x202E }, 868 { 0x2060, 0x2064 }, { 0x206A, 0x206F }, { 0x20D0, 0x20F0 }, 869 { 0x2CEF, 0x2CF1 }, { 0x2D7F, 0x2D7F }, { 0x2DE0, 0x2DFF }, 870 { 0x302A, 0x302F }, { 0x3099, 0x309A }, { 0xA66F, 0xA672 }, 871 { 0xA67C, 0xA67D }, { 0xA6F0, 0xA6F1 }, { 0xA802, 0xA802 }, 872 { 0xA806, 0xA806 }, { 0xA80B, 0xA80B }, { 0xA825, 0xA826 }, 873 { 0xA8C4, 0xA8C4 }, { 0xA8E0, 0xA8F1 }, { 0xA926, 0xA92D }, 874 { 0xA947, 0xA951 }, { 0xA980, 0xA982 }, { 0xA9B3, 0xA9B3 }, 875 { 0xA9B6, 0xA9B9 }, { 0xA9BC, 0xA9BC }, { 0xAA29, 0xAA2E }, 876 { 0xAA31, 0xAA32 }, { 0xAA35, 0xAA36 }, { 0xAA43, 0xAA43 }, 877 { 0xAA4C, 0xAA4C }, { 0xAAB0, 0xAAB0 }, { 0xAAB2, 0xAAB4 }, 878 { 0xAAB7, 0xAAB8 }, { 0xAABE, 0xAABF }, { 0xAAC1, 0xAAC1 }, 879 { 0xABE5, 0xABE5 }, { 0xABE8, 0xABE8 }, { 0xABED, 0xABED }, 880 { 0xFB1E, 0xFB1E }, { 0xFE00, 0xFE0F }, { 0xFE20, 0xFE26 }, 881 { 0xFEFF, 0xFEFF }, { 0xFFF9, 0xFFFB } 882 }; 883 size_t min = 0, mid, max = NELEM(comb) - 1; 884 885 /* test for 8-bit control characters */ 886 if (c < 32 || (c >= 0x7F && c < 0xA0)) 887 return (c ? -1 : 0); 888 889 /* binary search in table of non-spacing characters */ 890 if (c >= comb[0].first && c <= comb[max].last) 891 while (max >= min) { 892 mid = (min + max) / 2; 893 if (c > comb[mid].last) 894 min = mid + 1; 895 else if (c < comb[mid].first) 896 max = mid - 1; 897 else 898 return (0); 899 } 900 901 /* if we arrive here, c is not a combining or C0/C1 control char */ 902 903 return ((c >= 0x1100 && ( 904 c <= 0x115F || /* Hangul Jamo init. consonants */ 905 c == 0x2329 || c == 0x232A || 906 (c >= 0x2E80 && c <= 0xA4CF && c != 0x303F) || /* CJK ... Yi */ 907 (c >= 0xAC00 && c <= 0xD7A3) || /* Hangul Syllables */ 908 (c >= 0xF900 && c <= 0xFAFF) || /* CJK Compatibility Ideographs */ 909 (c >= 0xFE10 && c <= 0xFE19) || /* Vertical forms */ 910 (c >= 0xFE30 && c <= 0xFE6F) || /* CJK Compatibility Forms */ 911 (c >= 0xFF00 && c <= 0xFF60) || /* Fullwidth Forms */ 912 (c >= 0xFFE0 && c <= 0xFFE6))) ? 2 : 1); 913 } 914 /* --- end of wcwidth.c excerpt --- */ 915 #endif 916 917 /* 918 * Wrapper around access(2) because it says root can execute everything 919 * on some operating systems. Does not set errno, no user needs it. Use 920 * this iff mode can have the X_OK bit set, access otherwise. 921 */ 922 int 923 ksh_access(const char *fn, int mode) 924 { 925 int rv; 926 struct stat sb; 927 928 if ((rv = access(fn, mode)) == 0 && kshuid == 0 && (mode & X_OK) && 929 (rv = stat(fn, &sb)) == 0 && !S_ISDIR(sb.st_mode) && 930 (sb.st_mode & (S_IXUSR|S_IXGRP|S_IXOTH)) == 0) 931 rv = -1; 932 933 return (rv); 934 } 935
