NPAR TESTS: Fix two test failures.
[pspp] / src / output / measure.c
1 /* PSPP - a program for statistical analysis.
2    Copyright (C) 1997-9, 2000, 2007, 2009, 2010 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/measure.h>
20
21 #include <ctype.h>
22 #include <errno.h>
23 #if HAVE_LC_PAPER
24 #include <langinfo.h>
25 #endif
26 #include <libpspp/str.h>
27 #include <stdlib.h>
28
29 #include <data/file-name.h>
30
31 #include "gl/error.h"
32
33 #include "gettext.h"
34 #define _(msgid) gettext (msgid)
35
36 static double parse_unit (const char *);
37 static bool parse_paper_size (const char *, int *h, int *v);
38 static bool get_standard_paper_size (struct substring name, int *h, int *v);
39 static bool read_paper_conf (const char *file_name, int *h, int *v);
40 static bool get_default_paper_size (int *h, int *v);
41
42 /* Determines the size of a dimensional measurement and returns
43    the size in units of 1/72000".  Units are assumed to be
44    millimeters unless otherwise specified.  Returns -1 on
45    error. */
46 int
47 measure_dimension (const char *dimen)
48 {
49   double raw, factor;
50   char *tail;
51
52   /* Number. */
53   raw = strtod (dimen, &tail);
54   if (raw < 0.0)
55     goto syntax_error;
56
57   /* Unit. */
58   factor = parse_unit (tail);
59   if (factor == 0.0)
60     goto syntax_error;
61
62   return raw * factor;
63
64 syntax_error:
65   error (0, 0, _("`%s' is not a valid length."), dimen);
66   return -1;
67 }
68
69 /* Stores the dimensions, in 1/72000" units, of paper identified
70    by SIZE into *H and *V.  SIZE can be the name of a kind of
71    paper ("a4", "letter", ...) or a pair of dimensions
72    ("210x297", "8.5x11in", ...).  Returns true on success, false
73    on failure.  On failure, *H and *V are set for A4 paper. */
74 bool
75 measure_paper (const char *size, int *h, int *v)
76 {
77   struct substring s;
78   bool ok;
79
80   s = ss_cstr (size);
81   ss_trim (&s, ss_cstr (CC_SPACES));
82
83   if (ss_is_empty (s))
84     {
85       /* Treat empty string as default paper size. */
86       ok = get_default_paper_size (h, v);
87     }
88   else if (isdigit (ss_first (s)))
89     {
90       /* Treat string that starts with digit as explicit size. */
91       ok = parse_paper_size (size, h, v);
92       if (!ok)
93         error (0, 0, _("syntax error in paper size `%s'"), size);
94     }
95   else
96     {
97       /* Check against standard paper sizes. */
98       ok = get_standard_paper_size (s, h, v);
99     }
100
101   /* Default to A4 on error. */
102   if (!ok)
103     {
104       *h = 210 * (72000 / 25.4);
105       *v = 297 * (72000 / 25.4);
106     }
107   return ok;
108 }
109 \f
110 /* Parses UNIT as a dimensional unit.  Returns the multiplicative
111    factor needed to change a quantity measured in that unit into
112    1/72000" units.  If UNIT is empty, it is treated as
113    millimeters.  If the unit is unrecognized, returns 0. */
114 static double
115 parse_unit (const char *unit)
116 {
117   struct unit
118     {
119       char name[3];
120       double factor;
121     };
122
123   static const struct unit units[] =
124     {
125       {"pt", 72000 / 72},
126       {"pc", 72000 / 72 * 12.0},
127       {"in", 72000},
128       {"cm", 72000 / 2.54},
129       {"mm", 72000 / 25.4},
130       {"", 72000 / 25.4},
131     };
132
133   const struct unit *p;
134
135   unit += strspn (unit, CC_SPACES);
136   for (p = units; p < units + sizeof units / sizeof *units; p++)
137     if (!strcasecmp (unit, p->name))
138       return p->factor;
139   return 0.0;
140 }
141
142 /* Stores the dimensions in 1/72000" units of paper identified by
143    SIZE, which is of form `HORZ x VERT [UNIT]' where HORZ and
144    VERT are numbers and UNIT is an optional unit of measurement,
145    into *H and *V.  Return true on success. */
146 static bool
147 parse_paper_size (const char *size, int *h, int *v)
148 {
149   double raw_h, raw_v, factor;
150   char *tail;
151
152   /* Width. */
153   raw_h = strtod (size, &tail);
154   if (raw_h <= 0.0)
155     return false;
156
157   /* Delimiter. */
158   tail += strspn (tail, CC_SPACES "x,");
159
160   /* Length. */
161   raw_v = strtod (tail, &tail);
162   if (raw_v <= 0.0)
163     return false;
164
165   /* Unit. */
166   factor = parse_unit (tail);
167   if (factor == 0.0)
168     return false;
169
170   *h = raw_h * factor + .5;
171   *v = raw_v * factor + .5;
172   return true;
173 }
174
175 static bool
176 get_standard_paper_size (struct substring name, int *h, int *v)
177 {
178   static const char *sizes[][2] =
179     {
180       {"a0", "841 x 1189 mm"},
181       {"a1", "594 x 841 mm"},
182       {"a2", "420 x 594 mm"},
183       {"a3", "297 x 420 mm"},
184       {"a4", "210 x 297 mm"},
185       {"a5", "148 x 210 mm"},
186       {"b5", "176 x 250 mm"},
187       {"a6", "105 x 148 mm"},
188       {"a7", "74 x 105 mm"},
189       {"a8", "52 x 74 mm"},
190       {"a9", "37 x 52 mm"},
191       {"a10", "26 x 37 mm"},
192       {"b0", "1000 x 1414 mm"},
193       {"b1", "707 x 1000 mm"},
194       {"b2", "500 x 707 mm"},
195       {"b3", "353 x 500 mm"},
196       {"b4", "250 x 353 mm"},
197       {"letter", "612 x 792 pt"},
198       {"legal", "612 x 1008 pt"},
199       {"executive", "522 x 756 pt"},
200       {"note", "612 x 792 pt"},
201       {"11x17", "792 x 1224 pt"},
202       {"tabloid", "792 x 1224 pt"},
203       {"statement", "396 x 612 pt"},
204       {"halfletter", "396 x 612 pt"},
205       {"halfexecutive", "378 x 522 pt"},
206       {"folio", "612 x 936 pt"},
207       {"quarto", "610 x 780 pt"},
208       {"ledger", "1224 x 792 pt"},
209       {"archA", "648 x 864 pt"},
210       {"archB", "864 x 1296 pt"},
211       {"archC", "1296 x 1728 pt"},
212       {"archD", "1728 x 2592 pt"},
213       {"archE", "2592 x 3456 pt"},
214       {"flsa", "612 x 936 pt"},
215       {"flse", "612 x 936 pt"},
216       {"csheet", "1224 x 1584 pt"},
217       {"dsheet", "1584 x 2448 pt"},
218       {"esheet", "2448 x 3168 pt"},
219     };
220
221   size_t i;
222
223   for (i = 0; i < sizeof sizes / sizeof *sizes; i++)
224     if (ss_equals_case (ss_cstr (sizes[i][0]), name))
225       {
226         bool ok = parse_paper_size (sizes[i][1], h, v);
227         assert (ok);
228         return ok;
229       }
230   error (0, 0, _("unknown paper type `%.*s'"),
231          (int) ss_length (name), ss_data (name));
232   return false;
233 }
234
235 /* Reads file FILE_NAME to find a paper size.  Stores the
236    dimensions, in 1/72000" units, into *H and *V.  Returns true
237    on success, false on failure. */
238 static bool
239 read_paper_conf (const char *file_name, int *h, int *v)
240 {
241   struct string line = DS_EMPTY_INITIALIZER;
242   int line_number = 0;
243   FILE *file;
244
245   file = fopen (file_name, "r");
246   if (file == NULL)
247     {
248       error (0, errno, _("error opening input file `%s'"), file_name);
249       return false;
250     }
251
252   for (;;)
253     {
254       struct substring name;
255
256       if (!ds_read_config_line (&line, &line_number, file))
257         {
258           if (ferror (file))
259             error (0, errno, _("error reading file `%s'"), file_name);
260           break;
261         }
262
263       name = ds_ss (&line);
264       ss_trim (&name, ss_cstr (CC_SPACES));
265       if (!ss_is_empty (name))
266         {
267           bool ok = get_standard_paper_size (name, h, v);
268           fclose (file);
269           ds_destroy (&line);
270           return ok;
271         }
272     }
273
274   fclose (file);
275   ds_destroy (&line);
276   error (0, 0, _("paper size file `%s' does not state a paper size"),
277          file_name);
278   return false;
279 }
280
281 /* The user didn't specify a paper size, so let's choose a
282    default based on his environment.  Stores the
283    dimensions, in 1/72000" units, into *H and *V.  Returns true
284    on success, false on failure. */
285 static bool
286 get_default_paper_size (int *h, int *v)
287 {
288   /* libpaper in Debian (and other distributions?) allows the
289      paper size to be specified in $PAPERSIZE or in a file
290      specified in $PAPERCONF. */
291   if (getenv ("PAPERSIZE") != NULL)
292     return get_standard_paper_size (ss_cstr (getenv ("PAPERSIZE")), h, v);
293   if (getenv ("PAPERCONF") != NULL)
294     return read_paper_conf (getenv ("PAPERCONF"), h, v);
295
296 #if HAVE_LC_PAPER
297   /* LC_PAPER is a non-standard glibc extension. */
298   *h = (int) nl_langinfo(_NL_PAPER_WIDTH) * (72000 / 25.4);
299   *v = (int) nl_langinfo(_NL_PAPER_HEIGHT) * (72000 / 25.4);
300   if (*h > 0 && *v > 0)
301      return true;
302 #endif
303
304   /* libpaper defaults to /etc/papersize. */
305   if (fn_exists ("/etc/papersize"))
306     return read_paper_conf ("/etc/papersize", h, v);
307
308   /* Can't find a default. */
309   return false;
310 }
311