contrib/dialog/inputstr.c

   1 /*
   2  *  $Id: inputstr.c,v 1.90 2019/07/24 23:42:20 tom Exp $
   3  *
   4  *  inputstr.c -- functions for input/display of a string
   5  *
   6  *  Copyright 2000-2018,2019    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(("# cache %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(("# 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     size_t s_len = strlen(string);
 208     bool result = TRUE;
 209
 210     if (cache->s_len == 0
 211         || cache->s_len < s_len
 212         || cache->list == 0
 213         || !SAME_CACHE(cache, string, (size_t) s_len)) {
 214         unsigned need = (i_len + 1);
 215
 216         if (cache->list == 0) {
 217             cache->list = dlg_malloc(int, need);
 218         } else if (cache->i_len < i_len) {
 219             cache->list = dlg_realloc(int, need, cache->list);
 220         }
 221         assert_ptr(cache->list, "load_cache");
 222         cache->i_len = i_len;
 223
 224         if (cache->s_len >= s_len && cache->string != 0) {
 225             strcpy(cache->string, string);
 226         } else {
 227             if (cache->string != 0)
 228                 free(cache->string);
 229             cache->string = dlg_strclone(string);
 230         }
 231         cache->s_len = s_len;
 232
 233         result = FALSE;
 234     }
 235     return result;
 236 }
 237
 238 #ifdef USE_WIDE_CURSES
 239 /*
 240  * Like same_cache2(), but we are only concerned about caching a copy of the
 241  * string and its associated length.
 242  */
 243 static bool
 244 same_cache1(CACHE * cache, const char *string, size_t i_len)
 245 {
 246     size_t s_len = strlen(string);
 247     bool result = TRUE;
 248
 249     if (cache->s_len != s_len
 250         || !SAME_CACHE(cache, string, (size_t) s_len)) {
 251
 252         if (cache->s_len >= s_len && cache->string != 0) {
 253             strcpy(cache->string, string);
 254         } else {
 255             if (cache->string != 0)
 256                 free(cache->string);
 257             cache->string = dlg_strclone(string);
 258         }
 259         cache->s_len = s_len;
 260         cache->i_len = i_len;
 261
 262         result = FALSE;
 263     }
 264     return result;
 265 }
 266 #endif /* USE_CACHING */
 267
 268 /*
 269  * Counts the number of bytes that make up complete wide-characters, up to byte
 270  * 'len'.  If there is no locale set, simply return the original length.
 271  */
 272 #ifdef USE_WIDE_CURSES
 273 static int
 274 dlg_count_wcbytes(const char *string, size_t len)
 275 {
 276     int result;
 277
 278     if (have_locale()) {
 279         CACHE *cache = load_cache(cCntWideBytes, string);
 280         if (!same_cache1(cache, string, len)) {
 281             while (len != 0) {
 282                 size_t code = 0;
 283                 const char *src = cache->string;
 284                 mbstate_t state;
 285                 char save = cache->string[len];
 286
 287                 cache->string[len] = '\0';
 288                 memset(&state, 0, sizeof(state));
 289                 code = mbsrtowcs((wchar_t *) 0, &src, len, &state);
 290                 cache->string[len] = save;
 291                 if ((int) code >= 0) {
 292                     break;
 293                 }
 294                 --len;
 295             }
 296             cache->i_len = len;
 297         }
 298         result = (int) cache->i_len;
 299     } else {
 300         result = (int) len;
 301     }
 302     return result;
 303 }
 304 #endif /* USE_WIDE_CURSES */
 305
 306 /*
 307  * Counts the number of wide-characters in the string.
 308  */
 309 int
 310 dlg_count_wchars(const char *string)
 311 {
 312     int result;
 313 #ifdef USE_WIDE_CURSES
 314
 315     if (have_locale()) {
 316         size_t len = strlen(string);
 317         CACHE *cache = load_cache(cCntWideChars, string);
 318
 319         if (!same_cache1(cache, string, len)) {
 320             const char *src = cache->string;
 321             mbstate_t state;
 322             int part = dlg_count_wcbytes(cache->string, len);
 323             char save = cache->string[part];
 324             wchar_t *temp = dlg_calloc(wchar_t, len + 1);
 325
 326             if (temp != 0) {
 327                 size_t code;
 328
 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     CACHE *cache = load_cache(cInxWideChars, string);
 357
 358     if (!same_cache2(cache, string, len)) {
 359         const char *current = string;
 360         unsigned inx;
 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     CACHE *cache = load_cache(cInxCols, string);
 411
 412     if (!same_cache2(cache, string, len)) {
 413         unsigned inx;
 414
 415         cache->list[0] = 0;
 416 #ifdef USE_WIDE_CURSES
 417         if (have_locale()) {
 418             size_t num_bytes = strlen(string);
 419             const int *inx_wchars = dlg_index_wchars(string);
 420             mbstate_t state;
 421
 422             for (inx = 0; inx < len; ++inx) {
 423                 int result;
 424
 425                 if (string[inx_wchars[inx]] == TAB) {
 426                     result = ((cache->list[inx] | 7) + 1) - cache->list[inx];
 427                 } else {
 428                     wchar_t temp[2];
 429                     size_t check;
 430
 431                     memset(&state, 0, sizeof(state));
 432                     memset(temp, 0, sizeof(temp));
 433                     check = mbrtowc(temp,
 434                                     string + inx_wchars[inx],
 435                                     num_bytes - (size_t) inx_wchars[inx],
 436                                     &state);
 437                     if ((int) check <= 0) {
 438                         result = 1;
 439                     } else {
 440                         result = wcwidth(temp[0]);
 441                     }
 442                     if (result < 0) {
 443                         const wchar_t *printable;
 444                         cchar_t temp2, *temp2p = &temp2;
 445                         setcchar(temp2p, temp, 0, 0, 0);
 446                         printable = wunctrl(temp2p);
 447                         result = printable ? (int) wcslen(printable) : 1;
 448                     }
 449                 }
 450                 cache->list[inx + 1] = result;
 451                 if (inx != 0)
 452                     cache->list[inx + 1] += cache->list[inx];
 453             }
 454         } else
 455 #endif /* USE_WIDE_CURSES */
 456         {
 457             for (inx = 0; inx < len; ++inx) {
 458                 chtype ch = UCH(string[inx]);
 459
 460                 if (ch == TAB)
 461                     cache->list[inx + 1] =
 462                         ((cache->list[inx] | 7) + 1) - cache->list[inx];
 463                 else if (isprint(UCH(ch)))
 464                     cache->list[inx + 1] = 1;
 465                 else {
 466                     const char *printable;
 467                     printable = unctrl(ch);
 468                     cache->list[inx + 1] = (printable
 469                                             ? (int) strlen(printable)
 470                                             : 1);
 471                 }
 472                 if (inx != 0)
 473                     cache->list[inx + 1] += cache->list[inx];
 474             }
 475         }
 476     }
 477     return cache->list;
 478 }
 479
 480 /*
 481  * Returns the number of columns used for a string.  That happens to be the
 482  * end-value of the cols[] array.
 483  */
 484 int
 485 dlg_count_columns(const char *string)
 486 {
 487     int result = 0;
 488     int limit = dlg_count_wchars(string);
 489     if (limit > 0) {
 490         const int *cols = dlg_index_columns(string);
 491         result = cols[limit];
 492     } else {
 493         result = (int) strlen(string);
 494     }
 495     dlg_finish_string(string);
 496     return result;
 497 }
 498
 499 /*
 500  * Given a column limit, count the number of wide characters that can fit
 501  * into that limit.  The offset is used to skip over a leading character
 502  * that was already written.
 503  */
 504 int
 505 dlg_limit_columns(const char *string, int limit, int offset)
 506 {
 507     const int *cols = dlg_index_columns(string);
 508     int result = dlg_count_wchars(string);
 509
 510     while (result > 0 && (cols[result] - cols[offset]) > limit)
 511         --result;
 512     return result;
 513 }
 514
 515 /*
 516  * Updates the string and character-offset, given various editing characters
 517  * or literal characters which are inserted at the character-offset.
 518  */
 519 bool
 520 dlg_edit_string(char *string, int *chr_offset, int key, int fkey, bool force)
 521 {
 522     int i;
 523     int len = (int) strlen(string);
 524     int limit = dlg_count_wchars(string);
 525     const int *indx = dlg_index_wchars(string);
 526     int offset = dlg_find_index(indx, limit, *chr_offset);
 527     int max_len = dlg_max_input(MAX_LEN);
 528     bool edit = TRUE;
 529
 530     /* transform editing characters into equivalent function-keys */
 531     if (!fkey) {
 532         fkey = TRUE;            /* assume we transform */
 533         switch (key) {
 534         case 0:
 535             break;
 536         case ESC:
 537         case TAB:
 538             fkey = FALSE;       /* this is used for navigation */
 539             break;
 540         default:
 541             fkey = FALSE;       /* ...no, we did not transform */
 542             break;
 543         }
 544     }
 545
 546     if (fkey) {
 547         switch (key) {
 548         case 0:         /* special case for loop entry */
 549             edit = force;
 550             break;
 551         case DLGK_GRID_LEFT:
 552             if (*chr_offset && offset > 0)
 553                 *chr_offset = indx[offset - 1];
 554             break;
 555         case DLGK_GRID_RIGHT:
 556             if (offset < limit)
 557                 *chr_offset = indx[offset + 1];
 558             break;
 559         case DLGK_BEGIN:
 560             if (*chr_offset)
 561                 *chr_offset = 0;
 562             break;
 563         case DLGK_FINAL:
 564             if (offset < limit)
 565                 *chr_offset = indx[limit];
 566             break;
 567         case DLGK_DELETE_LEFT:
 568             if (offset) {
 569                 int gap = indx[offset] - indx[offset - 1];
 570                 *chr_offset = indx[offset - 1];
 571                 if (gap > 0) {
 572                     for (i = *chr_offset;
 573                          (string[i] = string[i + gap]) != '\0';
 574                          i++) {
 575                         ;
 576                     }
 577                 }
 578             }
 579             break;
 580         case DLGK_DELETE_RIGHT:
 581             if (limit) {
 582                 if (--limit == 0) {
 583                     string[*chr_offset = 0] = '\0';
 584                 } else {
 585                     int gap = ((offset <= limit)
 586                                ? (indx[offset + 1] - indx[offset])
 587                                : 0);
 588                     if (gap > 0) {
 589                         for (i = indx[offset];
 590                              (string[i] = string[i + gap]) != '\0';
 591                              i++) {
 592                             ;
 593                         }
 594                     } else if (offset > 0) {
 595                         string[indx[offset - 1]] = '\0';
 596                     }
 597                     if (*chr_offset > indx[limit])
 598                         *chr_offset = indx[limit];
 599                 }
 600             }
 601             break;
 602         case DLGK_DELETE_ALL:
 603             string[*chr_offset = 0] = '\0';
 604             break;
 605         case DLGK_ENTER:
 606             edit = 0;
 607             break;
 608 #ifdef KEY_RESIZE
 609         case KEY_RESIZE:
 610             edit = 0;
 611             break;
 612 #endif
 613         case DLGK_GRID_UP:
 614         case DLGK_GRID_DOWN:
 615         case DLGK_FIELD_NEXT:
 616         case DLGK_FIELD_PREV:
 617             edit = 0;
 618             break;
 619         case ERR:
 620             edit = 0;
 621             break;
 622         default:
 623             beep();
 624             break;
 625         }
 626     } else {
 627         if (key == ESC || key == ERR) {
 628             edit = 0;
 629         } else {
 630             if (len < max_len) {
 631                 for (i = ++len; i > *chr_offset; i--)
 632                     string[i] = string[i - 1];
 633                 string[*chr_offset] = (char) key;
 634                 *chr_offset += 1;
 635             } else {
 636                 (void) beep();
 637             }
 638         }
 639     }
 640     return edit;
 641 }
 642
 643 static void
 644 compute_edit_offset(const char *string,
 645                     int chr_offset,
 646                     int x_last,
 647                     int *p_dpy_column,
 648                     int *p_scroll_amt)
 649 {
 650     const int *cols = dlg_index_columns(string);
 651     const int *indx = dlg_index_wchars(string);
 652     int limit = dlg_count_wchars(string);
 653     int offset = dlg_find_index(indx, limit, chr_offset);
 654     int offset2;
 655     int dpy_column;
 656     int n;
 657
 658     for (n = offset2 = 0; n <= offset; ++n) {
 659         if ((cols[offset] - cols[n]) < x_last
 660             && (offset == limit || (cols[offset + 1] - cols[n]) < x_last)) {
 661             offset2 = n;
 662             break;
 663         }
 664     }
 665
 666     dpy_column = cols[offset] - cols[offset2];
 667
 668     if (p_dpy_column != 0)
 669         *p_dpy_column = dpy_column;
 670     if (p_scroll_amt != 0)
 671         *p_scroll_amt = offset2;
 672 }
 673
 674 /*
 675  * Given the character-offset in the string, returns the display-offset where
 676  * we will position the cursor.
 677  */
 678 int
 679 dlg_edit_offset(char *string, int chr_offset, int x_last)
 680 {
 681     int result;
 682
 683     compute_edit_offset(string, chr_offset, x_last, &result, 0);
 684
 685     return result;
 686 }
 687
 688 /*
 689  * Displays the string, shifted as necessary, to fit within the box and show
 690  * the current character-offset.
 691  */
 692 void
 693 dlg_show_string(WINDOW *win,
 694                 const char *string,     /* string to display (may be multibyte) */
 695                 int chr_offset, /* character (not bytes) offset */
 696                 chtype attr,    /* window-attributes */
 697                 int y_base,     /* beginning row on screen */
 698                 int x_base,     /* beginning column on screen */
 699                 int x_last,     /* number of columns on screen */
 700                 bool hidden,    /* if true, do not echo */
 701                 bool force)     /* if true, force repaint */
 702 {
 703     x_last = MIN(x_last + x_base, getmaxx(win)) - x_base;
 704
 705     if (hidden && !dialog_vars.insecure) {
 706         if (force) {
 707             (void) wmove(win, y_base, x_base);
 708             wrefresh(win);
 709         }
 710     } else {
 711         const int *cols = dlg_index_columns(string);
 712         const int *indx = dlg_index_wchars(string);
 713         int limit = dlg_count_wchars(string);
 714
 715         int i, j, k;
 716         int input_x;
 717         int scrollamt;
 718
 719         compute_edit_offset(string, chr_offset, x_last, &input_x, &scrollamt);
 720
 721         dlg_attrset(win, attr);
 722         (void) wmove(win, y_base, x_base);
 723         for (i = scrollamt, k = 0; i < limit && k < x_last; ++i) {
 724             int check = cols[i + 1] - cols[scrollamt];
 725             if (check <= x_last) {
 726                 for (j = indx[i]; j < indx[i + 1]; ++j) {
 727                     chtype ch = UCH(string[j]);
 728                     if (hidden && dialog_vars.insecure) {
 729                         waddch(win, '*');
 730                     } else if (ch == TAB) {
 731                         int count = cols[i + 1] - cols[i];
 732                         while (--count >= 0)
 733                             waddch(win, ' ');
 734                     } else {
 735                         waddch(win, ch);
 736                     }
 737                 }
 738                 k = check;
 739             } else {
 740                 break;
 741             }
 742         }
 743         while (k++ < x_last)
 744             waddch(win, ' ');
 745         (void) wmove(win, y_base, x_base + input_x);
 746         wrefresh(win);
 747     }
 748 }
 749
 750 /*
 751  * Discard cached data for the given string.
 752  */
 753 void
 754 dlg_finish_string(const char *string)
 755 {
 756 #if USE_CACHING
 757     if ((string != 0) && dialog_state.finish_string) {
 758         CACHE *p = cache_list;
 759         CACHE *q = 0;
 760         CACHE *r;
 761
 762         while (p != 0) {
 763             if (p->string_at == string) {
 764 #ifdef HAVE_TSEARCH
 765                 if (tdelete(p, &sorted_cache, compare_cache) == 0) {
 766                     continue;
 767                 }
 768                 trace_cache(__FILE__, __LINE__);
 769 #endif
 770                 if (p->string != 0)
 771                     free(p->string);
 772                 if (p->list != 0)
 773                     free(p->list);
 774                 if (p == cache_list) {
 775                     cache_list = p->next;
 776                     r = cache_list;
 777                 } else {
 778                     q->next = p->next;
 779                     r = q;
 780                 }
 781                 free(p);
 782                 p = r;
 783             } else {
 784                 q = p;
 785                 p = p->next;
 786             }
 787         }
 788     }
 789 #else
 790     (void) string;
 791 #endif
 792 }
 793
 794 #ifdef NO_LEAKS
 795 void
 796 _dlg_inputstr_leaks(void)
 797 {
 798 #if USE_CACHING
 799     dialog_state.finish_string = TRUE;
 800     trace_cache(__FILE__, __LINE__);
 801     while (cache_list != 0) {
 802         dlg_finish_string(cache_list->string_at);
 803     }
 804 #endif /* USE_CACHING */
 805 }
 806 #endif /* NO_LEAKS */