1 /* 2 * $Id: inputstr.c,v 1.84 2014/09/01 16:11:08 tom Exp $ 3 * 4 * inputstr.c -- functions for input/display of a string 5 * 6 * Copyright 2000-2013,2014 Thomas E. Dickey 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU Lesser General Public License, version 2.1 10 * as published by the Free Software Foundation. 11 * 12 * This program is distributed in the hope that it will be useful, but 13 * WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 * Lesser General Public License for more details. 16 * 17 * You should have received a copy of the GNU Lesser General Public 18 * License along with this program; if not, write to 19 * Free Software Foundation, Inc. 20 * 51 Franklin St., Fifth Floor 21 * Boston, MA 02110, USA. 22 */ 23 24 #include <dialog.h> 25 #include <dlg_keys.h> 26 27 #include <errno.h> 28 29 #ifdef HAVE_SETLOCALE 30 #include <locale.h> 31 #endif 32 33 #if defined(HAVE_SEARCH_H) && defined(HAVE_TSEARCH) 34 #include <search.h> 35 #else 36 #undef HAVE_TSEARCH 37 #endif 38 39 #ifdef NEED_WCHAR_H 40 #include <wchar.h> 41 #endif 42 43 #if defined(USE_WIDE_CURSES) 44 #define USE_CACHING 1 45 #elif defined(HAVE_XDIALOG) 46 #define USE_CACHING 1 /* editbox really needs caching! */ 47 #else 48 #define USE_CACHING 0 49 #endif 50 51 typedef struct _cache { 52 struct _cache *next; 53 #if USE_CACHING 54 int cache_num; /* tells what type of data is in list[] */ 55 const char *string_at; /* unique: associate caches by char* */ 56 #endif 57 size_t s_len; /* strlen(string) - we add 1 for EOS */ 58 size_t i_len; /* length(list) - we add 1 for EOS */ 59 char *string; /* a copy of the last-processed string */ 60 int *list; /* indices into the string */ 61 } CACHE; 62 63 #if USE_CACHING 64 #define SAME_CACHE(c,s,l) (c->string != 0 && memcmp(c->string,s,l) == 0) 65 66 static CACHE *cache_list; 67 68 typedef enum { 69 cInxCols 70 ,cCntWideBytes 71 ,cCntWideChars 72 ,cInxWideChars 73 ,cMAX 74 } CACHE_USED; 75 76 #ifdef HAVE_TSEARCH 77 static void *sorted_cache; 78 #endif 79 80 #ifdef USE_WIDE_CURSES 81 static int 82 have_locale(void) 83 { 84 static int result = -1; 85 if (result < 0) { 86 char *test = setlocale(LC_ALL, 0); 87 if (test == 0 || *test == 0) { 88 result = FALSE; 89 } else if (strcmp(test, "C") && strcmp(test, "POSIX")) { 90 result = TRUE; 91 } else { 92 result = FALSE; 93 } 94 } 95 return result; 96 } 97 #endif 98 99 #ifdef HAVE_TSEARCH 100 101 #if 0 102 static void 103 show_tsearch(const void *nodep, const VISIT which, const int depth) 104 { 105 const CACHE *p = *(CACHE * const *) nodep; 106 (void) depth; 107 if (which == postorder || which == leaf) { 108 dlg_trace_msg("\tcache %p %p:%s\n", p, p->string, p->string); 109 } 110 } 111 112 static void 113 trace_cache(const char *fn, int ln) 114 { 115 dlg_trace_msg("trace_cache %s@%d\n", fn, ln); 116 twalk(sorted_cache, show_tsearch); 117 } 118 119 #else 120 #define trace_cache(fn, ln) /* nothing */ 121 #endif 122 123 #define CMP(a,b) (((a) > (b)) ? 1 : (((a) < (b)) ? -1 : 0)) 124 125 static int 126 compare_cache(const void *a, const void *b) 127 { 128 const CACHE *p = (const CACHE *) a; 129 const CACHE *q = (const CACHE *) b; 130 int result = CMP(p->cache_num, q->cache_num); 131 if (result == 0) 132 result = CMP(p->string_at, q->string_at); 133 return result; 134 } 135 #endif 136 137 static CACHE * 138 find_cache(int cache_num, const char *string) 139 { 140 CACHE *p; 141 142 #ifdef HAVE_TSEARCH 143 void *pp; 144 CACHE find; 145 146 memset(&find, 0, sizeof(find)); 147 find.cache_num = cache_num; 148 find.string_at = string; 149 150 if ((pp = tfind(&find, &sorted_cache, compare_cache)) != 0) { 151 p = *(CACHE **) pp; 152 } else { 153 p = 0; 154 } 155 #else 156 for (p = cache_list; p != 0; p = p->next) { 157 if (p->string_at == string) { 158 break; 159 } 160 } 161 #endif 162 return p; 163 } 164 165 static CACHE * 166 make_cache(int cache_num, const char *string) 167 { 168 CACHE *p; 169 170 p = dlg_calloc(CACHE, 1); 171 assert_ptr(p, "load_cache"); 172 p->next = cache_list; 173 cache_list = p; 174 175 p->cache_num = cache_num; 176 p->string_at = string; 177 178 #ifdef HAVE_TSEARCH 179 (void) tsearch(p, &sorted_cache, compare_cache); 180 #endif 181 return p; 182 } 183 184 static CACHE * 185 load_cache(int cache_num, const char *string) 186 { 187 CACHE *p; 188 189 if ((p = find_cache(cache_num, string)) == 0) { 190 p = make_cache(cache_num, string); 191 } 192 return p; 193 } 194 #else 195 static CACHE my_cache; 196 #define SAME_CACHE(c,s,l) (c->string != 0) 197 #define load_cache(cache, string) &my_cache 198 #endif /* USE_CACHING */ 199 200 /* 201 * If the given string has not changed, we do not need to update the index. 202 * If we need to update the index, allocate enough memory for it. 203 */ 204 static bool 205 same_cache2(CACHE * cache, const char *string, unsigned i_len) 206 { 207 unsigned need; 208 size_t s_len = strlen(string); 209 bool result = TRUE; 210 211 if (cache->s_len == 0 212 || cache->s_len < s_len 213 || cache->list == 0 214 || !SAME_CACHE(cache, string, (size_t) s_len)) { 215 216 need = (i_len + 1); 217 if (cache->list == 0) { 218 cache->list = dlg_malloc(int, need); 219 } else if (cache->i_len < i_len) { 220 cache->list = dlg_realloc(int, need, cache->list); 221 } 222 assert_ptr(cache->list, "load_cache"); 223 cache->i_len = i_len; 224 225 if (cache->s_len >= s_len && cache->string != 0) { 226 strcpy(cache->string, string); 227 } else { 228 if (cache->string != 0) 229 free(cache->string); 230 cache->string = dlg_strclone(string); 231 } 232 cache->s_len = s_len; 233 234 result = FALSE; 235 } 236 return result; 237 } 238 239 #ifdef USE_WIDE_CURSES 240 /* 241 * Like same_cache2(), but we are only concerned about caching a copy of the 242 * string and its associated length. 243 */ 244 static bool 245 same_cache1(CACHE * cache, const char *string, size_t i_len) 246 { 247 size_t s_len = strlen(string); 248 bool result = TRUE; 249 250 if (cache->s_len != s_len 251 || !SAME_CACHE(cache, string, (size_t) s_len)) { 252 253 if (cache->s_len >= s_len && cache->string != 0) { 254 strcpy(cache->string, string); 255 } else { 256 if (cache->string != 0) 257 free(cache->string); 258 cache->string = dlg_strclone(string); 259 } 260 cache->s_len = s_len; 261 cache->i_len = i_len; 262 263 result = FALSE; 264 } 265 return result; 266 } 267 #endif /* USE_CACHING */ 268 269 /* 270 * Counts the number of bytes that make up complete wide-characters, up to byte 271 * 'len'. If there is no locale set, simply return the original length. 272 */ 273 #ifdef USE_WIDE_CURSES 274 static int 275 dlg_count_wcbytes(const char *string, size_t len) 276 { 277 int result; 278 279 if (have_locale()) { 280 CACHE *cache = load_cache(cCntWideBytes, string); 281 if (!same_cache1(cache, string, len)) { 282 while (len != 0) { 283 size_t code = 0; 284 const char *src = cache->string; 285 mbstate_t state; 286 char save = cache->string[len]; 287 288 cache->string[len] = '\0'; 289 memset(&state, 0, sizeof(state)); 290 code = mbsrtowcs((wchar_t *) 0, &src, len, &state); 291 cache->string[len] = save; 292 if ((int) code >= 0) { 293 break; 294 } 295 --len; 296 } 297 cache->i_len = len; 298 } 299 result = (int) cache->i_len; 300 } else { 301 result = (int) len; 302 } 303 return result; 304 } 305 #endif /* USE_WIDE_CURSES */ 306 307 /* 308 * Counts the number of wide-characters in the string. 309 */ 310 int 311 dlg_count_wchars(const char *string) 312 { 313 int result; 314 #ifdef USE_WIDE_CURSES 315 316 if (have_locale()) { 317 size_t len = strlen(string); 318 CACHE *cache = load_cache(cCntWideChars, string); 319 320 if (!same_cache1(cache, string, len)) { 321 const char *src = cache->string; 322 mbstate_t state; 323 int part = dlg_count_wcbytes(cache->string, len); 324 char save = cache->string[part]; 325 size_t code; 326 wchar_t *temp = dlg_calloc(wchar_t, len + 1); 327 328 if (temp != 0) { 329 cache->string[part] = '\0'; 330 memset(&state, 0, sizeof(state)); 331 code = mbsrtowcs(temp, &src, (size_t) part, &state); 332 cache->i_len = ((int) code >= 0) ? wcslen(temp) : 0; 333 cache->string[part] = save; 334 free(temp); 335 } else { 336 cache->i_len = 0; 337 } 338 } 339 result = (int) cache->i_len; 340 } else 341 #endif /* USE_WIDE_CURSES */ 342 { 343 result = (int) strlen(string); 344 } 345 return result; 346 } 347 348 /* 349 * Build an index of the wide-characters in the string, so we can easily tell 350 * which byte-offset begins a given wide-character. 351 */ 352 const int * 353 dlg_index_wchars(const char *string) 354 { 355 unsigned len = (unsigned) dlg_count_wchars(string); 356 unsigned inx; 357 CACHE *cache = load_cache(cInxWideChars, string); 358 359 if (!same_cache2(cache, string, len)) { 360 const char *current = string; 361 362 cache->list[0] = 0; 363 for (inx = 1; inx <= len; ++inx) { 364 #ifdef USE_WIDE_CURSES 365 if (have_locale()) { 366 mbstate_t state; 367 int width; 368 memset(&state, 0, sizeof(state)); 369 width = (int) mbrlen(current, strlen(current), &state); 370 if (width <= 0) 371 width = 1; /* FIXME: what if we have a control-char? */ 372 current += width; 373 cache->list[inx] = cache->list[inx - 1] + width; 374 } else 375 #endif /* USE_WIDE_CURSES */ 376 { 377 (void) current; 378 cache->list[inx] = (int) inx; 379 } 380 } 381 } 382 return cache->list; 383 } 384 385 /* 386 * Given the character-offset to find in the list, return the corresponding 387 * array index. 388 */ 389 int 390 dlg_find_index(const int *list, int limit, int to_find) 391 { 392 int result; 393 for (result = 0; result <= limit; ++result) { 394 if (to_find == list[result] 395 || result == limit 396 || ((result < limit) && (to_find < list[result + 1]))) { 397 break; 398 } 399 } 400 return result; 401 } 402 403 /* 404 * Build a list of the display-columns for the given string's characters. 405 */ 406 const int * 407 dlg_index_columns(const char *string) 408 { 409 unsigned len = (unsigned) dlg_count_wchars(string); 410 unsigned inx; 411 CACHE *cache = load_cache(cInxCols, string); 412 413 if (!same_cache2(cache, string, len)) { 414 cache->list[0] = 0; 415 #ifdef USE_WIDE_CURSES 416 if (have_locale()) { 417 size_t num_bytes = strlen(string); 418 const int *inx_wchars = dlg_index_wchars(string); 419 mbstate_t state; 420 421 for (inx = 0; inx < len; ++inx) { 422 wchar_t temp[2]; 423 size_t check; 424 int result; 425 426 if (string[inx_wchars[inx]] == TAB) { 427 result = ((cache->list[inx] | 7) + 1) - cache->list[inx]; 428 } else { 429 memset(&state, 0, sizeof(state)); 430 memset(temp, 0, sizeof(temp)); 431 check = mbrtowc(temp, 432 string + inx_wchars[inx], 433 num_bytes - (size_t) inx_wchars[inx], 434 &state); 435 if ((int) check <= 0) { 436 result = 1; 437 } else { 438 result = wcwidth(temp[0]); 439 } 440 if (result < 0) { 441 const wchar_t *printable; 442 cchar_t temp2, *temp2p = &temp2; 443 setcchar(temp2p, temp, 0, 0, 0); 444 printable = wunctrl(temp2p); 445 result = printable ? (int) wcslen(printable) : 1; 446 } 447 } 448 cache->list[inx + 1] = result; 449 if (inx != 0) 450 cache->list[inx + 1] += cache->list[inx]; 451 } 452 } else 453 #endif /* USE_WIDE_CURSES */ 454 { 455 for (inx = 0; inx < len; ++inx) { 456 chtype ch = UCH(string[inx]); 457 458 if (ch == TAB) 459 cache->list[inx + 1] = 460 ((cache->list[inx] | 7) + 1) - cache->list[inx]; 461 else if (isprint(ch)) 462 cache->list[inx + 1] = 1; 463 else { 464 const char *printable; 465 printable = unctrl(ch); 466 cache->list[inx + 1] = (printable 467 ? (int) strlen(printable) 468 : 1); 469 } 470 if (inx != 0) 471 cache->list[inx + 1] += cache->list[inx]; 472 } 473 } 474 } 475 return cache->list; 476 } 477 478 /* 479 * Returns the number of columns used for a string. That happens to be the 480 * end-value of the cols[] array. 481 */ 482 int 483 dlg_count_columns(const char *string) 484 { 485 int result = 0; 486 int limit = dlg_count_wchars(string); 487 if (limit > 0) { 488 const int *cols = dlg_index_columns(string); 489 result = cols[limit]; 490 } else { 491 result = (int) strlen(string); 492 } 493 dlg_finish_string(string); 494 return result; 495 } 496 497 /* 498 * Given a column limit, count the number of wide characters that can fit 499 * into that limit. The offset is used to skip over a leading character 500 * that was already written. 501 */ 502 int 503 dlg_limit_columns(const char *string, int limit, int offset) 504 { 505 const int *cols = dlg_index_columns(string); 506 int result = dlg_count_wchars(string); 507 508 while (result > 0 && (cols[result] - cols[offset]) > limit) 509 --result; 510 return result; 511 } 512 513 /* 514 * Updates the string and character-offset, given various editing characters 515 * or literal characters which are inserted at the character-offset. 516 */ 517 bool 518 dlg_edit_string(char *string, int *chr_offset, int key, int fkey, bool force) 519 { 520 int i; 521 int len = (int) strlen(string); 522 int limit = dlg_count_wchars(string); 523 const int *indx = dlg_index_wchars(string); 524 int offset = dlg_find_index(indx, limit, *chr_offset); 525 int max_len = dlg_max_input(MAX_LEN); 526 bool edit = TRUE; 527 528 /* transform editing characters into equivalent function-keys */ 529 if (!fkey) { 530 fkey = TRUE; /* assume we transform */ 531 switch (key) { 532 case 0: 533 break; 534 case ESC: 535 case TAB: 536 fkey = FALSE; /* this is used for navigation */ 537 break; 538 default: 539 fkey = FALSE; /* ...no, we did not transform */ 540 break; 541 } 542 } 543 544 if (fkey) { 545 switch (key) { 546 case 0: /* special case for loop entry */ 547 edit = force; 548 break; 549 case DLGK_GRID_LEFT: 550 if (*chr_offset && offset > 0) 551 *chr_offset = indx[offset - 1]; 552 break; 553 case DLGK_GRID_RIGHT: 554 if (offset < limit) 555 *chr_offset = indx[offset + 1]; 556 break; 557 case DLGK_BEGIN: 558 if (*chr_offset) 559 *chr_offset = 0; 560 break; 561 case DLGK_FINAL: 562 if (offset < limit) 563 *chr_offset = indx[limit]; 564 break; 565 case DLGK_DELETE_LEFT: 566 if (offset) { 567 int gap = indx[offset] - indx[offset - 1]; 568 *chr_offset = indx[offset - 1]; 569 if (gap > 0) { 570 for (i = *chr_offset; 571 (string[i] = string[i + gap]) != '\0'; 572 i++) { 573 ; 574 } 575 } 576 } 577 break; 578 case DLGK_DELETE_RIGHT: 579 if (limit) { 580 if (--limit == 0) { 581 string[*chr_offset = 0] = '\0'; 582 } else { 583 int gap = ((offset <= limit) 584 ? (indx[offset + 1] - indx[offset]) 585 : 0); 586 if (gap > 0) { 587 for (i = indx[offset]; 588 (string[i] = string[i + gap]) != '\0'; 589 i++) { 590 ; 591 } 592 } else if (offset > 0) { 593 string[indx[offset - 1]] = '\0'; 594 } 595 if (*chr_offset > indx[limit]) 596 *chr_offset = indx[limit]; 597 } 598 } 599 break; 600 case DLGK_DELETE_ALL: 601 string[*chr_offset = 0] = '\0'; 602 break; 603 case DLGK_ENTER: 604 edit = 0; 605 break; 606 #ifdef KEY_RESIZE 607 case KEY_RESIZE: 608 edit = 0; 609 break; 610 #endif 611 case DLGK_GRID_UP: 612 case DLGK_GRID_DOWN: 613 case DLGK_FIELD_NEXT: 614 case DLGK_FIELD_PREV: 615 edit = 0; 616 break; 617 case ERR: 618 edit = 0; 619 break; 620 default: 621 beep(); 622 break; 623 } 624 } else { 625 if (key == ESC || key == ERR) { 626 edit = 0; 627 } else { 628 if (len < max_len) { 629 for (i = ++len; i > *chr_offset; i--) 630 string[i] = string[i - 1]; 631 string[*chr_offset] = (char) key; 632 *chr_offset += 1; 633 } else { 634 (void) beep(); 635 } 636 } 637 } 638 return edit; 639 } 640 641 static void 642 compute_edit_offset(const char *string, 643 int chr_offset, 644 int x_last, 645 int *p_dpy_column, 646 int *p_scroll_amt) 647 { 648 const int *cols = dlg_index_columns(string); 649 const int *indx = dlg_index_wchars(string); 650 int limit = dlg_count_wchars(string); 651 int offset = dlg_find_index(indx, limit, chr_offset); 652 int offset2; 653 int dpy_column; 654 int n; 655 656 for (n = offset2 = 0; n <= offset; ++n) { 657 if ((cols[offset] - cols[n]) < x_last 658 && (offset == limit || (cols[offset + 1] - cols[n]) < x_last)) { 659 offset2 = n; 660 break; 661 } 662 } 663 664 dpy_column = cols[offset] - cols[offset2]; 665 666 if (p_dpy_column != 0) 667 *p_dpy_column = dpy_column; 668 if (p_scroll_amt != 0) 669 *p_scroll_amt = offset2; 670 } 671 672 /* 673 * Given the character-offset in the string, returns the display-offset where 674 * we will position the cursor. 675 */ 676 int 677 dlg_edit_offset(char *string, int chr_offset, int x_last) 678 { 679 int result; 680 681 compute_edit_offset(string, chr_offset, x_last, &result, 0); 682 683 return result; 684 } 685 686 /* 687 * Displays the string, shifted as necessary, to fit within the box and show 688 * the current character-offset. 689 */ 690 void 691 dlg_show_string(WINDOW *win, 692 const char *string, /* string to display (may be multibyte) */ 693 int chr_offset, /* character (not bytes) offset */ 694 chtype attr, /* window-attributes */ 695 int y_base, /* beginning row on screen */ 696 int x_base, /* beginning column on screen */ 697 int x_last, /* number of columns on screen */ 698 bool hidden, /* if true, do not echo */ 699 bool force) /* if true, force repaint */ 700 { 701 x_last = MIN(x_last + x_base, getmaxx(win)) - x_base; 702 703 if (hidden && !dialog_vars.insecure) { 704 if (force) { 705 (void) wmove(win, y_base, x_base); 706 wrefresh(win); 707 } 708 } else { 709 const int *cols = dlg_index_columns(string); 710 const int *indx = dlg_index_wchars(string); 711 int limit = dlg_count_wchars(string); 712 713 int i, j, k; 714 int input_x; 715 int scrollamt; 716 717 compute_edit_offset(string, chr_offset, x_last, &input_x, &scrollamt); 718 719 (void) wattrset(win, attr); 720 (void) wmove(win, y_base, x_base); 721 for (i = scrollamt, k = 0; i < limit && k < x_last; ++i) { 722 int check = cols[i + 1] - cols[scrollamt]; 723 if (check <= x_last) { 724 for (j = indx[i]; j < indx[i + 1]; ++j) { 725 chtype ch = UCH(string[j]); 726 if (hidden && dialog_vars.insecure) { 727 waddch(win, '*'); 728 } else if (ch == TAB) { 729 int count = cols[i + 1] - cols[i]; 730 while (--count >= 0) 731 waddch(win, ' '); 732 } else { 733 waddch(win, ch); 734 } 735 } 736 k = check; 737 } else { 738 break; 739 } 740 } 741 while (k++ < x_last) 742 waddch(win, ' '); 743 (void) wmove(win, y_base, x_base + input_x); 744 wrefresh(win); 745 } 746 } 747 748 /* 749 * Discard cached data for the given string. 750 */ 751 void 752 dlg_finish_string(const char *string) 753 { 754 #if USE_CACHING 755 if ((string != 0) && dialog_state.finish_string) { 756 CACHE *p = cache_list; 757 CACHE *q = 0; 758 CACHE *r; 759 760 while (p != 0) { 761 if (p->string_at == string) { 762 #ifdef HAVE_TSEARCH 763 if (tdelete(p, &sorted_cache, compare_cache) == 0) { 764 continue; 765 } 766 trace_cache(__FILE__, __LINE__); 767 #endif 768 if (p->string != 0) 769 free(p->string); 770 if (p->list != 0) 771 free(p->list); 772 if (p == cache_list) { 773 cache_list = p->next; 774 r = cache_list; 775 } else { 776 q->next = p->next; 777 r = q; 778 } 779 free(p); 780 p = r; 781 } else { 782 q = p; 783 p = p->next; 784 } 785 } 786 } 787 #else 788 (void) string; 789 #endif 790 } 791 792 #ifdef NO_LEAKS 793 void 794 _dlg_inputstr_leaks(void) 795 { 796 #if USE_CACHING 797 dialog_state.finish_string = TRUE; 798 trace_cache(__FILE__, __LINE__); 799 while (cache_list != 0) { 800 dlg_finish_string(cache_list->string_at); 801 } 802 #endif /* USE_CACHING */ 803 } 804 #endif /* NO_LEAKS */ 805