src/data/data-in.c

   1 /* PSPP - a program for statistical analysis.
   2    Copyright (C) 1997-9, 2000, 2006 Free Software Foundation, Inc.
   3
   4    This program is free software: you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation, either version 3 of the License, or
   7    (at your option) any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program.  If not, see <http://www.gnu.org/licenses/>. */
  16
  17 #include <config.h>
  18
  19 #include "data-in.h"
  20
  21 #include <ctype.h>
  22 #include <errno.h>
  23 #include <math.h>
  24 #include <stdarg.h>
  25 #include <stddef.h>
  26 #include <stdint.h>
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <stdbool.h>
  30
  31 #include "calendar.h"
  32 #include "identifier.h"
  33 #include "settings.h"
  34 #include "value.h"
  35
  36 #include <libpspp/assertion.h>
  37 #include <libpspp/compiler.h>
  38 #include <libpspp/integer-format.h>
  39 #include <libpspp/magic.h>
  40 #include <libpspp/message.h>
  41 #include <libpspp/misc.h>
  42 #include <libpspp/str.h>
  43
  44 #include "c-ctype.h"
  45 #include "minmax.h"
  46 #include "size_max.h"
  47 #include "xalloc.h"
  48
  49 #include "gettext.h"
  50 #define _(msgid) gettext (msgid)
  51 \f
  52 /* Information about parsing one data field. */
  53 struct data_in
  54   {
  55     struct substring input;     /* Source. */
  56     enum fmt_type format;       /* Input format. */
  57     int implied_decimals;       /* Number of implied decimal places. */
  58
  59     union value *output;        /* Destination. */
  60     int width;                  /* Output width. */
  61
  62     int first_column;           /* First column of field; 0 if inapplicable. */
  63     int last_column;            /* Last column. */
  64   };
  65
  66 /* Integer format used for IB and PIB input. */
  67 static enum integer_format input_integer_format = INTEGER_NATIVE;
  68
  69 /* Floating-point format used for RB and RBHEX input. */
  70 static enum float_format input_float_format = FLOAT_NATIVE_DOUBLE;
  71
  72 typedef bool data_in_parser_func (struct data_in *);
  73 #define FMT(NAME, METHOD, IMIN, OMIN, IO, CATEGORY) \
  74         static data_in_parser_func parse_##METHOD;
  75 #include "format.def"
  76
  77 static void vdata_warning (const struct data_in *, const char *, va_list)
  78      PRINTF_FORMAT (2, 0);
  79 static void data_warning (const struct data_in *, const char *, ...)
  80      PRINTF_FORMAT (2, 3);
  81
  82 static void apply_implied_decimals (struct data_in *);
  83 static void default_result (struct data_in *);
  84 static bool trim_spaces_and_check_missing (struct data_in *);
  85
  86 static int hexit_value (int c);
  87 \f
  88 /* Parses the characters in INPUT according to FORMAT.  Stores
  89    the parsed representation in OUTPUT, which has the given WIDTH
  90    (0 for a numeric field, otherwise the string width).
  91
  92    If no decimal point is included in a numeric format, then
  93    IMPLIED_DECIMALS decimal places are implied.  Specify 0 if no
  94    decimal places should be implied.
  95
  96    If FIRST_COLUMN is nonzero, then it should be the 1-based
  97    column number of the first character in INPUT, used in error
  98    messages. */
  99 bool
 100 data_in (struct substring input,
 101          enum fmt_type format, int implied_decimals,
 102          int first_column, union value *output, int width)
 103 {
 104   static data_in_parser_func *const handlers[FMT_NUMBER_OF_FORMATS] =
 105     {
 106 #define FMT(NAME, METHOD, IMIN, OMIN, IO, CATEGORY) parse_##METHOD,
 107 #include "format.def"
 108     };
 109
 110   struct data_in i;
 111   bool ok;
 112
 113   assert ((width != 0) == fmt_is_string (format));
 114
 115   i.input = input;
 116   i.format = format;
 117   i.implied_decimals = implied_decimals;
 118
 119   i.output = output;
 120   i.width = width;
 121
 122   i.first_column = first_column;
 123   i.last_column = first_column + ss_length (input) - 1;
 124
 125   if (!ss_is_empty (i.input))
 126     {
 127       ok = handlers[i.format] (&i);
 128       if (!ok)
 129         default_result (&i);
 130     }
 131   else
 132     {
 133       default_result (&i);
 134       ok = true;
 135     }
 136
 137   return ok;
 138 }
 139
 140 /* Returns the integer format used for IB and PIB input. */
 141 enum integer_format
 142 data_in_get_integer_format (void)
 143 {
 144   return input_integer_format;
 145 }
 146
 147 /* Sets the integer format used for IB and PIB input to
 148    FORMAT. */
 149 void
 150 data_in_set_integer_format (enum integer_format format)
 151 {
 152   input_integer_format = format;
 153 }
 154
 155 /* Returns the floating-point format used for RB and RBHEX
 156    input. */
 157 enum float_format
 158 data_in_get_float_format (void)
 159 {
 160   return input_float_format;
 161 }
 162
 163 /* Sets the floating-point format used for RB and RBHEX input to
 164    FORMAT. */
 165 void
 166 data_in_set_float_format (enum float_format format)
 167 {
 168   input_float_format = format;
 169 }
 170 \f
 171 /* Format parsers. */
 172
 173 /* Parses F, COMMA, DOT, DOLLAR, PCT, and E input formats. */
 174 static bool
 175 parse_number (struct data_in *i)
 176 {
 177   const struct fmt_number_style *style = fmt_get_style (i->format);
 178
 179   struct string tmp;
 180
 181   bool explicit_decimals = false;
 182   int save_errno;
 183   char *tail;
 184
 185   assert (fmt_get_category (i->format) != FMT_CAT_CUSTOM);
 186
 187   /* Trim spaces and check for missing value representation. */
 188   if (trim_spaces_and_check_missing (i))
 189     return true;
 190
 191   ds_init_empty (&tmp);
 192   ds_extend (&tmp, 64);
 193
 194   /* Prefix character may precede sign. */
 195   if (!ss_is_empty (style->prefix))
 196     {
 197       ss_match_char (&i->input, ss_first (style->prefix));
 198       ss_ltrim (&i->input, ss_cstr (CC_SPACES));
 199     }
 200
 201   /* Sign. */
 202   if (ss_match_char (&i->input, '-'))
 203     {
 204       ds_put_char (&tmp, '-');
 205       ss_ltrim (&i->input, ss_cstr (CC_SPACES));
 206     }
 207   else
 208     {
 209       ss_match_char (&i->input, '+');
 210       ss_ltrim (&i->input, ss_cstr (CC_SPACES));
 211     }
 212
 213   /* Prefix character may follow sign. */
 214   if (!ss_is_empty (style->prefix))
 215     {
 216       ss_match_char (&i->input, ss_first (style->prefix));
 217       ss_ltrim (&i->input, ss_cstr (CC_SPACES));
 218     }
 219
 220   /* Digits before decimal point. */
 221   while (c_isdigit (ss_first (i->input)))
 222     {
 223       ds_put_char (&tmp, ss_get_char (&i->input));
 224       if (style->grouping != 0)
 225         ss_match_char (&i->input, style->grouping);
 226     }
 227
 228   /* Decimal point and following digits. */
 229   if (ss_match_char (&i->input, style->decimal))
 230     {
 231       explicit_decimals = true;
 232       ds_put_char (&tmp, '.');
 233       while (c_isdigit (ss_first (i->input)))
 234         ds_put_char (&tmp, ss_get_char (&i->input));
 235     }
 236
 237   /* Exponent. */
 238   if (!ds_is_empty (&tmp)
 239       && !ss_is_empty (i->input)
 240       && strchr ("eEdD-+", ss_first (i->input)))
 241     {
 242       explicit_decimals = true;
 243       ds_put_char (&tmp, 'e');
 244
 245       if (strchr ("eEdD", ss_first (i->input)))
 246         {
 247           ss_advance (&i->input, 1);
 248           ss_match_char (&i->input, ' ');
 249         }
 250
 251       if (ss_first (i->input) == '-' || ss_first (i->input) == '+')
 252         {
 253           if (ss_get_char (&i->input) == '-')
 254             ds_put_char (&tmp, '-');
 255           ss_match_char (&i->input, ' ');
 256         }
 257
 258       while (c_isdigit (ss_first (i->input)))
 259         ds_put_char (&tmp, ss_get_char (&i->input));
 260     }
 261
 262   /* Suffix character. */
 263   if (!ss_is_empty (style->suffix))
 264     ss_match_char (&i->input, ss_first (style->suffix));
 265
 266   if (!ss_is_empty (i->input))
 267     {
 268       if (ds_is_empty (&tmp))
 269         data_warning (i, _("Field contents are not numeric."));
 270       else
 271         data_warning (i, _("Number followed by garbage."));
 272       ds_destroy (&tmp);
 273       return false;
 274     }
 275
 276   /* Let strtod() do the conversion. */
 277   save_errno = errno;
 278   errno = 0;
 279   i->output->f = strtod (ds_cstr (&tmp), &tail);
 280   if (*tail != '\0')
 281     {
 282       data_warning (i, _("Invalid numeric syntax."));
 283       errno = save_errno;
 284       ds_destroy (&tmp);
 285       return false;
 286     }
 287   else if (errno == ERANGE)
 288     {
 289       if (fabs (i->output->f) > 1)
 290         {
 291           data_warning (i, _("Too-large number set to system-missing."));
 292           i->output->f = SYSMIS;
 293         }
 294       else
 295         {
 296           data_warning (i, _("Too-small number set to zero."));
 297           i->output->f = 0.0;
 298         }
 299     }
 300   else
 301     {
 302       errno = save_errno;
 303       if (!explicit_decimals)
 304         apply_implied_decimals (i);
 305     }
 306
 307   ds_destroy (&tmp);
 308   return true;
 309 }
 310
 311 /* Parses N format. */
 312 static bool
 313 parse_N (struct data_in *i)
 314 {
 315   int c;
 316
 317   i->output->f = 0;
 318   while ((c = ss_get_char (&i->input)) != EOF)
 319     {
 320       if (!c_isdigit (c))
 321         {
 322           data_warning (i, _("All characters in field must be digits."));
 323           return false;
 324         }
 325       i->output->f = i->output->f * 10.0 + (c - '0');
 326     }
 327
 328   apply_implied_decimals (i);
 329   return true;
 330 }
 331
 332 /* Parses PIBHEX format. */
 333 static bool
 334 parse_PIBHEX (struct data_in *i)
 335 {
 336   double n;
 337   int c;
 338
 339   n = 0.0;
 340
 341   while ((c = ss_get_char (&i->input)) != EOF)
 342     {
 343       if (!c_isxdigit (c))
 344         {
 345           data_warning (i, _("Unrecognized character in field."));
 346           return false;
 347         }
 348       n = n * 16.0 + hexit_value (c);
 349     }
 350
 351   i->output->f = n;
 352   return true;
 353 }
 354
 355 /* Parses RBHEX format. */
 356 static bool
 357 parse_RBHEX (struct data_in *i)
 358 {
 359   double d;
 360   size_t j;
 361
 362   memset (&d, 0, sizeof d);
 363   for (j = 0; !ss_is_empty (i->input) && j < sizeof d; j++)
 364     {
 365       int hi = ss_get_char (&i->input);
 366       int lo = ss_get_char (&i->input);
 367       if (lo == EOF)
 368         {
 369           data_warning (i, _("Field must have even length."));
 370           return false;
 371         }
 372       else if (!c_isxdigit (hi) || !c_isxdigit (lo))
 373         {
 374           data_warning (i, _("Field must contain only hex digits."));
 375           return false;
 376         }
 377       ((unsigned char *) &d)[j] = 16 * hexit_value (hi) + hexit_value (lo);
 378     }
 379
 380   i->output->f = d;
 381
 382   return true;
 383 }
 384
 385 /* Digits for Z format. */
 386 static const char z_digits[] = "0123456789{ABCDEFGHI}JKLMNOPQR";
 387
 388 /* Returns true if C is a Z format digit, false otherwise. */
 389 static bool
 390 is_z_digit (int c)
 391 {
 392   return c > 0 && strchr (z_digits, c) != NULL;
 393 }
 394
 395 /* Returns the (absolute value of the) value of C as a Z format
 396    digit. */
 397 static int
 398 z_digit_value (int c)
 399 {
 400   assert (is_z_digit (c));
 401   return (strchr (z_digits, c) - z_digits) % 10;
 402 }
 403
 404 /* Returns true if Z format digit C represents a negative value,
 405    false otherwise. */
 406 static bool
 407 is_negative_z_digit (int c)
 408 {
 409   assert (is_z_digit (c));
 410   return (strchr (z_digits, c) - z_digits) >= 20;
 411 }
 412
 413 /* Parses Z format. */
 414 static bool
 415 parse_Z (struct data_in *i)
 416 {
 417   struct string tmp;
 418
 419   int save_errno;
 420
 421   bool got_dot = false;
 422   bool got_final_digit = false;
 423
 424   /* Trim spaces and check for missing value representation. */
 425   if (trim_spaces_and_check_missing (i))
 426     return true;
 427
 428   ds_init_empty (&tmp);
 429   ds_extend (&tmp, 64);
 430
 431   ds_put_char (&tmp, '+');
 432   while (!ss_is_empty (i->input))
 433     {
 434       int c = ss_get_char (&i->input);
 435       if (c_isdigit (c) && !got_final_digit)
 436         ds_put_char (&tmp, c);
 437       else if (is_z_digit (c) && !got_final_digit)
 438         {
 439           ds_put_char (&tmp, z_digit_value (c) + '0');
 440           if (is_negative_z_digit (c))
 441             ds_data (&tmp)[0] = '-';
 442           got_final_digit = true;
 443         }
 444       else if (c == '.' && !got_dot)
 445         {
 446           ds_put_char (&tmp, '.');
 447           got_dot = true;
 448         }
 449       else
 450         {
 451           ds_destroy (&tmp);
 452           return false;
 453         }
 454     }
 455
 456   if (!ss_is_empty (i->input))
 457     {
 458       if (ds_length (&tmp) == 1)
 459         data_warning (i, _("Field contents are not numeric."));
 460       else
 461         data_warning (i, _("Number followed by garbage."));
 462       ds_destroy (&tmp);
 463       return false;
 464     }
 465
 466   /* Let strtod() do the conversion. */
 467   save_errno = errno;
 468   errno = 0;
 469   i->output->f = strtod (ds_cstr (&tmp), NULL);
 470   if (errno == ERANGE)
 471     {
 472       if (fabs (i->output->f) > 1)
 473         {
 474           data_warning (i, _("Too-large number set to system-missing."));
 475           i->output->f = SYSMIS;
 476         }
 477       else
 478         {
 479           data_warning (i, _("Too-small number set to zero."));
 480           i->output->f = 0.0;
 481         }
 482     }
 483   else
 484     {
 485       errno = save_errno;
 486       if (!got_dot)
 487         apply_implied_decimals (i);
 488     }
 489
 490   ds_destroy (&tmp);
 491   return true;
 492 }
 493
 494 /* Parses IB format. */
 495 static bool
 496 parse_IB (struct data_in *i)
 497 {
 498   size_t bytes;
 499   uint64_t value;
 500   uint64_t sign_bit;
 501
 502   bytes = MIN (8, ss_length (i->input));
 503   value = integer_get (input_integer_format, ss_data (i->input), bytes);
 504
 505   sign_bit = UINT64_C(1) << (8 * bytes - 1);
 506   if (!(value & sign_bit))
 507     i->output->f = value;
 508   else
 509     {
 510       /* Sign-extend to full 64 bits. */
 511       value -= sign_bit << 1;
 512       i->output->f = -(double) -value;
 513     }
 514
 515   apply_implied_decimals (i);
 516
 517   return true;
 518 }
 519
 520 /* Parses PIB format. */
 521 static bool
 522 parse_PIB (struct data_in *i)
 523 {
 524   i->output->f = integer_get (input_integer_format, ss_data (i->input),
 525                               MIN (8, ss_length (i->input)));
 526
 527   apply_implied_decimals (i);
 528
 529   return true;
 530 }
 531
 532 /* Consumes the first character of S.  Stores its high 4 bits in
 533    HIGH_NIBBLE and its low 4 bits in LOW_NIBBLE. */
 534 static void
 535 get_nibbles (struct substring *s, int *high_nibble, int *low_nibble)
 536 {
 537   int c = ss_get_char (s);
 538   assert (c != EOF);
 539   *high_nibble = (c >> 4) & 15;
 540   *low_nibble = c & 15;
 541 }
 542
 543 /* Parses P format. */
 544 static bool
 545 parse_P (struct data_in *i)
 546 {
 547   int high_nibble, low_nibble;
 548
 549   i->output->f = 0.0;
 550
 551   while (ss_length (i->input) > 1)
 552     {
 553       get_nibbles (&i->input, &high_nibble, &low_nibble);
 554       if (high_nibble > 9 || low_nibble > 9)
 555         return false;
 556       i->output->f = (100 * i->output->f) + (10 * high_nibble) + low_nibble;
 557     }
 558
 559   get_nibbles (&i->input, &high_nibble, &low_nibble);
 560   if (high_nibble > 9)
 561     return false;
 562   i->output->f = (10 * i->output->f) + high_nibble;
 563   if (low_nibble < 10)
 564     i->output->f = (10 * i->output->f) + low_nibble;
 565   else if (low_nibble == 0xb || low_nibble == 0xd)
 566     i->output->f = -i->output->f;
 567
 568   apply_implied_decimals (i);
 569
 570   return true;
 571 }
 572
 573 /* Parses PK format. */
 574 static bool
 575 parse_PK (struct data_in *i)
 576 {
 577   i->output->f = 0.0;
 578   while (!ss_is_empty (i->input))
 579     {
 580       int high_nibble, low_nibble;
 581
 582       get_nibbles (&i->input, &high_nibble, &low_nibble);
 583       if (high_nibble > 9 || low_nibble > 9)
 584         {
 585           i->output->f = SYSMIS;
 586           return true;
 587         }
 588       i->output->f = (100 * i->output->f) + (10 * high_nibble) + low_nibble;
 589     }
 590
 591   apply_implied_decimals (i);
 592
 593   return true;
 594 }
 595
 596 /* Parses RB format. */
 597 static bool
 598 parse_RB (struct data_in *i)
 599 {
 600   size_t size = float_get_size (input_float_format);
 601   if (ss_length (i->input) >= size)
 602     float_convert (input_float_format, ss_data (i->input),
 603                    FLOAT_NATIVE_DOUBLE, &i->output->f);
 604   else
 605     i->output->f = SYSMIS;
 606
 607   return true;
 608 }
 609
 610 /* Parses A format. */
 611 static bool
 612 parse_A (struct data_in *i)
 613 {
 614   buf_copy_rpad (i->output->s, i->width,
 615                  ss_data (i->input), ss_length (i->input));
 616   return true;
 617 }
 618
 619 /* Parses AHEX format. */
 620 static bool
 621 parse_AHEX (struct data_in *i)
 622 {
 623   size_t j;
 624
 625   for (j = 0; ; j++)
 626     {
 627       int hi = ss_get_char (&i->input);
 628       int lo = ss_get_char (&i->input);
 629       if (hi == EOF)
 630         break;
 631       else if (lo == EOF)
 632         {
 633           data_warning (i, _("Field must have even length."));
 634           return false;
 635         }
 636
 637       if (!c_isxdigit (hi) || !c_isxdigit (lo))
 638         {
 639           data_warning (i, _("Field must contain only hex digits."));
 640           return false;
 641         }
 642
 643       if (j < i->width)
 644         i->output->s[j] = hexit_value (hi) * 16 + hexit_value (lo);
 645     }
 646
 647   memset (i->output->s + j, ' ', i->width - j);
 648
 649   return true;
 650 }
 651 \f
 652 /* Date & time format components. */
 653
 654 /* Sign of a time value. */
 655 enum time_sign
 656   {
 657     SIGN_NO_TIME,       /* No time yet encountered. */
 658     SIGN_POSITIVE,      /* Positive time. */
 659     SIGN_NEGATIVE       /* Negative time. */
 660   };
 661
 662 /* Parses a signed decimal integer from at most the first
 663    MAX_DIGITS characters in I, storing the result into *RESULT.
 664    Returns true if successful, false if no integer was
 665    present. */
 666 static bool
 667 parse_int (struct data_in *i, long *result, size_t max_digits)
 668 {
 669   struct substring head = ss_head (i->input, max_digits);
 670   size_t n = ss_get_long (&head, result);
 671   if (n)
 672     {
 673       ss_advance (&i->input, n);
 674       return true;
 675     }
 676   else
 677     {
 678       data_warning (i, _("Syntax error in date field."));
 679       return false;
 680     }
 681 }
 682
 683 /* Parses a date integer between 1 and 31 from I, storing it into
 684    *DAY.
 685    Returns true if successful, false if no date was present. */
 686 static bool
 687 parse_day (struct data_in *i, long *day)
 688 {
 689   if (!parse_int (i, day, SIZE_MAX))
 690     return false;
 691   if (*day >= 1 && *day <= 31)
 692     return true;
 693
 694   data_warning (i, _("Day (%ld) must be between 1 and 31."), *day);
 695   return false;
 696 }
 697
 698 /* Parses an integer from the beginning of I.
 699    Adds SECONDS_PER_UNIT times the absolute value of the integer
 700    to *TIME.
 701    If *TIME_SIGN is SIGN_NO_TIME, allows a sign to precede the
 702    time and sets *TIME_SIGN.  Otherwise, does not allow a sign.
 703    Returns true if successful, false if no integer was present. */
 704 static bool
 705 parse_time_units (struct data_in *i, double seconds_per_unit,
 706                   enum time_sign *time_sign, double *time)
 707
 708 {
 709   long units;
 710
 711   if (*time_sign == SIGN_NO_TIME)
 712     {
 713       if (ss_match_char (&i->input, '-'))
 714         *time_sign = SIGN_NEGATIVE;
 715       else
 716         {
 717           ss_match_char (&i->input, '+');
 718           *time_sign = SIGN_POSITIVE;
 719         }
 720     }
 721   if (!parse_int (i, &units, SIZE_MAX))
 722     return false;
 723   if (units < 0)
 724     {
 725       data_warning (i, _("Syntax error in date field."));
 726       return false;
 727     }
 728   *time += units * seconds_per_unit;
 729   return true;
 730 }
 731
 732 /* Parses a data delimiter from the beginning of I.
 733    Returns true if successful, false if no delimiter was
 734    present. */
 735 static bool
 736 parse_date_delimiter (struct data_in *i)
 737 {
 738   if (ss_ltrim (&i->input, ss_cstr ("-/.," CC_SPACES)))
 739     return true;
 740
 741   data_warning (i, _("Delimiter expected between fields in date."));
 742   return false;
 743 }
 744
 745 /* Parses spaces at the beginning of I. */
 746 static void
 747 parse_spaces (struct data_in *i)
 748 {
 749   ss_ltrim (&i->input, ss_cstr (CC_SPACES));
 750 }
 751
 752 static struct substring
 753 parse_name_token (struct data_in *i)
 754 {
 755   struct substring token;
 756   ss_get_chars (&i->input, ss_span (i->input, ss_cstr (CC_LETTERS)), &token);
 757   return token;
 758 }
 759
 760 /* Reads a name from I and sets *OUTPUT to the value associated
 761    with that name.  If ALLOW_SUFFIXES is true, then names that
 762    begin with one of the names are accepted; otherwise, only
 763    exact matches (except for case) are allowed.
 764    Returns true if successful, false otherwise. */
 765 static bool
 766 match_name (struct substring token, const char **names, long *output)
 767 {
 768   int i;
 769
 770   for (i = 1; *names != NULL; i++)
 771     if (ss_equals_case (ss_cstr (*names++), token))
 772       {
 773         *output = i;
 774         return true;
 775       }
 776
 777   return false;
 778 }
 779
 780 /* Parses a month name or number from the beginning of I,
 781    storing the month (in range 1...12) into *MONTH.
 782    Returns true if successful, false if no month was present. */
 783 static bool
 784 parse_month (struct data_in *i, long *month)
 785 {
 786   if (c_isdigit (ss_first (i->input)))
 787     {
 788       if (!parse_int (i, month, SIZE_MAX))
 789         return false;
 790       if (*month >= 1 && *month <= 12)
 791         return true;
 792     }
 793   else
 794     {
 795       static const char *english_names[] =
 796         {
 797           "jan", "feb", "mar", "apr", "may", "jun",
 798           "jul", "aug", "sep", "oct", "nov", "dec",
 799           NULL,
 800         };
 801
 802       static const char *roman_names[] =
 803         {
 804           "i", "ii", "iii", "iv", "v", "vi",
 805           "vii", "viii", "ix", "x", "xi", "xii",
 806           NULL,
 807         };
 808
 809       struct substring token = parse_name_token (i);
 810       if (match_name (ss_head (token, 3), english_names, month)
 811           || match_name (ss_head (token, 4), roman_names, month))
 812         return true;
 813     }
 814
 815   data_warning (i, _("Unrecognized month format.  Months may be specified "
 816                      "as Arabic or Roman numerals or as at least 3 letters "
 817                      "of their English names."));
 818   return false;
 819 }
 820
 821 /* Parses a year of at most MAX_DIGITS from the beginning of I,
 822    storing a "4-digit" year into *YEAR. */
 823 static bool
 824 parse_year (struct data_in *i, long *year, size_t max_digits)
 825 {
 826   if (!parse_int (i, year, max_digits))
 827     return false;
 828
 829   if (*year >= 0 && *year <= 99)
 830     {
 831       int epoch = get_epoch ();
 832       int epoch_century = ROUND_DOWN (epoch, 100);
 833       int epoch_offset = epoch - epoch_century;
 834       if (*year >= epoch_offset)
 835         *year += epoch_century;
 836       else
 837         *year += epoch_century + 100;
 838     }
 839   if (*year >= 1582 || *year <= 19999)
 840     return true;
 841
 842   data_warning (i, _("Year (%ld) must be between 1582 and 19999."), *year);
 843   return false;
 844 }
 845
 846 /* Returns true if input in I has been exhausted,
 847    false otherwise. */
 848 static bool
 849 parse_trailer (struct data_in *i)
 850 {
 851   if (ss_is_empty (i->input))
 852     return true;
 853
 854   data_warning (i, _("Trailing garbage \"%.*s\" following date."),
 855               (int) ss_length (i->input), ss_data (i->input));
 856   return false;
 857 }
 858
 859 /* Parses a 3-digit Julian day-of-year value from I into *YDAY.
 860    Returns true if successful, false on failure. */
 861 static bool
 862 parse_yday (struct data_in *i, long *yday)
 863 {
 864   struct substring num_s;
 865   long num;
 866
 867   ss_get_chars (&i->input, 3, &num_s);
 868   if (ss_span (num_s, ss_cstr (CC_DIGITS)) != 3)
 869     {
 870       data_warning (i, _("Julian day must have exactly three digits."));
 871       return false;
 872     }
 873   else if (!ss_get_long (&num_s, &num) || num < 1 || num > 366)
 874     {
 875       data_warning (i, _("Julian day (%ld) must be between 1 and 366."), num);
 876       return false;
 877     }
 878
 879   *yday = num;
 880   return true;
 881 }
 882
 883 /* Parses a quarter-of-year integer between 1 and 4 from I.
 884    Stores the corresponding month into *MONTH.
 885    Returns true if successful, false if no quarter was present. */
 886 static bool
 887 parse_quarter (struct data_in *i, long int *month)
 888 {
 889   long quarter;
 890
 891   if (!parse_int (i, &quarter, SIZE_MAX))
 892     return false;
 893   if (quarter >= 1 && quarter <= 4)
 894     {
 895       *month = (quarter - 1) * 3 + 1;
 896       return true;
 897     }
 898
 899   data_warning (i, _("Quarter (%ld) must be between 1 and 4."), quarter);
 900   return false;
 901 }
 902
 903 /* Parses a week-of-year integer between 1 and 53 from I,
 904    Stores the corresponding year-of-day into *YDAY.
 905    Returns true if successful, false if no week was present. */
 906 static bool
 907 parse_week (struct data_in *i, long int *yday)
 908 {
 909   long week;
 910
 911   if (!parse_int (i, &week, SIZE_MAX))
 912     return false;
 913   if (week >= 1 && week <= 53)
 914     {
 915       *yday = (week - 1) * 7 + 1;
 916       return true;
 917     }
 918
 919   data_warning (i, _("Week (%ld) must be between 1 and 53."), week);
 920   return false;
 921 }
 922
 923 /* Parses a time delimiter from the beginning of I.
 924    Returns true if successful, false if no delimiter was
 925    present. */
 926 static bool
 927 parse_time_delimiter (struct data_in *i)
 928 {
 929   if (ss_ltrim (&i->input, ss_cstr (":" CC_SPACES)) > 0)
 930     return true;
 931
 932   data_warning (i, _("Delimiter expected between fields in time."));
 933   return false;
 934 }
 935
 936 /* Parses minutes and optional seconds from the beginning of I.
 937    The time is converted into seconds, which are added to
 938    *TIME.
 939    Returns true if successful, false if an error was found. */
 940 static bool
 941 parse_minute_second (struct data_in *i, double *time)
 942 {
 943   long minute;
 944   char buf[64];
 945   char *cp;
 946
 947   /* Parse minutes. */
 948   if (!parse_int (i, &minute, SIZE_MAX))
 949     return false;
 950   if (minute < 0 || minute > 59)
 951     {
 952       data_warning (i, _("Minute (%ld) must be between 0 and 59."), minute);
 953       return false;
 954     }
 955   *time += 60. * minute;
 956
 957   /* Check for seconds. */
 958   if (ss_ltrim (&i->input, ss_cstr (":" CC_SPACES)) == 0
 959       || !c_isdigit (ss_first (i->input)))
 960    return true;
 961
 962   /* Parse seconds. */
 963   cp = buf;
 964   while (c_isdigit (ss_first (i->input)))
 965     *cp++ = ss_get_char (&i->input);
 966   if (ss_match_char (&i->input, fmt_decimal_char (FMT_F)))
 967     *cp++ = '.';
 968   while (c_isdigit (ss_first (i->input)))
 969     *cp++ = ss_get_char (&i->input);
 970   *cp = '\0';
 971
 972   *time += strtod (buf, NULL);
 973
 974   return true;
 975 }
 976
 977 /* Parses a weekday name from the beginning of I,
 978    storing a value of 1=Sunday...7=Saturday into *WEEKDAY.
 979    Returns true if successful, false if an error was found. */
 980 static bool
 981 parse_weekday (struct data_in *i, long *weekday)
 982 {
 983   static const char *weekday_names[] =
 984     {
 985       "su", "mo", "tu", "we", "th", "fr", "sa",
 986       NULL,
 987     };
 988
 989   struct substring token = parse_name_token (i);
 990   bool ok = match_name (ss_head (token, 2), weekday_names, weekday);
 991   if (!ok)
 992     data_warning (i, _("Unrecognized weekday name.  At least the first two "
 993                        "letters of an English weekday name must be "
 994                        "specified."));
 995   return ok;
 996 }
 997 \f
 998 /* Date & time formats. */
 999
1000 /* Helper function for passing to
1001    calendar_gregorian_to_offset. */
1002 static void
1003 calendar_error (void *i_, const char *format, ...)
1004 {
1005   struct data_in *i = i_;
1006   va_list args;
1007
1008   va_start (args, format);
1009   vdata_warning (i, format, args);
1010   va_end (args);
1011 }
1012
1013 /* Parses WKDAY format. */
1014 static bool
1015 parse_WKDAY (struct data_in *i)
1016 {
1017   long weekday;
1018
1019   if (trim_spaces_and_check_missing (i))
1020     return true;
1021
1022   if (!parse_weekday (i, &weekday)
1023       || !parse_trailer (i))
1024     return false;
1025
1026   i->output->f = weekday;
1027   return true;
1028 }
1029
1030 /* Parses MONTH format. */
1031 static bool
1032 parse_MONTH (struct data_in *i)
1033 {
1034   long month;
1035
1036   if (trim_spaces_and_check_missing (i))
1037     return true;
1038
1039   if (!parse_month (i, &month)
1040       || !parse_trailer (i))
1041     return false;
1042
1043   i->output->f = month;
1044   return true;
1045 }
1046
1047 /* Parses DATE, ADATE, EDATE, JDATE, SDATE, QYR, MOYR, KWYR,
1048    DATETIME, TIME and DTIME formats. */
1049 static bool
1050 parse_date (struct data_in *i)
1051 {
1052   long int year = INT_MIN;
1053   long int month = 1;
1054   long int day = 1;
1055   long int yday = 1;
1056   double time = 0, date = 0;
1057   enum time_sign time_sign = SIGN_NO_TIME;
1058
1059   const char *template = fmt_date_template (i->format);
1060   size_t template_width = strlen (template);
1061
1062   if (trim_spaces_and_check_missing (i))
1063     return true;
1064
1065   while (*template != '\0')
1066     {
1067       unsigned char ch = *template;
1068       int count = 1;
1069       bool ok;
1070
1071       while (template[count] == ch)
1072         count++;
1073       template += count;
1074
1075       ok = true;
1076       switch (ch)
1077         {
1078         case 'd':
1079           ok = count < 3 ? parse_day (i, &day) : parse_yday (i, &yday);
1080           break;
1081         case 'm':
1082           ok = parse_month (i, &month);
1083           break;
1084         case 'y':
1085           {
1086             size_t max_digits;
1087             if (!c_isalpha (*template))
1088               max_digits = SIZE_MAX;
1089             else
1090               {
1091                 if (ss_length (i->input) >= template_width + 2)
1092                   max_digits = 4;
1093                 else
1094                   max_digits = 2;
1095               }
1096             ok = parse_year (i, &year, max_digits);
1097           }
1098           break;
1099         case 'q':
1100           ok = parse_quarter (i, &month);
1101           break;
1102         case 'w':
1103           ok = parse_week (i, &yday);
1104           break;
1105         case 'D':
1106           ok = parse_time_units (i, 60. * 60. * 24., &time_sign, &time);
1107           break;
1108         case 'H':
1109           ok = parse_time_units (i, 60. * 60., &time_sign, &time);
1110           break;
1111         case 'M':
1112           ok = parse_minute_second (i, &time);
1113           break;
1114         case '-':
1115         case '/':
1116         case '.':
1117         case 'X':
1118           ok = parse_date_delimiter (i);
1119           break;
1120         case ':':
1121           ok = parse_time_delimiter (i);
1122         case ' ':
1123           parse_spaces (i);
1124           break;
1125         default:
1126           assert (count == 1);
1127           if (!ss_match_char (&i->input, c_toupper (ch))
1128               && !ss_match_char (&i->input, c_tolower (ch)))
1129             {
1130               data_warning (i, _("`%c' expected in date field."), ch);
1131               return false;
1132             }
1133           break;
1134         }
1135       if (!ok)
1136         return false;
1137     }
1138   if (!parse_trailer (i))
1139     return false;
1140
1141   if (year != INT_MIN)
1142     {
1143       double ofs = calendar_gregorian_to_offset (year, month, day,
1144                                                  calendar_error, i);
1145       if (ofs == SYSMIS)
1146         return false;
1147       date = (yday - 1 + ofs) * 60. * 60. * 24.;
1148     }
1149   else
1150     date = 0.;
1151   i->output->f = date + (time_sign == SIGN_NEGATIVE ? -time : time);
1152
1153   return true;
1154 }
1155 \f
1156 /* Utility functions. */
1157
1158 /* Outputs FORMAT with the given ARGS as a warning for input
1159    I. */
1160 static void
1161 vdata_warning (const struct data_in *i, const char *format, va_list args)
1162 {
1163   struct msg m;
1164   struct string text;
1165
1166   ds_init_empty (&text);
1167   ds_put_char (&text, '(');
1168   if (i->first_column != 0)
1169     {
1170       if (i->first_column == i->last_column)
1171         ds_put_format (&text, _("column %d"), i->first_column);
1172       else
1173         ds_put_format (&text, _("columns %d-%d"),
1174                        i->first_column, i->last_column);
1175       ds_put_cstr (&text, ", ");
1176     }
1177   ds_put_format (&text, _("%s field) "), fmt_name (i->format));
1178   ds_put_vformat (&text, format, args);
1179
1180   m.category = MSG_DATA;
1181   m.severity = MSG_WARNING;
1182   m.text = ds_cstr (&text);
1183
1184   msg_emit (&m);
1185 }
1186
1187 /* Outputs FORMAT with the given ARGS as a warning for input
1188    I. */
1189 static void
1190 data_warning (const struct data_in *i, const char *format, ...)
1191 {
1192   va_list args;
1193
1194   va_start (args, format);
1195   vdata_warning (i, format, args);
1196   va_end (args);
1197 }
1198
1199 /* Apply implied decimal places to output. */
1200 static void
1201 apply_implied_decimals (struct data_in *i)
1202 {
1203   if (i->implied_decimals > 0)
1204     i->output->f /= pow (10., i->implied_decimals);
1205 }
1206
1207 /* Sets the default result for I.
1208    For a numeric format, this is the value set on SET BLANKS
1209    (typically system-missing); for a string format, it is all
1210    spaces. */
1211 static void
1212 default_result (struct data_in *i)
1213 {
1214   if (fmt_is_string (i->format))
1215     memset (i->output->s, ' ', i->width);
1216   else
1217     i->output->f = get_blanks ();
1218 }
1219
1220 /* Trims leading and trailing spaces from I.
1221    If the result is empty, or a single period character, then
1222    sets the default result and returns true; otherwise, returns
1223    false. */
1224 static bool
1225 trim_spaces_and_check_missing (struct data_in *i)
1226 {
1227   ss_trim (&i->input, ss_cstr (" "));
1228   if (ss_is_empty (i->input) || ss_equals (i->input, ss_cstr (".")))
1229     {
1230       default_result (i);
1231       return true;
1232     }
1233   return false;
1234 }
1235
1236 /* Returns the integer value of hex digit C. */
1237 static int
1238 hexit_value (int c)
1239 {
1240   const char s[] = "0123456789abcdef";
1241   const char *cp = strchr (s, c_tolower ((unsigned char) c));
1242
1243   assert (cp != NULL);
1244   return cp - s;
1245 }