a40e4226a1a18e9d3ddbde602f4976dba0c292e5
[pspp] / src / language / data-io / placement-parser.c
1 /* PSPP - a program for statistical analysis.
2    Copyright (C) 2006, 2010, 2011, 2012 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 "language/data-io/placement-parser.h"
20
21 #include <assert.h>
22
23 #include "data/format.h"
24 #include "language/lexer/format-parser.h"
25 #include "language/lexer/lexer.h"
26 #include "libpspp/message.h"
27 #include "libpspp/pool.h"
28 #include "libpspp/str.h"
29
30 #include "gl/xalloc.h"
31 #include "gl/xsize.h"
32
33 #include "gettext.h"
34 #define _(msgid) gettext (msgid)
35
36 /* Extensions to the format specifiers used only for
37    placement. */
38 enum
39   {
40     PRS_TYPE_T = SCHAR_MAX - 3, /* Tab to absolute column. */
41     PRS_TYPE_X,                 /* Skip columns. */
42     PRS_TYPE_NEW_REC            /* Next record. */
43   };
44
45 static bool fixed_parse_columns (struct lexer *, struct pool *, size_t var_cnt,
46                                  enum fmt_use, struct fmt_spec **, size_t *);
47 static bool fixed_parse_fortran (struct lexer *l, struct pool *, enum fmt_use,
48                                  struct fmt_spec **, size_t *);
49
50 /* Parses Fortran-like or column-based specifications for placing
51    variable data in fixed positions in columns and rows, that is,
52    formats like those parsed by DATA LIST or PRINT.  Returns true
53    only if successful.
54
55    The formats parsed are either input or output formats, according
56    to USE.
57
58    If USE is FMT_FOR_INPUT, then T, X, and / "formats" are parsed,
59    in addition to regular formats.  If USE is FMT_FOR_OUTPUT, then
60    T and X "formats" are parsed but not /.
61
62    If successful, formats for VAR_CNT variables are stored in
63    *FORMATS, and the number of formats required is stored in
64    *FORMAT_CNT.  *FORMAT_CNT may be greater than VAR_CNT because
65    of T, X, and / "formats", but success guarantees that exactly
66    VAR_CNT variables will be placed by the output formats.  The
67    caller should call execute_placement_format to process those
68    "formats" in interpreting the output.
69
70    Uses POOL for allocation.  When the caller is finished
71    interpreting *FORMATS, POOL may be destroyed. */
72 bool
73 parse_var_placements (struct lexer *lexer, struct pool *pool, size_t var_cnt,
74                       enum fmt_use use,
75                       struct fmt_spec **formats, size_t *format_cnt)
76 {
77   assert (var_cnt > 0);
78   if (lex_is_number (lexer))
79     return fixed_parse_columns (lexer, pool, var_cnt, use,
80                                 formats, format_cnt);
81   else if (lex_match (lexer, T_LPAREN))
82     {
83       size_t assignment_cnt;
84       size_t i;
85
86       if (!fixed_parse_fortran (lexer, pool, use, formats, format_cnt))
87         return false;
88
89       assignment_cnt = 0;
90       for (i = 0; i < *format_cnt; i++)
91         assignment_cnt += (*formats)[i].type < FMT_NUMBER_OF_FORMATS;
92
93       if (assignment_cnt != var_cnt)
94         {
95           msg (SE, _("Number of variables specified (%zu) "
96                      "differs from number of variable formats (%zu)."),
97                var_cnt, assignment_cnt);
98           return false;
99         }
100
101       return true;
102     }
103   else
104     {
105       msg (SE, _("SPSS-like or Fortran-like format "
106                  "specification expected after variable names."));
107       return false;
108     }
109 }
110
111 /* Implements parse_var_placements for column-based formats. */
112 static bool
113 fixed_parse_columns (struct lexer *lexer, struct pool *pool, size_t var_cnt,
114                      enum fmt_use use,
115                      struct fmt_spec **formats, size_t *format_cnt)
116 {
117   struct fmt_spec format;
118   int fc, lc;
119   size_t i;
120
121   if ( !parse_column_range (lexer, 1, &fc, &lc, NULL) )
122     return false;
123
124   /* Divide columns evenly. */
125   format.w = (lc - fc + 1) / var_cnt;
126   if ((lc - fc + 1) % var_cnt)
127     {
128       msg (SE, _("The %d columns %d-%d "
129                  "can't be evenly divided into %zu fields."),
130            lc - fc + 1, fc, lc, var_cnt);
131       return false;
132     }
133
134   /* Format specifier. */
135   if (lex_match (lexer, T_LPAREN))
136     {
137       /* Get format type. */
138       if (lex_token (lexer) == T_ID)
139         {
140           if (!parse_format_specifier_name (lexer, &format.type))
141             return false;
142           lex_match (lexer, T_COMMA);
143         }
144       else
145         format.type = FMT_F;
146
147       /* Get decimal places. */
148       if (lex_is_integer (lexer))
149         {
150           format.d = lex_integer (lexer);
151           lex_get (lexer);
152         }
153       else
154         format.d = 0;
155
156       if (!lex_force_match (lexer, T_RPAREN))
157         return false;
158     }
159   else
160     {
161       format.type = FMT_F;
162       format.d = 0;
163     }
164   if (!fmt_check (&format, use))
165     return false;
166
167   *formats = pool_nalloc (pool, var_cnt + 1, sizeof **formats);
168   *format_cnt = var_cnt + 1;
169   (*formats)[0].type = PRS_TYPE_T;
170   (*formats)[0].w = fc;
171   for (i = 1; i <= var_cnt; i++)
172     (*formats)[i] = format;
173   return true;
174 }
175
176 /* Implements parse_var_placements for Fortran-like formats. */
177 static bool
178 fixed_parse_fortran (struct lexer *lexer, struct pool *pool, enum fmt_use use,
179                      struct fmt_spec **formats, size_t *format_cnt)
180 {
181   size_t formats_allocated = 0;
182   size_t formats_used = 0;
183
184   *formats = NULL;
185   while (!lex_match (lexer, T_RPAREN))
186     {
187       struct fmt_spec f;
188       struct fmt_spec *new_formats;
189       size_t new_format_cnt;
190       size_t count;
191       size_t formats_needed;
192
193       /* Parse count. */
194       if (lex_is_integer (lexer))
195         {
196           count = lex_integer (lexer);
197           lex_get (lexer);
198         }
199       else
200         count = 1;
201
202       /* Parse format specifier. */
203       if (lex_match (lexer, T_LPAREN))
204         {
205           /* Call ourselves recursively to handle parentheses. */
206           if (!fixed_parse_fortran (lexer, pool, use,
207                                     &new_formats, &new_format_cnt))
208             return false;
209         }
210       else
211         {
212           new_formats = &f;
213           new_format_cnt = 1;
214           if (use == FMT_FOR_INPUT && lex_match (lexer, T_SLASH))
215             f.type = PRS_TYPE_NEW_REC;
216           else
217             {
218               char type[FMT_TYPE_LEN_MAX + 1];
219
220               if (!parse_abstract_format_specifier (lexer, type, &f.w, &f.d))
221                 return false;
222
223               if (!strcasecmp (type, "T"))
224                 f.type = PRS_TYPE_T;
225               else if (!strcasecmp (type, "X"))
226                 {
227                   f.type = PRS_TYPE_X;
228                   f.w = count;
229                   count = 1;
230                 }
231               else
232                 {
233                   if (!fmt_from_name (type, &f.type))
234                     {
235                       msg (SE, _("Unknown format type `%s'."), type);
236                       return false;
237                     }
238                   if (!fmt_check (&f, use))
239                     return false;
240                 }
241             }
242         }
243
244       /* Add COUNT copies of the NEW_FORMAT_CNT formats in
245          NEW_FORMATS to FORMATS. */
246       if (new_format_cnt != 0
247           && size_overflow_p (xtimes (xsum (formats_used,
248                                             xtimes (count, new_format_cnt)),
249                                       sizeof *formats)))
250         xalloc_die ();
251       formats_needed = count * new_format_cnt;
252       if (formats_used + formats_needed > formats_allocated)
253         {
254           formats_allocated = formats_used + formats_needed;
255           *formats = pool_2nrealloc (pool, *formats, &formats_allocated,
256                                      sizeof **formats);
257         }
258       for (; count > 0; count--)
259         {
260           memcpy (&(*formats)[formats_used], new_formats,
261                   sizeof **formats * new_format_cnt);
262           formats_used += new_format_cnt;
263         }
264
265       lex_match (lexer, T_COMMA);
266     }
267
268   *format_cnt = formats_used;
269   return true;
270 }
271
272 /* Checks whether FORMAT represents one of the special "formats"
273    for T, X, or /.  If so, updates *RECORD or *COLUMN (or both)
274    as appropriate, and returns true.  Otherwise, returns false
275    without any side effects. */
276 bool
277 execute_placement_format (const struct fmt_spec *format,
278                           int *record, int *column)
279 {
280   switch ((int) format->type)
281     {
282     case PRS_TYPE_X:
283       *column += format->w;
284       return true;
285
286     case PRS_TYPE_T:
287       *column = format->w;
288       return true;
289
290     case PRS_TYPE_NEW_REC:
291       (*record)++;
292       *column = 1;
293       return true;
294
295     default:
296       assert (format->type < FMT_NUMBER_OF_FORMATS);
297       return false;
298     }
299 }
300
301 /* Parses a BASE-based column using LEXER.  Returns true and
302    stores a 1-based column number into *COLUMN if successful,
303    otherwise emits an error message and returns false. */
304 static bool
305 parse_column (int value, int base, int *column)
306 {
307   assert (base == 0 || base == 1);
308   *column = value - base + 1;
309   if (*column < 1)
310     {
311       if (base == 1)
312         msg (SE, _("Column positions for fields must be positive."));
313       else
314         msg (SE, _("Column positions for fields must not be negative."));
315       return false;
316     }
317   return true;
318 }
319
320 /* Parse a column or a range of columns, specified as a single
321    integer or two integers delimited by a dash.  Stores the range
322    in *FIRST_COLUMN and *LAST_COLUMN.  (If only a single integer
323    is given, it is stored in both.)  If RANGE_SPECIFIED is
324    non-null, then *RANGE_SPECIFIED is set to true if the syntax
325    contained a dash, false otherwise.  Returns true if
326    successful, false if the syntax was invalid or the values
327    specified did not make sense.
328
329    If BASE is 0, zero-based column numbers are parsed; if BASE is
330    1, 1-based column numbers are parsed.  Regardless of BASE, the
331    values stored in *FIRST_COLUMN and *LAST_COLUMN are
332    1-based. */
333 bool
334 parse_column_range (struct lexer *lexer, int base,
335                     int *first_column, int *last_column,
336                     bool *range_specified)
337 {
338   /* First column. */
339   if (!lex_force_int (lexer)
340       || !parse_column (lex_integer (lexer), base, first_column))
341     return false;
342   lex_get (lexer);
343
344   /* Last column. */
345   if (lex_is_integer (lexer) && lex_integer (lexer) < 0)
346     {
347       if (!parse_column (-lex_integer (lexer), base, last_column))
348         return false;
349       lex_get (lexer);
350
351       if (*last_column < *first_column)
352         {
353           msg (SE, _("The ending column for a field must be "
354                      "greater than the starting column."));
355           return false;
356         }
357
358       if (range_specified)
359         *range_specified = true;
360     }
361   else
362     {
363       *last_column = *first_column;
364       if (range_specified)
365         *range_specified = false;
366     }
367
368   return true;
369 }
370
371 /* Parses a (possibly empty) sequence of slashes, each of which
372    may be followed by an integer.  A slash on its own increases
373    *RECORD by 1 and sets *COLUMN to 1.  A slash followed by an
374    integer sets *RECORD to the integer, as long as that increases
375    *RECORD, and sets *COLUMN to 1.
376
377    Returns true if successful, false on syntax error. */
378 bool
379 parse_record_placement (struct lexer *lexer, int *record, int *column)
380 {
381   while (lex_match (lexer, T_SLASH))
382     {
383       if (lex_is_integer (lexer))
384         {
385           if (lex_integer (lexer) <= *record)
386             {
387               msg (SE, _("The record number specified, %ld, is at or "
388                          "before the previous record, %d.  Data "
389                          "fields must be listed in order of "
390                          "increasing record number."),
391                    lex_integer (lexer), *record);
392               return false;
393             }
394           *record = lex_integer (lexer);
395           lex_get (lexer);
396         }
397       else
398         (*record)++;
399       *column = 1;
400     }
401   assert (*record >= 1);
402
403   return true;
404 }