1 /* PSPP - computes sample statistics.
2 Copyright (C) 2006 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 <language/data-io/placement-parser.h>
26 #include <language/lexer/format-parser.h>
27 #include <language/lexer/lexer.h>
28 #include <libpspp/message.h>
29 #include <libpspp/pool.h>
30 #include <libpspp/str.h>
36 #define _(msgid) gettext (msgid)
38 /* Extensions to the format specifiers used only for
42 PRS_TYPE_T = -1, /* Tab to absolute column. */
43 PRS_TYPE_X = -2, /* Skip columns. */
44 PRS_TYPE_NEW_REC = -3 /* Next record. */
47 static bool fixed_parse_columns (struct pool *, size_t var_cnt,
48 struct fmt_spec **, size_t *);
49 static bool fixed_parse_fortran (struct pool *,
50 struct fmt_spec **, size_t *);
52 /* Parses Fortran-like or column-based specifications for placing
53 variable data in fixed positions in columns and rows, that is,
54 formats like those parsed by DATA LIST or PRINT. Returns true
57 If successful, formats for VAR_CNT variables are stored in
58 *FORMATS, and the number of formats required is stored in
59 *FORMAT_CNT. *FORMAT_CNT may be greater than VAR_CNT because
60 of T, X, and / "formats", but success guarantees that exactly
61 VAR_CNT variables will be placed by the output formats. The
62 caller should call execute_placement_format to process those
63 "formats" in interpreting the output.
65 Uses POOL for allocation. When the caller is finished
66 interpreting *FORMATS, POOL may be destroyed. */
68 parse_var_placements (struct pool *pool, size_t var_cnt,
69 struct fmt_spec **formats, size_t *format_cnt)
73 return fixed_parse_columns (pool, var_cnt, formats, format_cnt);
74 else if (lex_match ('('))
76 size_t assignment_cnt;
79 if (!fixed_parse_fortran (pool, formats, format_cnt))
83 for (i = 0; i < *format_cnt; i++)
84 assignment_cnt += (*formats)[i].type >= 0;
86 if (assignment_cnt != var_cnt)
88 msg (SE, _("Number of variables specified (%d) "
89 "differs from number of variable formats (%d)."),
90 (int) var_cnt, (int) assignment_cnt);
98 msg (SE, _("SPSS-like or Fortran-like format "
99 "specification expected after variable names."));
104 /* Implements parse_var_placements for column-based formats. */
106 fixed_parse_columns (struct pool *pool, size_t var_cnt,
107 struct fmt_spec **formats, size_t *format_cnt)
109 struct fmt_spec format;
113 if (!parse_column_range (&fc, &lc, NULL))
116 /* Divide columns evenly. */
117 format.w = (lc - fc + 1) / var_cnt;
118 if ((lc - fc + 1) % var_cnt)
120 msg (SE, _("The %d columns %d-%d "
121 "can't be evenly divided into %d fields."),
122 lc - fc + 1, fc, lc, var_cnt);
126 /* Format specifier. */
129 /* Get format type. */
132 if (!parse_format_specifier_name (&format.type))
139 /* Get decimal places. */
140 if (lex_is_integer ())
142 format.d = lex_integer ();
148 if (!lex_force_match (')'))
156 if (!check_input_specifier (&format, 1))
159 *formats = pool_nalloc (pool, var_cnt + 1, sizeof **formats);
160 *format_cnt = var_cnt + 1;
161 (*formats)[0].type = PRS_TYPE_T;
162 (*formats)[0].w = fc;
163 for (i = 1; i <= var_cnt; i++)
164 (*formats)[i] = format;
168 /* Implements parse_var_placements for Fortran-like formats. */
170 fixed_parse_fortran (struct pool *pool,
171 struct fmt_spec **formats, size_t *format_cnt)
173 size_t formats_allocated = 0;
174 size_t formats_used = 0;
177 while (!lex_match (')'))
180 struct fmt_spec *new_formats;
181 size_t new_format_cnt;
183 size_t formats_needed;
186 if (lex_is_integer ())
188 count = lex_integer ();
194 /* Parse format specifier. */
197 /* Call ourselves recursively to handle parentheses. */
198 if (!fixed_parse_fortran (pool, &new_formats, &new_format_cnt))
206 f.type = PRS_TYPE_NEW_REC;
209 char type[FMT_TYPE_LEN_MAX + 1];
211 if (!parse_abstract_format_specifier (type, &f.w, &f.d))
214 if (!strcasecmp (type, "T"))
216 else if (!strcasecmp (type, "X"))
224 if (!fmt_type_from_string (type, &f.type))
226 msg (SE, _("Unknown format type \"%s\"."), type);
229 if (!check_input_specifier (&f, 1))
235 /* Add COUNT copies of the NEW_FORMAT_CNT formats in
236 NEW_FORMATS to FORMATS. */
237 if (new_format_cnt != 0
238 && size_overflow_p (xtimes (xsum (formats_used,
239 xtimes (count, new_format_cnt)),
242 formats_needed = count * new_format_cnt;
243 if (formats_used + formats_needed > formats_allocated)
245 formats_allocated = formats_used + formats_needed;
246 *formats = pool_2nrealloc (pool, *formats, &formats_allocated,
249 for (; count > 0; count--)
251 memcpy (&(*formats)[formats_used], new_formats,
252 sizeof **formats * new_format_cnt);
253 formats_used += new_format_cnt;
259 *format_cnt = formats_used;
263 /* Checks whether FORMAT represents one of the special "formats"
264 for T, X, or /. If so, updates *RECORD or *COLUMN (or both)
265 as appropriate, and returns true. Otherwise, returns false
266 without any side effects. */
268 execute_placement_format (const struct fmt_spec *format,
269 int *record, int *column)
271 switch (format->type)
274 *column += format->w;
281 case PRS_TYPE_NEW_REC:
287 assert (format->type >= 0 && format->type < FMT_NUMBER_OF_FORMATS);
292 /* Parse a column or a range of columns, specified as a single
293 integer or two integer delimited by a dash. Stores the range
294 in *FIRST_COLUMN and *LAST_COLUMN. (If only a single integer
295 is given, it is stored in both.) If RANGE_SPECIFIED is
296 non-null, then *RANGE_SPECIFIED is set to true if the syntax
297 contained a dash, false otherwise. Returns true if
298 successful, false if the syntax was invalid or the values
299 specified did not make sense. */
301 parse_column_range (int *first_column, int *last_column,
302 bool *range_specified)
305 if (!lex_force_int ())
307 *first_column = lex_integer ();
308 if (*first_column < 1)
310 msg (SE, _("Column positions for fields must be positive."));
316 lex_negative_to_dash ();
319 if (!lex_force_int ())
321 *last_column = lex_integer ();
322 if (*last_column < 1)
324 msg (SE, _("Column positions for fields must be positive."));
327 else if (*last_column < *first_column)
329 msg (SE, _("The ending column for a field must be "
330 "greater than the starting column."));
335 *range_specified = true;
340 *last_column = *first_column;
342 *range_specified = false;
348 /* Parses a (possibly empty) sequence of slashes, each of which
349 may be followed by an integer. A slash on its own increases
350 *RECORD by 1 and sets *COLUMN to 1. A slash followed by an
351 integer sets *RECORD to the integer, as long as that increases
352 *RECORD, and sets *COLUMN to 1.
354 Returns true if successful, false on syntax error. */
356 parse_record_placement (int *record, int *column)
358 while (lex_match ('/'))
360 if (lex_is_integer ())
362 if (lex_integer () <= *record)
364 msg (SE, _("The record number specified, %ld, is at or "
365 "before the previous record, %d. Data "
366 "fields must be listed in order of "
367 "increasing record number."),
368 lex_integer (), *record);
371 *record = lex_integer ();
378 assert (*record >= 1);