1 /* PSPP - a program for statistical analysis.
2 Copyright (C) 2009, 2010, 2011, 2012, 2013, 2014 Free Software Foundation, Inc.
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.
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.
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/>. */
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"
40 #include "gl/progname.h"
41 #include "gl/xalloc.h"
42 #include "gl/xvasprintf.h"
44 /* --emphasis: Enable emphasis in ASCII driver? */
47 /* --box: ASCII driver box option. */
50 /* -o, --output: Base name for output files. */
51 static const char *output_base = "render";
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 *, struct lexer *);
59 main (int argc, char **argv)
61 const char *input_file_name;
63 set_program_name (argv[0]);
65 output_engine_push ();
66 input_file_name = parse_options (argc, argv);
70 struct lex_reader *reader = lex_reader_for_file (input_file_name, NULL,
76 struct lexer *lexer = lex_create ();
77 lex_set_message_handler (lexer, output_msg);
78 lex_include (lexer, reader);
83 while (lex_match (lexer, T_ENDCMD))
85 if (lex_match (lexer, T_STOP))
98 static void PRINTF_FORMAT (2, 3)
99 register_driver (struct string_map *options,
100 const char *output_file, ...)
103 va_start (args, output_file);
104 string_map_insert_nocopy (options, xstrdup ("output-file"),
105 xvasprintf (output_file, args));
108 struct output_driver *driver = output_driver_create (options);
111 output_driver_register (driver);
115 configure_drivers (int width, int length UNUSED, int min_break)
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));
123 string_map_insert_nocopy (&options, xstrdup ("min-hbreak"),
124 xasprintf ("%d", min_break));
125 string_map_insert (&options, "emphasis", emphasis ? "true" : "false");
127 string_map_insert (&options, "box", box);
128 register_driver (&options, "-");
130 /* Render to <base>.pdf. */
131 string_map_insert (&options, "top-margin", "0");
132 string_map_insert (&options, "bottom-margin", "0");
133 string_map_insert (&options, "left-margin", "0");
134 string_map_insert (&options, "right-margin", "0");
135 string_map_insert (&options, "paper-size", "99x99in");
136 string_map_insert (&options, "trim", "true");
137 register_driver (&options, "%s.pdf", output_base);
139 /* Render to <base>-paged.pdf. */
140 register_driver (&options, "%s-paged.pdf", output_base);
142 /* Render to <base>.txt. */
143 string_map_insert (&options, "box", "unicode");
144 register_driver (&options, "%s.txt", output_base);
146 /* Render to <base>-ascii.txt. */
147 string_map_insert (&options, "box", "ascii");
148 register_driver (&options, "%s-ascii.txt", output_base);
150 /* Render additional versions. */
151 register_driver (&options, "%s.csv", output_base);
152 register_driver (&options, "%s.odt", output_base);
153 register_driver (&options, "%s.spv", output_base);
154 register_driver (&options, "%s.html", output_base);
155 register_driver (&options, "%s.tex", output_base);
156 string_map_destroy (&options);
160 parse_options (int argc, char **argv)
169 OPT_WIDTH = UCHAR_MAX + 1,
177 static const struct option options[] =
179 {"width", required_argument, NULL, OPT_WIDTH},
180 {"length", required_argument, NULL, OPT_LENGTH},
181 {"min-break", required_argument, NULL, OPT_MIN_BREAK},
182 {"emphasis", no_argument, NULL, OPT_EMPHASIS},
183 {"box", required_argument, NULL, OPT_BOX},
184 {"output", required_argument, NULL, 'o'},
185 {"table-look", required_argument, NULL, OPT_TABLE_LOOK},
186 {"help", no_argument, NULL, OPT_HELP},
190 int c = getopt_long (argc, argv, "o:", options, NULL);
197 width = atoi (optarg);
201 length = atoi (optarg);
205 min_break = atoi (optarg);
217 output_base = optarg;
222 struct pivot_table_look *look;
223 char *err = pivot_table_look_read (optarg, &look);
225 error (1, 0, "%s", err);
226 pivot_table_look_set_default (look);
227 pivot_table_look_unref (look);
247 configure_drivers (width, length, min_break);
249 if (optind + 1 != argc)
250 error (1, 0, "exactly one non-option argument required; "
251 "use --help for help");
258 printf ("%s, to test rendering of PSPP tables\n"
259 "usage: %s [OPTIONS] INPUT\n"
261 " --width=WIDTH set page width in characters\n"
262 " --length=LINE set page length in lines\n",
263 program_name, program_name);
268 force_match (struct lexer *lexer, enum token_type type)
270 if (!lex_force_match (lexer, type))
275 force_string (struct lexer *lexer)
277 if (!lex_force_string (lexer))
282 force_int (struct lexer *lexer)
284 if (!lex_force_int (lexer))
289 force_num (struct lexer *lexer)
291 if (!lex_force_num (lexer))
296 parse_settings_value_show (struct lexer *lexer, const char *name,
297 enum settings_value_show *show)
299 if (lex_match_id (lexer, name))
301 lex_match (lexer, T_EQUALS);
303 if (lex_match_id (lexer, "DEFAULT"))
304 *show = SETTINGS_VALUE_SHOW_DEFAULT;
305 else if (lex_match_id (lexer, "VALUE"))
306 *show = SETTINGS_VALUE_SHOW_VALUE;
307 else if (lex_match_id (lexer, "LABEL"))
308 *show = SETTINGS_VALUE_SHOW_LABEL;
309 else if (lex_match_id (lexer, "BOTH"))
310 *show = SETTINGS_VALUE_SHOW_BOTH;
313 lex_error_expecting (lexer, "DEFAULT", "VALUE", "LABEL", "BOTH");
324 parse_string_setting (struct lexer *lexer, const char *name, char **stringp)
326 if (lex_match_id (lexer, name))
328 lex_match (lexer, T_EQUALS);
329 force_string (lexer);
332 *stringp = xstrdup (lex_tokcstr (lexer));
342 match_kw (struct lexer *lexer, const char *kw)
344 return (!strcmp (kw, "ALL")
345 ? lex_match (lexer, T_ALL)
346 : lex_match_id (lexer, kw));
350 parse_bool_setting_with_default (struct lexer *lexer, const char *name,
351 const char *true_kw, const char *false_kw,
352 int default_value, bool *out)
354 if (lex_match_id (lexer, name))
356 if (default_value >= 0)
358 if (!lex_match (lexer, T_EQUALS))
359 *out = default_value;
363 force_match (lexer, T_EQUALS);
365 if (match_kw (lexer, true_kw))
367 else if (match_kw (lexer, false_kw))
371 lex_error_expecting (lexer, true_kw, false_kw);
382 parse_bool_setting (struct lexer *lexer, const char *name,
383 const char *true_kw, const char *false_kw,
386 return parse_bool_setting_with_default (lexer, name, true_kw, false_kw, -1,
391 parse_yesno_setting (struct lexer *lexer, const char *name, bool *out)
393 return parse_bool_setting_with_default (lexer, name, "YES", "NO", true, out);
396 static struct cell_color
397 read_color (struct lexer *lexer)
399 struct cell_color color;
400 if (!parse_color__ (lex_tokcstr (lexer), &color))
402 msg (SE, "%s: unknown color", lex_tokcstr (lexer));
410 parse_color_pair_setting (struct lexer *lexer, const char *name,
411 struct cell_color out[2])
413 if (lex_match_id (lexer, name))
415 lex_match (lexer, T_EQUALS);
416 out[0] = read_color (lexer);
417 out[1] = lex_is_string (lexer) ? read_color (lexer) : out[0];
425 parse_int_setting (struct lexer *lexer, const char *name, int *out)
427 if (lex_match_id (lexer, name))
429 lex_match (lexer, T_EQUALS);
431 *out = lex_integer (lexer);
440 read_font_style (struct lexer *lexer, struct font_style *fs)
442 while (parse_yesno_setting (lexer, "BOLD", &fs->bold)
443 || parse_yesno_setting (lexer, "ITALIC", &fs->italic)
444 || parse_yesno_setting (lexer, "UNDERLINE", &fs->underline)
445 || parse_yesno_setting (lexer, "MARKUP", &fs->markup)
446 || parse_color_pair_setting (lexer, "FG", fs->fg)
447 || parse_color_pair_setting (lexer, "BG", fs->bg)
448 || parse_string_setting (lexer, "FACE", &fs->typeface)
449 || parse_int_setting (lexer, "SIZE", &fs->size))
454 parse_halign_setting (struct lexer *lexer, enum table_halign *halign,
455 double *decimal_offset)
457 if (lex_match_id (lexer, "RIGHT"))
458 *halign = TABLE_HALIGN_RIGHT;
459 else if (lex_match_id (lexer, "LEFT"))
460 *halign = TABLE_HALIGN_LEFT;
461 else if (lex_match_id (lexer, "CELL"))
462 *halign = TABLE_HALIGN_CENTER;
463 else if (lex_match_id (lexer, "MIXED"))
464 *halign = TABLE_HALIGN_MIXED;
465 else if (lex_match_id (lexer, "DECIMAL"))
467 if (lex_is_number (lexer))
469 *decimal_offset = lex_number (lexer);
480 parse_valign_setting (struct lexer *lexer, enum table_valign *valign)
482 if (lex_match_id (lexer, "TOP"))
483 *valign = TABLE_VALIGN_TOP;
484 else if (lex_match_id (lexer, "MIDDLE"))
485 *valign = TABLE_VALIGN_CENTER;
486 else if (lex_match_id (lexer, "BOTTOM"))
487 *valign = TABLE_VALIGN_BOTTOM;
495 parse_margin_setting (struct lexer *lexer, int margin[TABLE_N_AXES][2])
497 if (lex_match_id (lexer, "MARGINS"))
502 lex_match (lexer, T_EQUALS);
504 while (lex_is_number (lexer) && n < 4)
506 values[n++] = lex_number (lexer);
512 margin[TABLE_HORZ][0] = margin[TABLE_HORZ][1] = values[0];
513 margin[TABLE_VERT][0] = margin[TABLE_VERT][1] = values[0];
517 margin[TABLE_HORZ][0] = margin[TABLE_HORZ][1] = values[1];
518 margin[TABLE_VERT][0] = margin[TABLE_VERT][1] = values[0];
522 margin[TABLE_VERT][0] = values[0];
523 margin[TABLE_HORZ][0] = margin[TABLE_HORZ][1] = values[1];
524 margin[TABLE_VERT][1] = values[2];
529 margin[TABLE_VERT][0] = values[0];
530 margin[TABLE_HORZ][1] = values[1];
531 margin[TABLE_VERT][1] = values[2];
532 margin[TABLE_HORZ][0] = values[3];
542 read_cell_style (struct lexer *lexer, struct cell_style *cs)
544 while (parse_halign_setting (lexer, &cs->halign, &cs->decimal_offset)
545 || parse_valign_setting (lexer, &cs->valign)
546 || parse_margin_setting (lexer, cs->margin))
551 read_value_option (struct lexer *lexer, const struct pivot_table *pt,
552 struct pivot_value *value,
553 const struct table_area_style *base_style)
555 enum settings_value_show *show
556 = (value->type == PIVOT_VALUE_NUMERIC ? &value->numeric.show
557 : value->type == PIVOT_VALUE_STRING ? &value->string.show
558 : value->type == PIVOT_VALUE_VARIABLE ? &value->variable.show
560 if (show && parse_settings_value_show (lexer, "SHOW", show))
564 = (value->type == PIVOT_VALUE_NUMERIC ? &value->numeric.var_name
565 : value->type == PIVOT_VALUE_STRING ? &value->string.var_name
567 if (var_name && parse_string_setting (lexer, "VAR", var_name))
571 = (value->type == PIVOT_VALUE_NUMERIC ? &value->numeric.value_label
572 : value->type == PIVOT_VALUE_STRING ? &value->string.value_label
573 : value->type == PIVOT_VALUE_VARIABLE ? &value->variable.var_label
575 if (label && parse_string_setting (lexer, "LABEL", label))
578 if (value->type == PIVOT_VALUE_STRING && lex_match_id (lexer, "HEX"))
580 value->string.hex = true;
584 if (value->type == PIVOT_VALUE_NUMERIC)
588 bool ok = parse_format_specifier (lexer, &fmt);
593 if (!fmt_check_output (&fmt)
594 || !fmt_check_type_compat (&fmt, VAL_NUMERIC))
597 value->numeric.format = fmt;
602 if (lex_match_id (lexer, "SUBSCRIPTS"))
604 lex_match (lexer, T_EQUALS);
606 struct pivot_value_ex *ex = pivot_value_ex_rw (value);
607 size_t allocated_subscripts = ex->n_subscripts;
608 while (lex_token (lexer) == T_STRING)
610 if (ex->n_subscripts >= allocated_subscripts)
611 ex->subscripts = x2nrealloc (ex->subscripts, &allocated_subscripts,
612 sizeof *ex->subscripts);
614 ex->subscripts[ex->n_subscripts++] = xstrdup (lex_tokcstr (lexer));
620 if (lex_match_id (lexer, "FONT") && base_style)
622 lex_match (lexer, T_EQUALS);
624 struct pivot_value_ex *ex = pivot_value_ex_rw (value);
627 ex->font_style = xmalloc (sizeof *ex->font_style);
628 font_style_copy (NULL, ex->font_style, &base_style->font_style);
630 read_font_style (lexer, ex->font_style);
634 if (lex_match_id (lexer, "CELL") && base_style)
636 lex_match (lexer, T_EQUALS);
638 struct pivot_value_ex *ex = pivot_value_ex_rw (value);
641 ex->cell_style = xmalloc (sizeof *ex->cell_style);
642 *ex->cell_style = base_style->cell_style;
644 read_cell_style (lexer, ex->cell_style);
648 if (lex_match_id (lexer, "FOOTNOTE"))
650 lex_match (lexer, T_EQUALS);
652 while (lex_is_integer (lexer))
654 size_t idx = lex_integer (lexer);
657 if (idx >= pt->n_footnotes)
659 msg (SE, "Footnote %zu not available "
660 "(only %zu footnotes defined)", idx, pt->n_footnotes);
663 pivot_value_add_footnote (value, pt->footnotes[idx]);
668 lex_error (lexer, "Syntax error expecting valid value option.");
672 static struct pivot_value *
673 read_value (struct lexer *lexer, const struct pivot_table *pt,
674 const struct table_area_style *base_style)
676 struct pivot_value *value;
677 if (lex_is_number (lexer))
679 value = pivot_value_new_number (lex_number (lexer));
682 else if (lex_is_string (lexer))
684 value = xmalloc (sizeof *value);
685 *value = (struct pivot_value) {
687 .type = PIVOT_VALUE_STRING,
688 .s = xstrdup (lex_tokcstr (lexer))
693 else if (lex_token (lexer) == T_ID)
695 value = xmalloc (sizeof *value);
696 *value = (struct pivot_value) {
698 .type = PIVOT_VALUE_VARIABLE,
699 .var_name = xstrdup (lex_tokcstr (lexer))
706 msg (SE, "Expecting pivot_value");
710 while (lex_match (lexer, T_LBRACK))
712 read_value_option (lexer, pt, value, base_style);
713 force_match (lexer, T_RBRACK);
720 read_group (struct lexer *lexer, struct pivot_table *pt,
721 struct pivot_category *group,
722 const struct table_area_style *label_style)
724 if (lex_match (lexer, T_ASTERISK))
725 group->show_label = true;
727 force_match (lexer, T_LPAREN);
728 if (lex_match (lexer, T_RPAREN))
733 struct pivot_value *name = read_value (lexer, pt, label_style);
734 if (lex_token (lexer) == T_ASTERISK
735 || lex_token (lexer) == T_LPAREN)
736 read_group (lexer, pt, pivot_category_create_group__ (group, name),
741 if (lex_token (lexer) == T_ID
742 && is_pivot_result_class (lex_tokcstr (lexer)))
744 rc = xstrdup (lex_tokcstr (lexer));
750 pivot_category_create_leaf_rc (group, name, rc);
755 while (lex_match (lexer, T_COMMA));
756 force_match (lexer, T_RPAREN);
760 read_dimension (struct lexer *lexer, struct pivot_table *pt,
761 enum pivot_axis_type a,
762 const struct table_area_style *label_style)
764 if (!pivot_table_is_empty (pt))
765 error (1, 0, "can't add dimensions after adding data");
767 lex_match (lexer, T_EQUALS);
769 struct pivot_value *name = read_value (lexer, pt, label_style);
770 struct pivot_dimension *dim = pivot_dimension_create__ (pt, a, name);
771 read_group (lexer, pt, dim->root, label_style);
775 read_look (struct lexer *lexer, struct pivot_table *pt)
777 lex_match (lexer, T_EQUALS);
779 if (lex_is_string (lexer))
781 struct pivot_table_look *look;
782 char *error = pivot_table_look_read (lex_tokcstr (lexer), &look);
785 msg (SE, "%s", error);
790 pivot_table_set_look (pt, look);
791 pivot_table_look_unref (look);
794 struct pivot_table_look *look = pivot_table_look_unshare (
795 pivot_table_look_ref (pt->look));
798 if (!parse_bool_setting (lexer, "EMPTY", "HIDE", "SHOW",
800 && !parse_bool_setting (lexer, "ROWLABELS", "CORNER", "NESTED",
801 &look->row_labels_in_corner)
802 && !parse_bool_setting (lexer, "MARKERS", "NUMERIC", "ALPHA",
803 &look->show_numeric_markers)
804 && !parse_bool_setting (lexer, "LEVEL", "SUPER", "SUB",
805 &look->footnote_marker_superscripts)
806 && !parse_bool_setting (lexer, "LAYERS", "ALL", "CURRENT",
807 &look->print_all_layers)
808 && !parse_bool_setting (lexer, "PAGINATELAYERS", "YES", "NO",
809 &look->paginate_layers)
810 && !parse_bool_setting (lexer, "HSHRINK", "YES", "NO",
811 &look->shrink_to_fit[TABLE_HORZ])
812 && !parse_bool_setting (lexer, "VSHRINK", "YES", "NO",
813 &look->shrink_to_fit[TABLE_VERT])
814 && !parse_bool_setting (lexer, "TOPCONTINUATION", "YES", "NO",
815 &look->top_continuation)
816 && !parse_bool_setting (lexer, "BOTTOMCONTINUATION", "YES", "NO",
817 &look->bottom_continuation)
818 && !parse_string_setting (lexer, "CONTINUATION",
819 &look->continuation))
822 pivot_table_set_look (pt, look);
823 pivot_table_look_unref (look);
826 static enum table_stroke
827 read_stroke (struct lexer *lexer)
829 for (int stroke = 0; stroke < TABLE_N_STROKES; stroke++)
830 if (lex_match_id (lexer, table_stroke_to_string (stroke)))
833 lex_error (lexer, "Syntax error expecting stroke.");
838 parse_value_setting (struct lexer *lexer, const struct pivot_table *pt,
840 struct pivot_value **valuep,
841 struct table_area_style *base_style)
843 if (lex_match_id (lexer, name))
845 lex_match (lexer, T_EQUALS);
847 pivot_value_destroy (*valuep);
848 *valuep = read_value (lexer, pt, base_style);
857 read_border (struct lexer *lexer, struct pivot_table *pt)
859 static const char *const pivot_border_ids[PIVOT_N_BORDERS] = {
860 [PIVOT_BORDER_TITLE] = "title",
861 [PIVOT_BORDER_OUTER_LEFT] = "outer-left",
862 [PIVOT_BORDER_OUTER_TOP] = "outer-top",
863 [PIVOT_BORDER_OUTER_RIGHT] = "outer-right",
864 [PIVOT_BORDER_OUTER_BOTTOM] = "outer-bottom",
865 [PIVOT_BORDER_INNER_LEFT] = "inner-left",
866 [PIVOT_BORDER_INNER_TOP] = "inner-top",
867 [PIVOT_BORDER_INNER_RIGHT] = "inner-right",
868 [PIVOT_BORDER_INNER_BOTTOM] = "inner-bottom",
869 [PIVOT_BORDER_DATA_LEFT] = "data-left",
870 [PIVOT_BORDER_DATA_TOP] = "data-top",
871 [PIVOT_BORDER_DIM_ROW_HORZ] = "dim-row-horz",
872 [PIVOT_BORDER_DIM_ROW_VERT] = "dim-row-vert",
873 [PIVOT_BORDER_DIM_COL_HORZ] = "dim-col-horz",
874 [PIVOT_BORDER_DIM_COL_VERT] = "dim-col-vert",
875 [PIVOT_BORDER_CAT_ROW_HORZ] = "cat-row-horz",
876 [PIVOT_BORDER_CAT_ROW_VERT] = "cat-row-vert",
877 [PIVOT_BORDER_CAT_COL_HORZ] = "cat-col-horz",
878 [PIVOT_BORDER_CAT_COL_VERT] = "cat-col-vert",
881 lex_match (lexer, T_EQUALS);
883 struct pivot_table_look *look = pivot_table_look_unshare (
884 pivot_table_look_ref (pt->look));
885 while (lex_token (lexer) == T_STRING)
887 char *s = xstrdup (lex_tokcstr (lexer));
889 force_match (lexer, T_LPAREN);
891 struct table_border_style style = TABLE_BORDER_STYLE_INITIALIZER;
892 style.stroke = read_stroke (lexer);
893 if (lex_is_string (lexer))
894 style.color = read_color (lexer);
895 force_match (lexer, T_RPAREN);
898 for (int b = 0; b < PIVOT_N_BORDERS; b++)
900 if (!fnmatch (s, pivot_border_ids[b], 0))
902 look->borders[b] = style;
908 msg (SE, "%s: no matching borders", s);
913 pivot_table_set_look (pt, look);
914 pivot_table_look_unref (look);
918 read_footnote (struct lexer *lexer, struct pivot_table *pt)
921 if (lex_match (lexer, T_LBRACK))
925 idx = lex_integer (lexer);
928 force_match (lexer, T_RBRACK);
931 idx = pt->n_footnotes;
932 lex_match (lexer, T_EQUALS);
934 struct pivot_value *content
935 = read_value (lexer, pt, &pt->look->areas[PIVOT_AREA_FOOTER]);
937 struct pivot_value *marker;
938 if (lex_match_id (lexer, "MARKER"))
940 lex_match (lexer, T_EQUALS);
941 marker = read_value (lexer, pt, &pt->look->areas[PIVOT_AREA_FOOTER]);
946 bool show = !lex_match_id (lexer, "HIDE");
947 pivot_table_create_footnote__ (pt, idx, marker, content)->show = show;
951 read_cell (struct lexer *lexer, struct pivot_table *pt)
953 force_match (lexer, T_LBRACK);
955 size_t *lo = xnmalloc (pt->n_dimensions, sizeof *lo);
956 size_t *hi = xnmalloc (pt->n_dimensions, sizeof *hi);
957 for (size_t i = 0; i < pt->n_dimensions; i++)
959 const struct pivot_dimension *d = pt->dimensions[i];
962 force_match (lexer, T_COMMA);
966 msg (SE, "can't define data because dimension %zu has no categories",
971 if (lex_match (lexer, T_ALL))
974 hi[i] = d->n_leaves - 1;
979 lo[i] = hi[i] = lex_integer (lexer);
982 if (lex_match_id (lexer, "THRU"))
985 hi[i] = lex_integer (lexer);
991 msg (SE, "%zu THRU %zu is not a valid range", lo[i], hi[i]);
994 if (hi[i] >= d->n_leaves)
996 msg (SE, "dimension %zu (%s) has only %zu categories",
997 i, pivot_value_to_string (d->root->name, pt),
1003 force_match (lexer, T_RBRACK);
1005 struct pivot_value *value = NULL;
1006 bool delete = false;
1007 if (lex_match (lexer, T_EQUALS))
1009 if (lex_match_id (lexer, "DELETE"))
1012 value = read_value (lexer, pt, &pt->look->areas[PIVOT_AREA_DATA]);
1015 size_t *dindexes = xmemdup (lo, pt->n_dimensions * sizeof *lo);
1016 for (size_t i = 0; ; i++)
1019 pivot_table_delete (pt, dindexes);
1021 pivot_table_put (pt, dindexes, pt->n_dimensions,
1023 ? pivot_value_clone (value)
1024 : pivot_value_new_integer (i)));
1026 for (size_t j = 0; j < pt->n_dimensions; j++)
1028 if (++dindexes[j] <= hi[j])
1030 dindexes[j] = lo[j];
1037 pivot_value_destroy (value);
1043 static struct pivot_dimension *
1044 parse_dim_name (struct lexer *lexer, struct pivot_table *table)
1046 force_string (lexer);
1047 for (size_t i = 0; i < table->n_dimensions; i++)
1049 struct pivot_dimension *dim = table->dimensions[i];
1051 struct string s = DS_EMPTY_INITIALIZER;
1052 pivot_value_format_body (dim->root->name, table, &s);
1053 bool match = !strcmp (ds_cstr (&s), lex_tokcstr (lexer));
1063 lex_error (lexer, "unknown dimension");
1067 static enum pivot_axis_type
1068 parse_axis_type (struct lexer *lexer)
1070 if (lex_match_id (lexer, "ROW"))
1071 return PIVOT_AXIS_ROW;
1072 else if (lex_match_id (lexer, "COLUMN"))
1073 return PIVOT_AXIS_COLUMN;
1074 else if (lex_match_id (lexer, "LAYER"))
1075 return PIVOT_AXIS_LAYER;
1078 lex_error_expecting (lexer, "ROW", "COLUMN", "LAYER");
1084 move_dimension (struct lexer *lexer, struct pivot_table *table)
1086 struct pivot_dimension *dim = parse_dim_name (lexer, table);
1088 enum pivot_axis_type axis = parse_axis_type (lexer);
1091 if (lex_is_integer (lexer))
1093 position = lex_integer (lexer);
1099 pivot_table_move_dimension (table, dim, axis, position);
1103 swap_axes (struct lexer *lexer, struct pivot_table *table)
1105 enum pivot_axis_type a = parse_axis_type (lexer);
1106 enum pivot_axis_type b = parse_axis_type (lexer);
1107 pivot_table_swap_axes (table, a, b);
1111 read_current_layer (struct lexer *lexer, struct pivot_table *table)
1113 lex_match (lexer, T_EQUALS);
1115 const struct pivot_axis *layer_axis = &table->axes[PIVOT_AXIS_LAYER];
1116 for (size_t i = 0; i < layer_axis->n_dimensions; i++)
1118 const struct pivot_dimension *dim = layer_axis->dimensions[i];
1121 size_t index = lex_integer (lexer);
1122 if (index >= dim->n_leaves)
1124 lex_error (lexer, "only %zu dimensions", dim->n_leaves);
1129 table->current_layer[i] = index;
1134 read_table (struct lexer *lexer)
1136 bool displayed = false;
1138 struct pivot_table *pt = pivot_table_create ("Default Title");
1139 while (lex_match (lexer, T_SLASH))
1141 assert (!pivot_table_is_shared (pt));
1144 if (lex_match_id (lexer, "ROW"))
1145 read_dimension (lexer, pt, PIVOT_AXIS_ROW,
1146 &pt->look->areas[PIVOT_AREA_ROW_LABELS]);
1147 else if (lex_match_id (lexer, "COLUMN"))
1148 read_dimension (lexer, pt, PIVOT_AXIS_COLUMN,
1149 &pt->look->areas[PIVOT_AREA_COLUMN_LABELS]);
1150 else if (lex_match_id (lexer, "LAYER"))
1151 read_dimension (lexer, pt, PIVOT_AXIS_LAYER,
1152 &pt->look->areas[PIVOT_AREA_LAYERS]);
1153 else if (lex_match_id (lexer, "LOOK"))
1154 read_look (lexer, pt);
1155 else if (lex_match_id (lexer, "ROTATE"))
1157 lex_match (lexer, T_EQUALS);
1158 while (lex_token (lexer) == T_ID)
1159 if (!parse_bool_setting (lexer, "INNERCOLUMNS", "YES", "NO",
1160 &pt->rotate_inner_column_labels)
1161 && !parse_bool_setting (lexer, "OUTERROWS", "YES", "NO",
1162 &pt->rotate_outer_row_labels))
1165 else if (lex_match_id (lexer, "SHOW"))
1167 lex_match (lexer, T_EQUALS);
1168 while (lex_token (lexer) == T_ID)
1170 if (parse_bool_setting (lexer, "GRID", "YES", "NO",
1171 &pt->show_grid_lines)
1172 || parse_bool_setting (lexer, "CAPTION", "YES", "NO",
1174 || parse_bool_setting (lexer, "TITLE", "YES", "NO",
1178 if (parse_settings_value_show (lexer, "VALUES", &pt->show_values)
1179 || parse_settings_value_show (lexer, "VARIABLES",
1180 &pt->show_variables))
1183 if (lex_match_id (lexer, "LAYER"))
1184 read_current_layer (lexer, pt);
1189 else if (parse_value_setting (lexer, pt, "TITLE", &pt->title,
1190 &pt->look->areas[PIVOT_AREA_TITLE])
1191 || parse_value_setting (lexer, pt, "SUBTYPE", &pt->subtype,
1193 || parse_value_setting (lexer, pt, "CORNER", &pt->corner_text,
1194 &pt->look->areas[PIVOT_AREA_CORNER])
1195 || parse_value_setting (lexer, pt, "CAPTION", &pt->caption,
1196 &pt->look->areas[PIVOT_AREA_CAPTION])
1197 || parse_string_setting (lexer, "NOTES", &pt->notes))
1201 else if (lex_match_id (lexer, "BORDER"))
1202 read_border (lexer, pt);
1203 else if (lex_match_id (lexer, "TRANSPOSE"))
1204 pivot_table_transpose (pt);
1205 else if (lex_match_id (lexer, "SWAP"))
1206 swap_axes (lexer, pt);
1207 else if (lex_match_id (lexer, "MOVE"))
1208 move_dimension (lexer, pt);
1209 else if (lex_match_id (lexer, "CELLS"))
1210 read_cell (lexer, pt);
1211 else if (lex_match_id (lexer, "FOOTNOTE"))
1212 read_footnote (lexer, pt);
1213 else if (lex_match_id (lexer, "DUMP"))
1214 pivot_table_dump (pt, 0);
1215 else if (lex_match_id (lexer, "DISPLAY"))
1217 pivot_table_submit (pivot_table_ref (pt));
1218 pt = pivot_table_unshare (pt);
1223 msg (SE, "Expecting keyword");
1229 pivot_table_submit (pt);
1231 pivot_table_unref (pt);
1233 force_match (lexer, T_ENDCMD);
1237 output_msg (const struct msg *m_, struct lexer *lexer)
1240 .category = m_->category,
1241 .severity = m_->severity,
1242 .location = (m_->location ? m_->location
1243 : lexer ? lex_get_location (lexer, 0, 0)
1245 .command_name = output_get_uppercase_command_name (),
1249 output_item_submit (message_item_create (&m));
1251 free (m.command_name);
1252 if (m.location != m_->location)
1253 msg_location_destroy (m.location);