index/zsets.c

   1 /*
   2  * Copyright (C) 1994-2002, Index Data
   3  * All rights reserved.
   4  * Sebastian Hammer, Adam Dickmeiss
   5  *
   6  * $Id: zsets.c,v 1.36 2002-04-18 20:22:09 adam Exp $
   7  */
   8 #include <stdio.h>
   9 #include <assert.h>
  10 #ifdef WIN32
  11 #include <io.h>
  12 #else
  13 #include <unistd.h>
  14 #endif
  15
  16 #include "index.h"
  17 #include <rstemp.h>
  18
  19 #define SORT_IDX_ENTRYSIZE 64
  20 #define ZSET_SORT_MAX_LEVEL 3
  21
  22 struct zebra_set_term_entry {
  23     int reg_type;
  24     char *db;
  25     int set;
  26     int use;
  27     char *term;
  28 };
  29 struct zebra_set {
  30     char *name;
  31     RSET rset;
  32     NMEM nmem;
  33     int hits;
  34     int num_bases;
  35     char **basenames;
  36     Z_RPNQuery *rpn;
  37     struct zset_sort_info *sort_info;
  38     struct zebra_set_term_entry *term_entries;
  39     int term_entries_max;
  40     struct zebra_set *next;
  41     int locked;
  42 };
  43
  44 struct zset_sort_entry {
  45     int sysno;
  46     int score;
  47     char buf[ZSET_SORT_MAX_LEVEL][SORT_IDX_ENTRYSIZE];
  48 };
  49
  50 struct zset_sort_info {
  51     int max_entries;
  52     int num_entries;
  53     struct zset_sort_entry *all_entries;
  54     struct zset_sort_entry **entries;
  55 };
  56
  57 ZebraSet resultSetAddRPN (ZebraHandle zh, ODR input, ODR output,
  58                           Z_RPNQuery *rpn, int num_bases,
  59                           char **basenames,
  60                           const char *setname)
  61 {
  62     ZebraSet zebraSet;
  63     int i;
  64
  65     zh->errCode = 0;
  66     zh->errString = NULL;
  67     zh->hits = 0;
  68
  69     zebraSet = resultSetAdd (zh, setname, 1);
  70     if (!zebraSet)
  71         return 0;
  72     zebraSet->locked = 1;
  73     zebraSet->rpn = 0;
  74     zebraSet->nmem = nmem_create ();
  75
  76     zebraSet->num_bases = num_bases;
  77     zebraSet->basenames =
  78         nmem_malloc (zebraSet->nmem, num_bases * sizeof(*zebraSet->basenames));
  79     for (i = 0; i<num_bases; i++)
  80         zebraSet->basenames[i] = nmem_strdup (zebraSet->nmem, basenames[i]);
  81
  82
  83     zebraSet->rset = rpn_search (zh, output->mem, rpn,
  84                                  zebraSet->num_bases,
  85                                  zebraSet->basenames, zebraSet->name,
  86                                  zebraSet);
  87     zh->hits = zebraSet->hits;
  88     if (zebraSet->rset)
  89         zebraSet->rpn = rpn;
  90     zebraSet->locked = 0;
  91     return zebraSet;
  92 }
  93
  94 void resultSetAddTerm (ZebraHandle zh, ZebraSet s, int reg_type,
  95                        const char *db, int set,
  96                        int use, const char *term)
  97 {
  98     if (!s->nmem)
  99         s->nmem = nmem_create ();
 100     if (!s->term_entries)
 101     {
 102         int i;
 103         s->term_entries_max = 1000;
 104         s->term_entries =
 105             nmem_malloc (s->nmem, s->term_entries_max *
 106                          sizeof(*s->term_entries));
 107         for (i = 0; i < s->term_entries_max; i++)
 108             s->term_entries[i].term = 0;
 109     }
 110     if (s->hits < s->term_entries_max)
 111     {
 112         s->term_entries[s->hits].reg_type = reg_type;
 113         s->term_entries[s->hits].db = nmem_strdup (s->nmem, db);
 114         s->term_entries[s->hits].set = set;
 115         s->term_entries[s->hits].use = use;
 116         s->term_entries[s->hits].term = nmem_strdup (s->nmem, term);
 117     }
 118     (s->hits)++;
 119 }
 120
 121
 122 const char *zebra_resultSetTerms (ZebraHandle zh, const char *setname,
 123                                   int no, int *count, int *no_max)
 124 {
 125     ZebraSet s = resultSetGet (zh, setname);
 126
 127     *count = 0;
 128     *no_max = 0;
 129     if (!s || !s->rset)
 130         return 0;
 131     *no_max = s->rset->no_rset_terms;
 132     if (no < 0 || no >= *no_max)
 133         return 0;
 134     *count = s->rset->rset_terms[no]->count;
 135     return s->rset->rset_terms[no]->name;
 136 }
 137
 138
 139 ZebraSet resultSetAdd (ZebraHandle zh, const char *name, int ov)
 140 {
 141     ZebraSet s;
 142     int i;
 143
 144     for (s = zh->sets; s; s = s->next)
 145         if (!strcmp (s->name, name))
 146             break;
 147     if (s)
 148     {
 149         logf (LOG_DEBUG, "updating result set %s", name);
 150         if (!ov || s->locked)
 151             return NULL;
 152         if (s->rset)
 153             rset_delete (s->rset);
 154         if (s->nmem)
 155             nmem_destroy (s->nmem);
 156     }
 157     else
 158     {
 159         logf (LOG_DEBUG, "adding result set %s", name);
 160         s = (ZebraSet) xmalloc (sizeof(*s));
 161         s->next = zh->sets;
 162         zh->sets = s;
 163         s->name = (char *) xmalloc (strlen(name)+1);
 164         strcpy (s->name, name);
 165
 166         s->sort_info = (struct zset_sort_info *)
 167             xmalloc (sizeof(*s->sort_info));
 168         s->sort_info->max_entries = 1000;
 169         s->sort_info->entries = (struct zset_sort_entry **)
 170             xmalloc (sizeof(*s->sort_info->entries) *
 171                      s->sort_info->max_entries);
 172         s->sort_info->all_entries = (struct zset_sort_entry *)
 173             xmalloc (sizeof(*s->sort_info->all_entries) *
 174                      s->sort_info->max_entries);
 175         for (i = 0; i < s->sort_info->max_entries; i++)
 176             s->sort_info->entries[i] = s->sort_info->all_entries + i;
 177     }
 178     s->locked = 0;
 179     s->term_entries = 0;
 180     s->hits = 0;
 181     s->rset = 0;
 182     s->nmem = 0;
 183     s->rpn = 0;
 184     return s;
 185 }
 186
 187 ZebraSet resultSetGet (ZebraHandle zh, const char *name)
 188 {
 189     ZebraSet s;
 190
 191     for (s = zh->sets; s; s = s->next)
 192         if (!strcmp (s->name, name))
 193         {
 194             if (!s->term_entries && !s->rset && s->rpn)
 195             {
 196                 NMEM nmem = nmem_create ();
 197                 yaz_log (LOG_LOG, "research %s", name);
 198                 s->rset =
 199                     rpn_search (zh, nmem, s->rpn, s->num_bases,
 200                                 s->basenames, s->name, s);
 201                 nmem_destroy (nmem);
 202             }
 203             return s;
 204         }
 205     return NULL;
 206 }
 207
 208 void resultSetInvalidate (ZebraHandle zh)
 209 {
 210     ZebraSet s = zh->sets;
 211
 212     for (; s; s = s->next)
 213     {
 214         if (s->rset)
 215             rset_delete (s->rset);
 216         s->rset = 0;
 217     }
 218 }
 219
 220 void resultSetDestroy (ZebraHandle zh, int num, char **names,int *statuses)
 221 {
 222     ZebraSet * ss = &zh->sets;
 223     int i;
 224
 225     if (statuses)
 226         for (i = 0; i<num; i++)
 227             statuses[i] = Z_DeleteStatus_resultSetDidNotExist;
 228     zh->errCode = 0;
 229     zh->errString = NULL;
 230     while (*ss)
 231     {
 232         int i = -1;
 233         ZebraSet s = *ss;
 234         if (num >= 0)
 235         {
 236             for (i = 0; i<num; i++)
 237                 if (!strcmp (s->name, names[i]))
 238                 {
 239                     if (statuses)
 240                         statuses[i] = Z_DeleteStatus_success;
 241                     i = -1;
 242                     break;
 243                 }
 244         }
 245         if (i < 0)
 246         {
 247             *ss = s->next;
 248
 249             xfree (s->sort_info->all_entries);
 250             xfree (s->sort_info->entries);
 251             xfree (s->sort_info);
 252
 253             if (s->nmem)
 254                 nmem_destroy (s->nmem);
 255             if (s->rset)
 256                 rset_delete (s->rset);
 257             xfree (s->name);
 258             xfree (s);
 259         }
 260         else
 261             ss = &s->next;
 262     }
 263 }
 264
 265 ZebraPosSet zebraPosSetCreate (ZebraHandle zh, const char *name,
 266                                int num, int *positions)
 267 {
 268     ZebraSet sset;
 269     ZebraPosSet sr = 0;
 270     RSET rset;
 271     int i;
 272     struct zset_sort_info *sort_info;
 273
 274     if (!(sset = resultSetGet (zh, name)))
 275         return NULL;
 276     if (!(rset = sset->rset))
 277     {
 278         if (!sset->term_entries)
 279             return 0;
 280         sr = (ZebraPosSet) xmalloc (sizeof(*sr) * num);
 281         for (i = 0; i<num; i++)
 282         {
 283             sr[i].sysno = 0;
 284             sr[i].score = -1;
 285             sr[i].term = 0;
 286             sr[i].db = 0;
 287
 288             if (positions[i] <= sset->term_entries_max)
 289             {
 290                 sr[i].term = sset->term_entries[positions[i]-1].term;
 291                 sr[i].db = sset->term_entries[positions[i]-1].db;
 292             }
 293         }
 294     }
 295     else
 296     {
 297         sr = (ZebraPosSet) xmalloc (sizeof(*sr) * num);
 298         for (i = 0; i<num; i++)
 299         {
 300             sr[i].sysno = 0;
 301             sr[i].score = -1;
 302             sr[i].term = 0;
 303             sr[i].db = 0;
 304         }
 305         sort_info = sset->sort_info;
 306         if (sort_info)
 307         {
 308             int position;
 309
 310             for (i = 0; i<num; i++)
 311             {
 312                 position = positions[i];
 313                 if (position > 0 && position <= sort_info->num_entries)
 314                 {
 315                     logf (LOG_DEBUG, "got pos=%d (sorted)", position);
 316                     sr[i].sysno = sort_info->entries[position-1]->sysno;
 317                     sr[i].score = sort_info->entries[position-1]->score;
 318                 }
 319             }
 320         }
 321         /* did we really get all entries using sort ? */
 322         for (i = 0; i<num; i++)
 323         {
 324             if (!sr[i].sysno)
 325                 break;
 326         }
 327         if (i < num) /* nope, get the rest, unsorted - sorry */
 328         {
 329             int position = 0;
 330             int num_i = 0;
 331             int psysno = 0;
 332             int term_index;
 333             RSFD rfd;
 334             struct it_key key;
 335
 336             if (sort_info)
 337                 position = sort_info->num_entries;
 338             while (num_i < num && positions[num_i] < position)
 339                 num_i++;
 340             rfd = rset_open (rset, RSETF_READ);
 341             while (num_i < num && rset_read (rset, rfd, &key, &term_index))
 342             {
 343                 if (key.sysno != psysno)
 344                 {
 345                     psysno = key.sysno;
 346                     if (sort_info)
 347                     {
 348                         /* determine we alreay have this in our set */
 349                         for (i = sort_info->num_entries; --i >= 0; )
 350                             if (psysno == sort_info->entries[i]->sysno)
 351                                 break;
 352                         if (i >= 0)
 353                             continue;
 354                     }
 355                     position++;
 356                     assert (num_i < num);
 357                     if (position == positions[num_i])
 358                     {
 359                         sr[num_i].sysno = psysno;
 360                         logf (LOG_DEBUG, "got pos=%d (unsorted)", position);
 361                         sr[num_i].score = -1;
 362                         num_i++;
 363                     }
 364                 }
 365             }
 366             rset_close (rset, rfd);
 367         }
 368     }
 369     return sr;
 370 }
 371
 372 void zebraPosSetDestroy (ZebraHandle zh, ZebraPosSet records, int num)
 373 {
 374     xfree (records);
 375 }
 376
 377 struct sortKeyInfo {
 378     int relation;
 379     int attrUse;
 380     int numerical;
 381 };
 382
 383 void resultSetInsertSort (ZebraHandle zh, ZebraSet sset,
 384                           struct sortKeyInfo *criteria, int num_criteria,
 385                           int sysno)
 386 {
 387     struct zset_sort_entry this_entry;
 388     struct zset_sort_entry *new_entry = NULL;
 389     struct zset_sort_info *sort_info = sset->sort_info;
 390     int i, j;
 391
 392     sortIdx_sysno (zh->reg->sortIdx, sysno);
 393     for (i = 0; i<num_criteria; i++)
 394     {
 395         sortIdx_type (zh->reg->sortIdx, criteria[i].attrUse);
 396         sortIdx_read (zh->reg->sortIdx, this_entry.buf[i]);
 397     }
 398     i = sort_info->num_entries;
 399     while (--i >= 0)
 400     {
 401         int rel = 0;
 402         for (j = 0; j<num_criteria; j++)
 403         {
 404             if (criteria[j].numerical)
 405             {
 406                 double diff = atof(this_entry.buf[j]) -
 407                               atof(sort_info->entries[i]->buf[j]);
 408                 rel = 0;
 409                 if (diff > 0.0)
 410                     rel = 1;
 411                 else if (diff < 0.0)
 412                     rel = -1;
 413             }
 414             else
 415             {
 416                 rel = memcmp (this_entry.buf[j], sort_info->entries[i]->buf[j],
 417                           SORT_IDX_ENTRYSIZE);
 418             }
 419             if (rel)
 420                 break;
 421         }
 422         if (!rel)
 423             break;
 424         if (criteria[j].relation == 'A')
 425         {
 426             if (rel > 0)
 427                 break;
 428         }
 429         else if (criteria[j].relation == 'D')
 430         {
 431             if (rel < 0)
 432                 break;
 433         }
 434     }
 435     ++i;
 436     j = sort_info->max_entries;
 437     if (i == j)
 438         return;
 439
 440     if (sort_info->num_entries == j)
 441         --j;
 442     else
 443         j = (sort_info->num_entries)++;
 444     new_entry = sort_info->entries[j];
 445     while (j != i)
 446     {
 447         sort_info->entries[j] = sort_info->entries[j-1];
 448         --j;
 449     }
 450     sort_info->entries[i] = new_entry;
 451     assert (new_entry);
 452     for (i = 0; i<num_criteria; i++)
 453         memcpy (new_entry->buf[i], this_entry.buf[i], SORT_IDX_ENTRYSIZE);
 454     new_entry->sysno = sysno;
 455     new_entry->score = -1;
 456 }
 457
 458 void resultSetInsertRank (ZebraHandle zh, struct zset_sort_info *sort_info,
 459                           int sysno, int score, int relation)
 460 {
 461     struct zset_sort_entry *new_entry = NULL;
 462     int i, j;
 463
 464     i = sort_info->num_entries;
 465     while (--i >= 0)
 466     {
 467         int rel = 0;
 468
 469         rel = score - sort_info->entries[i]->score;
 470
 471         if (relation == 'D')
 472         {
 473             if (rel >= 0)
 474                 break;
 475         }
 476         else if (relation == 'A')
 477         {
 478             if (rel <= 0)
 479                 break;
 480         }
 481     }
 482     ++i;
 483     j = sort_info->max_entries;
 484     if (i == j)
 485         return;
 486
 487     if (sort_info->num_entries == j)
 488         --j;
 489     else
 490         j = (sort_info->num_entries)++;
 491
 492     new_entry = sort_info->entries[j];
 493     while (j != i)
 494     {
 495         sort_info->entries[j] = sort_info->entries[j-1];
 496         --j;
 497     }
 498     sort_info->entries[i] = new_entry;
 499     assert (new_entry);
 500     new_entry->sysno = sysno;
 501     new_entry->score = score;
 502 }
 503
 504 void resultSetSort (ZebraHandle zh, NMEM nmem,
 505                     int num_input_setnames, const char **input_setnames,
 506                     const char *output_setname,
 507                     Z_SortKeySpecList *sort_sequence, int *sort_status)
 508 {
 509     ZebraSet sset;
 510     RSET rset;
 511
 512     if (num_input_setnames == 0)
 513     {
 514         zh->errCode = 208;
 515         return ;
 516     }
 517     if (num_input_setnames > 1)
 518     {
 519         zh->errCode = 230;
 520         return;
 521     }
 522     logf (LOG_DEBUG, "result set sort input=%s output=%s",
 523           *input_setnames, output_setname);
 524     sset = resultSetGet (zh, input_setnames[0]);
 525     if (!sset)
 526     {
 527         zh->errCode = 30;
 528         zh->errString = nmem_strdup (nmem, input_setnames[0]);
 529         return;
 530     }
 531     if (!(rset = sset->rset))
 532     {
 533         zh->errCode = 30;
 534         zh->errString = nmem_strdup (nmem, input_setnames[0]);
 535         return;
 536     }
 537     if (strcmp (output_setname, input_setnames[0]))
 538     {
 539         rset = rset_dup (rset);
 540         sset = resultSetAdd (zh, output_setname, 1);
 541         sset->rset = rset;
 542     }
 543     resultSetSortSingle (zh, nmem, sset, rset, sort_sequence, sort_status);
 544 }
 545
 546 void resultSetSortSingle (ZebraHandle zh, NMEM nmem,
 547                           ZebraSet sset, RSET rset,
 548                           Z_SortKeySpecList *sort_sequence, int *sort_status)
 549 {
 550     int i, psysno = 0;
 551     struct it_key key;
 552     struct sortKeyInfo sort_criteria[3];
 553     int num_criteria;
 554     int term_index;
 555     RSFD rfd;
 556
 557     logf (LOG_LOG, "resultSetSortSingle start");
 558     sset->sort_info->num_entries = 0;
 559
 560     sset->hits = 0;
 561     num_criteria = sort_sequence->num_specs;
 562     if (num_criteria > 3)
 563         num_criteria = 3;
 564     for (i = 0; i < num_criteria; i++)
 565     {
 566         Z_SortKeySpec *sks = sort_sequence->specs[i];
 567         Z_SortKey *sk;
 568
 569         if (*sks->sortRelation == Z_SortRelation_ascending)
 570             sort_criteria[i].relation = 'A';
 571         else if (*sks->sortRelation == Z_SortRelation_descending)
 572             sort_criteria[i].relation = 'D';
 573         else
 574         {
 575             zh->errCode = 214;
 576             return;
 577         }
 578         if (sks->sortElement->which == Z_SortElement_databaseSpecific)
 579         {
 580             zh->errCode = 210;
 581             return;
 582         }
 583         else if (sks->sortElement->which != Z_SortElement_generic)
 584         {
 585             zh->errCode = 237;
 586             return;
 587         }
 588         sk = sks->sortElement->u.generic;
 589         switch (sk->which)
 590         {
 591         case Z_SortKey_sortField:
 592             logf (LOG_DEBUG, "Sort: key %d is of type sortField", i+1);
 593             zh->errCode = 207;
 594             return;
 595         case Z_SortKey_elementSpec:
 596             logf (LOG_DEBUG, "Sort: key %d is of type elementSpec", i+1);
 597             zh->errCode = 207;
 598             return;
 599         case Z_SortKey_sortAttributes:
 600             logf (LOG_DEBUG, "Sort: key %d is of type sortAttributes", i+1);
 601             sort_criteria[i].attrUse =
 602                 zebra_maps_sort (zh->reg->zebra_maps,
 603                                  sk->u.sortAttributes,
 604                                  &sort_criteria[i].numerical);
 605             logf (LOG_DEBUG, "use value = %d", sort_criteria[i].attrUse);
 606             if (sort_criteria[i].attrUse == -1)
 607             {
 608                 zh->errCode = 116;
 609                 return;
 610             }
 611             if (sortIdx_type (zh->reg->sortIdx, sort_criteria[i].attrUse))
 612             {
 613                 zh->errCode = 207;
 614                 return;
 615             }
 616             break;
 617         }
 618     }
 619     rfd = rset_open (rset, RSETF_READ);
 620     while (rset_read (rset, rfd, &key, &term_index))
 621     {
 622         if (key.sysno != psysno)
 623         {
 624             (sset->hits)++;
 625             psysno = key.sysno;
 626             resultSetInsertSort (zh, sset,
 627                                  sort_criteria, num_criteria, psysno);
 628         }
 629     }
 630     rset_close (rset, rfd);
 631
 632     for (i = 0; i < rset->no_rset_terms; i++)
 633         yaz_log (LOG_LOG, "term=\"%s\" nn=%d type=%s count=%d",
 634                  rset->rset_terms[i]->name,
 635                  rset->rset_terms[i]->nn,
 636                  rset->rset_terms[i]->flags,
 637                  rset->rset_terms[i]->count);
 638
 639     *sort_status = Z_SortStatus_success;
 640     logf (LOG_LOG, "resultSetSortSingle end");
 641 }
 642
 643 RSET resultSetRef (ZebraHandle zh, Z_ResultSetId *resultSetId)
 644 {
 645     ZebraSet s;
 646
 647     if ((s = resultSetGet (zh, resultSetId)))
 648         return s->rset;
 649     return NULL;
 650 }
 651
 652 void resultSetRank (ZebraHandle zh, ZebraSet zebraSet, RSET rset)
 653 {
 654     int kno = 0;
 655     struct it_key key;
 656     RSFD rfd;
 657     int term_index, i;
 658     ZebraRankClass rank_class;
 659     struct rank_control *rc;
 660     struct zset_sort_info *sort_info;
 661
 662     sort_info = zebraSet->sort_info;
 663     sort_info->num_entries = 0;
 664     zebraSet->hits = 0;
 665     rfd = rset_open (rset, RSETF_READ);
 666
 667     yaz_log (LOG_LOG, "resultSetRank");
 668
 669     rank_class = zebraRankLookup (zh, "rank-1");
 670     rc = rank_class->control;
 671
 672     if (rset_read (rset, rfd, &key, &term_index))
 673     {
 674         int psysno = key.sysno;
 675         int score;
 676         void *handle =
 677             (*rc->begin) (zh->reg, rank_class->class_handle, rset);
 678         (zebraSet->hits)++;
 679         do
 680         {
 681             kno++;
 682             if (key.sysno != psysno)
 683             {
 684                 score = (*rc->calc) (handle, psysno);
 685
 686                 resultSetInsertRank (zh, sort_info, psysno, score, 'A');
 687                 (zebraSet->hits)++;
 688                 psysno = key.sysno;
 689             }
 690             (*rc->add) (handle, key.seqno, term_index);
 691         }
 692         while (rset_read (rset, rfd, &key, &term_index));
 693         score = (*rc->calc) (handle, psysno);
 694         resultSetInsertRank (zh, sort_info, psysno, score, 'A');
 695         (*rc->end) (zh->reg, handle);
 696     }
 697     rset_close (rset, rfd);
 698
 699     for (i = 0; i < rset->no_rset_terms; i++)
 700         yaz_log (LOG_LOG, "term=\"%s\" nn=%d type=%s count=%d",
 701                  rset->rset_terms[i]->name,
 702                  rset->rset_terms[i]->nn,
 703                  rset->rset_terms[i]->flags,
 704                  rset->rset_terms[i]->count);
 705
 706     yaz_log (LOG_LOG, "%d keys, %d distinct sysnos", kno, zebraSet->hits);
 707 }
 708
 709 ZebraRankClass zebraRankLookup (ZebraHandle zh, const char *name)
 710 {
 711     ZebraRankClass p = zh->reg->rank_classes;
 712     while (p && strcmp (p->control->name, name))
 713         p = p->next;
 714     if (p && !p->init_flag)
 715     {
 716         if (p->control->create)
 717             p->class_handle = (*p->control->create)(zh->reg);
 718         p->init_flag = 1;
 719     }
 720     return p;
 721 }
 722
 723 void zebraRankInstall (struct zebra_register *reg, struct rank_control *ctrl)
 724 {
 725     ZebraRankClass p = (ZebraRankClass) xmalloc (sizeof(*p));
 726     p->control = (struct rank_control *) xmalloc (sizeof(*p->control));
 727     memcpy (p->control, ctrl, sizeof(*p->control));
 728     p->control->name = xstrdup (ctrl->name);
 729     p->init_flag = 0;
 730     p->next = reg->rank_classes;
 731     reg->rank_classes = p;
 732 }
 733
 734 void zebraRankDestroy (struct zebra_register *reg)
 735 {
 736     ZebraRankClass p = reg->rank_classes;
 737     while (p)
 738     {
 739         ZebraRankClass p_next = p->next;
 740         if (p->init_flag && p->control->destroy)
 741             (*p->control->destroy)(reg, p->class_handle);
 742         xfree (p->control->name);
 743         xfree (p->control);
 744         xfree (p);
 745         p = p_next;
 746     }
 747     reg->rank_classes = NULL;
 748 }