src/ui/gui/find-dialog.c

   1 /* PSPPIRE - a graphical user interface for PSPP.
   2    Copyright (C) 2007, 2009  Free Software Foundation
   3
   4    This program is free software: you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation, either version 3 of the License, or
   7    (at your option) any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program.  If not, see <http://www.gnu.org/licenses/>. */
  16
  17
  18 /* This module implements the "Find" dialog; a dialog box to locate cases
  19 which match particular strings */
  20
  21 #include <config.h>
  22
  23 #include "find-dialog.h"
  24 #include "psppire-selector.h"
  25 #include "psppire-dialog.h"
  26 #include "helper.h"
  27 #include "psppire-data-window.h"
  28 #include "dict-display.h"
  29 #include <data/value.h>
  30 #include <data/format.h>
  31 #include <data/datasheet.h>
  32 #include <data/data-in.h>
  33 #include "psppire-data-store.h"
  34 #include <ctype.h>
  35 #include <sys/types.h>
  36 #include <regex.h>
  37 #include <libpspp/cast.h>
  38 #include <libpspp/message.h>
  39
  40 #include <gtk/gtk.h>
  41 #include <stdlib.h>
  42
  43 #include "xalloc.h"
  44
  45 #include <gettext.h>
  46 #define _(msgid) gettext (msgid)
  47 #define N_(msgid) msgid
  48
  49
  50 /* FIXME: These shouldn't be here */
  51 #include "psppire-var-store.h"
  52
  53 struct find_dialog
  54 {
  55   GtkBuilder *xml;
  56   PsppireDict *dict;
  57   struct datasheet *data;
  58   PsppireDataWindow *de;
  59   GtkWidget *variable_entry;
  60   GtkWidget *value_entry;
  61   GtkWidget *value_labels_checkbox;
  62   GtkWidget *match_regexp_checkbox;
  63   GtkWidget *match_substring_checkbox;
  64 };
  65
  66 static void
  67 find_value (const struct find_dialog *fd, casenumber current_row,
  68            casenumber *row, int *column);
  69
  70
  71 /* A callback which occurs whenever the "Refresh" button is clicked,
  72    and when the dialog pops up.
  73    It restores the dialog to its default state.
  74 */
  75 static void
  76 refresh (GObject *obj, const struct find_dialog *fd)
  77 {
  78   gtk_toggle_button_set_active
  79     (GTK_TOGGLE_BUTTON (get_widget_assert (fd->xml, "find-wrap")),
  80      FALSE);
  81
  82   gtk_toggle_button_set_active
  83     (GTK_TOGGLE_BUTTON (get_widget_assert (fd->xml, "find-backwards")),
  84      FALSE);
  85
  86   gtk_entry_set_text (GTK_ENTRY (fd->variable_entry), "");
  87   gtk_entry_set_text (GTK_ENTRY (fd->value_entry), "");
  88
  89   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (fd->match_regexp_checkbox),
  90                                 FALSE);
  91
  92   gtk_toggle_button_set_active
  93     (GTK_TOGGLE_BUTTON (fd->match_substring_checkbox), FALSE);
  94
  95
  96   gtk_toggle_button_set_active
  97     (GTK_TOGGLE_BUTTON (fd->match_substring_checkbox), FALSE);
  98 }
  99
 100 /* Callback on the "Find" button */
 101 static void
 102 do_find (GObject *obj, const struct find_dialog *fd)
 103 {
 104   casenumber x = -1;
 105   gint column = -1;
 106   glong row;
 107
 108   g_object_get (fd->de->data_editor, "current-case", &row, NULL);
 109
 110   if ( row < 0 )
 111     row = 0;
 112
 113   find_value (fd, row, &x, &column);
 114
 115
 116   if ( x != -1)
 117     {
 118       gtk_notebook_set_current_page (GTK_NOTEBOOK (fd->de->data_editor),
 119                                      PSPPIRE_DATA_EDITOR_DATA_VIEW);
 120
 121       g_object_set (fd->de->data_editor,
 122                     "current-case", x,
 123                     "current-variable", column,
 124                     NULL);
 125     }
 126
 127 }
 128
 129 /* Callback on the selector.
 130    It gets invoked whenever a variable is selected */
 131 static void
 132 on_select (GtkEntry *entry, gpointer data)
 133 {
 134   struct find_dialog *fd = data;
 135   const char *var_name = gtk_entry_get_text (GTK_ENTRY (fd->variable_entry));
 136   struct variable *var = dict_lookup_var (fd->dict->dict, var_name);
 137   gboolean search_labels ;
 138
 139   g_return_if_fail (var);
 140
 141   gtk_widget_set_sensitive (fd->value_labels_checkbox,
 142                             var_has_value_labels (var));
 143
 144   search_labels =
 145     gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (fd->value_labels_checkbox));
 146
 147   gtk_widget_set_sensitive (fd->match_regexp_checkbox,
 148                             var_is_alpha (var) || search_labels);
 149
 150
 151   gtk_widget_set_sensitive (fd->match_substring_checkbox,
 152                             var_is_alpha (var) || search_labels);
 153 }
 154
 155 /* Callback on the selector.
 156    It gets invoked whenever a variable is unselected */
 157 static void
 158 on_deselect (GtkEntry *entry, gpointer data)
 159 {
 160   struct find_dialog *fd = data;
 161
 162   gtk_widget_set_sensitive (fd->value_labels_checkbox, FALSE);
 163   gtk_widget_set_sensitive (fd->match_substring_checkbox, FALSE);
 164   gtk_widget_set_sensitive (fd->match_regexp_checkbox, FALSE);
 165 }
 166
 167 static void
 168 value_labels_toggled (GtkToggleButton *tb, gpointer data)
 169 {
 170   struct find_dialog *fd = data;
 171
 172   const char *var_name = gtk_entry_get_text (GTK_ENTRY (fd->variable_entry));
 173   const struct variable *var = dict_lookup_var (fd->dict->dict, var_name);
 174
 175   gboolean active = gtk_toggle_button_get_active  (tb) ;
 176
 177   gtk_widget_set_sensitive (fd->match_substring_checkbox,
 178                             active || (var && var_is_alpha (var)));
 179
 180   gtk_widget_set_sensitive (fd->match_regexp_checkbox,
 181                               active || (var && var_is_alpha (var)));
 182 }
 183
 184 /* Pops up the Find dialog box
 185  */
 186 void
 187 find_dialog (GObject *o, gpointer data)
 188 {
 189   PsppireDataWindow *de = PSPPIRE_DATA_WINDOW (data);
 190
 191   struct find_dialog fd;
 192
 193   GtkWidget *dialog ;
 194   GtkWidget *source ;
 195   GtkWidget *selector;
 196   GtkWidget *find_button;
 197
 198   GtkWidget *buttonbox;
 199
 200   PsppireVarStore *vs ;
 201   PsppireDataStore *ds ;
 202
 203   fd.xml = builder_new ("find.ui");
 204   fd.de = de;
 205
 206   find_button = gtk_button_new_from_stock  (GTK_STOCK_FIND);
 207   gtk_widget_show (find_button);
 208
 209   buttonbox = get_widget_assert (fd.xml, "find-buttonbox");
 210
 211   gtk_box_pack_start_defaults (GTK_BOX (buttonbox), find_button);
 212   gtk_box_reorder_child (GTK_BOX (buttonbox), find_button, 0);
 213
 214   dialog = get_widget_assert (fd.xml, "find-dialog");
 215   source = get_widget_assert (fd.xml, "find-variable-treeview");
 216   selector = get_widget_assert (fd.xml, "find-selector");
 217
 218   g_object_get (de->data_editor,
 219                 "var-store", &vs,
 220                 "data-store", &ds,
 221                 NULL);
 222
 223   g_object_get (vs, "dictionary", &fd.dict, NULL);
 224
 225   fd.data = ds->datasheet;
 226
 227   fd.variable_entry        = get_widget_assert (fd.xml, "find-variable-entry");
 228   fd.value_entry           = get_widget_assert (fd.xml, "find-value-entry");
 229   fd.value_labels_checkbox =
 230     get_widget_assert (fd.xml,
 231                        "find-value-labels-checkbutton");
 232
 233   fd.match_regexp_checkbox =
 234     get_widget_assert (fd.xml,
 235                        "find-match-regexp-checkbutton");
 236
 237   fd.match_substring_checkbox =
 238     get_widget_assert (fd.xml,
 239                        "find-match-substring-checkbutton");
 240
 241
 242
 243   gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (de));
 244
 245
 246   g_object_set (source, "model", fd.dict,
 247         "selection-mode", GTK_SELECTION_SINGLE,
 248         NULL);
 249
 250
 251   psppire_selector_set_filter_func (PSPPIRE_SELECTOR (selector),
 252                                     is_currently_in_entry);
 253
 254   g_signal_connect (dialog, "refresh", G_CALLBACK (refresh),  &fd);
 255
 256   g_signal_connect (find_button, "clicked", G_CALLBACK (do_find),  &fd);
 257
 258   g_signal_connect (selector, "selected",
 259                     G_CALLBACK (on_select),  &fd);
 260
 261   g_signal_connect (selector, "de-selected",
 262                     G_CALLBACK (on_deselect),  &fd);
 263
 264   g_signal_connect (fd.value_labels_checkbox, "toggled",
 265                     G_CALLBACK (value_labels_toggled),  &fd);
 266
 267
 268   psppire_dialog_run (PSPPIRE_DIALOG (dialog));
 269
 270   g_object_unref (fd.xml);
 271 }
 272
 273 \f
 274 /* Iterators */
 275
 276 static void
 277 forward (casenumber *i, struct datasheet *data UNUSED)
 278 {
 279   ++*i;
 280 }
 281
 282
 283 static void
 284 forward_wrap (casenumber *i, struct datasheet *data)
 285 {
 286   if ( ++*i >=  datasheet_get_n_rows (data) ) *i = 0;
 287 }
 288
 289 static void
 290 backward (casenumber *i, struct datasheet *data UNUSED)
 291 {
 292   --*i;
 293 }
 294
 295
 296 static void
 297 backward_wrap (casenumber *i, struct datasheet *data)
 298 {
 299   if ( --*i < 0 )
 300     *i = datasheet_get_n_rows (data) - 1;
 301 }
 302
 303
 304 /* Current plus one */
 305 static casenumber
 306 cp1 (casenumber current, struct datasheet *data)
 307 {
 308   return current + 1;
 309 }
 310
 311 /* Current plus one, circular */
 312 static casenumber
 313 cp1c (casenumber current, struct datasheet *data)
 314 {
 315   casenumber next = current;
 316
 317   forward_wrap (&next, data);
 318
 319   return next;
 320 }
 321
 322
 323 /* Current minus one */
 324 static casenumber
 325 cm1 (casenumber current, struct datasheet *data)
 326 {
 327   return current - 1;
 328 }
 329
 330 /* Current minus one, circular */
 331 static casenumber
 332 cm1c (casenumber current, struct datasheet *data)
 333 {
 334   casenumber next = current;
 335
 336   backward_wrap (&next, data);
 337
 338   return next;
 339 }
 340
 341
 342 static casenumber
 343 last (casenumber current, struct datasheet *data)
 344 {
 345   return datasheet_get_n_rows (data) ;
 346 }
 347
 348 static casenumber
 349 minus1 (casenumber current, struct datasheet *data)
 350 {
 351   return -1;
 352 }
 353
 354 /* An type to facilitate iterating through casenumbers */
 355 struct casenum_iterator
 356 {
 357   /* returns the first case to access */
 358   casenumber (*start) (casenumber, struct datasheet *);
 359
 360   /* Returns one past the last case to access */
 361   casenumber (*end) (casenumber, struct datasheet *);
 362
 363   /* Sets the first arg to the next case to access */
 364   void (*next) (casenumber *, struct datasheet *);
 365 };
 366
 367 enum iteration_type{
 368   FORWARD = 0,
 369   FORWARD_WRAP,
 370   REVERSE,
 371   REVERSE_WRAP,
 372   n_iterators
 373 };
 374
 375 static const struct casenum_iterator ip[n_iterators] =
 376   {
 377     {cp1, last, forward},
 378     {cp1c, cm1, forward_wrap},
 379     {cm1, minus1, backward},
 380     {cm1c, cp1, backward_wrap}
 381   };
 382
 383
 384 \f
 385 /* A factory returning an iterator according to the dialog box's settings */
 386 static const struct casenum_iterator *
 387 get_iteration_params (const struct find_dialog *fd)
 388 {
 389   gboolean wrap = gtk_toggle_button_get_active
 390     (GTK_TOGGLE_BUTTON (get_widget_assert (fd->xml, "find-wrap")));
 391
 392   gboolean reverse = gtk_toggle_button_get_active
 393     (GTK_TOGGLE_BUTTON (get_widget_assert (fd->xml, "find-backwards")));
 394
 395   if ( wrap )
 396     {
 397       if ( reverse )
 398         return &ip[REVERSE_WRAP];
 399       else
 400         return &ip[FORWARD_WRAP];
 401     }
 402   else
 403     {
 404       if ( reverse )
 405         return &ip[REVERSE];
 406       else
 407         return &ip[FORWARD];
 408     }
 409 }
 410
 411
 412 enum string_cmp_flags
 413   {
 414     STR_CMP_SUBSTR = 0x01, /* Find strings which are substrings of the
 415                               values */
 416     STR_CMP_REGEXP = 0x02, /* Match against a regular expression */
 417
 418     STR_CMP_LABELS = 0x04  /* Match against the values' labels instead
 419                               of the data */
 420   };
 421
 422
 423 /* An abstract base type for comparing union values against a reference */
 424 struct comparator
 425 {
 426   const struct variable *var;
 427   enum string_cmp_flags flags;
 428   const PsppireDict *dict;
 429
 430   bool (*compare) (const struct comparator *,
 431                    const union value *);
 432
 433   void (*destroy) (struct comparator *);
 434 };
 435
 436
 437 /* A comparator which operates on the unadulterated union values */
 438 struct value_comparator
 439 {
 440   struct comparator parent;
 441   union value pattern;
 442 };
 443
 444 /* A comparator which matches string values or parts thereof */
 445 struct string_comparator
 446 {
 447   struct comparator parent;
 448   const char *pattern;
 449 };
 450
 451 /* A comparator to match string values against a POSIX.2 regular expression */
 452 struct regexp_comparator
 453 {
 454   struct comparator parent;
 455   regex_t re;
 456 };
 457
 458
 459 static bool
 460 value_compare (const struct comparator *cmptr,
 461                const union value *v)
 462 {
 463   const struct value_comparator *vc = (const struct value_comparator *) cmptr;
 464   return 0 == value_compare_3way (v, &vc->pattern, var_get_width (cmptr->var));
 465 }
 466
 467
 468 /* Return true if the label of VAL matches the reference string*/
 469 static bool
 470 string_label_compare (const struct comparator *cmptr,
 471                 const union value *val)
 472 {
 473   const struct string_comparator *ssc =
 474     (const struct string_comparator *) cmptr;
 475
 476   const char *text = var_lookup_value_label (cmptr->var, val);
 477   int width = strlen (text);
 478
 479   assert ( cmptr->flags & STR_CMP_LABELS);
 480
 481   g_return_val_if_fail (width > 0, false);
 482
 483   if ( cmptr->flags & STR_CMP_SUBSTR)
 484     return (NULL != g_strstr_len (text, width, ssc->pattern));
 485   else
 486     return (0 == strncmp (text, ssc->pattern, width));
 487 }
 488
 489 /* Return true if VAL matches the reference string*/
 490 static bool
 491 string_value_compare (const struct comparator *cmptr,
 492                       const union value *val)
 493 {
 494   bool found;
 495   char *text;
 496   const struct string_comparator *ssc =
 497     (const struct string_comparator *) cmptr;
 498
 499   int width = var_get_width (cmptr->var);
 500   g_return_val_if_fail (width > 0, false);
 501   assert ( ! (cmptr->flags & STR_CMP_LABELS));
 502
 503   text = value_to_text (*val, cmptr->dict, *var_get_write_format (cmptr->var));
 504
 505   if ( cmptr->flags & STR_CMP_SUBSTR)
 506     found =  (NULL != g_strstr_len (text, width, ssc->pattern));
 507   else
 508     found = (0 == strncmp (text, ssc->pattern, width));
 509
 510   free (text);
 511   return found;
 512 }
 513
 514
 515
 516 /* Return true if VAL matched the regexp */
 517 static bool
 518 regexp_value_compare (const struct comparator *cmptr,
 519                 const union value *val)
 520 {
 521   char *text;
 522   bool retval;
 523   const struct regexp_comparator *rec =
 524     (const struct regexp_comparator *) cmptr;
 525
 526   int width = var_get_width (cmptr->var);
 527
 528   assert  ( ! (cmptr->flags & STR_CMP_LABELS) );
 529
 530   g_return_val_if_fail (width > 0, false);
 531
 532   text = value_to_text (*val, cmptr->dict, *var_get_write_format (cmptr->var));
 533   /* We must remove trailing whitespace, otherwise $ will not match where
 534      one would expect */
 535   g_strchomp (text);
 536
 537   retval = (0 == regexec (&rec->re, text, 0, 0, 0));
 538
 539   g_free (text);
 540
 541   return retval;
 542 }
 543
 544 /* Return true if the label of VAL matched the regexp */
 545 static bool
 546 regexp_label_compare (const struct comparator *cmptr,
 547                       const union value *val)
 548 {
 549   const char *text;
 550   const struct regexp_comparator *rec =
 551     (const struct regexp_comparator *) cmptr;
 552
 553   int width ;
 554
 555   assert ( cmptr->flags & STR_CMP_LABELS);
 556
 557   text = var_lookup_value_label (cmptr->var, val);
 558   width = strlen (text);
 559
 560   g_return_val_if_fail (width > 0, false);
 561
 562   return (0 == regexec (&rec->re, text, 0, 0, 0));
 563 }
 564
 565
 566
 567 static void
 568 regexp_destroy (struct comparator *cmptr)
 569 {
 570   struct regexp_comparator *rec
 571     = UP_CAST (cmptr, struct regexp_comparator, parent);
 572
 573   regfree (&rec->re);
 574 }
 575
 576 static void
 577 cmptr_value_destroy (struct comparator *cmptr)
 578 {
 579   struct value_comparator *vc
 580     = UP_CAST (cmptr, struct value_comparator, parent);
 581   value_destroy (&vc->pattern, var_get_width (cmptr->var));
 582 }
 583
 584
 585 static struct comparator *
 586 value_comparator_create (const struct variable *var, const PsppireDict *dict, const char *target)
 587 {
 588   struct value_comparator *vc = xzalloc (sizeof (*vc));
 589   struct comparator *cmptr = &vc->parent;
 590
 591   cmptr->flags = 0;
 592   cmptr->var = var;
 593   cmptr->compare  = value_compare ;
 594   cmptr->destroy = cmptr_value_destroy;
 595   cmptr->dict = dict;
 596
 597   text_to_value (target, dict, var, &vc->pattern);
 598
 599   return cmptr;
 600 }
 601
 602 static struct comparator *
 603 string_comparator_create (const struct variable *var, const PsppireDict *dict,
 604                           const char *target,
 605                           enum string_cmp_flags flags)
 606 {
 607   struct string_comparator *ssc = xzalloc (sizeof (*ssc));
 608   struct comparator *cmptr = &ssc->parent;
 609
 610   cmptr->flags = flags;
 611   cmptr->var = var;
 612   cmptr->dict = dict;
 613
 614   if ( flags & STR_CMP_LABELS)
 615     cmptr->compare = string_label_compare;
 616   else
 617     cmptr->compare = string_value_compare;
 618
 619   ssc->pattern = target;
 620
 621   return cmptr;
 622 }
 623
 624
 625 static struct comparator *
 626 regexp_comparator_create (const struct variable *var, const PsppireDict *dict, const char *target,
 627                           enum string_cmp_flags flags)
 628 {
 629   int code;
 630   struct regexp_comparator *rec = xzalloc (sizeof (*rec));
 631   struct comparator *cmptr = &rec->parent;
 632
 633   cmptr->flags = flags;
 634   cmptr->var = var;
 635   cmptr->dict = dict;
 636   cmptr->compare  = (flags & STR_CMP_LABELS)
 637     ? regexp_label_compare : regexp_value_compare ;
 638
 639   cmptr->destroy  = regexp_destroy;
 640
 641   code = regcomp (&rec->re, target, 0);
 642   if ( code != 0 )
 643     {
 644       char *errbuf = NULL;
 645       size_t errbuf_size = regerror (code, &rec->re, errbuf,  0);
 646
 647       errbuf = xmalloc (errbuf_size);
 648
 649       regerror (code, &rec->re, errbuf, errbuf_size);
 650
 651       msg (ME, _("Bad regular expression: %s"), errbuf);
 652
 653       free ( cmptr);
 654       free (errbuf);
 655       return NULL;
 656     }
 657
 658   return cmptr;
 659 }
 660
 661
 662 /* Compare V against CMPTR's reference */
 663 static bool
 664 comparator_compare (const struct comparator *cmptr,
 665                     const union value *v)
 666 {
 667   return cmptr->compare (cmptr, v);
 668 }
 669
 670 /* Destroy CMPTR */
 671 static void
 672 comparator_destroy (struct comparator *cmptr)
 673 {
 674   if ( ! cmptr )
 675     return ;
 676
 677   if ( cmptr->destroy )
 678     cmptr->destroy (cmptr);
 679
 680   free (cmptr);
 681 }
 682
 683
 684 static struct comparator *
 685 comparator_factory (const struct variable *var, const PsppireDict *dict, const char *str,
 686                     enum string_cmp_flags flags)
 687 {
 688   if ( flags & STR_CMP_REGEXP )
 689     return regexp_comparator_create (var, dict, str, flags);
 690
 691   if ( flags & (STR_CMP_SUBSTR | STR_CMP_LABELS) )
 692     return string_comparator_create (var, dict, str, flags);
 693
 694   return value_comparator_create (var, dict, str);
 695 }
 696
 697
 698 /* Find the row and column specified by the dialog FD, starting at CURRENT_ROW.
 699    After the function returns, *ROW contains the row and *COLUMN the column.
 700    If no such case is found, then *ROW will be set to -1
 701  */
 702 static void
 703 find_value (const struct find_dialog *fd, casenumber current_row,
 704            casenumber *row, int *column)
 705 {
 706   int width;
 707   const struct variable *var;
 708   const char *var_name = gtk_entry_get_text (GTK_ENTRY (fd->variable_entry));
 709   const char *target_string = gtk_entry_get_text (GTK_ENTRY (fd->value_entry));
 710
 711   enum string_cmp_flags flags = 0;
 712   g_assert (current_row >= 0);
 713
 714   var = dict_lookup_var (fd->dict->dict, var_name);
 715   if ( ! var )
 716     return ;
 717
 718   width = var_get_width (var);
 719
 720   *column = var_get_dict_index (var);
 721   *row = -1;
 722
 723   if ( gtk_toggle_button_get_active
 724        (GTK_TOGGLE_BUTTON (fd->match_substring_checkbox)))
 725     flags |= STR_CMP_SUBSTR;
 726
 727   if ( gtk_toggle_button_get_active
 728        (GTK_TOGGLE_BUTTON (fd->match_regexp_checkbox)))
 729     flags |= STR_CMP_REGEXP;
 730
 731   if ( gtk_toggle_button_get_active
 732        (GTK_TOGGLE_BUTTON (fd->value_labels_checkbox)))
 733     flags |= STR_CMP_LABELS;
 734
 735   {
 736     union value val;
 737     casenumber i;
 738     const struct casenum_iterator *ip = get_iteration_params (fd);
 739     struct comparator *cmptr =
 740       comparator_factory (var, fd->dict, target_string, flags);
 741
 742     value_init (&val, width);
 743     if ( ! cmptr)
 744       goto finish;
 745
 746     for (i = ip->start (current_row, fd->data);
 747          i != ip->end (current_row, fd->data);
 748          ip->next (&i, fd->data))
 749       {
 750         datasheet_get_value (fd->data, i, var_get_case_index (var), &val);
 751
 752         if ( comparator_compare (cmptr, &val))
 753           {
 754             *row = i;
 755             break;
 756           }
 757       }
 758
 759   finish:
 760     comparator_destroy (cmptr);
 761     value_destroy (&val, width);
 762   }
 763 }