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