Vendor branch: Update dialog 1.2-20121230 => 1.2-20150920
[dragonfly.git] / contrib / dialog / inputstr.c
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 */