gui: Fix behavior of print preview in psppire-output-window.
[pspp] / src / data / case-tmpfile.c
1 /* PSPP - a program for statistical analysis.
2    Copyright (C) 2007, 2009, 2010, 2011 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 "data/case-tmpfile.h"
20
21 #include <errno.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24
25 #include "libpspp/assertion.h"
26 #include "libpspp/taint.h"
27 #include "libpspp/ext-array.h"
28
29 #include "gl/error.h"
30 #include "gl/xalloc.h"
31
32 /* A temporary file that stores an array of cases. */
33 struct case_tmpfile
34   {
35     struct taint *taint;        /* Taint. */
36     struct caseproto *proto;    /* Format of cases in the tmpfile. */
37     size_t case_size;           /* Number of bytes per case. */
38     size_t *offsets;            /* Offset to each value. */
39     struct ext_array *ext_array; /* Temporary file. */
40   };
41
42 /* Returns the number of bytes needed to store a value with the
43    given WIDTH on disk. */
44 static size_t
45 width_to_n_bytes (int width)
46 {
47   return width == 0 ? sizeof (double) : width;
48 }
49
50 /* Returns the address of the data in VALUE (for reading or
51    writing to/from disk).  VALUE must have the given WIDTH. */
52 static void *
53 value_to_data (const union value *value_, int width)
54 {
55   union value *value = CONST_CAST (union value *, value_);
56   assert (sizeof value->f == sizeof (double));
57   if (width == 0)
58     return &value->f;
59   else
60     return value_str_rw (value, width);
61 }
62
63 /* Creates and returns a new case_tmpfile that will store cases
64    that match case prototype PROTO.  The caller retains
65    ownership of PROTO. */
66 struct case_tmpfile *
67 case_tmpfile_create (const struct caseproto *proto)
68 {
69   struct case_tmpfile *ctf;
70   size_t n_values;
71   size_t i;
72
73   ctf = xmalloc (sizeof *ctf);
74   ctf->taint = taint_create ();
75   ctf->ext_array = ext_array_create ();
76   ctf->proto = caseproto_ref (proto);
77   ctf->case_size = 0;
78   n_values = caseproto_get_n_widths (proto);
79   ctf->offsets = xmalloc (n_values * sizeof *ctf->offsets);
80   for (i = 0; i < n_values; i++)
81     {
82       size_t width = caseproto_get_width (proto, i);
83       ctf->offsets[i] = ctf->case_size;
84       ctf->case_size += width == -1 ? 0 : width == 0 ? sizeof (double) : width;
85     }
86   return ctf;
87 }
88
89 /* Destroys case_tmpfile CTF.
90    Returns true if CTF was tainted, which is caused by an I/O
91    error on case_tmpfile access or by taint propagation to the
92    case_tmpfile. */
93 bool
94 case_tmpfile_destroy (struct case_tmpfile *ctf)
95 {
96   bool ok = true;
97   if (ctf != NULL)
98     {
99       struct taint *taint = ctf->taint;
100       ext_array_destroy (ctf->ext_array);
101       caseproto_unref (ctf->proto);
102       free (ctf->offsets);
103       free (ctf);
104       ok = taint_destroy (taint);
105     }
106   return ok;
107 }
108
109 /* Returns true if CTF is tainted, which is caused by an I/O
110    error on case_tmpfile access or by taint propagation to the
111    case_tmpfile. */
112 bool
113 case_tmpfile_error (const struct case_tmpfile *ctf)
114 {
115   return taint_is_tainted (ctf->taint);
116 }
117
118 /* Marks CTF as tainted. */
119 void
120 case_tmpfile_force_error (struct case_tmpfile *ctf)
121 {
122   taint_set_taint (ctf->taint);
123 }
124
125 /* Returns CTF's taint object. */
126 const struct taint *
127 case_tmpfile_get_taint (const struct case_tmpfile *ctf)
128 {
129   return ctf->taint;
130 }
131
132 /* Reads N_VALUES values into VALUES, from the case numbered
133    CASE_IDX starting START_VALUE values into that case.  Returns
134    true if successful, false if CTF is tainted or an I/O error
135    occurs during the operation.
136
137    The results of this function are undefined if any of the
138    values read have not been previously written to CTF. */
139 bool
140 case_tmpfile_get_values (const struct case_tmpfile *ctf,
141                          casenumber case_idx, size_t start_value,
142                          union value values[], size_t n_values)
143 {
144   off_t case_offset = (off_t) ctf->case_size * case_idx;
145   size_t i;
146
147   assert (caseproto_range_is_valid (ctf->proto, start_value, n_values));
148   for (i = start_value; i < start_value + n_values; i++)
149     {
150       int width = caseproto_get_width (ctf->proto, i);
151       if (width != -1
152           && !ext_array_read (ctf->ext_array, case_offset + ctf->offsets[i],
153                               width_to_n_bytes (width),
154                               value_to_data (&values[i], width)))
155           return false;
156     }
157   return true;
158 }
159
160 /* Reads the case numbered CASE_IDX from CTF.
161    Returns the case if successful or a null pointer if CTF is
162    tainted or an I/O error occurs during the operation.
163
164    The results of this function are undefined if the case read
165    from CTF had not previously been written. */
166 struct ccase *
167 case_tmpfile_get_case (const struct case_tmpfile *ctf, casenumber case_idx)
168 {
169   struct ccase *c = case_create (ctf->proto);
170   if (case_tmpfile_get_values (ctf, case_idx, 0, case_data_all_rw (c),
171                                caseproto_get_n_widths (ctf->proto)))
172     return c;
173   else
174     {
175       case_unref (c);
176       return NULL;
177     }
178 }
179
180 /* Writes N_VALUES values from VALUES, into the case numbered
181    CASE_IDX starting START_VALUE values into that case.
182    Returns true if successful, false if CTF is tainted or an I/O
183    error occurs during the operation. */
184 bool
185 case_tmpfile_put_values (struct case_tmpfile *ctf,
186                          casenumber case_idx, size_t start_value,
187                          const union value values[], size_t n_values)
188 {
189   off_t case_offset = (off_t) ctf->case_size * case_idx;
190   size_t i;
191
192   assert (caseproto_range_is_valid (ctf->proto, start_value, n_values));
193   for (i = start_value; i < start_value + n_values; i++)
194     {
195       int width = caseproto_get_width (ctf->proto, i);
196       if (width != -1
197           && !ext_array_write (ctf->ext_array, case_offset + ctf->offsets[i],
198                                width_to_n_bytes (width),
199                                value_to_data (values++, width)))
200           return false;
201     }
202   return true;
203 }
204
205 /* Writes C to CTF as the case numbered CASE_IDX.
206    Returns true if successful, false if CTF is tainted or an I/O
207    error occurs during the operation. */
208 bool
209 case_tmpfile_put_case (struct case_tmpfile *ctf, casenumber case_idx,
210                        struct ccase *c)
211 {
212   bool ok = case_tmpfile_put_values (ctf, case_idx, 0, case_data_all (c),
213                                      caseproto_get_n_widths (ctf->proto));
214   case_unref (c);
215   return ok;
216 }
217