src/data/format.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 "format.h"
  22 #include <ctype.h>
  23 #include "message.h"
  24 #include <stdlib.h>
  25 #include "misc.h"
  26 #include "identifier.h"
  27 #include "str.h"
  28 #include "variable.h"
  29
  30 #include "gettext.h"
  31 #define _(msgid) gettext (msgid)
  32
  33 #define DEFFMT(LABEL, NAME, N_ARGS, IMIN_W, IMAX_W, OMIN_W, OMAX_W, CAT, \
  34                OUTPUT, SPSS_FMT) \
  35         {NAME, N_ARGS, IMIN_W, IMAX_W, OMIN_W, OMAX_W, CAT, OUTPUT, SPSS_FMT},
  36 struct fmt_desc formats[FMT_NUMBER_OF_FORMATS + 1] =
  37 {
  38 #include "format.def"
  39   {"",         -1, -1,  -1, -1,   -1, 0000, -1, -1},
  40 };
  41
  42 /* Common formats. */
  43 const struct fmt_spec f8_2 = {FMT_F, 8, 2};
  44
  45 /* Converts F to its string representation (for instance, "F8.2") and
  46    returns a pointer to a static buffer containing that string. */
  47 char *
  48 fmt_to_string (const struct fmt_spec *f)
  49 {
  50   static char buf[32];
  51
  52   if (formats[f->type].n_args >= 2)
  53     sprintf (buf, "%s%d.%d", formats[f->type].name, f->w, f->d);
  54   else
  55     sprintf (buf, "%s%d", formats[f->type].name, f->w);
  56   return buf;
  57 }
  58
  59 /* Does checks in common betwen check_input_specifier() and
  60    check_output_specifier() and returns true if so.  Otherwise,
  61    emits an error message (if EMIT_ERROR is nonzero) and returns
  62    false. */
  63 static bool
  64 check_common_specifier (const struct fmt_spec *spec, bool emit_error)
  65 {
  66   struct fmt_desc *f ;
  67   char *str;
  68
  69   if ( spec->type > FMT_NUMBER_OF_FORMATS )
  70     {
  71       if (emit_error)
  72         msg (SE, _("Format specifies a bad type (%d)"), spec->type);
  73
  74       return false;
  75     }
  76
  77   f = &formats[spec->type];
  78   str = fmt_to_string (spec);
  79
  80   if ((f->cat & FCAT_EVEN_WIDTH) && spec->w % 2)
  81     {
  82       if (emit_error)
  83         msg (SE, _("Format %s specifies an odd width %d, but "
  84                    "an even width is required."),
  85              str, spec->w);
  86       return false;
  87     }
  88   if (f->n_args > 1 && (spec->d < 0 || spec->d > 16))
  89     {
  90       if (emit_error)
  91         msg (SE, _("Format %s specifies a bad number of "
  92                    "implied decimal places %d.  Input format %s allows "
  93                    "up to 16 implied decimal places."), str, spec->d, f->name);
  94       return false;
  95     }
  96   return true;
  97 }
  98
  99 /* Checks whether SPEC is valid as an input format and returns
 100    nonzero if so.  Otherwise, emits an error message (if
 101    EMIT_ERROR is nonzero) and returns zero. */
 102 int
 103 check_input_specifier (const struct fmt_spec *spec, int emit_error)
 104 {
 105   struct fmt_desc *f ;
 106   char *str ;
 107
 108   if (!check_common_specifier (spec, emit_error))
 109     return false;
 110
 111   f = &formats[spec->type];
 112   str = fmt_to_string (spec);
 113
 114
 115   if (spec->type == FMT_X)
 116     return 1;
 117   if (f->cat & FCAT_OUTPUT_ONLY)
 118     {
 119       if (emit_error)
 120         msg (SE, _("Format %s may not be used for input."), f->name);
 121       return 0;
 122     }
 123   if (spec->w < f->Imin_w || spec->w > f->Imax_w)
 124     {
 125       if (emit_error)
 126         msg (SE, _("Input format %s specifies a bad width %d.  "
 127                    "Format %s requires a width between %d and %d."),
 128              str, spec->w, f->name, f->Imin_w, f->Imax_w);
 129       return 0;
 130     }
 131   if ((spec->type == FMT_F || spec->type == FMT_COMMA
 132           || spec->type == FMT_DOLLAR)
 133       && spec->d > spec->w)
 134     {
 135       if (emit_error)
 136         msg (SE, _("Input format %s is invalid because it specifies more "
 137                    "decimal places than the field width."), str);
 138       return 0;
 139     }
 140   return 1;
 141 }
 142
 143 /* Checks whether SPEC is valid as an output format and returns
 144    nonzero if so.  Otherwise, emits an error message (if
 145    EMIT_ERROR is nonzero) and returns zero. */
 146 int
 147 check_output_specifier (const struct fmt_spec *spec, int emit_error)
 148 {
 149   struct fmt_desc *f;
 150   char *str ;
 151
 152   if (!check_common_specifier (spec, emit_error))
 153     return false;
 154
 155   f = &formats[spec->type];
 156   str = fmt_to_string (spec);
 157
 158   if (spec->type == FMT_X)
 159     return 1;
 160   if (spec->w < f->Omin_w || spec->w > f->Omax_w)
 161     {
 162       if (emit_error)
 163         msg (SE, _("Output format %s specifies a bad width %d.  "
 164                    "Format %s requires a width between %d and %d."),
 165              str, spec->w, f->name, f->Omin_w, f->Omax_w);
 166       return 0;
 167     }
 168   if ((spec->type == FMT_F || spec->type == FMT_COMMA
 169           || spec->type == FMT_DOLLAR)
 170       && spec->d >= spec->w)
 171     {
 172       if (emit_error)
 173         msg (SE, _("Output format %s is invalid because it specifies as "
 174                    "many decimal places as the field width, which "
 175                    "fails to allow space for a decimal point.  "
 176                    "Try %s%d.%d instead."),
 177              str, f->name, spec->d + 1, spec->d);
 178       return 0;
 179     }
 180   return 1;
 181 }
 182
 183 /* Checks that FORMAT is appropriate for a variable of the given
 184    TYPE and returns true if so.  Otherwise returns false and (if
 185    EMIT_ERROR is true) emits an error message. */
 186 bool
 187 check_specifier_type (const struct fmt_spec *format,
 188                       int type, bool emit_error)
 189 {
 190   const struct fmt_desc *f = &formats[format->type];
 191   assert (type == NUMERIC || type == ALPHA);
 192   if ((type == ALPHA) != ((f->cat & FCAT_STRING) != 0))
 193     {
 194       if (emit_error)
 195         msg (SE, _("%s variables are not compatible with %s format %s."),
 196              type == ALPHA ? _("String") : _("Numeric"),
 197              type == ALPHA ? _("numeric") : _("string"),
 198              fmt_to_string (format));
 199       return false;
 200     }
 201   return true;
 202 }
 203
 204 /* Checks that FORMAT is appropriate for a variable of the given
 205    WIDTH and returns true if so.  Otherwise returns false and (if
 206    EMIT_ERROR is true) emits an error message. */
 207 bool
 208 check_specifier_width (const struct fmt_spec *format,
 209                        int width, bool emit_error)
 210 {
 211   if (!check_specifier_type (format, width != 0 ? ALPHA : NUMERIC, emit_error))
 212     return false;
 213   if (get_format_var_width (format) != width)
 214     {
 215       if (emit_error)
 216         msg (SE, _("String variable with width %d not compatible with "
 217                    "format %s."),
 218              width, fmt_to_string (format));
 219       return false;
 220     }
 221   return true;
 222 }
 223
 224 /* Converts input format specifier INPUT into output format
 225    specifier OUTPUT. */
 226 void
 227 convert_fmt_ItoO (const struct fmt_spec *input, struct fmt_spec *output)
 228 {
 229   assert (check_input_specifier (input, 0));
 230
 231   output->type = formats[input->type].output;
 232   output->w = input->w;
 233   if (output->w > formats[output->type].Omax_w)
 234     output->w = formats[output->type].Omax_w;
 235   output->d = input->d;
 236
 237   switch (input->type)
 238     {
 239     case FMT_F:
 240     case FMT_N:
 241       if (output->d > 0)
 242         output->w++;
 243       break;
 244     case FMT_E:
 245       output->w = max (max (input->w, input->d+7), 10);
 246       output->d = max (input->d, 3);
 247       break;
 248     case FMT_COMMA:
 249     case FMT_DOT:
 250       /* nothing is necessary */
 251       break;
 252     case FMT_DOLLAR:
 253     case FMT_PCT:
 254       if (output->w < 2)
 255         output->w = 2;
 256       break;
 257     case FMT_PIBHEX:
 258       {
 259         static const int map[] = {4, 6, 9, 11, 14, 16, 18, 21};
 260         assert (input->w % 2 == 0 && input->w >= 2 && input->w <= 16);
 261         output->w = map[input->w / 2 - 1];
 262         break;
 263       }
 264     case FMT_RBHEX:
 265       output->w = 8, output->d = 2;     /* FIXME */
 266       break;
 267     case FMT_IB:
 268     case FMT_PIB:
 269     case FMT_P:
 270     case FMT_PK:
 271     case FMT_RB:
 272       if (input->d < 1)
 273         output->w = 8, output->d = 2;
 274       else
 275         output->w = 9 + input->d;
 276       break;
 277     case FMT_CCA:
 278     case FMT_CCB:
 279     case FMT_CCC:
 280     case FMT_CCD:
 281     case FMT_CCE:
 282       assert (0);
 283     case FMT_Z:
 284     case FMT_A:
 285       /* nothing is necessary */
 286       break;
 287     case FMT_AHEX:
 288       output->w = input->w / 2;
 289       break;
 290     case FMT_DATE:
 291     case FMT_EDATE:
 292     case FMT_SDATE:
 293     case FMT_ADATE:
 294     case FMT_JDATE:
 295       /* nothing is necessary */
 296       break;
 297     case FMT_QYR:
 298       if (output->w < 6)
 299         output->w = 6;
 300       break;
 301     case FMT_MOYR:
 302       /* nothing is necessary */
 303       break;
 304     case FMT_WKYR:
 305       if (output->w < 8)
 306         output->w = 8;
 307       break;
 308     case FMT_TIME:
 309     case FMT_DTIME:
 310     case FMT_DATETIME:
 311     case FMT_WKDAY:
 312     case FMT_MONTH:
 313       /* nothing is necessary */
 314       break;
 315     default:
 316       assert (0);
 317     }
 318
 319   assert (check_output_specifier (output, 0));
 320 }
 321
 322 /* Returns the width corresponding to the format specifier.  The
 323    return value is the value of the `width' member of a `struct
 324    variable' for such an input format. */
 325 int
 326 get_format_var_width (const struct fmt_spec *spec)
 327 {
 328   if (spec->type == FMT_AHEX)
 329     return spec->w / 2;
 330   else if (spec->type == FMT_A)
 331     return spec->w;
 332   else
 333     return 0;
 334 }
 335
 336 /* Returns the PSPP format corresponding to the given SPSS
 337    format. */
 338 int
 339 translate_fmt (int spss)
 340 {
 341   int type;
 342
 343   for (type = 0; type < FMT_NUMBER_OF_FORMATS; type++)
 344     if (formats[type].spss == spss)
 345       return type;
 346   return -1;
 347 }
 348
 349 /* Returns an input format specification with type TYPE, width W,
 350    and D decimals. */
 351 struct fmt_spec
 352 make_input_format (int type, int w, int d)
 353 {
 354   struct fmt_spec f;
 355   f.type = type;
 356   f.w = w;
 357   f.d = d;
 358   assert (check_input_specifier (&f, 0));
 359   return f;
 360 }
 361
 362 /* Returns an output format specification with type TYPE, width
 363    W, and D decimals. */
 364 struct fmt_spec
 365 make_output_format (int type, int w, int d)
 366 {
 367   struct fmt_spec f;
 368   f.type = type;
 369   f.w = w;
 370   f.d = d;
 371   assert (check_output_specifier (&f, 0));
 372   return f;
 373 }