src/data/variable.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 #include "variable.h"
  22 #include <libpspp/message.h>
  23 #include <stdlib.h>
  24 #include <libpspp/alloc.h>
  25 #include <libpspp/compiler.h>
  26 #include "dictionary.h"
  27 #include <libpspp/hash.h>
  28 #include "identifier.h"
  29 #include <libpspp/misc.h>
  30 #include <libpspp/str.h>
  31 #include "value-labels.h"
  32
  33 #include "gettext.h"
  34 #define _(msgid) gettext (msgid)
  35
  36 /* Returns an adjective describing the given variable TYPE,
  37    suitable for use in phrases like "numeric variable". */
  38 const char *
  39 var_type_adj (enum var_type type)
  40 {
  41   return type == NUMERIC ? _("numeric") : _("string");
  42 }
  43
  44 /* Returns a noun describing a value of the given variable TYPE,
  45    suitable for use in phrases like "a number". */
  46 const char *
  47 var_type_noun (enum var_type type)
  48 {
  49   return type == NUMERIC ? _("number") : _("string");
  50 }
  51
  52 /* Assign auxiliary data AUX to variable V, which must not
  53    already have auxiliary data.  Before V's auxiliary data is
  54    cleared, AUX_DTOR(V) will be called. */
  55 void *
  56 var_attach_aux (struct variable *v,
  57                 void *aux, void (*aux_dtor) (struct variable *))
  58 {
  59   assert (v->aux == NULL);
  60   assert (aux != NULL);
  61   v->aux = aux;
  62   v->aux_dtor = aux_dtor;
  63   return aux;
  64 }
  65
  66 /* Remove auxiliary data, if any, from V, and returns it, without
  67    calling any associated destructor. */
  68 void *
  69 var_detach_aux (struct variable *v)
  70 {
  71   void *aux = v->aux;
  72   assert (aux != NULL);
  73   v->aux = NULL;
  74   return aux;
  75 }
  76
  77 /* Clears auxiliary data, if any, from V, and calls any
  78    associated destructor. */
  79 void
  80 var_clear_aux (struct variable *v)
  81 {
  82   assert (v != NULL);
  83   if (v->aux != NULL)
  84     {
  85       if (v->aux_dtor != NULL)
  86         v->aux_dtor (v);
  87       v->aux = NULL;
  88     }
  89 }
  90
  91 /* This function is appropriate for use an auxiliary data
  92    destructor (passed as AUX_DTOR to var_attach_aux()) for the
  93    case where the auxiliary data should be passed to free(). */
  94 void
  95 var_dtor_free (struct variable *v)
  96 {
  97   free (v->aux);
  98 }
  99
 100 /* Compares A and B, which both have the given WIDTH, and returns
 101    a strcmp()-type result. */
 102 int
 103 compare_values (const union value *a, const union value *b, int width)
 104 {
 105   if (width == 0)
 106     return a->f < b->f ? -1 : a->f > b->f;
 107   else
 108     return memcmp (a->s, b->s, min(MAX_SHORT_STRING, width));
 109 }
 110
 111 /* Create a hash of v */
 112 unsigned
 113 hash_value(const union value  *v, int width)
 114 {
 115   unsigned id_hash;
 116
 117   if ( 0 == width )
 118     id_hash = hsh_hash_double (v->f);
 119   else
 120     id_hash = hsh_hash_bytes (v->s, min(MAX_SHORT_STRING, width));
 121
 122   return id_hash;
 123 }
 124
 125
 126
 127 \f
 128 /* Returns true if NAME is an acceptable name for a variable,
 129    false otherwise.  If ISSUE_ERROR is true, issues an
 130    explanatory error message on failure. */
 131 bool
 132 var_is_valid_name (const char *name, bool issue_error)
 133 {
 134   size_t length, i;
 135
 136   assert (name != NULL);
 137
 138   /* Note that strlen returns number of BYTES, not the number of
 139      CHARACTERS */
 140   length = strlen (name);
 141
 142   bool plausible = var_is_plausible_name(name, issue_error);
 143
 144   if ( ! plausible )
 145     return false;
 146
 147
 148   if (!lex_is_id1 (name[0]))
 149     {
 150       if (issue_error)
 151         msg (SE, _("Character `%c' (in %s), may not appear "
 152                    "as the first character in a variable name."),
 153              name[0], name);
 154       return false;
 155     }
 156
 157
 158   for (i = 0; i < length; i++)
 159     {
 160     if (!lex_is_idn (name[i]))
 161       {
 162         if (issue_error)
 163           msg (SE, _("Character `%c' (in %s) may not appear in "
 164                      "a variable name."),
 165                name[i], name);
 166         return false;
 167       }
 168     }
 169
 170   return true;
 171 }
 172
 173 /*
 174    Returns true if NAME is an plausible name for a variable,
 175    false otherwise.  If ISSUE_ERROR is true, issues an
 176    explanatory error message on failure.
 177    This function makes no use of LC_CTYPE.
 178 */
 179 bool
 180 var_is_plausible_name (const char *name, bool issue_error)
 181 {
 182   size_t length;
 183
 184   assert (name != NULL);
 185
 186   /* Note that strlen returns number of BYTES, not the number of
 187      CHARACTERS */
 188   length = strlen (name);
 189   if (length < 1)
 190     {
 191       if (issue_error)
 192         msg (SE, _("Variable name cannot be empty string."));
 193       return false;
 194     }
 195   else if (length > LONG_NAME_LEN)
 196     {
 197       if (issue_error)
 198         msg (SE, _("Variable name %s exceeds %d-character limit."),
 199              name, (int) LONG_NAME_LEN);
 200       return false;
 201     }
 202
 203   if (lex_id_to_token (name, strlen (name)) != T_ID)
 204     {
 205       if (issue_error)
 206         msg (SE, _("`%s' may not be used as a variable name because it "
 207                    "is a reserved word."), name);
 208       return false;
 209     }
 210
 211   return true;
 212 }
 213
 214 /* A hsh_compare_func that orders variables A and B by their
 215    names. */
 216 int
 217 compare_var_names (const void *a_, const void *b_, void *foo UNUSED)
 218 {
 219   const struct variable *a = a_;
 220   const struct variable *b = b_;
 221
 222   return strcasecmp (a->name, b->name);
 223 }
 224
 225 /* A hsh_hash_func that hashes variable V based on its name. */
 226 unsigned
 227 hash_var_name (const void *v_, void *foo UNUSED)
 228 {
 229   const struct variable *v = v_;
 230
 231   return hsh_hash_case_string (v->name);
 232 }
 233
 234 /* A hsh_compare_func that orders pointers to variables A and B
 235    by their names. */
 236 int
 237 compare_var_ptr_names (const void *a_, const void *b_, void *foo UNUSED)
 238 {
 239   struct variable *const *a = a_;
 240   struct variable *const *b = b_;
 241
 242   return strcasecmp ((*a)->name, (*b)->name);
 243 }
 244
 245 /* A hsh_hash_func that hashes pointer to variable V based on its
 246    name. */
 247 unsigned
 248 hash_var_ptr_name (const void *v_, void *foo UNUSED)
 249 {
 250   struct variable *const *v = v_;
 251
 252   return hsh_hash_case_string ((*v)->name);
 253 }
 254 \f
 255 /* Sets V's short_name to SHORT_NAME, truncating it to
 256    SHORT_NAME_LEN characters and converting it to uppercase in
 257    the process. */
 258 void
 259 var_set_short_name (struct variable *v, const char *short_name)
 260 {
 261   assert (v != NULL);
 262   assert (short_name[0] == '\0' || var_is_plausible_name (short_name, false));
 263
 264   str_copy_trunc (v->short_name, sizeof v->short_name, short_name);
 265   str_uppercase (v->short_name);
 266 }
 267
 268 /* Clears V's short name. */
 269 void
 270 var_clear_short_name (struct variable *v)
 271 {
 272   assert (v != NULL);
 273
 274   v->short_name[0] = '\0';
 275 }
 276
 277 /* Sets V's short name to BASE, followed by a suffix of the form
 278    _A, _B, _C, ..., _AA, _AB, etc. according to the value of
 279    SUFFIX.  Truncates BASE as necessary to fit. */
 280 void
 281 var_set_short_name_suffix (struct variable *v, const char *base, int suffix)
 282 {
 283   char string[SHORT_NAME_LEN + 1];
 284   char *start, *end;
 285   int len, ofs;
 286
 287   assert (v != NULL);
 288   assert (suffix >= 0);
 289   assert (strlen (v->short_name) > 0);
 290
 291   /* Set base name. */
 292   var_set_short_name (v, base);
 293
 294   /* Compose suffix_string. */
 295   start = end = string + sizeof string - 1;
 296   *end = '\0';
 297   do
 298     {
 299       *--start = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"[suffix % 26];
 300       if (start <= string + 1)
 301         msg (SE, _("Variable suffix too large."));
 302       suffix /= 26;
 303     }
 304   while (suffix > 0);
 305   *--start = '_';
 306
 307   /* Append suffix_string to V's short name. */
 308   len = end - start;
 309   if (len + strlen (v->short_name) > SHORT_NAME_LEN)
 310     ofs = SHORT_NAME_LEN - len;
 311   else
 312     ofs = strlen (v->short_name);
 313   strcpy (v->short_name + ofs, start);
 314 }
 315
 316
 317 /* Returns the dictionary class corresponding to a variable named
 318    NAME. */
 319 enum dict_class
 320 dict_class_from_id (const char *name)
 321 {
 322   assert (name != NULL);
 323
 324   switch (name[0])
 325     {
 326     default:
 327       return DC_ORDINARY;
 328     case '$':
 329       return DC_SYSTEM;
 330     case '#':
 331       return DC_SCRATCH;
 332     }
 333 }
 334
 335 /* Returns the name of dictionary class DICT_CLASS. */
 336 const char *
 337 dict_class_to_name (enum dict_class dict_class)
 338 {
 339   switch (dict_class)
 340     {
 341     case DC_ORDINARY:
 342       return _("ordinary");
 343     case DC_SYSTEM:
 344       return _("system");
 345     case DC_SCRATCH:
 346       return _("scratch");
 347     default:
 348       assert (0);
 349       abort ();
 350     }
 351 }