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