index/extract.c

   1 /* $Id: extract.c,v 1.246 2006-12-18 23:40:07 adam Exp $
   2    Copyright (C) 1995-2006
   3    Index Data ApS
   4
   5 This file is part of the Zebra server.
   6
   7 Zebra is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 2, or (at your option) any later
  10 version.
  11
  12 Zebra is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  20
  21 */
  22
  23 #include <stdio.h>
  24 #include <assert.h>
  25 #include <ctype.h>
  26 #ifdef WIN32
  27 #include <io.h>
  28 #endif
  29 #if HAVE_UNISTD_H
  30 #include <unistd.h>
  31 #endif
  32 #include <fcntl.h>
  33
  34 #include "index.h"
  35 #include "orddict.h"
  36 #include <direntz.h>
  37 #include <charmap.h>
  38
  39 static int log_level_extract = 0;
  40 static int log_level_details = 0;
  41 static int log_level_initialized = 0;
  42
  43 static void zebra_init_log_level(void)
  44 {
  45     if (!log_level_initialized)
  46     {
  47         log_level_initialized = 1;
  48
  49         log_level_extract = yaz_log_module_level("extract");
  50         log_level_details = yaz_log_module_level("indexdetails");
  51     }
  52 }
  53
  54 static void extract_flush_record_keys(ZebraHandle zh, zint sysno,
  55                                       int cmd, zebra_rec_keys_t reckeys,
  56                                       zint staticrank);
  57 static void extract_flush_sort_keys(ZebraHandle zh, zint sysno,
  58                                     int cmd, zebra_rec_keys_t skp);
  59 static void extract_schema_add (struct recExtractCtrl *p, Odr_oid *oid);
  60 static void extract_token_add (RecWord *p);
  61
  62 static void logRecord (ZebraHandle zh)
  63 {
  64     ++zh->records_processed;
  65     if (!(zh->records_processed % 1000))
  66     {
  67         yaz_log(YLOG_LOG, "Records: "ZINT_FORMAT" i/u/d "
  68                 ZINT_FORMAT"/"ZINT_FORMAT"/"ZINT_FORMAT,
  69                 zh->records_processed, zh->records_inserted,
  70                 zh->records_updated, zh->records_deleted);
  71     }
  72 }
  73
  74 static void extract_add_index_string (RecWord *p,
  75                                       zinfo_index_category_t cat,
  76                                       const char *str, int length);
  77
  78 static void extract_set_store_data_prepare(struct recExtractCtrl *p);
  79
  80 static void extract_init(struct recExtractCtrl *p, RecWord *w)
  81 {
  82     w->seqno = 1;
  83     w->index_name = "any";
  84     w->index_type = 'w';
  85     w->extractCtrl = p;
  86     w->record_id = 0;
  87     w->section_id = 0;
  88     w->segment = 0;
  89 }
  90
  91 static void searchRecordKey(ZebraHandle zh,
  92                             zebra_rec_keys_t reckeys,
  93                             const char *index_name,
  94                             const char **ws, int ws_length)
  95 {
  96     int i;
  97     int ch = -1;
  98     zinfo_index_category_t cat = zinfo_index_category_index;
  99
 100     for (i = 0; i<ws_length; i++)
 101         ws[i] = NULL;
 102
 103     if (ch < 0)
 104         ch = zebraExplain_lookup_attr_str(zh->reg->zei, cat, '0', index_name);
 105     if (ch < 0)
 106         ch = zebraExplain_lookup_attr_str(zh->reg->zei, cat, 'p', index_name);
 107     if (ch < 0)
 108         ch = zebraExplain_lookup_attr_str(zh->reg->zei, cat, 'w', index_name);
 109
 110     if (ch < 0)
 111         return ;
 112
 113     if (zebra_rec_keys_rewind(reckeys))
 114     {
 115         zint startSeq = -1;
 116         const char *str;
 117         size_t slen;
 118         struct it_key key;
 119         zint seqno;
 120         while (zebra_rec_keys_read(reckeys, &str, &slen, &key))
 121         {
 122             assert(key.len <= IT_KEY_LEVEL_MAX && key.len > 2);
 123
 124             seqno = key.mem[key.len-1];
 125
 126             if (key.mem[0] == ch)
 127             {
 128                 zint woff;
 129
 130                 if (startSeq == -1)
 131                     startSeq = seqno;
 132                 woff = seqno - startSeq;
 133                 if (woff >= 0 && woff < ws_length)
 134                     ws[woff] = str;
 135             }
 136         }
 137     }
 138 }
 139
 140 #define FILE_MATCH_BLANK "\t "
 141
 142 static char *get_match_from_spec(ZebraHandle zh,
 143                           zebra_rec_keys_t reckeys,
 144                           const char *fname, const char *spec)
 145 {
 146     static char dstBuf[2048];      /* static here ??? */
 147     char *dst = dstBuf;
 148     const char *s = spec;
 149
 150     while (1)
 151     {
 152         for (; *s && strchr(FILE_MATCH_BLANK, *s); s++)
 153             ;
 154         if (!*s)
 155             break;
 156         if (*s == '(')
 157         {
 158             const char *ws[32];
 159             char attset_str[64], attname_str[64];
 160             int i;
 161             int first = 1;
 162
 163             for (s++; strchr(FILE_MATCH_BLANK, *s); s++)
 164                 ;
 165             for (i = 0; *s && *s != ',' && *s != ')' &&
 166                      !strchr(FILE_MATCH_BLANK, *s); s++)
 167                 if (i+1 < sizeof(attset_str))
 168                     attset_str[i++] = *s;
 169             attset_str[i] = '\0';
 170
 171             for (; strchr(FILE_MATCH_BLANK, *s); s++)
 172                 ;
 173             if (*s != ',')
 174                 strcpy(attname_str, attset_str);
 175             else
 176             {
 177                 for (s++; strchr(FILE_MATCH_BLANK, *s); s++)
 178                     ;
 179                 for (i = 0; *s && *s != ')' &&
 180                          !strchr(FILE_MATCH_BLANK, *s); s++)
 181                     if (i+1 < sizeof(attname_str))
 182                         attname_str[i++] = *s;
 183                 attname_str[i] = '\0';
 184             }
 185
 186             searchRecordKey (zh, reckeys, attname_str, ws, 32);
 187
 188             if (*s != ')')
 189             {
 190                 yaz_log (YLOG_WARN, "Missing ) in match criteria %s in group %s",
 191                       spec, zh->m_group ? zh->m_group : "none");
 192                 return NULL;
 193             }
 194             s++;
 195
 196             for (i = 0; i<32; i++)
 197                 if (ws[i])
 198                 {
 199                     if (first)
 200                     {
 201                         *dst++ = ' ';
 202                         first = 0;
 203                     }
 204                     strcpy (dst, ws[i]);
 205                     dst += strlen(ws[i]);
 206                 }
 207             if (first)
 208             {
 209                 yaz_log (YLOG_WARN, "Record didn't contain match"
 210                       " fields in (%s,%s)", attset_str, attname_str);
 211                 return NULL;
 212             }
 213         }
 214         else if (*s == '$')
 215         {
 216             int spec_len;
 217             char special[64];
 218             const char *spec_src = NULL;
 219             const char *s1 = ++s;
 220             while (*s1 && !strchr(FILE_MATCH_BLANK, *s1))
 221                 s1++;
 222
 223             spec_len = s1 - s;
 224             if (spec_len > sizeof(special)-1)
 225                 spec_len = sizeof(special)-1;
 226             memcpy (special, s, spec_len);
 227             special[spec_len] = '\0';
 228             s = s1;
 229
 230             if (!strcmp (special, "group"))
 231                 spec_src = zh->m_group;
 232             else if (!strcmp (special, "database"))
 233                 spec_src = zh->basenames[0];
 234             else if (!strcmp (special, "filename")) {
 235                 spec_src = fname;
 236             }
 237             else if (!strcmp (special, "type"))
 238                 spec_src = zh->m_record_type;
 239             else
 240                 spec_src = NULL;
 241             if (spec_src)
 242             {
 243                 strcpy (dst, spec_src);
 244                 dst += strlen (spec_src);
 245             }
 246         }
 247         else if (*s == '\"' || *s == '\'')
 248         {
 249             int stopMarker = *s++;
 250             char tmpString[64];
 251             int i = 0;
 252
 253             while (*s && *s != stopMarker)
 254             {
 255                 if (i+1 < sizeof(tmpString))
 256                     tmpString[i++] = *s++;
 257             }
 258             if (*s)
 259                 s++;
 260             tmpString[i] = '\0';
 261             strcpy (dst, tmpString);
 262             dst += strlen (tmpString);
 263         }
 264         else
 265         {
 266             yaz_log (YLOG_WARN, "Syntax error in match criteria %s in group %s",
 267                   spec, zh->m_group ? zh->m_group : "none");
 268             return NULL;
 269         }
 270         *dst++ = 1;
 271     }
 272     if (dst == dstBuf)
 273     {
 274         yaz_log (YLOG_WARN, "No match criteria for record %s in group %s",
 275               fname, zh->m_group ? zh->m_group : "none");
 276         return NULL;
 277     }
 278     *dst = '\0';
 279     return dstBuf;
 280 }
 281
 282 struct recordLogInfo {
 283     const char *fname;
 284     int recordOffset;
 285     struct recordGroup *rGroup;
 286 };
 287
 288 static void init_extractCtrl(ZebraHandle zh, struct recExtractCtrl *ctrl)
 289 {
 290     int i;
 291     for (i = 0; i<256; i++)
 292     {
 293         if (zebra_maps_is_positioned(zh->reg->zebra_maps, i))
 294             ctrl->seqno[i] = 1;
 295         else
 296             ctrl->seqno[i] = 0;
 297     }
 298     ctrl->flagShowRecords = !zh->m_flag_rw;
 299 }
 300
 301 static void all_matches_add(struct recExtractCtrl *ctrl)
 302 {
 303     RecWord word;
 304     extract_init(ctrl, &word);
 305     word.index_name = "_ALLRECORDS";
 306     word.index_type = 'w';
 307     word.seqno = 1;
 308     extract_add_index_string (&word, zinfo_index_category_alwaysmatches,
 309                               "", 0);
 310 }
 311
 312 ZEBRA_RES zebra_extract_file(ZebraHandle zh, zint *sysno, const char *fname,
 313                              int deleteFlag)
 314 {
 315     ZEBRA_RES r = ZEBRA_OK;
 316     int i, fd;
 317     char gprefix[128];
 318     char ext[128];
 319     char ext_res[128];
 320     struct file_read_info *fi = 0;
 321     const char *original_record_type = 0;
 322     RecType recType;
 323     void *recTypeClientData;
 324     struct ZebraRecStream stream, *streamp;
 325
 326     zebra_init_log_level();
 327
 328     if (!zh->m_group || !*zh->m_group)
 329         *gprefix = '\0';
 330     else
 331         sprintf (gprefix, "%s.", zh->m_group);
 332
 333     yaz_log(log_level_extract, "zebra_extract_file %s", fname);
 334
 335     /* determine file extension */
 336     *ext = '\0';
 337     for (i = strlen(fname); --i >= 0; )
 338         if (fname[i] == '/')
 339             break;
 340         else if (fname[i] == '.')
 341         {
 342             strcpy (ext, fname+i+1);
 343             break;
 344         }
 345     /* determine file type - depending on extension */
 346     original_record_type = zh->m_record_type;
 347     if (!zh->m_record_type)
 348     {
 349         sprintf (ext_res, "%srecordType.%s", gprefix, ext);
 350         zh->m_record_type = res_get (zh->res, ext_res);
 351     }
 352     if (!zh->m_record_type)
 353     {
 354         if (zh->records_processed < zh->m_file_verbose_limit)
 355             yaz_log (YLOG_LOG, "? %s", fname);
 356         return 0;
 357     }
 358     /* determine match criteria */
 359     if (!zh->m_record_id)
 360     {
 361         sprintf (ext_res, "%srecordId.%s", gprefix, ext);
 362         zh->m_record_id = res_get (zh->res, ext_res);
 363     }
 364
 365     if (!(recType =
 366           recType_byName (zh->reg->recTypes, zh->res, zh->m_record_type,
 367                           &recTypeClientData)))
 368     {
 369         yaz_log(YLOG_WARN, "No such record type: %s", zh->m_record_type);
 370         return ZEBRA_FAIL;
 371     }
 372
 373     switch(recType->version)
 374     {
 375     case 0:
 376         break;
 377     default:
 378         yaz_log(YLOG_WARN, "Bad filter version: %s", zh->m_record_type);
 379     }
 380     if (sysno && deleteFlag)
 381     {
 382         streamp = 0;
 383         fi = 0;
 384     }
 385     else
 386     {
 387         char full_rep[1024];
 388
 389         if (zh->path_reg && !yaz_is_abspath (fname))
 390         {
 391             strcpy (full_rep, zh->path_reg);
 392             strcat (full_rep, "/");
 393             strcat (full_rep, fname);
 394         }
 395         else
 396             strcpy (full_rep, fname);
 397
 398         if ((fd = open (full_rep, O_BINARY|O_RDONLY)) == -1)
 399         {
 400             yaz_log (YLOG_WARN|YLOG_ERRNO, "open %s", full_rep);
 401             zh->m_record_type = original_record_type;
 402             return ZEBRA_FAIL;
 403         }
 404         streamp = &stream;
 405         zebra_create_stream_fd(streamp, fd, 0);
 406     }
 407     while(1)
 408     {
 409         int more = 0;
 410         r = zebra_extract_record_stream(zh, streamp,
 411                                         deleteFlag,
 412                                         0, /* tst_mode */
 413                                         zh->m_record_type,
 414                                         sysno,
 415                                         0, /*match_criteria */
 416                                         fname,
 417                                         1, /* force_update */
 418                                         1, /* allow_update */
 419                                         recType, recTypeClientData, &more);
 420         if (!more)
 421             break;
 422         if (sysno)
 423         {
 424             break;
 425         }
 426     }
 427     if (streamp)
 428         stream.destroy(streamp);
 429     zh->m_record_type = original_record_type;
 430     return r;
 431 }
 432
 433 /*
 434   If sysno is provided, then it's used to identify the reocord.
 435   If not, and match_criteria is provided, then sysno is guessed
 436   If not, and a record is provided, then sysno is got from there
 437
 438  */
 439
 440 ZEBRA_RES zebra_buffer_extract_record(ZebraHandle zh,
 441                                       const char *buf, size_t buf_size,
 442                                       int delete_flag,
 443                                       int test_mode,
 444                                       const char *recordType,
 445                                       zint *sysno,
 446                                       const char *match_criteria,
 447                                       const char *fname,
 448                                       int force_update,
 449                                       int allow_update)
 450 {
 451     struct ZebraRecStream stream;
 452     ZEBRA_RES res;
 453     void *clientData;
 454     RecType recType = 0;
 455     int more = 0;
 456
 457     if (recordType && *recordType)
 458     {
 459         yaz_log(log_level_extract,
 460                 "Record type explicitly specified: %s", recordType);
 461         recType = recType_byName (zh->reg->recTypes, zh->res, recordType,
 462                                   &clientData);
 463     }
 464     else
 465     {
 466         if (!(zh->m_record_type))
 467         {
 468             yaz_log (YLOG_WARN, "No such record type defined");
 469             return ZEBRA_FAIL;
 470         }
 471         yaz_log(log_level_extract, "Get record type from rgroup: %s",
 472                 zh->m_record_type);
 473         recType = recType_byName (zh->reg->recTypes, zh->res,
 474                                   zh->m_record_type, &clientData);
 475         recordType = zh->m_record_type;
 476     }
 477
 478     if (!recType)
 479     {
 480         yaz_log (YLOG_WARN, "No such record type: %s", recordType);
 481         return ZEBRA_FAIL;
 482     }
 483
 484     zebra_create_stream_mem(&stream, buf, buf_size);
 485
 486     res = zebra_extract_record_stream(zh, &stream,
 487                                       delete_flag,
 488                                       test_mode,
 489                                       recordType,
 490                                       sysno,
 491                                       match_criteria,
 492                                       fname,
 493                                       force_update,
 494                                       allow_update,
 495                                       recType, clientData, &more);
 496     stream.destroy(&stream);
 497     return res;
 498 }
 499
 500
 501 ZEBRA_RES zebra_extract_record_stream(ZebraHandle zh,
 502                                       struct ZebraRecStream *stream,
 503                                       int delete_flag,
 504                                       int test_mode,
 505                                       const char *recordType,
 506                                       zint *sysno,
 507                                       const char *match_criteria,
 508                                       const char *fname,
 509                                       int force_update,
 510                                       int allow_update,
 511                                       RecType recType,
 512                                       void *recTypeClientData,
 513                                       int *more)
 514
 515 {
 516     zint sysno0 = 0;
 517     RecordAttr *recordAttr;
 518     struct recExtractCtrl extractCtrl;
 519     int r;
 520     const char *matchStr = 0;
 521     Record rec;
 522     off_t start_offset = 0, end_offset = 0;
 523     const char *pr_fname = fname;  /* filename to print .. */
 524     int show_progress = zh->records_processed < zh->m_file_verbose_limit ? 1:0;
 525
 526     zebra_init_log_level();
 527
 528     if (!pr_fname)
 529         pr_fname = "<no file>";  /* make it printable if file is omitted */
 530
 531     zebra_rec_keys_reset(zh->reg->keys);
 532     zebra_rec_keys_reset(zh->reg->sortKeys);
 533
 534     if (zebraExplain_curDatabase (zh->reg->zei, zh->basenames[0]))
 535     {
 536         if (zebraExplain_newDatabase (zh->reg->zei, zh->basenames[0],
 537                                       zh->m_explain_database))
 538             return ZEBRA_FAIL;
 539     }
 540
 541     if (stream)
 542     {
 543         off_t null_offset = 0;
 544         extractCtrl.stream = stream;
 545
 546         start_offset = stream->tellf(stream);
 547
 548         extractCtrl.first_record = start_offset ? 0 : 1;
 549
 550         stream->endf(stream, &null_offset);;
 551
 552         extractCtrl.init = extract_init;
 553         extractCtrl.tokenAdd = extract_token_add;
 554         extractCtrl.schemaAdd = extract_schema_add;
 555         extractCtrl.dh = zh->reg->dh;
 556         extractCtrl.handle = zh;
 557         extractCtrl.match_criteria[0] = '\0';
 558         extractCtrl.staticrank = 0;
 559
 560         init_extractCtrl(zh, &extractCtrl);
 561
 562         extract_set_store_data_prepare(&extractCtrl);
 563
 564         r = (*recType->extract)(recTypeClientData, &extractCtrl);
 565
 566         if (r == RECCTRL_EXTRACT_EOF)
 567             return ZEBRA_FAIL;
 568         else if (r == RECCTRL_EXTRACT_ERROR_GENERIC)
 569         {
 570             /* error occured during extraction ... */
 571             yaz_log (YLOG_WARN, "extract error: generic");
 572             return ZEBRA_FAIL;
 573         }
 574         else if (r == RECCTRL_EXTRACT_ERROR_NO_SUCH_FILTER)
 575         {
 576             /* error occured during extraction ... */
 577             yaz_log (YLOG_WARN, "extract error: no such filter");
 578             return ZEBRA_FAIL;
 579         }
 580
 581         all_matches_add(&extractCtrl);
 582
 583         if (extractCtrl.match_criteria[0])
 584             match_criteria = extractCtrl.match_criteria;
 585
 586
 587         end_offset = stream->endf(stream, 0);
 588
 589         if (!end_offset)
 590             end_offset = stream->tellf(stream);
 591         else
 592             stream->seekf(stream, end_offset);
 593
 594     }
 595
 596
 597     *more = 1;
 598     if (!sysno)
 599     {
 600         sysno = &sysno0;
 601
 602         if (match_criteria && *match_criteria) {
 603             matchStr = match_criteria;
 604         } else {
 605             if (zh->m_record_id && *zh->m_record_id) {
 606                 matchStr = get_match_from_spec(zh, zh->reg->keys, pr_fname,
 607                                                zh->m_record_id);
 608                 if (!matchStr)
 609                 {
 610                     yaz_log (YLOG_LOG, "error %s %s " ZINT_FORMAT, recordType,
 611                              pr_fname, (zint) start_offset);
 612                     return ZEBRA_FAIL;
 613                 }
 614             }
 615         }
 616         if (matchStr)
 617         {
 618             int db_ord = zebraExplain_get_database_ord(zh->reg->zei);
 619             char *rinfo = dict_lookup_ord(zh->reg->matchDict, db_ord,
 620                                           matchStr);
 621             if (rinfo)
 622             {
 623                 assert(*rinfo == sizeof(*sysno));
 624                 memcpy (sysno, rinfo+1, sizeof(*sysno));
 625             }
 626         }
 627     }
 628     if (zebra_rec_keys_empty(zh->reg->keys))
 629     {
 630         /* the extraction process returned no information - the record
 631            is probably empty - unless flagShowRecords is in use */
 632         if (test_mode)
 633             return ZEBRA_OK;
 634     }
 635
 636     if (! *sysno)
 637     {
 638         /* new record */
 639         if (delete_flag)
 640         {
 641             yaz_log (YLOG_LOG, "delete %s %s " ZINT_FORMAT, recordType,
 642                          pr_fname, (zint) start_offset);
 643             yaz_log (YLOG_WARN, "cannot delete record above (seems new)");
 644             return ZEBRA_FAIL;
 645         }
 646         if (show_progress)
 647             yaz_log (YLOG_LOG, "add %s %s " ZINT_FORMAT, recordType, pr_fname,
 648                      (zint) start_offset);
 649         rec = rec_new (zh->reg->records);
 650
 651         *sysno = rec->sysno;
 652
 653         recordAttr = rec_init_attr (zh->reg->zei, rec);
 654         if (extractCtrl.staticrank < 0)
 655         {
 656             yaz_log(YLOG_WARN, "Negative staticrank for record. Set to 0");
 657             extractCtrl.staticrank = 0;
 658         }
 659         recordAttr->staticrank = extractCtrl.staticrank;
 660
 661         if (matchStr)
 662         {
 663             int db_ord = zebraExplain_get_database_ord(zh->reg->zei);
 664             dict_insert_ord(zh->reg->matchDict, db_ord, matchStr,
 665                             sizeof(*sysno), sysno);
 666         }
 667
 668         extract_flush_sort_keys(zh, *sysno, 1, zh->reg->sortKeys);
 669         extract_flush_record_keys(zh, *sysno, 1, zh->reg->keys,
 670                                   recordAttr->staticrank);
 671         zh->records_inserted++;
 672     }
 673     else
 674     {
 675         /* record already exists */
 676         zebra_rec_keys_t delkeys = zebra_rec_keys_open();
 677         zebra_rec_keys_t sortKeys = zebra_rec_keys_open();
 678         if (!allow_update)
 679         {
 680             yaz_log (YLOG_LOG, "skipped %s %s " ZINT_FORMAT,
 681                          recordType, pr_fname, (zint) start_offset);
 682             logRecord(zh);
 683             return ZEBRA_FAIL;
 684         }
 685
 686         rec = rec_get (zh->reg->records, *sysno);
 687         assert (rec);
 688
 689         recordAttr = rec_init_attr (zh->reg->zei, rec);
 690
 691         /* decrease total size */
 692         zebraExplain_recordBytesIncrement (zh->reg->zei,
 693                                            - recordAttr->recordSize);
 694
 695         zebra_rec_keys_set_buf(delkeys,
 696                                rec->info[recInfo_delKeys],
 697                                rec->size[recInfo_delKeys],
 698                                0);
 699         zebra_rec_keys_set_buf(sortKeys,
 700                                rec->info[recInfo_sortKeys],
 701                                rec->size[recInfo_sortKeys],
 702                                0);
 703
 704         extract_flush_sort_keys(zh, *sysno, 0, sortKeys);
 705         extract_flush_record_keys(zh, *sysno, 0, delkeys,
 706                                   recordAttr->staticrank);
 707         if (delete_flag)
 708         {
 709             /* record going to be deleted */
 710             if (zebra_rec_keys_empty(delkeys))
 711             {
 712                 yaz_log(YLOG_LOG, "delete %s %s " ZINT_FORMAT, recordType,
 713                         pr_fname, (zint) start_offset);
 714                 yaz_log(YLOG_WARN, "cannot delete file above, "
 715                         "storeKeys false (3)");
 716             }
 717             else
 718             {
 719                 if (show_progress)
 720                     yaz_log(YLOG_LOG, "delete %s %s " ZINT_FORMAT, recordType,
 721                             pr_fname, (zint) start_offset);
 722                 zh->records_deleted++;
 723                 if (matchStr)
 724                 {
 725                     int db_ord = zebraExplain_get_database_ord(zh->reg->zei);
 726                     dict_delete_ord(zh->reg->matchDict, db_ord, matchStr);
 727                 }
 728                 rec_del (zh->reg->records, &rec);
 729             }
 730             rec_free(&rec);
 731             logRecord(zh);
 732             return ZEBRA_OK;
 733         }
 734         else
 735         {
 736             if (show_progress)
 737                 yaz_log(YLOG_LOG, "update %s %s " ZINT_FORMAT, recordType,
 738                         pr_fname, (zint) start_offset);
 739             recordAttr->staticrank = extractCtrl.staticrank;
 740             extract_flush_sort_keys(zh, *sysno, 1, zh->reg->sortKeys);
 741             extract_flush_record_keys(zh, *sysno, 1, zh->reg->keys,
 742                                       recordAttr->staticrank);
 743             zh->records_updated++;
 744         }
 745         zebra_rec_keys_close(delkeys);
 746         zebra_rec_keys_close(sortKeys);
 747     }
 748     /* update file type */
 749     xfree (rec->info[recInfo_fileType]);
 750     rec->info[recInfo_fileType] =
 751         rec_strdup (recordType, &rec->size[recInfo_fileType]);
 752
 753     /* update filename */
 754     xfree (rec->info[recInfo_filename]);
 755     rec->info[recInfo_filename] =
 756         rec_strdup (fname, &rec->size[recInfo_filename]);
 757
 758     /* update delete keys */
 759     xfree (rec->info[recInfo_delKeys]);
 760     if (!zebra_rec_keys_empty(zh->reg->keys) && zh->m_store_keys == 1)
 761     {
 762         zebra_rec_keys_get_buf(zh->reg->keys,
 763                                &rec->info[recInfo_delKeys],
 764                                &rec->size[recInfo_delKeys]);
 765     }
 766     else
 767     {
 768         rec->info[recInfo_delKeys] = NULL;
 769         rec->size[recInfo_delKeys] = 0;
 770     }
 771     /* update sort keys */
 772     xfree (rec->info[recInfo_sortKeys]);
 773
 774     zebra_rec_keys_get_buf(zh->reg->sortKeys,
 775                            &rec->info[recInfo_sortKeys],
 776                            &rec->size[recInfo_sortKeys]);
 777
 778     if (stream)
 779     {
 780         recordAttr->recordSize = end_offset - start_offset;
 781         zebraExplain_recordBytesIncrement(zh->reg->zei,
 782                                           recordAttr->recordSize);
 783     }
 784
 785     /* set run-number for this record */
 786     recordAttr->runNumber =
 787         zebraExplain_runNumberIncrement (zh->reg->zei, 0);
 788
 789     /* update store data */
 790     xfree (rec->info[recInfo_storeData]);
 791
 792     /* update store data */
 793     if (zh->store_data_buf)
 794     {
 795         rec->size[recInfo_storeData] = zh->store_data_size;
 796         rec->info[recInfo_storeData] = zh->store_data_buf;
 797         zh->store_data_buf = 0;
 798         recordAttr->recordSize = zh->store_data_size;
 799     }
 800     else if (zh->m_store_data)
 801     {
 802         off_t cur_offset = stream->tellf(stream);
 803
 804         rec->size[recInfo_storeData] = recordAttr->recordSize;
 805         rec->info[recInfo_storeData] = (char *)
 806             xmalloc (recordAttr->recordSize);
 807         stream->seekf(stream, start_offset);
 808         stream->readf(stream, rec->info[recInfo_storeData],
 809                       recordAttr->recordSize);
 810         stream->seekf(stream, cur_offset);
 811     }
 812     else
 813     {
 814         rec->info[recInfo_storeData] = NULL;
 815         rec->size[recInfo_storeData] = 0;
 816     }
 817     /* update database name */
 818     xfree (rec->info[recInfo_databaseName]);
 819     rec->info[recInfo_databaseName] =
 820         rec_strdup (zh->basenames[0], &rec->size[recInfo_databaseName]);
 821
 822     /* update offset */
 823     recordAttr->recordOffset = start_offset;
 824
 825     /* commit this record */
 826     rec_put (zh->reg->records, &rec);
 827     logRecord(zh);
 828     return ZEBRA_OK;
 829 }
 830
 831 ZEBRA_RES zebra_extract_explain(void *handle, Record rec, data1_node *n)
 832 {
 833     ZebraHandle zh = (ZebraHandle) handle;
 834     struct recExtractCtrl extractCtrl;
 835
 836     if (zebraExplain_curDatabase (zh->reg->zei,
 837                                   rec->info[recInfo_databaseName]))
 838     {
 839         abort();
 840         if (zebraExplain_newDatabase (zh->reg->zei,
 841                                       rec->info[recInfo_databaseName], 0))
 842             abort ();
 843     }
 844
 845     zebra_rec_keys_reset(zh->reg->keys);
 846     zebra_rec_keys_reset(zh->reg->sortKeys);
 847
 848     extractCtrl.init = extract_init;
 849     extractCtrl.tokenAdd = extract_token_add;
 850     extractCtrl.schemaAdd = extract_schema_add;
 851     extractCtrl.dh = zh->reg->dh;
 852
 853     init_extractCtrl(zh, &extractCtrl);
 854
 855     extractCtrl.flagShowRecords = 0;
 856     extractCtrl.match_criteria[0] = '\0';
 857     extractCtrl.staticrank = 0;
 858     extractCtrl.handle = handle;
 859     extractCtrl.first_record = 1;
 860
 861     extract_set_store_data_prepare(&extractCtrl);
 862
 863     if (n)
 864         grs_extract_tree(&extractCtrl, n);
 865
 866     if (rec->size[recInfo_delKeys])
 867     {
 868         zebra_rec_keys_t delkeys = zebra_rec_keys_open();
 869
 870         zebra_rec_keys_t sortkeys = zebra_rec_keys_open();
 871
 872         zebra_rec_keys_set_buf(delkeys, rec->info[recInfo_delKeys],
 873                                rec->size[recInfo_delKeys],
 874                                0);
 875         extract_flush_record_keys(zh, rec->sysno, 0, delkeys, 0);
 876         zebra_rec_keys_close(delkeys);
 877
 878         zebra_rec_keys_set_buf(sortkeys, rec->info[recInfo_sortKeys],
 879                                rec->size[recInfo_sortKeys],
 880                                0);
 881
 882         extract_flush_sort_keys(zh, rec->sysno, 0, sortkeys);
 883         zebra_rec_keys_close(sortkeys);
 884     }
 885     extract_flush_record_keys(zh, rec->sysno, 1, zh->reg->keys, 0);
 886     extract_flush_sort_keys(zh, rec->sysno, 1, zh->reg->sortKeys);
 887
 888     xfree (rec->info[recInfo_delKeys]);
 889     zebra_rec_keys_get_buf(zh->reg->keys,
 890                            &rec->info[recInfo_delKeys],
 891                            &rec->size[recInfo_delKeys]);
 892
 893     xfree (rec->info[recInfo_sortKeys]);
 894     zebra_rec_keys_get_buf(zh->reg->sortKeys,
 895                            &rec->info[recInfo_sortKeys],
 896                            &rec->size[recInfo_sortKeys]);
 897     return ZEBRA_OK;
 898 }
 899
 900 void extract_rec_keys_log(ZebraHandle zh, int is_insert,
 901                           zebra_rec_keys_t reckeys,
 902                           int level)
 903 {
 904     if (zebra_rec_keys_rewind(reckeys))
 905     {
 906         size_t slen;
 907         const char *str;
 908         struct it_key key;
 909         NMEM nmem = nmem_create();
 910
 911         while(zebra_rec_keys_read(reckeys, &str, &slen, &key))
 912         {
 913             char keystr[200]; /* room for zints to print */
 914             char *dst_term = 0;
 915             int ord = CAST_ZINT_TO_INT(key.mem[0]);
 916             int index_type, i;
 917             const char *string_index;
 918
 919             zebraExplain_lookup_ord(zh->reg->zei, ord, &index_type,
 920                                     0/* db */, &string_index);
 921             assert(index_type);
 922             zebra_term_untrans_iconv(zh, nmem, index_type,
 923                                      &dst_term, str);
 924             *keystr = '\0';
 925             for (i = 0; i<key.len; i++)
 926             {
 927                 sprintf(keystr + strlen(keystr), ZINT_FORMAT " ", key.mem[i]);
 928             }
 929
 930             if (*str < CHR_BASE_CHAR)
 931             {
 932                 int i;
 933                 char dst_buf[200]; /* room for special chars */
 934
 935                 strcpy(dst_buf , "?");
 936
 937                 if (!strcmp(str, ""))
 938                     strcpy(dst_buf, "alwaysmatches");
 939                 if (!strcmp(str, FIRST_IN_FIELD_STR))
 940                     strcpy(dst_buf, "firstinfield");
 941                 else if (!strcmp(str, CHR_UNKNOWN))
 942                     strcpy(dst_buf, "unknown");
 943                 else if (!strcmp(str, CHR_SPACE))
 944                     strcpy(dst_buf, "space");
 945
 946                 for (i = 0; i<slen; i++)
 947                 {
 948                     sprintf(dst_buf + strlen(dst_buf), " %d", str[i] & 0xff);
 949                 }
 950                 yaz_log(level, "%s%c %s %s", keystr, index_type,
 951                         string_index, dst_buf);
 952
 953             }
 954             else
 955                 yaz_log(level, "%s%c %s \"%s\"", keystr, index_type,
 956                         string_index, dst_term);
 957
 958             nmem_reset(nmem);
 959         }
 960         nmem_destroy(nmem);
 961     }
 962 }
 963
 964 void extract_rec_keys_adjust(ZebraHandle zh, int is_insert,
 965                              zebra_rec_keys_t reckeys)
 966 {
 967     ZebraExplainInfo zei = zh->reg->zei;
 968     struct ord_stat {
 969         int no;
 970         int ord;
 971         struct ord_stat *next;
 972     };
 973
 974     if (zebra_rec_keys_rewind(reckeys))
 975     {
 976         struct ord_stat *ord_list = 0;
 977         struct ord_stat *p;
 978         size_t slen;
 979         const char *str;
 980         struct it_key key_in;
 981         while(zebra_rec_keys_read(reckeys, &str, &slen, &key_in))
 982         {
 983             int ord = CAST_ZINT_TO_INT(key_in.mem[0]);
 984
 985             for (p = ord_list; p ; p = p->next)
 986                 if (p->ord == ord)
 987                 {
 988                     p->no++;
 989                     break;
 990                 }
 991             if (!p)
 992             {
 993                 p = xmalloc(sizeof(*p));
 994                 p->no = 1;
 995                 p->ord = ord;
 996                 p->next = ord_list;
 997                 ord_list = p;
 998             }
 999         }
1000
1001         p = ord_list;
1002         while (p)
1003         {
1004             struct ord_stat *p1 = p;
1005
1006             if (is_insert)
1007                 zebraExplain_ord_adjust_occurrences(zei, p->ord, p->no, 1);
1008             else
1009                 zebraExplain_ord_adjust_occurrences(zei, p->ord, - p->no, -1);
1010             p = p->next;
1011             xfree(p1);
1012         }
1013     }
1014 }
1015
1016 void extract_flush_record_keys(ZebraHandle zh, zint sysno, int cmd,
1017                                zebra_rec_keys_t reckeys,
1018                                zint staticrank)
1019 {
1020     ZebraExplainInfo zei = zh->reg->zei;
1021
1022     extract_rec_keys_adjust(zh, cmd, reckeys);
1023
1024     if (log_level_details)
1025     {
1026         yaz_log(log_level_details, "Keys for record " ZINT_FORMAT " %s",
1027                 sysno, cmd ? "insert" : "delete");
1028         extract_rec_keys_log(zh, cmd, reckeys, log_level_details);
1029     }
1030
1031     if (!zh->reg->key_block)
1032     {
1033         int mem = 1024*1024 * atoi( res_get_def( zh->res, "memmax", "8"));
1034         const char *key_tmp_dir = res_get_def (zh->res, "keyTmpDir", ".");
1035         int use_threads = atoi(res_get_def (zh->res, "threads", "1"));
1036         zh->reg->key_block = key_block_create(mem, key_tmp_dir, use_threads);
1037     }
1038     zebraExplain_recordCountIncrement (zei, cmd ? 1 : -1);
1039
1040     if (zebra_rec_keys_rewind(reckeys))
1041     {
1042         size_t slen;
1043         const char *str;
1044         struct it_key key_in;
1045         while(zebra_rec_keys_read(reckeys, &str, &slen, &key_in))
1046         {
1047             key_block_write(zh->reg->key_block, sysno,
1048                             &key_in, cmd, str, slen,
1049                             staticrank, zh->m_staticrank);
1050         }
1051     }
1052 }
1053
1054
1055 ZEBRA_RES zebra_rec_keys_to_snippets(ZebraHandle zh,
1056                                      zebra_rec_keys_t reckeys,
1057                                      zebra_snippets *snippets)
1058 {
1059     NMEM nmem = nmem_create();
1060     if (zebra_rec_keys_rewind(reckeys))
1061     {
1062         const char *str;
1063         size_t slen;
1064         struct it_key key;
1065         while (zebra_rec_keys_read(reckeys, &str, &slen, &key))
1066         {
1067             char *dst_term = 0;
1068             int ord;
1069             zint seqno;
1070             int index_type;
1071
1072             assert(key.len <= IT_KEY_LEVEL_MAX && key.len > 2);
1073             seqno = key.mem[key.len-1];
1074             ord = CAST_ZINT_TO_INT(key.mem[0]);
1075
1076             zebraExplain_lookup_ord(zh->reg->zei, ord, &index_type,
1077                                     0/* db */, 0 /* string_index */);
1078             assert(index_type);
1079             zebra_term_untrans_iconv(zh, nmem, index_type,
1080                                      &dst_term, str);
1081             zebra_snippets_append(snippets, seqno, ord, dst_term);
1082             nmem_reset(nmem);
1083         }
1084     }
1085     nmem_destroy(nmem);
1086     return ZEBRA_OK;
1087 }
1088
1089 void print_rec_keys(ZebraHandle zh, zebra_rec_keys_t reckeys)
1090 {
1091     yaz_log(YLOG_LOG, "print_rec_keys");
1092     if (zebra_rec_keys_rewind(reckeys))
1093     {
1094         const char *str;
1095         size_t slen;
1096         struct it_key key;
1097         while (zebra_rec_keys_read(reckeys, &str, &slen, &key))
1098         {
1099             char dst_buf[IT_MAX_WORD];
1100             zint seqno;
1101             int index_type;
1102             int ord = CAST_ZINT_TO_INT(key.mem[0]);
1103             const char *db = 0;
1104             assert(key.len <= IT_KEY_LEVEL_MAX && key.len > 2);
1105
1106             zebraExplain_lookup_ord(zh->reg->zei, ord, &index_type, &db, 0);
1107
1108             seqno = key.mem[key.len-1];
1109
1110             zebra_term_untrans(zh, index_type, dst_buf, str);
1111
1112             yaz_log(YLOG_LOG, "ord=%d seqno=" ZINT_FORMAT
1113                     " term=%s", ord, seqno, dst_buf);
1114         }
1115     }
1116 }
1117
1118 static void extract_add_index_string(RecWord *p, zinfo_index_category_t cat,
1119                                      const char *str, int length)
1120 {
1121     struct it_key key;
1122     ZebraHandle zh = p->extractCtrl->handle;
1123     ZebraExplainInfo zei = zh->reg->zei;
1124     int ch, i;
1125
1126     ch = zebraExplain_lookup_attr_str(zei, cat, p->index_type, p->index_name);
1127     if (ch < 0)
1128         ch = zebraExplain_add_attr_str(zei, cat, p->index_type, p->index_name);
1129
1130     i = 0;
1131     key.mem[i++] = ch;
1132     key.mem[i++] = p->record_id;
1133     key.mem[i++] = p->section_id;
1134
1135     if (zh->m_segment_indexing)
1136         key.mem[i++] = p->segment;
1137     key.mem[i++] = p->seqno;
1138     key.len = i;
1139
1140     zebra_rec_keys_write(zh->reg->keys, str, length, &key);
1141 }
1142
1143 static void extract_add_sort_string(RecWord *p, const char *str, int length)
1144 {
1145     struct it_key key;
1146     ZebraHandle zh = p->extractCtrl->handle;
1147     ZebraExplainInfo zei = zh->reg->zei;
1148     int ch;
1149     zinfo_index_category_t cat = zinfo_index_category_sort;
1150
1151     ch = zebraExplain_lookup_attr_str(zei, cat, p->index_type, p->index_name);
1152     if (ch < 0)
1153         ch = zebraExplain_add_attr_str(zei, cat, p->index_type, p->index_name);
1154     key.len = 2;
1155     key.mem[0] = ch;
1156     key.mem[1] = p->record_id;
1157
1158     zebra_rec_keys_write(zh->reg->sortKeys, str, length, &key);
1159 }
1160
1161 static void extract_add_string(RecWord *p, const char *string, int length)
1162 {
1163     ZebraHandle zh = p->extractCtrl->handle;
1164     assert (length > 0);
1165
1166     if (!p->index_name)
1167         return;
1168
1169     if (zebra_maps_is_sort(zh->reg->zebra_maps, p->index_type))
1170         extract_add_sort_string(p, string, length);
1171     else
1172     {
1173         extract_add_index_string(p, zinfo_index_category_index,
1174                                  string, length);
1175         if (zebra_maps_is_alwaysmatches(zh->reg->zebra_maps, p->index_type))
1176         {
1177             RecWord word;
1178             memcpy(&word, p, sizeof(word));
1179
1180             word.seqno = 1;
1181             extract_add_index_string(
1182                 &word, zinfo_index_category_alwaysmatches, "", 0);
1183         }
1184     }
1185 }
1186
1187 static void extract_add_incomplete_field(RecWord *p)
1188 {
1189     ZebraHandle zh = p->extractCtrl->handle;
1190     const char *b = p->term_buf;
1191     int remain = p->term_len;
1192     int first = 1;
1193     const char **map = 0;
1194
1195     if (remain > 0)
1196         map = zebra_maps_input(zh->reg->zebra_maps, p->index_type, &b, remain, 0);
1197
1198     while (map)
1199     {
1200         char buf[IT_MAX_WORD+1];
1201         int i, remain;
1202
1203         /* Skip spaces */
1204         while (map && *map && **map == *CHR_SPACE)
1205         {
1206             remain = p->term_len - (b - p->term_buf);
1207             if (remain > 0)
1208                 map = zebra_maps_input(zh->reg->zebra_maps, p->index_type, &b,
1209                                        remain, 0);
1210             else
1211                 map = 0;
1212         }
1213         if (!map)
1214             break;
1215         i = 0;
1216         while (map && *map && **map != *CHR_SPACE)
1217         {
1218             const char *cp = *map;
1219
1220             while (i < IT_MAX_WORD && *cp)
1221                 buf[i++] = *(cp++);
1222             remain = p->term_len - (b - p->term_buf);
1223             if (remain > 0)
1224                 map = zebra_maps_input(zh->reg->zebra_maps, p->index_type, &b, remain, 0);
1225             else
1226                 map = 0;
1227         }
1228         if (!i)
1229             return;
1230
1231         if (first)
1232         {
1233             first = 0;
1234             if (zebra_maps_is_first_in_field(zh->reg->zebra_maps, p->index_type))
1235             {
1236                 /* first in field marker */
1237                 extract_add_string(p, FIRST_IN_FIELD_STR, FIRST_IN_FIELD_LEN);
1238                 p->seqno++;
1239             }
1240         }
1241         extract_add_string (p, buf, i);
1242         p->seqno++;
1243     }
1244 }
1245
1246 static void extract_add_complete_field (RecWord *p)
1247 {
1248     ZebraHandle zh = p->extractCtrl->handle;
1249     const char *b = p->term_buf;
1250     char buf[IT_MAX_WORD+1];
1251     const char **map = 0;
1252     int i = 0, remain = p->term_len;
1253
1254     if (remain > 0)
1255         map = zebra_maps_input (zh->reg->zebra_maps, p->index_type, &b, remain, 1);
1256
1257     while (remain > 0 && i < IT_MAX_WORD)
1258     {
1259         while (map && *map && **map == *CHR_SPACE)
1260         {
1261             remain = p->term_len - (b - p->term_buf);
1262
1263             if (remain > 0)
1264             {
1265                 int first = i ? 0 : 1;  /* first position */
1266                 map = zebra_maps_input(zh->reg->zebra_maps, p->index_type, &b, remain, first);
1267             }
1268             else
1269                 map = 0;
1270         }
1271         if (!map)
1272             break;
1273
1274         if (i && i < IT_MAX_WORD)
1275             buf[i++] = *CHR_SPACE;
1276         while (map && *map && **map != *CHR_SPACE)
1277         {
1278             const char *cp = *map;
1279
1280             if (**map == *CHR_CUT)
1281             {
1282                 i = 0;
1283             }
1284             else
1285             {
1286                 if (i >= IT_MAX_WORD)
1287                     break;
1288                 while (i < IT_MAX_WORD && *cp)
1289                     buf[i++] = *(cp++);
1290             }
1291             remain = p->term_len  - (b - p->term_buf);
1292             if (remain > 0)
1293             {
1294                 map = zebra_maps_input (zh->reg->zebra_maps, p->index_type, &b,
1295                                         remain, 0);
1296             }
1297             else
1298                 map = 0;
1299         }
1300     }
1301     if (!i)
1302         return;
1303     extract_add_string (p, buf, i);
1304 }
1305
1306 static void extract_token_add(RecWord *p)
1307 {
1308     ZebraHandle zh = p->extractCtrl->handle;
1309     WRBUF wrbuf;
1310
1311     if (log_level_extract)
1312     {
1313         yaz_log(log_level_extract, "extract_token_add "
1314                 "type=%c index=%s seqno=" ZINT_FORMAT " s=%.*s",
1315                 p->index_type, p->index_name,
1316                 p->seqno, p->term_len, p->term_buf);
1317     }
1318     if ((wrbuf = zebra_replace(zh->reg->zebra_maps, p->index_type, 0,
1319                                p->term_buf, p->term_len)))
1320     {
1321         p->term_buf = wrbuf_buf(wrbuf);
1322         p->term_len = wrbuf_len(wrbuf);
1323     }
1324     if (zebra_maps_is_complete (zh->reg->zebra_maps, p->index_type))
1325         extract_add_complete_field (p);
1326     else
1327         extract_add_incomplete_field(p);
1328 }
1329
1330 static void extract_set_store_data_cb(struct recExtractCtrl *p,
1331                                       void *buf, size_t sz)
1332 {
1333     ZebraHandle zh = (ZebraHandle) p->handle;
1334
1335     xfree(zh->store_data_buf);
1336     zh->store_data_buf = 0;
1337     zh->store_data_size = 0;
1338     if (buf && sz)
1339     {
1340         zh->store_data_buf = xmalloc(sz);
1341         zh->store_data_size = sz;
1342         memcpy(zh->store_data_buf, buf, sz);
1343     }
1344 }
1345
1346 static void extract_set_store_data_prepare(struct recExtractCtrl *p)
1347 {
1348     ZebraHandle zh = (ZebraHandle) p->handle;
1349     xfree(zh->store_data_buf);
1350     zh->store_data_buf = 0;
1351     zh->store_data_size = 0;
1352     p->setStoreData = extract_set_store_data_cb;
1353 }
1354
1355 static void extract_schema_add(struct recExtractCtrl *p, Odr_oid *oid)
1356 {
1357     ZebraHandle zh = (ZebraHandle) p->handle;
1358     zebraExplain_addSchema (zh->reg->zei, oid);
1359 }
1360
1361 void extract_flush_sort_keys(ZebraHandle zh, zint sysno,
1362                              int cmd, zebra_rec_keys_t reckeys)
1363 {
1364 #if 0
1365     yaz_log(YLOG_LOG, "extract_flush_sort_keys cmd=%d sysno=" ZINT_FORMAT,
1366             cmd, sysno);
1367     extract_rec_keys_log(zh, cmd, reckeys, YLOG_LOG);
1368 #endif
1369
1370     if (zebra_rec_keys_rewind(reckeys))
1371     {
1372         zebra_sort_index_t si = zh->reg->sort_index;
1373         size_t slen;
1374         const char *str;
1375         struct it_key key_in;
1376
1377         zebra_sort_sysno(si, sysno);
1378
1379         while (zebra_rec_keys_read(reckeys, &str, &slen, &key_in))
1380         {
1381             int ord = CAST_ZINT_TO_INT(key_in.mem[0]);
1382
1383             zebra_sort_type(si, ord);
1384             if (cmd == 1)
1385                 zebra_sort_add(si, str, slen);
1386             else
1387                 zebra_sort_delete(si);
1388         }
1389     }
1390 }
1391
1392 /*
1393  * Local variables:
1394  * c-basic-offset: 4
1395  * indent-tabs-mode: nil
1396  * End:
1397  * vim: shiftwidth=4 tabstop=8 expandtab
1398  */
1399