src/ui/gui/find-dialog.c

   1 /* PSPPIRE - a graphical user interface for PSPP.
   2    Copyright (C) 2007, 2009, 2011, 2012, 2015, 2020  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 <ctype.h>
  24 #include <gtk/gtk.h>
  25 #include <regex.h>
  26 #include <stdlib.h>
  27 #include <sys/types.h>
  28 #include <math.h>
  29
  30 #include "data/data-in.h"
  31 #include "data/datasheet.h"
  32 #include "data/format.h"
  33 #include "data/value.h"
  34 #include "libpspp/cast.h"
  35 #include "libpspp/message.h"
  36 #include "ui/gui/builder-wrapper.h"
  37 #include "ui/gui/dict-display.h"
  38 #include "ui/gui/find-dialog.h"
  39 #include "ui/gui/helper.h"
  40 #include "ui/gui/psppire-data-store.h"
  41 #include "ui/gui/psppire-data-window.h"
  42 #include "ui/gui/psppire-dialog.h"
  43 #include "ui/gui/psppire-selector.h"
  44 #include <ssw-sheet.h>
  45
  46 #include "gl/xalloc.h"
  47
  48 #include <gettext.h>
  49 #define _(msgid) gettext (msgid)
  50 #define N_(msgid) msgid
  51
  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   SswSheet *sheet = SSW_SHEET (fd->de->data_editor->data_sheet);
 105   casenumber x = -1;
 106   gint column = -1;
 107   gint unused;
 108   gint row = 0;
 109   ssw_sheet_get_active_cell (sheet, &unused, &row);
 110
 111   find_value (fd, row, &x, &column);
 112
 113   if (x != -1)
 114     {
 115       gtk_notebook_set_current_page (GTK_NOTEBOOK (fd->de->data_editor),
 116                                      PSPPIRE_DATA_EDITOR_DATA_VIEW);
 117
 118       ssw_sheet_scroll_to (sheet, column, x);
 119       ssw_sheet_set_active_cell (sheet, column, x, NULL);
 120     }
 121 }
 122
 123 /* Callback on the selector.
 124    It gets invoked whenever a variable is selected */
 125 static void
 126 on_select (GtkEntry *entry, gpointer data)
 127 {
 128   struct find_dialog *fd = data;
 129   const char *var_name = gtk_entry_get_text (GTK_ENTRY (fd->variable_entry));
 130   struct variable *var = dict_lookup_var (fd->dict->dict, var_name);
 131   gboolean search_labels ;
 132
 133   g_return_if_fail (var);
 134
 135   gtk_widget_set_sensitive (fd->value_labels_checkbox,
 136                             var_has_value_labels (var));
 137
 138   search_labels =
 139     gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (fd->value_labels_checkbox));
 140
 141   gtk_widget_set_sensitive (fd->match_regexp_checkbox,
 142                             var_is_alpha (var) || search_labels);
 143
 144
 145   gtk_widget_set_sensitive (fd->match_substring_checkbox,
 146                             var_is_alpha (var) || search_labels);
 147 }
 148
 149 /* Callback on the selector.
 150    It gets invoked whenever a variable is unselected */
 151 static void
 152 on_deselect (GtkEntry *entry, gpointer data)
 153 {
 154   struct find_dialog *fd = data;
 155
 156   gtk_widget_set_sensitive (fd->value_labels_checkbox, FALSE);
 157   gtk_widget_set_sensitive (fd->match_substring_checkbox, FALSE);
 158   gtk_widget_set_sensitive (fd->match_regexp_checkbox, FALSE);
 159 }
 160
 161 static void
 162 value_labels_toggled (GtkToggleButton *tb, gpointer data)
 163 {
 164   struct find_dialog *fd = data;
 165
 166   const char *var_name = gtk_entry_get_text (GTK_ENTRY (fd->variable_entry));
 167   const struct variable *var = dict_lookup_var (fd->dict->dict, var_name);
 168
 169   gboolean active = gtk_toggle_button_get_active  (tb) ;
 170
 171   gtk_widget_set_sensitive (fd->match_substring_checkbox,
 172                             active || (var && var_is_alpha (var)));
 173
 174   gtk_widget_set_sensitive (fd->match_regexp_checkbox,
 175                               active || (var && var_is_alpha (var)));
 176 }
 177
 178 /* Pops up the Find dialog box
 179  */
 180 void
 181 find_dialog (PsppireDataWindow *de)
 182 {
 183   struct find_dialog fd;
 184
 185   GtkWidget *dialog ;
 186   GtkWidget *source ;
 187   GtkWidget *selector;
 188   GtkWidget *find_button;
 189
 190   GtkWidget *buttonbox;
 191
 192   PsppireDataStore *ds ;
 193
 194   fd.xml = builder_new ("find.ui");
 195   fd.de = de;
 196
 197   find_button = gtk_button_new_with_label (_("Find"));
 198   gtk_widget_show (find_button);
 199
 200   buttonbox = get_widget_assert (fd.xml, "find-buttonbox");
 201
 202   psppire_box_pack_start_defaults (GTK_BOX (buttonbox), find_button);
 203   gtk_box_reorder_child (GTK_BOX (buttonbox), find_button, 0);
 204
 205   dialog = get_widget_assert (fd.xml, "find-dialog");
 206   source = get_widget_assert (fd.xml, "find-variable-treeview");
 207   selector = get_widget_assert (fd.xml, "find-selector");
 208
 209   g_object_get (de->data_editor,
 210                 "dictionary", &fd.dict,
 211                 "data-store", &ds,
 212                 NULL);
 213
 214   fd.data = ds->datasheet;
 215
 216   fd.variable_entry        = get_widget_assert (fd.xml, "find-variable-entry");
 217   fd.value_entry           = get_widget_assert (fd.xml, "find-value-entry");
 218   fd.value_labels_checkbox =
 219     get_widget_assert (fd.xml,
 220                        "find-value-labels-checkbutton");
 221
 222   fd.match_regexp_checkbox =
 223     get_widget_assert (fd.xml,
 224                        "find-match-regexp-checkbutton");
 225
 226   fd.match_substring_checkbox =
 227     get_widget_assert (fd.xml,
 228                        "find-match-substring-checkbutton");
 229
 230
 231
 232   gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (de));
 233
 234
 235   g_object_set (source, "model", fd.dict,
 236         "selection-mode", GTK_SELECTION_SINGLE,
 237         NULL);
 238
 239
 240   psppire_selector_set_filter_func (PSPPIRE_SELECTOR (selector),
 241                                     is_currently_in_entry);
 242
 243   g_signal_connect (dialog, "refresh", G_CALLBACK (refresh),  &fd);
 244
 245   g_signal_connect (find_button, "clicked", G_CALLBACK (do_find),  &fd);
 246
 247   g_signal_connect (selector, "selected",
 248                     G_CALLBACK (on_select),  &fd);
 249
 250   g_signal_connect (selector, "de-selected",
 251                     G_CALLBACK (on_deselect),  &fd);
 252
 253   g_signal_connect (fd.value_labels_checkbox, "toggled",
 254                     G_CALLBACK (value_labels_toggled),  &fd);
 255
 256
 257   psppire_dialog_run (PSPPIRE_DIALOG (dialog));
 258
 259   g_object_unref (fd.xml);
 260 }
 261
 262 \f
 263 /* Iterators */
 264
 265 static void
 266 forward (casenumber *i, struct datasheet *data UNUSED)
 267 {
 268   ++*i;
 269 }
 270
 271
 272 static void
 273 forward_wrap (casenumber *i, struct datasheet *data)
 274 {
 275   if (++*i >=  datasheet_get_n_rows (data)) *i = 0;
 276 }
 277
 278 static void
 279 backward (casenumber *i, struct datasheet *data UNUSED)
 280 {
 281   --*i;
 282 }
 283
 284
 285 static void
 286 backward_wrap (casenumber *i, struct datasheet *data)
 287 {
 288   if (--*i < 0)
 289     *i = datasheet_get_n_rows (data) - 1;
 290 }
 291
 292
 293 /* Current plus one */
 294 static casenumber
 295 cp1 (casenumber current, struct datasheet *data)
 296 {
 297   return current + 1;
 298 }
 299
 300 /* Current plus one, circular */
 301 static casenumber
 302 cp1c (casenumber current, struct datasheet *data)
 303 {
 304   casenumber next = current;
 305
 306   forward_wrap (&next, data);
 307
 308   return next;
 309 }
 310
 311
 312 /* Current minus one */
 313 static casenumber
 314 cm1 (casenumber current, struct datasheet *data)
 315 {
 316   if (current == 0)
 317     return datasheet_get_n_rows (data) - 1;
 318
 319   return current - 1;
 320 }
 321
 322 /* Current minus one, circular */
 323 static casenumber
 324 cm1c (casenumber current, struct datasheet *data)
 325 {
 326   casenumber next = current;
 327
 328   backward_wrap (&next, data);
 329
 330   return next;
 331 }
 332
 333
 334 static casenumber
 335 last (casenumber current, struct datasheet *data)
 336 {
 337   return datasheet_get_n_rows (data) ;
 338 }
 339
 340 static casenumber
 341 minus1 (casenumber current, struct datasheet *data)
 342 {
 343   return -1;
 344 }
 345
 346 /* A type to facilitate iterating through casenumbers */
 347 struct casenum_iterator
 348 {
 349   /* returns the first case to access */
 350   casenumber (*start) (casenumber, struct datasheet *);
 351
 352   /* Returns one past the last case to access */
 353   casenumber (*end) (casenumber, struct datasheet *);
 354
 355   /* Sets the first arg to the next case to access */
 356   void (*next) (casenumber *, struct datasheet *);
 357 };
 358
 359 enum iteration_type{
 360   FORWARD = 0,
 361   FORWARD_WRAP,
 362   REVERSE,
 363   REVERSE_WRAP,
 364   n_iterators
 365 };
 366
 367 static const struct casenum_iterator case_iterator[n_iterators] =
 368   {
 369    /* Forward iterator (linear) */
 370     {cp1, last, forward},
 371
 372     /* Forward iterator (circular) */
 373     {cp1c, cm1, forward_wrap},
 374
 375     /* Reverse iterator (linear) */
 376     {cm1, minus1, backward},
 377
 378     /* Reverse iterator (circular */
 379     {cm1c, cp1, backward_wrap}
 380   };
 381
 382
 383 \f
 384 /* A factory returning an iterator according to the dialog box's settings */
 385 static const struct casenum_iterator *
 386 get_iteration_params (const struct find_dialog *fd)
 387 {
 388   gboolean wrap = gtk_toggle_button_get_active
 389     (GTK_TOGGLE_BUTTON (get_widget_assert (fd->xml, "find-wrap")));
 390
 391   gboolean reverse = gtk_toggle_button_get_active
 392     (GTK_TOGGLE_BUTTON (get_widget_assert (fd->xml, "find-backwards")));
 393
 394   if (wrap)
 395     {
 396       if (reverse)
 397         return &case_iterator[REVERSE_WRAP];
 398       else
 399         return &case_iterator[FORWARD_WRAP];
 400     }
 401   else
 402     {
 403       if (reverse)
 404         return &case_iterator[REVERSE];
 405       else
 406         return &case_iterator[FORWARD];
 407     }
 408 }
 409
 410
 411 enum string_cmp_flags
 412   {
 413     STR_CMP_SUBSTR = 0x01, /* Find strings which are substrings of the
 414                               values */
 415     STR_CMP_REGEXP = 0x02, /* Match against a regular expression */
 416
 417     STR_CMP_LABELS = 0x04  /* Match against the values' labels instead
 418                               of the data */
 419   };
 420
 421
 422 /* An abstract base type for comparing union values against a reference */
 423 struct comparator
 424 {
 425   const struct variable *var;
 426   enum string_cmp_flags flags;
 427
 428   bool (*compare) (const struct comparator *,
 429                    const union value *);
 430
 431   void (*destroy) (struct comparator *);
 432 };
 433
 434
 435 /* A comparator which operates on the numerical values,
 436    rounded to the number of decimal places indicated by
 437    the variable's format.  */
 438 struct numeric_comparator
 439 {
 440   struct comparator parent;
 441   double rounded_ref;
 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 /* Returns 10 raised to the power of X.
 459    X must be a non-negative integer.  */
 460 static inline int
 461 int_pow10 (int x)
 462 {
 463   int ret = 1;
 464   assert (x >= 0);
 465   while (x--)
 466     ret *= 10;
 467
 468   return ret;
 469 }
 470
 471 static bool
 472 value_compare (const struct comparator *cmptr,
 473                const union value *v)
 474 {
 475   const struct numeric_comparator *nc = (const struct numeric_comparator *) cmptr;
 476   struct fmt_spec fs = var_get_print_format (cmptr->var);
 477
 478   double c = nearbyint (v->f * int_pow10 (fs.d));
 479
 480   return c == nc->rounded_ref;
 481 }
 482
 483
 484 /* Return true if the label of VAL matches the reference string*/
 485 static bool
 486 string_label_compare (const struct comparator *cmptr,
 487                 const union value *val)
 488 {
 489   const struct string_comparator *ssc =
 490     (const struct string_comparator *) cmptr;
 491
 492   int width;
 493
 494   const char *text = var_lookup_value_label (cmptr->var, val);
 495   if (text == NULL)
 496     return false;
 497
 498   width = strlen (text);
 499
 500   assert (cmptr->flags & STR_CMP_LABELS);
 501
 502   g_return_val_if_fail (width > 0, false);
 503
 504   if (cmptr->flags & STR_CMP_SUBSTR)
 505     return (NULL != g_strstr_len (text, width, ssc->pattern));
 506   else
 507     return (0 == strncmp (text, ssc->pattern, width));
 508 }
 509
 510 /* Return true if VAL matches the reference string*/
 511 static bool
 512 string_value_compare (const struct comparator *cmptr,
 513                       const union value *val)
 514 {
 515   bool found;
 516   char *text;
 517   const struct string_comparator *ssc =
 518     (const struct string_comparator *) cmptr;
 519
 520   int width = var_get_width (cmptr->var);
 521   g_return_val_if_fail (width > 0, false);
 522   assert (! (cmptr->flags & STR_CMP_LABELS));
 523
 524   text = value_to_text (*val, cmptr->var);
 525
 526   if (cmptr->flags & STR_CMP_SUBSTR)
 527     found =  (NULL != g_strstr_len (text, width, ssc->pattern));
 528   else
 529     found = (0 == strncmp (text, ssc->pattern, width));
 530
 531   free (text);
 532   return found;
 533 }
 534
 535
 536
 537 /* Return true if VAL matched the regexp */
 538 static bool
 539 regexp_value_compare (const struct comparator *cmptr,
 540                 const union value *val)
 541 {
 542   char *text;
 543   bool retval;
 544   const struct regexp_comparator *rec =
 545     (const struct regexp_comparator *) cmptr;
 546
 547   int width = var_get_width (cmptr->var);
 548
 549   assert  (! (cmptr->flags & STR_CMP_LABELS));
 550
 551   g_return_val_if_fail (width > 0, false);
 552
 553   text = value_to_text (*val, cmptr->var);
 554   /* We must remove trailing whitespace, otherwise $ will not match where
 555      one would expect */
 556   g_strchomp (text);
 557
 558   retval = (0 == regexec (&rec->re, text, 0, 0, 0));
 559
 560   g_free (text);
 561
 562   return retval;
 563 }
 564
 565 /* Return true if the label of VAL matched the regexp */
 566 static bool
 567 regexp_label_compare (const struct comparator *cmptr,
 568                       const union value *val)
 569 {
 570   const char *text;
 571   const struct regexp_comparator *rec =
 572     (const struct regexp_comparator *) cmptr;
 573
 574   int width ;
 575
 576   assert (cmptr->flags & STR_CMP_LABELS);
 577
 578   text = var_lookup_value_label (cmptr->var, val);
 579   width = strlen (text);
 580
 581   g_return_val_if_fail (width > 0, false);
 582
 583   return (0 == regexec (&rec->re, text, 0, 0, 0));
 584 }
 585
 586
 587
 588 static void
 589 regexp_destroy (struct comparator *cmptr)
 590 {
 591   struct regexp_comparator *rec
 592     = UP_CAST (cmptr, struct regexp_comparator, parent);
 593
 594   regfree (&rec->re);
 595 }
 596
 597 static struct comparator *
 598 numeric_comparator_create (const struct variable *var, const char *target)
 599 {
 600   struct numeric_comparator *nc = XZALLOC (struct numeric_comparator);
 601   struct comparator *cmptr = &nc->parent;
 602
 603   cmptr->flags = 0;
 604   cmptr->var = var;
 605   cmptr->compare  = value_compare;
 606   struct fmt_spec fs = var_get_write_format (var);
 607
 608   union value val;
 609   text_to_value (target, var, &val);
 610   nc->rounded_ref = nearbyint (val.f * int_pow10 (fs.d));
 611   value_destroy (&val, var_get_width (var));
 612
 613   return cmptr;
 614 }
 615
 616 static struct comparator *
 617 string_comparator_create (const struct variable *var, const char *target,
 618                           enum string_cmp_flags flags)
 619 {
 620   struct string_comparator *ssc = XZALLOC (struct string_comparator);
 621   struct comparator *cmptr = &ssc->parent;
 622
 623   cmptr->flags = flags;
 624   cmptr->var = var;
 625
 626   if (flags & STR_CMP_LABELS)
 627     cmptr->compare = string_label_compare;
 628   else
 629     cmptr->compare = string_value_compare;
 630
 631   ssc->pattern = target;
 632
 633   return cmptr;
 634 }
 635
 636
 637 static struct comparator *
 638 regexp_comparator_create (const struct variable *var, const char *target,
 639                           enum string_cmp_flags flags)
 640 {
 641   int code;
 642   struct regexp_comparator *rec = XZALLOC (struct regexp_comparator);
 643   struct comparator *cmptr = &rec->parent;
 644
 645   cmptr->flags = flags;
 646   cmptr->var = var;
 647   cmptr->compare  = (flags & STR_CMP_LABELS)
 648     ? regexp_label_compare : regexp_value_compare ;
 649
 650   cmptr->destroy  = regexp_destroy;
 651
 652   code = regcomp (&rec->re, target, 0);
 653   if (code != 0)
 654     {
 655       char *errbuf = NULL;
 656       size_t errbuf_size = regerror (code, &rec->re, errbuf,  0);
 657
 658       errbuf = xmalloc (errbuf_size);
 659
 660       regerror (code, &rec->re, errbuf, errbuf_size);
 661
 662       msg (ME, _("Bad regular expression: %s"), errbuf);
 663
 664       free (cmptr);
 665       free (errbuf);
 666       return NULL;
 667     }
 668
 669   return cmptr;
 670 }
 671
 672
 673 /* Compare V against CMPTR's reference */
 674 static bool
 675 comparator_compare (const struct comparator *cmptr,
 676                     const union value *v)
 677 {
 678   return cmptr->compare (cmptr, v);
 679 }
 680
 681 /* Destroy CMPTR */
 682 static void
 683 comparator_destroy (struct comparator *cmptr)
 684 {
 685   if (! cmptr)
 686     return ;
 687
 688   if (cmptr->destroy)
 689     cmptr->destroy (cmptr);
 690
 691   free (cmptr);
 692 }
 693
 694
 695 static struct comparator *
 696 comparator_factory (const struct variable *var, const char *str,
 697                     enum string_cmp_flags flags)
 698 {
 699   if (flags & STR_CMP_REGEXP)
 700     return regexp_comparator_create (var, str, flags);
 701
 702   if (flags & (STR_CMP_SUBSTR | STR_CMP_LABELS))
 703     return string_comparator_create (var, str, flags);
 704
 705   return numeric_comparator_create (var, str);
 706 }
 707
 708
 709 /* Find the row and column specified by the dialog FD, starting at CURRENT_ROW.
 710    After the function returns, *ROW contains the row and *COLUMN the column.
 711    If no such case is found, then *ROW will be set to -1
 712  */
 713 static void
 714 find_value (const struct find_dialog *fd, casenumber current_row,
 715            casenumber *row, int *column)
 716 {
 717   int width;
 718   const struct variable *var;
 719   const char *var_name = gtk_entry_get_text (GTK_ENTRY (fd->variable_entry));
 720   const char *target_string = gtk_entry_get_text (GTK_ENTRY (fd->value_entry));
 721
 722   enum string_cmp_flags flags = 0;
 723
 724   var = dict_lookup_var (fd->dict->dict, var_name);
 725   if (! var)
 726     return ;
 727
 728   width = var_get_width (var);
 729
 730   *column = var_get_dict_index (var);
 731   *row = -1;
 732
 733   if (gtk_toggle_button_get_active
 734        (GTK_TOGGLE_BUTTON (fd->match_substring_checkbox)))
 735     flags |= STR_CMP_SUBSTR;
 736
 737   if (gtk_toggle_button_get_active
 738        (GTK_TOGGLE_BUTTON (fd->match_regexp_checkbox)))
 739     flags |= STR_CMP_REGEXP;
 740
 741   if (gtk_toggle_button_get_active
 742        (GTK_TOGGLE_BUTTON (fd->value_labels_checkbox)))
 743     flags |= STR_CMP_LABELS;
 744
 745   {
 746     union value val;
 747     casenumber i;
 748     const struct casenum_iterator *ip = get_iteration_params (fd);
 749     struct comparator *cmptr =
 750       comparator_factory (var, target_string, flags);
 751
 752     value_init (&val, width);
 753     if (! cmptr)
 754       goto finish;
 755
 756     for (i = ip->start (current_row, fd->data);
 757          i != ip->end (current_row, fd->data);
 758          ip->next (&i, fd->data))
 759       {
 760         datasheet_get_value (fd->data, i, var_get_dict_index (var), &val);
 761
 762         if (comparator_compare (cmptr, &val))
 763           {
 764             *row = i;
 765             break;
 766           }
 767       }
 768
 769   finish:
 770     comparator_destroy (cmptr);
 771     value_destroy (&val, width);
 772   }
 773 }