98336b2563f3aefd89d42ee6de5838b0cdd6df51
[pspp] / tests / output / pivot-table-test.c
1 /* PSPP - a program for statistical analysis.
2    Copyright (C) 2009, 2010, 2011, 2012, 2013, 2014 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 <errno.h>
20 #include <fnmatch.h>
21 #include <getopt.h>
22 #include <limits.h>
23 #include <stdarg.h>
24 #include <stdio.h>
25 #include <string.h>
26
27 #include "data/file-handle-def.h"
28 #include "language/lexer/lexer.h"
29 #include "language/lexer/format-parser.h"
30 #include "libpspp/assertion.h"
31 #include "libpspp/compiler.h"
32 #include "libpspp/i18n.h"
33 #include "libpspp/string-map.h"
34 #include "output/driver.h"
35 #include "output/options.h"
36 #include "output/output-item.h"
37 #include "output/pivot-table.h"
38
39 #include "gl/error.h"
40 #include "gl/progname.h"
41 #include "gl/xalloc.h"
42 #include "gl/xvasprintf.h"
43
44 /* --emphasis: Enable emphasis in ASCII driver? */
45 static bool emphasis;
46
47 /* --box: ASCII driver box option. */
48 static char *box;
49
50 /* -o, --output: Base name for output files. */
51 static const char *output_base = "render";
52
53 static const char *parse_options (int argc, char **argv);
54 static void usage (void) NO_RETURN;
55 static void read_table (struct lexer *);
56 static void output_msg (const struct msg *, void *);
57
58 int
59 main (int argc, char **argv)
60 {
61   const char *input_file_name;
62
63   set_program_name (argv[0]);
64   i18n_init ();
65   output_engine_push ();
66   input_file_name = parse_options (argc, argv);
67
68   settings_init ();
69
70   struct lex_reader *reader = lex_reader_for_file (input_file_name, NULL,
71                                                    LEX_SYNTAX_AUTO,
72                                                    LEX_ERROR_CONTINUE);
73   if (!reader)
74     exit (1);
75
76   struct lexer *lexer = lex_create ();
77   msg_set_handler (output_msg, lexer);
78   lex_include (lexer, reader);
79   lex_get (lexer);
80
81   for (;;)
82     {
83       while (lex_match (lexer, T_ENDCMD))
84         continue;
85       if (lex_match (lexer, T_STOP))
86         break;
87
88       read_table (lexer);
89     }
90
91   lex_destroy (lexer);
92   output_engine_pop ();
93   fh_done ();
94
95   return 0;
96 }
97
98 static void PRINTF_FORMAT (2, 3)
99 register_driver (struct string_map *options,
100                  const char *output_file, ...)
101 {
102   va_list args;
103   va_start (args, output_file);
104   string_map_insert_nocopy (options, xstrdup ("output-file"),
105                             xvasprintf (output_file, args));
106   va_end (args);
107
108   struct output_driver *driver = output_driver_create (options);
109   if (driver == NULL)
110     exit (EXIT_FAILURE);
111   output_driver_register (driver);
112 }
113
114 static void
115 configure_drivers (int width, int length UNUSED, int min_break)
116 {
117   /* Render to stdout. */
118   struct string_map options = STRING_MAP_INITIALIZER (options);
119   string_map_insert (&options, "format", "txt");
120   string_map_insert_nocopy (&options, xstrdup ("width"),
121                             xasprintf ("%d", width));
122   if (min_break >= 0)
123     string_map_insert_nocopy (&options, xstrdup ("min-hbreak"),
124                               xasprintf ("%d", min_break));
125   string_map_insert (&options, "emphasis", emphasis ? "true" : "false");
126   if (box != NULL)
127     string_map_insert (&options, "box", box);
128   register_driver (&options, "-");
129
130
131   /* Render to <base>.pdf. */
132   string_map_insert (&options, "top-margin", "0");
133   string_map_insert (&options, "bottom-margin", "0");
134   string_map_insert (&options, "left-margin", "0");
135   string_map_insert (&options, "right-margin", "0");
136   string_map_insert (&options, "paper-size", "99x99in");
137   string_map_insert (&options, "trim", "true");
138   register_driver (&options, "%s.pdf", output_base);
139
140   string_map_insert (&options, "box", "unicode");
141   register_driver (&options, "%s.txt", output_base);
142
143   string_map_insert (&options, "box", "ascii");
144   register_driver (&options, "%s-ascii.txt", output_base);
145
146   register_driver (&options, "%s.csv", output_base);
147   register_driver (&options, "%s.odt", output_base);
148   register_driver (&options, "%s.spv", output_base);
149   register_driver (&options, "%s.html", output_base);
150   register_driver (&options, "%s.tex", output_base);
151
152   string_map_destroy (&options);
153 }
154
155 static const char *
156 parse_options (int argc, char **argv)
157 {
158   int width = 79;
159   int length = 66;
160   int min_break = -1;
161
162   for (;;)
163     {
164       enum {
165         OPT_WIDTH = UCHAR_MAX + 1,
166         OPT_LENGTH,
167         OPT_MIN_BREAK,
168         OPT_EMPHASIS,
169         OPT_BOX,
170         OPT_TABLE_LOOK,
171         OPT_HELP
172       };
173       static const struct option options[] =
174         {
175           {"width", required_argument, NULL, OPT_WIDTH},
176           {"length", required_argument, NULL, OPT_LENGTH},
177           {"min-break", required_argument, NULL, OPT_MIN_BREAK},
178           {"emphasis", no_argument, NULL, OPT_EMPHASIS},
179           {"box", required_argument, NULL, OPT_BOX},
180           {"output", required_argument, NULL, 'o'},
181           {"table-look", required_argument, NULL, OPT_TABLE_LOOK},
182           {"help", no_argument, NULL, OPT_HELP},
183           {NULL, 0, NULL, 0},
184         };
185
186       int c = getopt_long (argc, argv, "o:", options, NULL);
187       if (c == -1)
188         break;
189
190       switch (c)
191         {
192         case OPT_WIDTH:
193           width = atoi (optarg);
194           break;
195
196         case OPT_LENGTH:
197           length = atoi (optarg);
198           break;
199
200         case OPT_MIN_BREAK:
201           min_break = atoi (optarg);
202           break;
203
204         case OPT_EMPHASIS:
205           emphasis = true;
206           break;
207
208         case OPT_BOX:
209           box = optarg;
210           break;
211
212         case 'o':
213           output_base = optarg;
214           break;
215
216         case OPT_TABLE_LOOK:
217           {
218             struct pivot_table_look *look;
219             char *err = pivot_table_look_read (optarg, &look);
220             if (err)
221               error (1, 0, "%s", err);
222             pivot_table_look_set_default (look);
223             pivot_table_look_unref (look);
224           }
225           break;
226
227         case OPT_HELP:
228           usage ();
229
230         case 0:
231           break;
232
233         case '?':
234           exit (EXIT_FAILURE);
235           break;
236
237         default:
238           NOT_REACHED ();
239         }
240
241     }
242
243   configure_drivers (width, length, min_break);
244
245   if (optind + 1 != argc)
246     error (1, 0, "exactly one non-option argument required; "
247            "use --help for help");
248   return argv[optind];
249 }
250
251 static void
252 usage (void)
253 {
254   printf ("%s, to test rendering of PSPP tables\n"
255           "usage: %s [OPTIONS] INPUT\n"
256           "\nOptions:\n"
257           "  --width=WIDTH   set page width in characters\n"
258           "  --length=LINE   set page length in lines\n",
259           program_name, program_name);
260   exit (EXIT_SUCCESS);
261 }
262
263 static void
264 force_match (struct lexer *lexer, enum token_type type)
265 {
266   if (!lex_force_match (lexer, type))
267     exit (1);
268 }
269
270 static void
271 force_string (struct lexer *lexer)
272 {
273   if (!lex_force_string (lexer))
274     exit (1);
275 }
276
277 static void
278 force_int (struct lexer *lexer)
279 {
280   if (!lex_force_int (lexer))
281     exit (1);
282 }
283
284 static void
285 force_num (struct lexer *lexer)
286 {
287   if (!lex_force_num (lexer))
288     exit (1);
289 }
290
291 static bool
292 parse_settings_value_show (struct lexer *lexer, const char *name,
293                            enum settings_value_show *show)
294 {
295   if (lex_match_id (lexer, name))
296     {
297       lex_match (lexer, T_EQUALS);
298
299       if (lex_match_id (lexer, "DEFAULT"))
300         *show = SETTINGS_VALUE_SHOW_DEFAULT;
301       else if (lex_match_id (lexer, "VALUE"))
302         *show = SETTINGS_VALUE_SHOW_VALUE;
303       else if (lex_match_id (lexer, "LABEL"))
304         *show = SETTINGS_VALUE_SHOW_LABEL;
305       else if (lex_match_id (lexer, "BOTH"))
306         *show = SETTINGS_VALUE_SHOW_BOTH;
307       else
308         {
309           lex_error_expecting (lexer, "DEFAULT", "VALUE", "LABEL", "BOTH");
310           exit (1);
311         }
312
313       return true;
314     }
315   else
316     return false;
317 }
318
319 static bool
320 parse_string_setting (struct lexer *lexer, const char *name, char **stringp)
321 {
322   if (lex_match_id (lexer, name))
323     {
324       lex_match (lexer, T_EQUALS);
325       force_string (lexer);
326
327       free (*stringp);
328       *stringp = xstrdup (lex_tokcstr (lexer));
329
330       lex_get (lexer);
331       return true;
332     }
333   else
334     return false;
335 }
336
337 static bool
338 match_kw (struct lexer *lexer, const char *kw)
339 {
340   return (!strcmp (kw, "ALL")
341           ? lex_match (lexer, T_ALL)
342           : lex_match_id (lexer, kw));
343 }
344
345 static bool
346 parse_bool_setting_with_default (struct lexer *lexer, const char *name,
347                                  const char *true_kw, const char *false_kw,
348                                  int default_value, bool *out)
349 {
350   if (lex_match_id (lexer, name))
351     {
352       if (default_value >= 0)
353         {
354           if (!lex_match (lexer, T_EQUALS))
355             *out = default_value;
356           return true;
357         }
358       else
359         force_match (lexer, T_EQUALS);
360
361       if (match_kw (lexer, true_kw))
362         *out = true;
363       else if (match_kw (lexer, false_kw))
364         *out = false;
365       else
366         {
367           lex_error_expecting (lexer, true_kw, false_kw);
368           exit (1);
369         }
370
371       return true;
372     }
373   else
374     return false;
375 }
376
377 static bool
378 parse_bool_setting (struct lexer *lexer, const char *name,
379                     const char *true_kw, const char *false_kw,
380                     bool *out)
381 {
382   return parse_bool_setting_with_default (lexer, name, true_kw, false_kw, -1,
383                                           out);
384 }
385
386 static bool
387 parse_yesno_setting (struct lexer *lexer, const char *name, bool *out)
388 {
389   return parse_bool_setting_with_default (lexer, name, "YES", "NO", true, out);
390 }
391
392 static struct cell_color
393 read_color (struct lexer *lexer)
394 {
395   struct cell_color color;
396   if (!parse_color__ (lex_tokcstr (lexer), &color))
397     {
398       msg (SE, "%s: unknown color", lex_tokcstr (lexer));
399       exit (1);
400     }
401   lex_get (lexer);
402   return color;
403 }
404
405 static bool
406 parse_color_pair_setting (struct lexer *lexer, const char *name,
407                           struct cell_color out[2])
408 {
409   if (lex_match_id (lexer, name))
410     {
411       lex_match (lexer, T_EQUALS);
412       out[0] = read_color (lexer);
413       out[1] = lex_is_string (lexer) ? read_color (lexer) : out[0];
414       return true;
415     }
416   else
417     return false;
418 }
419
420 static bool
421 parse_int_setting (struct lexer *lexer, const char *name, int *out)
422 {
423   if (lex_match_id (lexer, name))
424     {
425       lex_match (lexer, T_EQUALS);
426       force_int (lexer);
427       *out = lex_integer (lexer);
428       lex_get (lexer);
429       return true;
430     }
431   else
432     return false;
433 }
434
435 static void
436 read_font_style (struct lexer *lexer, struct font_style *fs)
437 {
438   while (parse_yesno_setting (lexer, "BOLD", &fs->bold)
439          || parse_yesno_setting (lexer, "ITALIC", &fs->italic)
440          || parse_yesno_setting (lexer, "UNDERLINE", &fs->underline)
441          || parse_yesno_setting (lexer, "MARKUP", &fs->markup)
442          || parse_color_pair_setting (lexer, "FG", fs->fg)
443          || parse_color_pair_setting (lexer, "BG", fs->bg)
444          || parse_string_setting (lexer, "FACE", &fs->typeface)
445          || parse_int_setting (lexer, "SIZE", &fs->size))
446     continue;
447 }
448
449 static bool
450 parse_halign_setting (struct lexer *lexer, enum table_halign *halign,
451                       double *decimal_offset)
452 {
453   if (lex_match_id (lexer, "RIGHT"))
454     *halign = TABLE_HALIGN_RIGHT;
455   else if (lex_match_id (lexer, "LEFT"))
456     *halign = TABLE_HALIGN_LEFT;
457   else if (lex_match_id (lexer, "CELL"))
458     *halign = TABLE_HALIGN_CENTER;
459   else if (lex_match_id (lexer, "MIXED"))
460     *halign = TABLE_HALIGN_MIXED;
461   else if (lex_match_id (lexer, "DECIMAL"))
462     {
463       if (lex_is_number (lexer))
464         {
465           *decimal_offset = lex_number (lexer);
466           lex_get (lexer);
467         }
468     }
469   else
470     return false;
471
472   return true;
473 }
474
475 static bool
476 parse_valign_setting (struct lexer *lexer, enum table_valign *valign)
477 {
478   if (lex_match_id (lexer, "TOP"))
479     *valign = TABLE_VALIGN_TOP;
480   else if (lex_match_id (lexer, "MIDDLE"))
481     *valign = TABLE_VALIGN_CENTER;
482   else if (lex_match_id (lexer, "BOTTOM"))
483     *valign = TABLE_VALIGN_BOTTOM;
484   else
485     return false;
486
487   return true;
488 }
489
490 static bool
491 parse_margin_setting (struct lexer *lexer, int margin[TABLE_N_AXES][2])
492 {
493   if (lex_match_id (lexer, "MARGINS"))
494     {
495       int values[4];
496       int n = 0;
497
498       lex_match (lexer, T_EQUALS);
499       force_num (lexer);
500       while (lex_is_number (lexer) && n < 4)
501         {
502           values[n++] = lex_number (lexer);
503           lex_get (lexer);
504         }
505
506       if (n == 1)
507         {
508           margin[TABLE_HORZ][0] = margin[TABLE_HORZ][1] = values[0];
509           margin[TABLE_VERT][0] = margin[TABLE_VERT][1] = values[0];
510         }
511       else if (n == 2)
512         {
513           margin[TABLE_HORZ][0] = margin[TABLE_HORZ][1] = values[1];
514           margin[TABLE_VERT][0] = margin[TABLE_VERT][1] = values[0];
515         }
516       else if (n == 3)
517         {
518           margin[TABLE_VERT][0] = values[0];
519           margin[TABLE_HORZ][0] = margin[TABLE_HORZ][1] = values[1];
520           margin[TABLE_VERT][1] = values[2];
521         }
522       else
523         {
524           assert (n == 4);
525           margin[TABLE_VERT][0] = values[0];
526           margin[TABLE_HORZ][1] = values[1];
527           margin[TABLE_VERT][1] = values[2];
528           margin[TABLE_HORZ][0] = values[3];
529         }
530
531       return true;
532     }
533   else
534     return false;
535 }
536
537 static void
538 read_cell_style (struct lexer *lexer, struct cell_style *cs)
539 {
540   while (parse_halign_setting (lexer, &cs->halign, &cs->decimal_offset)
541          || parse_valign_setting (lexer, &cs->valign)
542          || parse_margin_setting (lexer, cs->margin))
543     continue;
544 }
545
546 static void
547 read_value_option (struct lexer *lexer, const struct pivot_table *pt,
548                    struct pivot_value *value,
549                    const struct table_area_style *base_style)
550 {
551   enum settings_value_show *show
552     = (value->type == PIVOT_VALUE_NUMERIC ? &value->numeric.show
553        : value->type == PIVOT_VALUE_STRING ? &value->string.show
554        : value->type == PIVOT_VALUE_VARIABLE ? &value->variable.show
555        : NULL);
556   if (show && parse_settings_value_show (lexer, "SHOW", show))
557     return;
558
559   char **var_name
560     = (value->type == PIVOT_VALUE_NUMERIC ? &value->numeric.var_name
561        : value->type == PIVOT_VALUE_STRING ? &value->string.var_name
562        : NULL);
563   if (var_name && parse_string_setting (lexer, "VAR", var_name))
564     return;
565
566   char **label
567     = (value->type == PIVOT_VALUE_NUMERIC ? &value->numeric.value_label
568        : value->type == PIVOT_VALUE_STRING ? &value->string.value_label
569        : value->type == PIVOT_VALUE_VARIABLE ? &value->variable.var_label
570        : NULL);
571   if (label && parse_string_setting (lexer, "LABEL", label))
572     return;
573
574   if (value->type == PIVOT_VALUE_STRING && lex_match_id (lexer, "HEX"))
575     {
576       value->string.hex = true;
577       return;
578     }
579
580   if (value->type == PIVOT_VALUE_NUMERIC)
581     {
582       msg_disable ();
583       struct fmt_spec fmt;
584       bool ok = parse_format_specifier (lexer, &fmt);
585       msg_enable ();
586
587       if (ok)
588         {
589           if (!fmt_check_output (&fmt)
590               || !fmt_check_type_compat (&fmt, VAL_NUMERIC))
591             exit (1);
592
593           value->numeric.format = fmt;
594           return;
595         }
596     }
597
598   if (lex_match_id (lexer, "SUBSCRIPTS"))
599     {
600       lex_match (lexer, T_EQUALS);
601       size_t allocated_subscripts = value->n_subscripts;
602       while (lex_token (lexer) == T_STRING)
603         {
604           if (value->n_subscripts >= allocated_subscripts)
605             value->subscripts = x2nrealloc (value->subscripts,
606                                             &allocated_subscripts,
607                                             sizeof *value->subscripts);
608
609           value->subscripts[value->n_subscripts++] = xstrdup (
610             lex_tokcstr (lexer));
611           lex_get (lexer);
612         }
613       return;
614     }
615
616   if (lex_match_id (lexer, "FONT") && base_style)
617     {
618       lex_match (lexer, T_EQUALS);
619
620       if (!value->font_style)
621         {
622           value->font_style = xmalloc (sizeof *value->font_style);
623           font_style_copy (NULL, value->font_style, &base_style->font_style);
624         }
625       read_font_style (lexer, value->font_style);
626       return;
627     }
628
629   if (lex_match_id (lexer, "CELL") && base_style)
630     {
631       lex_match (lexer, T_EQUALS);
632
633       if (!value->cell_style)
634         {
635           value->cell_style = xmalloc (sizeof *value->cell_style);
636           *value->cell_style = base_style->cell_style;
637         }
638       read_cell_style (lexer, value->cell_style);
639       return;
640     }
641
642   if (lex_match_id (lexer, "FOOTNOTE"))
643     {
644       lex_match (lexer, T_EQUALS);
645
646       while (lex_is_integer (lexer))
647         {
648           size_t idx = lex_integer (lexer);
649           lex_get (lexer);
650
651           if (idx >= pt->n_footnotes)
652             {
653               msg (SE, "Footnote %zu not available "
654                    "(only %zu footnotes defined)", idx, pt->n_footnotes);
655               exit (1);
656             }
657           pivot_value_add_footnote (value, pt->footnotes[idx]);
658         }
659       return;
660     }
661
662   lex_error (lexer, "Expecting valid value option");
663   exit (1);
664 }
665
666 static struct pivot_value *
667 read_value (struct lexer *lexer, const struct pivot_table *pt,
668             const struct table_area_style *base_style)
669 {
670   struct pivot_value *value;
671   if (lex_is_number (lexer))
672     {
673       value = pivot_value_new_number (lex_number (lexer));
674       lex_get (lexer);
675     }
676   else if (lex_is_string (lexer))
677     {
678       value = xmalloc (sizeof *value);
679       *value = (struct pivot_value) {
680         .string = {
681           .type = PIVOT_VALUE_STRING,
682           .s = xstrdup (lex_tokcstr (lexer))
683         },
684       };
685       lex_get (lexer);
686     }
687   else if (lex_token (lexer) == T_ID)
688     {
689       value = xmalloc (sizeof *value);
690       *value = (struct pivot_value) {
691         .variable = {
692           .type = PIVOT_VALUE_VARIABLE,
693           .var_name = xstrdup (lex_tokcstr (lexer))
694         },
695       };
696       lex_get (lexer);
697     }
698   else
699     {
700       msg (SE, "Expecting pivot_value");
701       exit (1);
702     }
703
704   while (lex_match (lexer, T_LBRACK))
705     {
706       read_value_option (lexer, pt, value, base_style);
707       force_match (lexer, T_RBRACK);
708     }
709
710   return value;
711 }
712
713 static void
714 read_group (struct lexer *lexer, struct pivot_table *pt,
715             struct pivot_category *group,
716             const struct table_area_style *label_style)
717 {
718   if (lex_match (lexer, T_ASTERISK))
719     group->show_label = true;
720
721   force_match (lexer, T_LPAREN);
722   if (lex_match (lexer, T_RPAREN))
723     return;
724
725   do
726     {
727       struct pivot_value *name = read_value (lexer, pt, label_style);
728       if (lex_token (lexer) == T_ASTERISK
729           || lex_token (lexer) == T_LPAREN)
730         read_group (lexer, pt, pivot_category_create_group__ (group, name),
731                     label_style);
732       else
733         {
734           char *rc;
735           if (lex_token (lexer) == T_ID
736               && is_pivot_result_class (lex_tokcstr (lexer)))
737             {
738               rc = xstrdup (lex_tokcstr (lexer));
739               lex_get (lexer);
740             }
741           else
742             rc = NULL;
743
744           pivot_category_create_leaf_rc (group, name, rc);
745
746           free (rc);
747         }
748     }
749   while (lex_match (lexer, T_COMMA));
750   force_match (lexer, T_RPAREN);
751 }
752
753 static void
754 read_dimension (struct lexer *lexer, struct pivot_table *pt,
755                 enum pivot_axis_type a,
756                 const struct table_area_style *label_style)
757 {
758   if (!pivot_table_is_empty (pt))
759     error (1, 0, "can't add dimensions after adding data");
760
761   lex_match (lexer, T_EQUALS);
762
763   struct pivot_value *name = read_value (lexer, pt, label_style);
764   struct pivot_dimension *dim = pivot_dimension_create__ (pt, a, name);
765   read_group (lexer, pt, dim->root, label_style);
766 }
767
768 static void
769 read_look (struct lexer *lexer, struct pivot_table *pt)
770 {
771   lex_match (lexer, T_EQUALS);
772
773   if (lex_is_string (lexer))
774     {
775       struct pivot_table_look *look;
776       char *error = pivot_table_look_read (lex_tokcstr (lexer), &look);
777       if (error)
778         {
779           msg (SE, "%s", error);
780           exit (1);
781         }
782       lex_get (lexer);
783
784       pivot_table_set_look (pt, look);
785       pivot_table_look_unref (look);
786     }
787
788   struct pivot_table_look *look = pivot_table_look_unshare (
789     pivot_table_look_ref (pt->look));
790   for (;;)
791     {
792       if (!parse_bool_setting (lexer, "EMPTY", "HIDE", "SHOW",
793                                &look->omit_empty)
794           && !parse_bool_setting (lexer, "ROWLABELS", "CORNER", "NESTED",
795                                   &look->row_labels_in_corner)
796           && !parse_bool_setting (lexer, "MARKERS", "NUMERIC", "ALPHA",
797                                   &look->show_numeric_markers)
798           && !parse_bool_setting (lexer, "LEVEL", "SUPER", "SUB",
799                                   &look->footnote_marker_superscripts)
800           && !parse_bool_setting (lexer, "LAYERS", "ALL", "CURRENT",
801                                   &look->print_all_layers)
802           && !parse_bool_setting (lexer, "PAGINATELAYERS", "YES", "NO",
803                                   &look->paginate_layers)
804           && !parse_bool_setting (lexer, "HSHRINK", "YES", "NO",
805                                   &look->shrink_to_fit[TABLE_HORZ])
806           && !parse_bool_setting (lexer, "VSHRINK", "YES", "NO",
807                                   &look->shrink_to_fit[TABLE_VERT])
808           && !parse_bool_setting (lexer, "TOPCONTINUATION", "YES", "NO",
809                                   &look->top_continuation)
810           && !parse_bool_setting (lexer, "BOTTOMCONTINUATION", "YES", "NO",
811                                   &look->bottom_continuation)
812           && !parse_string_setting (lexer, "CONTINUATION",
813                                     &look->continuation))
814         break;
815     }
816   pivot_table_set_look (pt, look);
817   pivot_table_look_unref (look);
818 }
819
820 static enum table_stroke
821 read_stroke (struct lexer *lexer)
822 {
823   for (int stroke = 0; stroke < TABLE_N_STROKES; stroke++)
824     if (lex_match_id (lexer, table_stroke_to_string (stroke)))
825       return stroke;
826
827   lex_error (lexer, "expecting stroke");
828   exit (1);
829 }
830
831 static bool
832 parse_value_setting (struct lexer *lexer, const struct pivot_table *pt,
833                      const char *name,
834                      struct pivot_value **valuep,
835                      struct table_area_style *base_style)
836 {
837   if (lex_match_id (lexer, name))
838     {
839       lex_match (lexer, T_EQUALS);
840
841       pivot_value_destroy (*valuep);
842       *valuep = read_value (lexer, pt, base_style);
843
844       return true;
845     }
846   else
847     return false;
848 }
849
850 static void
851 read_border (struct lexer *lexer, struct pivot_table *pt)
852 {
853   static const char *const pivot_border_ids[PIVOT_N_BORDERS] = {
854     [PIVOT_BORDER_TITLE] = "title",
855     [PIVOT_BORDER_OUTER_LEFT] = "outer-left",
856     [PIVOT_BORDER_OUTER_TOP] = "outer-top",
857     [PIVOT_BORDER_OUTER_RIGHT] = "outer-right",
858     [PIVOT_BORDER_OUTER_BOTTOM] = "outer-bottom",
859     [PIVOT_BORDER_INNER_LEFT] = "inner-left",
860     [PIVOT_BORDER_INNER_TOP] = "inner-top",
861     [PIVOT_BORDER_INNER_RIGHT] = "inner-right",
862     [PIVOT_BORDER_INNER_BOTTOM] = "inner-bottom",
863     [PIVOT_BORDER_DATA_LEFT] = "data-left",
864     [PIVOT_BORDER_DATA_TOP] = "data-top",
865     [PIVOT_BORDER_DIM_ROW_HORZ] = "dim-row-horz",
866     [PIVOT_BORDER_DIM_ROW_VERT] = "dim-row-vert",
867     [PIVOT_BORDER_DIM_COL_HORZ] = "dim-col-horz",
868     [PIVOT_BORDER_DIM_COL_VERT] = "dim-col-vert",
869     [PIVOT_BORDER_CAT_ROW_HORZ] = "cat-row-horz",
870     [PIVOT_BORDER_CAT_ROW_VERT] = "cat-row-vert",
871     [PIVOT_BORDER_CAT_COL_HORZ] = "cat-col-horz",
872     [PIVOT_BORDER_CAT_COL_VERT] = "cat-col-vert",
873   };
874
875   lex_match (lexer, T_EQUALS);
876
877   struct pivot_table_look *look = pivot_table_look_unshare (
878     pivot_table_look_ref (pt->look));
879   while (lex_token (lexer) == T_STRING)
880     {
881       char *s = xstrdup (lex_tokcstr (lexer));
882       lex_get (lexer);
883       force_match (lexer, T_LPAREN);
884
885       struct table_border_style style = TABLE_BORDER_STYLE_INITIALIZER;
886       style.stroke = read_stroke (lexer);
887       if (lex_is_string (lexer))
888         style.color = read_color (lexer);
889       force_match (lexer, T_RPAREN);
890
891       int n = 0;
892       for (int b = 0; b < PIVOT_N_BORDERS; b++)
893         {
894           if (!fnmatch (s, pivot_border_ids[b], 0))
895             {
896               look->borders[b] = style;
897               n++;
898             }
899         }
900       if (!n)
901         {
902           msg (SE, "%s: no matching borders", s);
903           exit (1);
904         }
905       free (s);
906     }
907   pivot_table_set_look (pt, look);
908   pivot_table_look_unref (look);
909 }
910
911 static void
912 read_footnote (struct lexer *lexer, struct pivot_table *pt)
913 {
914   size_t idx;
915   if (lex_match (lexer, T_LBRACK))
916     {
917       force_int (lexer);
918
919       idx = lex_integer (lexer);
920       lex_get (lexer);
921
922       force_match (lexer, T_RBRACK);
923     }
924   else
925     idx = pt->n_footnotes;
926   lex_match (lexer, T_EQUALS);
927
928   struct pivot_value *content
929     = read_value (lexer, pt, &pt->look->areas[PIVOT_AREA_FOOTER]);
930
931   struct pivot_value *marker;
932   if (lex_match_id (lexer, "MARKER"))
933     {
934       lex_match (lexer, T_EQUALS);
935       marker = read_value (lexer, pt, &pt->look->areas[PIVOT_AREA_FOOTER]);
936     }
937   else
938     marker = NULL;
939
940   bool show = !lex_match_id (lexer, "HIDE");
941   pivot_table_create_footnote__ (pt, idx, marker, content)->show = show;
942 }
943
944 static void
945 read_cell (struct lexer *lexer, struct pivot_table *pt)
946 {
947   force_match (lexer, T_LBRACK);
948
949   size_t *lo = xnmalloc (pt->n_dimensions, sizeof *lo);
950   size_t *hi = xnmalloc (pt->n_dimensions, sizeof *hi);
951   for (size_t i = 0; i < pt->n_dimensions; i++)
952     {
953       const struct pivot_dimension *d = pt->dimensions[i];
954
955       if (i)
956         force_match (lexer, T_COMMA);
957
958       if (!d->n_leaves)
959         {
960           msg (SE, "can't define data because dimension %zu has no categories",
961                i);
962           exit (1);
963         }
964
965       if (lex_match (lexer, T_ALL))
966         {
967           lo[i] = 0;
968           hi[i] = d->n_leaves - 1;
969         }
970       else
971         {
972           force_int (lexer);
973           lo[i] = hi[i] = lex_integer (lexer);
974           lex_get (lexer);
975
976           if (lex_match_id (lexer, "THRU"))
977             {
978               force_int (lexer);
979               hi[i] = lex_integer (lexer);
980               lex_get (lexer);
981             }
982
983           if (hi[i] < lo[i])
984             {
985               msg (SE, "%zu THRU %zu is not a valid range", lo[i], hi[i]);
986               exit (1);
987             }
988           if (hi[i] >= d->n_leaves)
989             {
990               msg (SE, "dimension %zu (%s) has only %zu categories",
991                    i, pivot_value_to_string (d->root->name, pt),
992                    d->n_leaves);
993               exit (1);
994             }
995         }
996     }
997   force_match (lexer, T_RBRACK);
998
999   struct pivot_value *value = NULL;
1000   bool delete = false;
1001   if (lex_match (lexer, T_EQUALS))
1002     {
1003       if (lex_match_id (lexer, "DELETE"))
1004         delete = true;
1005       else
1006         value = read_value (lexer, pt, &pt->look->areas[PIVOT_AREA_DATA]);
1007     }
1008
1009   size_t *dindexes = xmemdup (lo, pt->n_dimensions * sizeof *lo);
1010   for (size_t i = 0; ; i++)
1011     {
1012       if (delete)
1013         pivot_table_delete (pt, dindexes);
1014       else
1015         pivot_table_put (pt, dindexes, pt->n_dimensions,
1016                          (value
1017                           ? pivot_value_clone (value)
1018                           : pivot_value_new_integer (i)));
1019
1020       for (size_t j = 0; j < pt->n_dimensions; j++)
1021         {
1022           if (++dindexes[j] <= hi[j])
1023             goto next;
1024           dindexes[j] = lo[j];
1025         }
1026         break;
1027     next:;
1028     }
1029   free (dindexes);
1030
1031   pivot_value_destroy (value);
1032
1033   free (lo);
1034   free (hi);
1035 }
1036
1037 static struct pivot_dimension *
1038 parse_dim_name (struct lexer *lexer, struct pivot_table *table)
1039 {
1040   force_string (lexer);
1041   for (size_t i = 0; i < table->n_dimensions; i++)
1042     {
1043       struct pivot_dimension *dim = table->dimensions[i];
1044
1045       struct string s = DS_EMPTY_INITIALIZER;
1046       pivot_value_format_body (dim->root->name, table, &s);
1047       bool match = !strcmp (ds_cstr (&s), lex_tokcstr (lexer));
1048       ds_destroy (&s);
1049
1050       if (match)
1051         {
1052           lex_get (lexer);
1053           return dim;
1054         }
1055     }
1056
1057   lex_error (lexer, "unknown dimension");
1058   exit (1);
1059 }
1060
1061 static enum pivot_axis_type
1062 parse_axis_type (struct lexer *lexer)
1063 {
1064   if (lex_match_id (lexer, "ROW"))
1065     return PIVOT_AXIS_ROW;
1066   else if (lex_match_id (lexer, "COLUMN"))
1067     return PIVOT_AXIS_COLUMN;
1068   else if (lex_match_id (lexer, "LAYER"))
1069     return PIVOT_AXIS_LAYER;
1070   else
1071     {
1072       lex_error_expecting (lexer, "ROW", "COLUMN", "LAYER");
1073       exit (1);
1074     }
1075 }
1076
1077 static void
1078 move_dimension (struct lexer *lexer, struct pivot_table *table)
1079 {
1080   struct pivot_dimension *dim = parse_dim_name (lexer, table);
1081
1082   enum pivot_axis_type axis = parse_axis_type (lexer);
1083
1084   size_t position;
1085   if (lex_is_integer (lexer))
1086     {
1087       position = lex_integer (lexer);
1088       lex_get (lexer);
1089     }
1090   else
1091     position = 0;
1092
1093   pivot_table_move_dimension (table, dim, axis, position);
1094 }
1095
1096 static void
1097 swap_axes (struct lexer *lexer, struct pivot_table *table)
1098 {
1099   enum pivot_axis_type a = parse_axis_type (lexer);
1100   enum pivot_axis_type b = parse_axis_type (lexer);
1101   pivot_table_swap_axes (table, a, b);
1102 }
1103
1104 static void
1105 read_current_layer (struct lexer *lexer, struct pivot_table *table)
1106 {
1107   lex_match (lexer, T_EQUALS);
1108
1109   const struct pivot_axis *layer_axis = &table->axes[PIVOT_AXIS_LAYER];
1110   for (size_t i = 0; i < layer_axis->n_dimensions; i++)
1111     {
1112       const struct pivot_dimension *dim = layer_axis->dimensions[i];
1113
1114       force_int (lexer);
1115       size_t index = lex_integer (lexer);
1116       if (index >= dim->n_leaves)
1117         {
1118           lex_error (lexer, "only %zu dimensions", dim->n_leaves);
1119           exit (1);
1120         }
1121       lex_get (lexer);
1122
1123       table->current_layer[i] = index;
1124     }
1125 }
1126
1127 static void
1128 read_table (struct lexer *lexer)
1129 {
1130   bool displayed = false;
1131
1132   struct pivot_table *pt = pivot_table_create ("Default Title");
1133   while (lex_match (lexer, T_SLASH))
1134     {
1135       assert (!pivot_table_is_shared (pt));
1136       displayed = false;
1137
1138       if (lex_match_id (lexer, "ROW"))
1139         read_dimension (lexer, pt, PIVOT_AXIS_ROW,
1140                         &pt->look->areas[PIVOT_AREA_ROW_LABELS]);
1141       else if (lex_match_id (lexer, "COLUMN"))
1142         read_dimension (lexer, pt, PIVOT_AXIS_COLUMN,
1143                         &pt->look->areas[PIVOT_AREA_COLUMN_LABELS]);
1144       else if (lex_match_id (lexer, "LAYER"))
1145         read_dimension (lexer, pt, PIVOT_AXIS_LAYER,
1146                         &pt->look->areas[PIVOT_AREA_LAYERS]);
1147       else if (lex_match_id (lexer, "LOOK"))
1148         read_look (lexer, pt);
1149       else if (lex_match_id (lexer, "ROTATE"))
1150         {
1151           lex_match (lexer, T_EQUALS);
1152           while (lex_token (lexer) == T_ID)
1153             if (!parse_bool_setting (lexer, "INNERCOLUMNS", "YES", "NO",
1154                                      &pt->rotate_inner_column_labels)
1155                 && !parse_bool_setting (lexer, "OUTERROWS", "YES", "NO",
1156                                         &pt->rotate_outer_row_labels))
1157               break;
1158         }
1159       else if (lex_match_id (lexer, "SHOW"))
1160         {
1161           lex_match (lexer, T_EQUALS);
1162           while (lex_token (lexer) == T_ID)
1163             {
1164               if (parse_bool_setting (lexer, "GRID", "YES", "NO",
1165                                       &pt->show_grid_lines)
1166                   || parse_bool_setting (lexer, "CAPTION", "YES", "NO",
1167                                          &pt->show_caption)
1168                   || parse_bool_setting (lexer, "TITLE", "YES", "NO",
1169                                          &pt->show_title))
1170                 continue;
1171
1172               if (parse_settings_value_show (lexer, "VALUES", &pt->show_values)
1173                   || parse_settings_value_show (lexer, "VARIABLES",
1174                                                 &pt->show_variables))
1175                 continue;
1176
1177               if (lex_match_id (lexer, "LAYER"))
1178                 read_current_layer (lexer, pt);
1179
1180               break;
1181             }
1182         }
1183       else if (parse_value_setting (lexer, pt, "TITLE", &pt->title,
1184                                     &pt->look->areas[PIVOT_AREA_TITLE])
1185                || parse_value_setting (lexer, pt, "SUBTYPE", &pt->subtype,
1186                                        NULL)
1187                || parse_value_setting (lexer, pt, "CORNER", &pt->corner_text,
1188                                        &pt->look->areas[PIVOT_AREA_CORNER])
1189                || parse_value_setting (lexer, pt, "CAPTION", &pt->caption,
1190                                        &pt->look->areas[PIVOT_AREA_CAPTION])
1191                || parse_string_setting (lexer, "NOTES", &pt->notes))
1192         {
1193           /* Nothing. */
1194         }
1195       else if (lex_match_id (lexer, "BORDER"))
1196         read_border (lexer, pt);
1197       else if (lex_match_id (lexer, "TRANSPOSE"))
1198         pivot_table_transpose (pt);
1199       else if (lex_match_id (lexer, "SWAP"))
1200         swap_axes (lexer, pt);
1201       else if (lex_match_id (lexer, "MOVE"))
1202         move_dimension (lexer, pt);
1203       else if (lex_match_id (lexer, "CELLS"))
1204         read_cell (lexer, pt);
1205       else if (lex_match_id (lexer, "FOOTNOTE"))
1206         read_footnote (lexer, pt);
1207       else if (lex_match_id (lexer, "DUMP"))
1208         pivot_table_dump (pt, 0);
1209       else if (lex_match_id (lexer, "DISPLAY"))
1210         {
1211           pivot_table_submit (pivot_table_ref (pt));
1212           pt = pivot_table_unshare (pt);
1213           displayed = true;
1214         }
1215       else
1216         {
1217           msg (SE, "Expecting keyword");
1218           exit (1);
1219         }
1220     }
1221
1222   if (!displayed)
1223     pivot_table_submit (pt);
1224   else
1225     pivot_table_unshare (pt);
1226
1227   force_match (lexer, T_ENDCMD);
1228 }
1229
1230 static void
1231 output_msg (const struct msg *m_, void *lexer_)
1232 {
1233   struct lexer *lexer = lexer_;
1234   struct msg m = *m_;
1235
1236   if (m.file_name == NULL)
1237     {
1238       m.file_name = CONST_CAST (char *, lex_get_file_name (lexer));
1239       m.first_line = lex_get_first_line_number (lexer, 0);
1240       m.last_line = lex_get_last_line_number (lexer, 0);
1241     }
1242
1243   m.command_name = output_get_uppercase_command_name ();
1244
1245   output_item_submit (message_item_create (&m));
1246
1247   free (m.command_name);
1248 }