sys-file-reader: Check that multiple response set names begin with `$'.
[pspp-builds.git] / src / output / table-casereader.c
1 /* PSPP - a program for statistical analysis.
2    Copyright (C) 2009 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 <output/table-provider.h>
20
21 #include <data/casereader.h>
22 #include <data/data-out.h>
23 #include <data/format.h>
24 #include <libpspp/i18n.h>
25
26 #include "gl/xalloc.h"
27
28 struct table_casereader
29   {
30     struct table table;
31     struct casereader *reader;
32     char *heading;
33     struct fmt_spec format;
34   };
35
36 static const struct table_class table_casereader_class;
37
38 static struct table_casereader *
39 table_casereader_cast (const struct table *table)
40 {
41   assert (table->class == &table_casereader_class);
42   return UP_CAST (table, struct table_casereader, table);
43 }
44
45 /* Returns a new table that has one column and the same number of rows as
46    READER.  Each row in the table is derived from column COLUMN in the same row
47    of READER by formatting with data_out() using the specified FORMAT (which
48    must be a valid format for the column's width).
49
50    If HEADING is nonnull, adds an additional row above the first row of data
51    that contains HEADING, and sets that row as a header row.
52
53    The returned table has no rules, except that if HEADING is nonnull, a single
54    line (TAL_1) separates HEADING from the first row if data. */
55 struct table *
56 table_from_casereader (const struct casereader *reader, size_t column,
57                        const char *heading, const struct fmt_spec *format)
58 {
59   struct table_casereader *tc;
60   struct table *t;
61
62   assert (fmt_check_width_compat (format,
63                                   caseproto_get_width (
64                                     casereader_get_proto (reader), column)));
65
66   tc = xmalloc (sizeof *tc);
67   t = &tc->table;
68   table_init (t, &table_casereader_class);
69   table_set_nc (t, 1);
70   table_set_nr (t, casereader_count_cases (reader));
71   tc->reader = casereader_project_1 (casereader_clone (reader), column);
72   tc->heading = NULL;
73   tc->format = *format;
74
75   if (heading != NULL)
76     {
77       tc->heading = xstrdup (heading);
78       table_set_nr (t, table_nr (t) + 1);
79       table_set_ht (t, 1);
80     }
81
82   return t;
83 }
84
85 static void
86 table_casereader_destroy (struct table *t)
87 {
88   struct table_casereader *tc = table_casereader_cast (t);
89   casereader_destroy (tc->reader);
90   free (tc->heading);
91   free (t);
92 }
93
94 static void
95 free_string (void *s_)
96 {
97   char *s = s_;
98   free (s);
99 }
100
101 static void
102 table_casereader_get_cell (const struct table *t, int x, int y,
103                            struct table_cell *cell)
104 {
105   struct table_casereader *tc = table_casereader_cast (t);
106   struct ccase *c;
107   char *s;
108
109   cell->d[TABLE_HORZ][0] = x;
110   cell->d[TABLE_HORZ][1] = x + 1;
111   cell->d[TABLE_VERT][0] = y;
112   cell->d[TABLE_VERT][1] = y + 1;
113   cell->options = TAB_RIGHT;
114   if (tc->heading != NULL)
115     {
116       if (y == 0)
117         {
118           s = xstrdup (tc->heading);
119           cell->contents = s;
120           cell->destructor = free_string;
121           cell->destructor_aux = s;
122           return;
123         }
124       y--;
125     }
126
127   c = casereader_peek (tc->reader, y);
128   if (c == NULL)
129     s = xstrdup ("I/O Error");
130   else
131     {
132       s = data_out (case_data_idx (c, 0), UTF8, &tc->format);
133       case_unref (c);
134     }
135   cell->contents = s;
136   cell->destructor = free_string;
137   cell->destructor_aux = s;
138 }
139
140 static int
141 table_casereader_get_rule (const struct table *t, enum table_axis axis,
142                            int x UNUSED, int y)
143 {
144   struct table_casereader *tc = table_casereader_cast (t);
145   return axis == TABLE_VERT && tc->heading != NULL && y == 1 ? TAL_1 : TAL_0;
146 }
147
148 static const struct table_class table_casereader_class =
149   {
150     table_casereader_destroy,
151     table_casereader_get_cell,
152     table_casereader_get_rule,
153     NULL,                       /* paste */
154     NULL,                       /* select (XXX) */
155   };