src/data/value-labels.c

   1 /* PSPP - computes sample statistics.
   2    Copyright (C) 1997-9, 2000 Free Software Foundation, Inc.
   3    Written by Ben Pfaff <blp@gnu.org>.
   4
   5    This program is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU General Public License as
   7    published by the Free Software Foundation; either version 2 of the
   8    License, or (at your option) any later version.
   9
  10    This program is distributed in the hope that it will be useful, but
  11    WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program; if not, write to the Free Software
  17    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  18    02110-1301, USA. */
  19
  20 #include <config.h>
  21
  22 #include "value-labels.h"
  23
  24 #include <stdlib.h>
  25
  26 #include <data/variable.h>
  27 #include <libpspp/alloc.h>
  28 #include <libpspp/compiler.h>
  29 #include <libpspp/hash.h>
  30 #include <libpspp/message.h>
  31 #include <libpspp/str.h>
  32
  33 static hsh_compare_func compare_int_val_lab;
  34 static hsh_hash_func hash_int_val_lab;
  35 static hsh_free_func free_int_val_lab;
  36
  37 struct atom;
  38 static struct atom *atom_create (const char *string);
  39 static void atom_destroy (struct atom *);
  40 static char *atom_to_string (const struct atom *);
  41
  42 /* A set of value labels. */
  43 struct val_labs
  44   {
  45     int width;                  /* 0=numeric, otherwise string width. */
  46     struct hsh_table *labels;   /* Hash table of `struct int_val_lab's. */
  47   };
  48
  49 /* Creates and returns a new, empty set of value labels with the
  50    given WIDTH, which must designate a numeric (0) or short
  51    string (1...MAX_SHORT_STRING inclusive) width. */
  52 struct val_labs *
  53 val_labs_create (int width)
  54 {
  55   struct val_labs *vls;
  56
  57   assert (width >= 0);
  58
  59   vls = xmalloc (sizeof *vls);
  60   vls->width = width;
  61   vls->labels = NULL;
  62   return vls;
  63 }
  64
  65 /* Creates and returns a new set of value labels identical to
  66    VLS. */
  67 struct val_labs *
  68 val_labs_copy (const struct val_labs *vls)
  69 {
  70   struct val_labs *copy;
  71   struct val_labs_iterator *i;
  72   struct val_lab *vl;
  73
  74   assert (vls != NULL);
  75
  76   copy = val_labs_create (vls->width);
  77   for (vl = val_labs_first (vls, &i); vl != NULL;
  78        vl = val_labs_next (vls, &i))
  79     val_labs_add (copy, vl->value, vl->label);
  80   return copy;
  81 }
  82
  83 /* Changes the width of VLS to NEW_WIDTH.  If VLS is numeric,
  84    NEW_WIDTH must be 0, otherwise it must be within the range
  85    1...MAX_SHORT_STRING inclusive. */
  86 void
  87 val_labs_set_width (struct val_labs *vls, int new_width)
  88 {
  89   assert (vls != NULL);
  90   assert ((vls->width == 0) == (new_width == 0));
  91
  92   vls->width = new_width;
  93 }
  94
  95 /* Destroys VLS. */
  96 void
  97 val_labs_destroy (struct val_labs *vls)
  98 {
  99   if (vls != NULL)
 100     {
 101       if (vls->labels != NULL)
 102         hsh_destroy (vls->labels);
 103       free (vls);
 104     }
 105 }
 106
 107 /* Removes all the value labels from VLS. */
 108 void
 109 val_labs_clear (struct val_labs *vls)
 110 {
 111   assert (vls != NULL);
 112
 113   hsh_destroy (vls->labels);
 114   vls->labels = NULL;
 115 }
 116
 117 /* Returns the number of value labels in VLS. */
 118 size_t
 119 val_labs_count (const struct val_labs *vls)
 120 {
 121   assert (vls != NULL);
 122
 123   if (vls->labels == NULL)
 124     return 0;
 125   else
 126     return hsh_count (vls->labels);
 127 }
 128 \f
 129 /* One value label in internal format. */
 130 struct int_val_lab
 131   {
 132     union value value;          /* The value being labeled. */
 133     struct atom *label;         /* A ref-counted string. */
 134   };
 135
 136 /* Creates and returns an int_val_lab based on VALUE and
 137    LABEL. */
 138 static struct int_val_lab *
 139 create_int_val_lab (struct val_labs *vls, union value value, const char *label)
 140 {
 141   struct int_val_lab *ivl;
 142
 143   assert (label != NULL);
 144   assert (vls->width <= MAX_SHORT_STRING);
 145
 146   ivl = xmalloc (sizeof *ivl);
 147   ivl->value = value;
 148   if (vls->width > 0)
 149     memset (ivl->value.s + vls->width, ' ', MAX_SHORT_STRING - vls->width);
 150   ivl->label = atom_create (label);
 151
 152   return ivl;
 153 }
 154
 155 /* If VLS does not already contain a value label for VALUE, adds
 156    LABEL for it and returns nonzero.  Otherwise, returns zero.
 157    Behavior is undefined if VLS's width is greater than
 158    MAX_SHORT_STRING. */
 159 int
 160 val_labs_add (struct val_labs *vls, union value value, const char *label)
 161 {
 162   struct int_val_lab *ivl;
 163   void **vlpp;
 164
 165   assert (vls != NULL);
 166   assert (vls->width <= MAX_SHORT_STRING);
 167   assert (label != NULL);
 168
 169   if (vls->labels == NULL)
 170     vls->labels = hsh_create (8, compare_int_val_lab, hash_int_val_lab,
 171                               free_int_val_lab, vls);
 172
 173   ivl = create_int_val_lab (vls, value, label);
 174   vlpp = hsh_probe (vls->labels, ivl);
 175   if (*vlpp == NULL)
 176     {
 177       *vlpp = ivl;
 178       return 1;
 179     }
 180   else
 181     {
 182       free_int_val_lab (ivl, vls);
 183       return 0;
 184     }
 185 }
 186
 187 /* Sets LABEL as the value label for VALUE in VLS.  Returns zero
 188    if there wasn't already a value label for VALUE, or nonzero if
 189    there was.  Behavior is undefined if VLS's width is greater
 190    than MAX_SHORT_STRING. */
 191 int
 192 val_labs_replace (struct val_labs *vls, union value value, const char *label)
 193 {
 194   struct int_val_lab *ivl;
 195
 196   assert (vls != NULL);
 197   assert (vls->width <= MAX_SHORT_STRING);
 198   assert (label != NULL);
 199
 200   if (vls->labels == NULL)
 201     {
 202       val_labs_add (vls, value, label);
 203       return 0;
 204     }
 205
 206   ivl = hsh_replace (vls->labels, create_int_val_lab (vls, value, label));
 207   if (ivl == NULL)
 208     return 0;
 209   else
 210     {
 211       free_int_val_lab (ivl, vls);
 212       return 1;
 213     }
 214 }
 215
 216 /* Removes any value label for VALUE within VLS.  Returns nonzero
 217    if a value label was removed. Behavior is undefined if VLS's
 218    width is greater than MAX_SHORT_STRING. */
 219 int
 220 val_labs_remove (struct val_labs *vls, union value value)
 221 {
 222   assert (vls != NULL);
 223   assert (vls->width <= MAX_SHORT_STRING);
 224
 225   if (vls->labels != NULL)
 226     {
 227       struct int_val_lab *ivl = create_int_val_lab (vls, value, "");
 228       int deleted = hsh_delete (vls->labels, ivl);
 229       free (ivl);
 230       return deleted;
 231     }
 232   else
 233     return 0;
 234 }
 235
 236 /* Searches VLS for a value label for VALUE.  If successful,
 237    returns the label; otherwise, returns a null pointer.  If
 238    VLS's width is greater than MAX_SHORT_STRING, always returns a
 239    null pointer. */
 240 char *
 241 val_labs_find (const struct val_labs *vls, union value value)
 242 {
 243   assert (vls != NULL);
 244
 245   if (vls->width > MAX_SHORT_STRING)
 246     return NULL;
 247
 248   if (vls->labels != NULL)
 249     {
 250       struct int_val_lab ivl, *vlp;
 251
 252       ivl.value = value;
 253       vlp = hsh_find (vls->labels, &ivl);
 254       if (vlp != NULL)
 255         return atom_to_string (vlp->label);
 256     }
 257   return NULL;
 258 }
 259 \f
 260 /* A value labels iterator. */
 261 struct val_labs_iterator
 262   {
 263     void **labels;              /* The labels, in order. */
 264     void **lp;                  /* Current label. */
 265     struct val_lab vl;          /* Structure presented to caller. */
 266   };
 267
 268 /* Sets up *IP for iterating through the value labels in VLS in
 269    no particular order.  Returns the first value label or a null
 270    pointer if VLS is empty.  If the return value is non-null,
 271    then val_labs_next() may be used to continue iterating or
 272    val_labs_done() to free up the iterator.  Otherwise, neither
 273    function may be called for *IP. */
 274 struct val_lab *
 275 val_labs_first (const struct val_labs *vls, struct val_labs_iterator **ip)
 276 {
 277   struct val_labs_iterator *i;
 278
 279   assert (vls != NULL);
 280   assert (ip != NULL);
 281
 282   if (vls->labels == NULL || vls->width > MAX_SHORT_STRING)
 283     return NULL;
 284
 285   i = *ip = xmalloc (sizeof *i);
 286   i->labels = hsh_data_copy (vls->labels);
 287   i->lp = i->labels;
 288   return val_labs_next (vls, ip);
 289 }
 290
 291 /* Sets up *IP for iterating through the value labels in VLS in
 292    sorted order of values.  Returns the first value label or a
 293    null pointer if VLS is empty.  If the return value is
 294    non-null, then val_labs_next() may be used to continue
 295    iterating or val_labs_done() to free up the iterator.
 296    Otherwise, neither function may be called for *IP. */
 297 struct val_lab *
 298 val_labs_first_sorted (const struct val_labs *vls,
 299                        struct val_labs_iterator **ip)
 300 {
 301   struct val_labs_iterator *i;
 302
 303   assert (vls != NULL);
 304   assert (ip != NULL);
 305
 306   if (vls->labels == NULL || vls->width > MAX_SHORT_STRING)
 307     return NULL;
 308
 309   i = *ip = xmalloc (sizeof *i);
 310   i->lp = i->labels = hsh_sort_copy (vls->labels);
 311   return val_labs_next (vls, ip);
 312 }
 313
 314 /* Returns the next value label in an iteration begun by
 315    val_labs_first() or val_labs_first_sorted().  If the return
 316    value is non-null, then val_labs_next() may be used to
 317    continue iterating or val_labs_done() to free up the iterator.
 318    Otherwise, neither function may be called for *IP. */
 319 struct val_lab *
 320 val_labs_next (const struct val_labs *vls, struct val_labs_iterator **ip)
 321 {
 322   struct val_labs_iterator *i;
 323   struct int_val_lab *ivl;
 324
 325   assert (vls != NULL);
 326   assert (vls->width <= MAX_SHORT_STRING);
 327   assert (ip != NULL);
 328   assert (*ip != NULL);
 329
 330   i = *ip;
 331   ivl = *i->lp++;
 332   if (ivl != NULL)
 333     {
 334       i->vl.value = ivl->value;
 335       i->vl.label = atom_to_string (ivl->label);
 336       return &i->vl;
 337     }
 338   else
 339     {
 340       free (i->labels);
 341       free (i);
 342       *ip = NULL;
 343       return NULL;
 344     }
 345 }
 346
 347 /* Discards the state for an incomplete iteration begun by
 348    val_labs_first() or val_labs_first_sorted(). */
 349 void
 350 val_labs_done (struct val_labs_iterator **ip)
 351 {
 352   struct val_labs_iterator *i;
 353
 354   assert (ip != NULL);
 355   assert (*ip != NULL);
 356
 357   i = *ip;
 358   free (i->labels);
 359   free (i);
 360   *ip = NULL;
 361 }
 362 \f
 363 /* Compares two value labels and returns a strcmp()-type result. */
 364 int
 365 compare_int_val_lab (const void *a_, const void *b_, void *vls_)
 366 {
 367   const struct int_val_lab *a = a_;
 368   const struct int_val_lab *b = b_;
 369   const struct val_labs *vls = vls_;
 370
 371   if (vls->width == 0)
 372     return a->value.f < b->value.f ? -1 : a->value.f > b->value.f;
 373   else
 374     return memcmp (a->value.s, b->value.s, vls->width);
 375 }
 376
 377 /* Hash a value label. */
 378 unsigned
 379 hash_int_val_lab (const void *vl_, void *vls_)
 380 {
 381   const struct int_val_lab *vl = vl_;
 382   const struct val_labs *vls = vls_;
 383
 384   if (vls->width == 0)
 385     return hsh_hash_double (vl->value.f);
 386   else
 387     return hsh_hash_bytes (vl->value.s, sizeof vl->value.s);
 388 }
 389
 390 /* Free a value label. */
 391 void
 392 free_int_val_lab (void *vl_, void *vls_ UNUSED)
 393 {
 394   struct int_val_lab *vl = vl_;
 395
 396   atom_destroy (vl->label);
 397   free (vl);
 398 }
 399 \f
 400 /* Atoms. */
 401
 402 /* An atom. */
 403 struct atom
 404   {
 405     char *string;               /* String value. */
 406     unsigned ref_count;         /* Number of references. */
 407   };
 408
 409 static hsh_compare_func compare_atoms;
 410 static hsh_hash_func hash_atom;
 411 static hsh_free_func free_atom;
 412
 413 /* Hash table of atoms. */
 414 static struct hsh_table *atoms;
 415
 416 /* Creates and returns an atom for STRING. */
 417 static struct atom *
 418 atom_create (const char *string)
 419 {
 420   struct atom a;
 421   void **app;
 422
 423   assert (string != NULL);
 424
 425   if (atoms == NULL)
 426     atoms = hsh_create (8, compare_atoms, hash_atom, free_atom, NULL);
 427
 428   a.string = (char *) string;
 429   app = hsh_probe (atoms, &a);
 430   if (*app != NULL)
 431     {
 432       struct atom *ap = *app;
 433       ap->ref_count++;
 434       return ap;
 435     }
 436   else
 437     {
 438       struct atom *ap = xmalloc (sizeof *ap);
 439       ap->string = xstrdup (string);
 440       ap->ref_count = 1;
 441       *app = ap;
 442       return ap;
 443     }
 444 }
 445
 446 /* Destroys ATOM. */
 447 static void
 448 atom_destroy (struct atom *atom)
 449 {
 450   if (atom != NULL)
 451     {
 452       assert (atom->ref_count > 0);
 453       atom->ref_count--;
 454       if (atom->ref_count == 0)
 455         hsh_force_delete (atoms, atom);
 456     }
 457 }
 458
 459 /* Returns the string associated with ATOM. */
 460 static  char *
 461 atom_to_string (const struct atom *atom)
 462 {
 463   assert (atom != NULL);
 464
 465   return atom->string;
 466 }
 467
 468 /* A hsh_compare_func that compares A and B. */
 469 static int
 470 compare_atoms (const void *a_, const void *b_, void *aux UNUSED)
 471 {
 472   const struct atom *a = a_;
 473   const struct atom *b = b_;
 474
 475   return strcmp (a->string, b->string);
 476 }
 477
 478 /* A hsh_hash_func that hashes ATOM. */
 479 static unsigned
 480 hash_atom (const void *atom_, void *aux UNUSED)
 481 {
 482   const struct atom *atom = atom_;
 483
 484   return hsh_hash_string (atom->string);
 485 }
 486
 487 /* A hsh_free_func that destroys ATOM. */
 488 static void
 489 free_atom (void *atom_, void *aux UNUSED)
 490 {
 491   struct atom *atom = atom_;
 492
 493   free (atom->string);
 494   free (atom);
 495 }
 496
 497
 498 /* Get a string representing the value.
 499    That is, if it has a label, then return that label,
 500    otherwise, if the value is alpha, then return the string for it,
 501    else format it and return the formatted string
 502 */
 503 const char *
 504 value_to_string (const union value *val, const struct variable *var)
 505 {
 506   char *s;
 507
 508   assert (val != NULL);
 509   assert (var != NULL);
 510
 511   s = val_labs_find (var->val_labs, *val);
 512   if (s == NULL)
 513     {
 514       static char buf[256];
 515       if (var->width != 0)
 516         str_copy_buf_trunc (buf, sizeof buf, val->s, var->width);
 517       else
 518         snprintf(buf, 100, "%g", val->f);
 519       s = buf;
 520     }
 521
 522   return s;
 523 }