1 /* PSPP - computes sample statistics.
2 Copyright (C) 1997-9, 2000 Free Software Foundation, Inc.
3 Written by Ben Pfaff <blp@gnu.org>.
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.
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.
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
22 #include <libpspp/message.h>
30 #include <libpspp/message.h>
32 #include <libpspp/compiler.h>
33 #include "identifier.h"
34 #include <libpspp/magic.h>
35 #include <libpspp/misc.h>
37 #include <libpspp/str.h>
41 #define _(msgid) gettext (msgid)
43 /* Specialized error routine. */
45 static void dls_error (const struct data_in *, const char *format, ...)
49 vdls_error (const struct data_in *i, const char *format, va_list args)
54 if (i->flags & DI_IGNORE_ERROR)
59 ds_printf (&text, _("(column %d"), i->f1);
61 ds_printf (&text, _("(columns %d-%d"), i->f1, i->f2);
62 ds_printf (&text, _(", field type %s) "), fmt_to_string (&i->format));
63 ds_vprintf (&text, format, args);
65 m.category = MSG_DATA;
66 m.severity = MSG_ERROR;
67 msg_location (&m.where);
68 m.text = ds_c_str (&text);
74 dls_error (const struct data_in *i, const char *format, ...)
78 va_start (args, format);
79 vdls_error (i, format, args);
83 /* Parsing utility functions. */
85 /* Excludes leading and trailing whitespace from I by adjusting
88 trim_whitespace (struct data_in *i)
90 while (i->s < i->e && isspace ((unsigned char) i->s[0]))
93 while (i->s < i->e && isspace ((unsigned char) i->e[-1]))
97 /* Returns nonzero if we're not at the end of the string being
100 have_char (struct data_in *i)
105 /* If implied decimal places are enabled, apply them to
108 apply_implied_decimals (struct data_in *i)
110 if ((i->flags & DI_IMPLIED_DECIMALS) && i->format.d > 0)
111 i->v->f /= pow (10., i->format.d);
114 /* Format parsers. */
116 static bool parse_int (struct data_in *i, long *result);
118 /* This function is based on strtod() from the GNU C library. */
120 parse_numeric (struct data_in *i)
122 int sign; /* +1 or -1. */
123 double num; /* The number so far. */
125 bool got_dot; /* Found a decimal point. */
126 size_t digit_cnt; /* Count of digits. */
128 int decimal; /* Decimal point character. */
129 int grouping; /* Grouping character. */
131 long int exponent; /* Number's exponent. */
132 int type; /* Usually same as i->format.type. */
136 type = i->format.type;
137 if (type == FMT_DOLLAR && have_char (i) && *i->s == '$')
146 sign = *i->s == '-' ? -1 : 1;
147 if (*i->s == '-' || *i->s == '+')
155 decimal = get_decimal();
156 grouping = get_grouping();
160 decimal = get_grouping();
161 grouping = get_decimal();
169 for (; have_char (i); i->s++)
171 if (isdigit ((unsigned char) *i->s))
175 /* Make sure that multiplication by 10 will not overflow. */
176 if (num > DBL_MAX * 0.1)
177 /* The value of the digit doesn't matter, since we have already
178 gotten as many digits as can be represented in a `double'.
179 This doesn't necessarily mean the result will overflow.
180 The exponent may reduce it to within range.
182 We just need to record that there was another
183 digit so that we can multiply by 10 later. */
186 num = (num * 10.0) + (*i->s - '0');
188 /* Keep track of the number of digits after the decimal point.
189 If we just divided by 10 here, we would lose precision. */
193 else if (!got_dot && *i->s == decimal)
194 /* Record that we have found the decimal point. */
196 else if ((type != FMT_COMMA && type != FMT_DOT) || *i->s != grouping)
197 /* Any other character terminates the number. */
208 dls_error (i, _("Field does not form a valid floating-point constant."));
213 if (have_char (i) && strchr ("eEdD-+", *i->s))
215 /* Get the exponent specified after the `e' or `E'. */
218 if (isalpha ((unsigned char) *i->s))
220 if (!parse_int (i, &exp))
228 else if (!got_dot && (i->flags & DI_IMPLIED_DECIMALS))
229 exponent -= i->format.d;
231 if (type == FMT_PCT && have_char (i) && *i->s == '%')
235 dls_error (i, _("Field contents followed by garbage."));
246 /* Multiply NUM by 10 to the EXPONENT power, checking for overflow
250 if (-exponent + digit_cnt > -(DBL_MIN_10_EXP) + 5
251 || num < DBL_MIN * pow (10.0, (double) -exponent))
253 dls_error (i, _("Underflow in floating-point constant."));
258 num *= pow (10.0, (double) exponent);
260 else if (exponent > 0)
262 if (num > DBL_MAX * pow (10.0, (double) -exponent))
264 dls_error (i, _("Overflow in floating-point constant."));
269 num *= pow (10.0, (double) exponent);
272 i->v->f = sign > 0 ? num : -num;
276 /* Returns the integer value of hex digit C. */
280 const char s[] = "0123456789abcdef";
281 const char *cp = strchr (s, tolower ((unsigned char) c));
288 parse_N (struct data_in *i)
293 for (cp = i->s; cp < i->e; cp++)
295 if (!isdigit ((unsigned char) *cp))
297 dls_error (i, _("All characters in field must be digits."));
301 i->v->f = i->v->f * 10.0 + (*cp - '0');
304 apply_implied_decimals (i);
309 parse_PIBHEX (struct data_in *i)
317 for (cp = i->s; cp < i->e; cp++)
319 if (!isxdigit ((unsigned char) *cp))
321 dls_error (i, _("Unrecognized character in field."));
325 n = n * 16.0 + hexit_value (*cp);
333 parse_RBHEX (struct data_in *i)
335 /* Validate input. */
337 if ((i->e - i->s) % 2)
339 dls_error (i, _("Field must have even length."));
346 for (cp = i->s; cp < i->e; cp++)
347 if (!isxdigit ((unsigned char) *cp))
349 dls_error (i, _("Field must contain only hex digits."));
359 unsigned char c[sizeof (double)];
365 memset (u.c, 0, sizeof u.c);
366 for (j = 0; j < min ((i->e - i->s) / 2, sizeof u.d); j++)
367 u.c[j] = 16 * hexit_value (i->s[j * 2]) + hexit_value (i->s[j * 2 + 1]);
376 parse_Z (struct data_in *i)
379 bool got_dot = false;
381 /* Warn user that we suck. */
388 _("Quality of zoned decimal (Z) input format code is "
389 "suspect. Check your results three times. Report bugs "
390 "to %s."),PACKAGE_BUGREPORT);
395 /* Validate input. */
400 dls_error (i, _("Zoned decimal field contains fewer than 2 "
405 /* Copy sign into buf[0]. */
406 if ((i->e[-1] & 0xc0) != 0xc0)
408 dls_error (i, _("Bad sign byte in zoned decimal number."));
411 buf[0] = (i->e[-1] ^ (i->e[-1] >> 1)) & 0x10 ? '-' : '+';
413 /* Copy digits into buf[1 ... len - 1] and terminate string. */
418 for (sp = i->s, dp = buf + 1; sp < i->e - 1; sp++, dp++)
424 else if ((*sp & 0xf0) == 0xf0 && (*sp & 0xf) < 10)
425 *dp = (*sp & 0xf) + '0';
428 dls_error (i, _("Format error in zoned decimal number."));
435 /* Parse as number. */
439 i->v->f = strtod (buf, &tail);
442 dls_error (i, _("Error in syntax of zoned decimal number."));
448 apply_implied_decimals (i);
454 parse_IB (struct data_in *i)
456 #ifndef WORDS_BIGENDIAN
459 const unsigned char *p;
463 /* We want the data to be in big-endian format. If this is a
464 little-endian machine, reverse the byte order. */
465 #ifdef WORDS_BIGENDIAN
466 p = (const unsigned char *) i->s;
468 memcpy (buf, i->s, i->e - i->s);
469 buf_reverse (buf, i->e - i->s);
470 p = (const unsigned char *) buf;
473 /* If the value is negative, we need to logical-NOT each value
484 for (j = 0; j < i->e - i->s; j++)
485 i->v->f = i->v->f * 256.0 + (p[j] ^ xor);
488 /* If the value is negative, add 1 and set the sign, to complete a
489 two's-complement negation. */
491 i->v->f = -(i->v->f + 1.0);
493 apply_implied_decimals (i);
499 parse_PIB (struct data_in *i)
505 for (j = 0; j < i->e - i->s; j++)
506 i->v->f = i->v->f * 256.0 + (unsigned char) i->s[j];
508 for (j = i->e - i->s - 1; j >= 0; j--)
509 i->v->f = i->v->f * 256.0 + (unsigned char) i->s[j];
512 apply_implied_decimals (i);
518 parse_P (struct data_in *i)
523 for (cp = i->s; cp < i->e - 1; cp++)
525 i->v->f = i->v->f * 10 + ((*cp >> 4) & 15);
526 i->v->f = i->v->f * 10 + (*cp & 15);
528 i->v->f = i->v->f * 10 + ((*cp >> 4) & 15);
529 if ((*cp ^ (*cp >> 1)) & 0x10)
532 apply_implied_decimals (i);
538 parse_PK (struct data_in *i)
543 for (cp = i->s; cp < i->e; cp++)
545 i->v->f = i->v->f * 10 + ((*cp >> 4) & 15);
546 i->v->f = i->v->f * 10 + (*cp & 15);
549 apply_implied_decimals (i);
555 parse_RB (struct data_in *i)
560 unsigned char c[sizeof (double)];
564 memset (u.c, 0, sizeof u.c);
565 memcpy (u.c, i->s, min (sizeof u.c, (size_t) (i->e - i->s)));
572 parse_A (struct data_in *i)
574 buf_copy_rpad (i->v->s, i->format.w, i->s, i->e - i->s);
579 parse_AHEX (struct data_in *i)
581 /* Validate input. */
583 if ((i->e - i->s) % 2)
585 dls_error (i, _("Field must have even length."));
592 for (cp = i->s; cp < i->e; cp++)
593 if (!isxdigit ((unsigned char) *cp))
595 dls_error (i, _("Field must contain only hex digits."));
604 for (j = 0; j < min (i->e - i->s, i->format.w); j += 2)
605 i->v->s[j / 2] = hexit_value (i->s[j]) * 16 + hexit_value (i->s[j + 1]);
606 memset (i->v->s + (i->e - i->s) / 2, ' ', (i->format.w - (i->e - i->s)) / 2);
612 /* Date & time format components. */
614 /* Advances *CP past any whitespace characters. */
616 skip_whitespace (struct data_in *i)
618 while (isspace ((unsigned char) *i->s))
623 parse_leader (struct data_in *i)
630 force_have_char (struct data_in *i)
635 dls_error (i, _("Unexpected end of field."));
640 parse_int (struct data_in *i, long *result)
642 bool negative = false;
644 if (!force_have_char (i))
652 else if (*i->s == '-')
659 if (!isdigit ((unsigned char) *i->s))
661 dls_error (i, _("Digit expected in field."));
668 *result = *result * 10 + (*i->s++ - '0');
669 if (!have_char (i) || !isdigit ((unsigned char) *i->s))
679 parse_day (struct data_in *i, long *day)
681 if (!parse_int (i, day))
683 if (*day >= 1 && *day <= 31)
686 dls_error (i, _("Day (%ld) must be between 1 and 31."), *day);
691 parse_day_count (struct data_in *i, long *day_count)
693 return parse_int (i, day_count);
697 parse_date_delimiter (struct data_in *i)
702 && (*i->s == '-' || *i->s == '/' || isspace ((unsigned char) *i->s)
703 || *i->s == '.' || *i->s == ','))
711 dls_error (i, _("Delimiter expected between fields in date."));
715 /* Association between a name and a value. */
718 const char *name; /* Name. */
719 bool can_abbreviate; /* True if name may be abbreviated. */
720 int value; /* Value associated with name. */
723 /* Reads a name from I and sets *OUTPUT to the value associated
724 with that name. Returns true if successful, false otherwise. */
726 parse_enum (struct data_in *i, const char *what,
727 const struct enum_name *enum_names,
732 const struct enum_name *ep;
734 /* Consume alphabetic characters. */
737 while (have_char (i) && isalpha ((unsigned char) *i->s))
744 dls_error (i, _("Parse error at `%c' expecting %s."), *i->s, what);
748 for (ep = enum_names; ep->name != NULL; ep++)
749 if ((ep->can_abbreviate
750 && lex_id_match_len (ep->name, strlen (ep->name), name, length))
751 || (!ep->can_abbreviate && length == strlen (ep->name)
752 && !buf_compare_case (name, ep->name, length)))
758 dls_error (i, _("Unknown %s `%.*s'."), what, (int) length, name);
763 parse_month (struct data_in *i, long *month)
765 static const struct enum_name month_names[] =
767 {"january", true, 1},
768 {"february", true, 2},
775 {"september", true, 9},
776 {"october", true, 10},
777 {"november", true, 11},
778 {"december", true, 12},
798 if (!force_have_char (i))
801 if (isdigit ((unsigned char) *i->s))
803 if (!parse_int (i, month))
805 if (*month >= 1 && *month <= 12)
808 dls_error (i, _("Month (%ld) must be between 1 and 12."), *month);
812 return parse_enum (i, _("month"), month_names, month);
816 parse_year (struct data_in *i, long *year)
818 if (!parse_int (i, year))
821 if (*year >= 0 && *year <= 199)
823 if (*year >= 1582 || *year <= 19999)
826 dls_error (i, _("Year (%ld) must be between 1582 and 19999."), *year);
831 parse_trailer (struct data_in *i)
837 dls_error (i, _("Trailing garbage \"%s\" following date."), i->s);
842 parse_julian (struct data_in *i, long *julian)
844 if (!parse_int (i, julian))
848 int day = *julian % 1000;
850 if (day < 1 || day > 366)
852 dls_error (i, _("Julian day (%d) must be between 1 and 366."), day);
858 int year = *julian / 1000;
860 if (year >= 0 && year <= 199)
862 else if (year < 1582 || year > 19999)
864 dls_error (i, _("Year (%d) must be between 1582 and 19999."), year);
873 parse_quarter (struct data_in *i, long *quarter)
875 if (!parse_int (i, quarter))
877 if (*quarter >= 1 && *quarter <= 4)
880 dls_error (i, _("Quarter (%ld) must be between 1 and 4."), *quarter);
885 parse_q_delimiter (struct data_in *i)
888 if (!have_char (i) || tolower ((unsigned char) *i->s) != 'q')
890 dls_error (i, _("`Q' expected between quarter and year."));
899 parse_week (struct data_in *i, long *week)
901 if (!parse_int (i, week))
903 if (*week >= 1 && *week <= 53)
906 dls_error (i, _("Week (%ld) must be between 1 and 53."), *week);
911 parse_wk_delimiter (struct data_in *i)
915 || tolower ((unsigned char) i->s[0]) != 'w'
916 || tolower ((unsigned char) i->s[1]) != 'k')
918 dls_error (i, _("`WK' expected between week and year."));
927 parse_time_delimiter (struct data_in *i)
931 while (have_char (i) && (*i->s == ':' || *i->s == '.'
932 || isspace ((unsigned char) *i->s)))
941 dls_error (i, _("Delimiter expected between fields in time."));
946 parse_hour (struct data_in *i, long *hour)
948 if (!parse_int (i, hour))
953 dls_error (i, _("Hour (%ld) must be positive."), *hour);
958 parse_minute (struct data_in *i, long *minute)
960 if (!parse_int (i, minute))
962 if (*minute >= 0 && *minute <= 59)
965 dls_error (i, _("Minute (%ld) must be between 0 and 59."), *minute);
970 parse_opt_second (struct data_in *i, double *second)
978 && (*i->s == ':' || *i->s == '.' || isspace ((unsigned char) *i->s)))
984 if (!delim || !isdigit ((unsigned char) *i->s))
991 while (have_char (i) && isdigit ((unsigned char) *i->s))
993 if (have_char (i) && *i->s == '.')
995 while (have_char (i) && isdigit ((unsigned char) *i->s))
999 *second = strtod (buf, NULL);
1005 parse_hour24 (struct data_in *i, long *hour24)
1007 if (!parse_int (i, hour24))
1009 if (*hour24 >= 0 && *hour24 <= 23)
1012 dls_error (i, _("Hour (%ld) must be between 0 and 23."), *hour24);
1018 parse_weekday (struct data_in *i, long *weekday)
1020 static const struct enum_name weekday_names[] =
1022 {"sunday", true, 1},
1024 {"monday", true, 2},
1026 {"tuesday", true, 3},
1028 {"wednesday", true, 4},
1030 {"thursday", true, 5},
1032 {"friday", true, 6},
1034 {"saturday", true, 7},
1040 return parse_enum (i, _("weekday"), weekday_names, weekday);
1044 parse_spaces (struct data_in *i)
1046 skip_whitespace (i);
1051 parse_sign (struct data_in *i, int *sign)
1053 if (!force_have_char (i))
1075 /* Date & time formats. */
1078 calendar_error (void *i_, const char *format, ...)
1080 struct data_in *i = i_;
1083 va_start (args, format);
1084 vdls_error (i, format, args);
1089 ymd_to_ofs (struct data_in *i, int year, int month, int day, double *ofs)
1091 *ofs = calendar_gregorian_to_offset (year, month, day, calendar_error, i);
1092 return *ofs != SYSMIS;
1096 ymd_to_date (struct data_in *i, int year, int month, int day, double *date)
1098 if (ymd_to_ofs (i, year, month, day, date))
1100 *date *= 60. * 60. * 24.;
1108 parse_DATE (struct data_in *i)
1110 long day, month, year;
1112 return (parse_leader (i)
1113 && parse_day (i, &day)
1114 && parse_date_delimiter (i)
1115 && parse_month (i, &month)
1116 && parse_date_delimiter (i)
1117 && parse_year (i, &year)
1118 && parse_trailer (i)
1119 && ymd_to_date (i, year, month, day, &i->v->f));
1123 parse_ADATE (struct data_in *i)
1125 long month, day, year;
1127 return (parse_leader (i)
1128 && parse_month (i, &month)
1129 && parse_date_delimiter (i)
1130 && parse_day (i, &day)
1131 && parse_date_delimiter (i)
1132 && parse_year (i, &year)
1133 && parse_trailer (i)
1134 && ymd_to_date (i, year, month, day, &i->v->f));
1138 parse_EDATE (struct data_in *i)
1140 long month, day, year;
1142 return (parse_leader (i)
1143 && parse_day (i, &day)
1144 && parse_date_delimiter (i)
1145 && parse_month (i, &month)
1146 && parse_date_delimiter (i)
1147 && parse_year (i, &year)
1148 && parse_trailer (i)
1149 && ymd_to_date (i, year, month, day, &i->v->f));
1153 parse_SDATE (struct data_in *i)
1155 long month, day, year;
1157 return (parse_leader (i)
1158 && parse_year (i, &year)
1159 && parse_date_delimiter (i)
1160 && parse_month (i, &month)
1161 && parse_date_delimiter (i)
1162 && parse_day (i, &day)
1163 && parse_trailer (i)
1164 && ymd_to_date (i, year, month, day, &i->v->f));
1168 parse_JDATE (struct data_in *i)
1173 if (!parse_leader (i)
1174 || !parse_julian (i, &julian)
1175 || !parse_trailer (i)
1176 || !ymd_to_ofs (i, julian / 1000, 1, 1, &ofs))
1179 i->v->f = (ofs + julian % 1000 - 1) * 60. * 60. * 24.;
1184 parse_QYR (struct data_in *i)
1188 return (parse_leader (i)
1189 && parse_quarter (i, &quarter)
1190 && parse_q_delimiter (i)
1191 && parse_year (i, &year)
1192 && parse_trailer (i)
1193 && ymd_to_date (i, year, (quarter - 1) * 3 + 1, 1, &i->v->f));
1197 parse_MOYR (struct data_in *i)
1201 return (parse_leader (i)
1202 && parse_month (i, &month)
1203 && parse_date_delimiter (i)
1204 && parse_year (i, &year)
1205 && parse_trailer (i)
1206 && ymd_to_date (i, year, month, 1, &i->v->f));
1210 parse_WKYR (struct data_in *i)
1215 if (!parse_leader (i)
1216 || !parse_week (i, &week)
1217 || !parse_wk_delimiter (i)
1218 || !parse_year (i, &year)
1219 || !parse_trailer (i))
1224 if (!ymd_to_ofs (i, year, 1, 1, &ofs))
1229 if (ymd_to_ofs (i, 1583, 1, 1, &ofs))
1234 i->v->f = (ofs + (week - 1) * 7) * 60. * 60. * 24.;
1239 parse_TIME (struct data_in *i)
1245 if (!parse_leader (i)
1246 || !parse_sign (i, &sign)
1247 || !parse_spaces (i)
1248 || !parse_hour (i, &hour)
1249 || !parse_time_delimiter (i)
1250 || !parse_minute (i, &minute)
1251 || !parse_opt_second (i, &second))
1254 i->v->f = (hour * 60. * 60. + minute * 60. + second) * sign;
1259 parse_DTIME (struct data_in *i)
1262 long day_count, hour;
1266 if (!parse_leader (i)
1267 || !parse_sign (i, &sign)
1268 || !parse_spaces (i)
1269 || !parse_day_count (i, &day_count)
1270 || !parse_time_delimiter (i)
1271 || !parse_hour (i, &hour)
1272 || !parse_time_delimiter (i)
1273 || !parse_minute (i, &minute)
1274 || !parse_opt_second (i, &second))
1277 i->v->f = (day_count * 60. * 60. * 24.
1285 parse_DATETIME (struct data_in *i)
1287 long day, month, year;
1292 if (!parse_leader (i)
1293 || !parse_day (i, &day)
1294 || !parse_date_delimiter (i)
1295 || !parse_month (i, &month)
1296 || !parse_date_delimiter (i)
1297 || !parse_year (i, &year)
1298 || !parse_time_delimiter (i)
1299 || !parse_hour24 (i, &hour24)
1300 || !parse_time_delimiter (i)
1301 || !parse_minute (i, &minute)
1302 || !parse_opt_second (i, &second)
1303 || !ymd_to_date (i, year, month, day, &i->v->f))
1306 i->v->f += hour24 * 60. * 60. + minute * 60. + second;
1311 parse_WKDAY (struct data_in *i)
1315 if (!parse_leader (i)
1316 || !parse_weekday (i, &weekday)
1317 || !parse_trailer (i))
1325 parse_MONTH (struct data_in *i)
1329 if (!parse_leader (i)
1330 || !parse_month (i, &month)
1331 || !parse_trailer (i))
1338 /* Main dispatcher. */
1341 default_result (struct data_in *i)
1343 const struct fmt_desc *const fmt = &formats[i->format.type];
1345 /* Default to SYSMIS or blanks. */
1346 if (fmt->cat & FCAT_STRING)
1347 memset (i->v->s, ' ', i->format.w);
1349 i->v->f = get_blanks();
1353 data_in (struct data_in *i)
1355 const struct fmt_desc *const fmt = &formats[i->format.type];
1357 assert (check_input_specifier (&i->format, 0));
1359 /* Check that we've got a string to work with. */
1360 if (i->e == i->s || i->format.w <= 0)
1366 i->f2 = i->f1 + (i->e - i->s) - 1;
1368 /* Make sure that the string isn't too long. */
1369 if (i->format.w > fmt->Imax_w)
1371 dls_error (i, _("Field too long (%d characters). Truncated after "
1373 i->format.w, fmt->Imax_w);
1374 i->format.w = fmt->Imax_w;
1377 if (fmt->cat & FCAT_BLANKS_SYSMIS)
1384 if (!isspace ((unsigned char) *cp))
1389 i->v->f = get_blanks();
1396 static bool (*const handlers[FMT_NUMBER_OF_FORMATS])(struct data_in *) =
1398 parse_numeric, parse_N, parse_numeric, parse_numeric,
1399 parse_numeric, parse_numeric, parse_numeric,
1400 parse_Z, parse_A, parse_AHEX, parse_IB, parse_P, parse_PIB,
1401 parse_PIBHEX, parse_PK, parse_RB, parse_RBHEX,
1402 NULL, NULL, NULL, NULL, NULL,
1403 parse_DATE, parse_EDATE, parse_SDATE, parse_ADATE, parse_JDATE,
1404 parse_QYR, parse_MOYR, parse_WKYR,
1405 parse_DATETIME, parse_TIME, parse_DTIME,
1406 parse_WKDAY, parse_MONTH,
1409 bool (*handler)(struct data_in *);
1412 handler = handlers[i->format.type];
1413 assert (handler != NULL);
1415 success = handler (i);
1423 /* Utility function. */
1425 /* Sets DI->{s,e} appropriately given that LINE has length LEN and the
1426 field starts at one-based column FC and ends at one-based column
1429 data_in_finite_line (struct data_in *di, const char *line, size_t len,
1432 di->s = line + ((size_t) fc <= len ? fc - 1 : len);
1433 di->e = line + ((size_t) lc <= len ? lc : len);