1 /* $Id: out.c,v 1.59 2015/01/30 04:11:50 schwarze Exp $ */
2 /*
3 * Copyright (c) 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv>
4 * Copyright (c) 2011, 2014, 2015 Ingo Schwarze <schwarze@openbsd.org>
5 *
6 * Permission to use, copy, modify, and distribute this software for any
7 * purpose with or without fee is hereby granted, provided that the above
8 * copyright notice and this permission notice appear in all copies.
9 *
10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17 */
18 #include "config.h"
19
20 #include <sys/types.h>
21
22 #include <assert.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <time.h>
26
27 #include "mandoc_aux.h"
28 #include "mandoc.h"
29 #include "out.h"
30
31 static void tblcalc_data(struct rofftbl *, struct roffcol *,
32 const struct tbl_opts *, const struct tbl_dat *);
33 static void tblcalc_literal(struct rofftbl *, struct roffcol *,
34 const struct tbl_dat *);
35 static void tblcalc_number(struct rofftbl *, struct roffcol *,
36 const struct tbl_opts *, const struct tbl_dat *);
37
38
39 /*
40 * Parse the *src string and store a scaling unit into *dst.
41 * If the string doesn't specify the unit, use the default.
42 * If no default is specified, fail.
43 * Return 2 on complete success, 1 when a conversion was done,
44 * but there was trailing garbage, and 0 on total failure.
45 */
46 int
a2roffsu(const char * src,struct roffsu * dst,enum roffscale def)47 a2roffsu(const char *src, struct roffsu *dst, enum roffscale def)
48 {
49 char *endptr;
50
51 dst->unit = def == SCALE_MAX ? SCALE_BU : def;
52 dst->scale = strtod(src, &endptr);
53 if (endptr == src)
54 return(0);
55
56 switch (*endptr++) {
57 case 'c':
58 dst->unit = SCALE_CM;
59 break;
60 case 'i':
61 dst->unit = SCALE_IN;
62 break;
63 case 'f':
64 dst->unit = SCALE_FS;
65 break;
66 case 'M':
67 dst->unit = SCALE_MM;
68 break;
69 case 'm':
70 dst->unit = SCALE_EM;
71 break;
72 case 'n':
73 dst->unit = SCALE_EN;
74 break;
75 case 'P':
76 dst->unit = SCALE_PC;
77 break;
78 case 'p':
79 dst->unit = SCALE_PT;
80 break;
81 case 'u':
82 dst->unit = SCALE_BU;
83 break;
84 case 'v':
85 dst->unit = SCALE_VS;
86 break;
87 case '\0':
88 endptr--;
89 /* FALLTHROUGH */
90 default:
91 if (SCALE_MAX == def)
92 return(0);
93 dst->unit = def;
94 break;
95 }
96
97 return(*endptr == '\0' ? 2 : 1);
98 }
99
100 /*
101 * Calculate the abstract widths and decimal positions of columns in a
102 * table. This routine allocates the columns structures then runs over
103 * all rows and cells in the table. The function pointers in "tbl" are
104 * used for the actual width calculations.
105 */
106 void
tblcalc(struct rofftbl * tbl,const struct tbl_span * sp,size_t totalwidth)107 tblcalc(struct rofftbl *tbl, const struct tbl_span *sp,
108 size_t totalwidth)
109 {
110 const struct tbl_opts *opts;
111 const struct tbl_dat *dp;
112 struct roffcol *col;
113 size_t ewidth, xwidth;
114 int spans;
115 int icol, maxcol, necol, nxcol, quirkcol;
116
117 /*
118 * Allocate the master column specifiers. These will hold the
119 * widths and decimal positions for all cells in the column. It
120 * must be freed and nullified by the caller.
121 */
122
123 assert(NULL == tbl->cols);
124 tbl->cols = mandoc_calloc((size_t)sp->opts->cols,
125 sizeof(struct roffcol));
126 opts = sp->opts;
127
128 for (maxcol = -1; sp; sp = sp->next) {
129 if (TBL_SPAN_DATA != sp->pos)
130 continue;
131 spans = 1;
132 /*
133 * Account for the data cells in the layout, matching it
134 * to data cells in the data section.
135 */
136 for (dp = sp->first; dp; dp = dp->next) {
137 /* Do not used spanned cells in the calculation. */
138 if (0 < --spans)
139 continue;
140 spans = dp->spans;
141 if (1 < spans)
142 continue;
143 icol = dp->layout->col;
144 if (maxcol < icol)
145 maxcol = icol;
146 col = tbl->cols + icol;
147 col->flags |= dp->layout->flags;
148 if (dp->layout->flags & TBL_CELL_WIGN)
149 continue;
150 tblcalc_data(tbl, col, opts, dp);
151 }
152 }
153
154 /*
155 * Count columns to equalize and columns to maximize.
156 * Find maximum width of the columns to equalize.
157 * Find total width of the columns *not* to maximize.
158 */
159
160 necol = nxcol = 0;
161 ewidth = xwidth = 0;
162 for (icol = 0; icol <= maxcol; icol++) {
163 col = tbl->cols + icol;
164 if (col->flags & TBL_CELL_EQUAL) {
165 necol++;
166 if (ewidth < col->width)
167 ewidth = col->width;
168 }
169 if (col->flags & TBL_CELL_WMAX)
170 nxcol++;
171 else
172 xwidth += col->width;
173 }
174
175 /*
176 * Equalize columns, if requested for any of them.
177 * Update total width of the columns not to maximize.
178 */
179
180 if (necol) {
181 for (icol = 0; icol <= maxcol; icol++) {
182 col = tbl->cols + icol;
183 if ( ! (col->flags & TBL_CELL_EQUAL))
184 continue;
185 if (col->width == ewidth)
186 continue;
187 if (nxcol && totalwidth)
188 xwidth += ewidth - col->width;
189 col->width = ewidth;
190 }
191 }
192
193 /*
194 * If there are any columns to maximize, find the total
195 * available width, deducting 3n margins between columns.
196 * Distribute the available width evenly.
197 */
198
199 if (nxcol && totalwidth) {
200 xwidth = totalwidth - xwidth - 3*maxcol -
201 (opts->opts & (TBL_OPT_BOX | TBL_OPT_DBOX) ?
202 2 : !!opts->lvert + !!opts->rvert);
203
204 /*
205 * Emulate a bug in GNU tbl width calculation that
206 * manifests itself for large numbers of x-columns.
207 * Emulating it for 5 x-columns gives identical
208 * behaviour for up to 6 x-columns.
209 */
210
211 if (nxcol == 5) {
212 quirkcol = xwidth % nxcol + 2;
213 if (quirkcol != 3 && quirkcol != 4)
214 quirkcol = -1;
215 } else
216 quirkcol = -1;
217
218 necol = 0;
219 ewidth = 0;
220 for (icol = 0; icol <= maxcol; icol++) {
221 col = tbl->cols + icol;
222 if ( ! (col->flags & TBL_CELL_WMAX))
223 continue;
224 col->width = (double)xwidth * ++necol / nxcol
225 - ewidth + 0.4995;
226 if (necol == quirkcol)
227 col->width--;
228 ewidth += col->width;
229 }
230 }
231 }
232
233 static void
tblcalc_data(struct rofftbl * tbl,struct roffcol * col,const struct tbl_opts * opts,const struct tbl_dat * dp)234 tblcalc_data(struct rofftbl *tbl, struct roffcol *col,
235 const struct tbl_opts *opts, const struct tbl_dat *dp)
236 {
237 size_t sz;
238
239 /* Branch down into data sub-types. */
240
241 switch (dp->layout->pos) {
242 case TBL_CELL_HORIZ:
243 /* FALLTHROUGH */
244 case TBL_CELL_DHORIZ:
245 sz = (*tbl->len)(1, tbl->arg);
246 if (col->width < sz)
247 col->width = sz;
248 break;
249 case TBL_CELL_LONG:
250 /* FALLTHROUGH */
251 case TBL_CELL_CENTRE:
252 /* FALLTHROUGH */
253 case TBL_CELL_LEFT:
254 /* FALLTHROUGH */
255 case TBL_CELL_RIGHT:
256 tblcalc_literal(tbl, col, dp);
257 break;
258 case TBL_CELL_NUMBER:
259 tblcalc_number(tbl, col, opts, dp);
260 break;
261 case TBL_CELL_DOWN:
262 break;
263 default:
264 abort();
265 /* NOTREACHED */
266 }
267 }
268
269 static void
tblcalc_literal(struct rofftbl * tbl,struct roffcol * col,const struct tbl_dat * dp)270 tblcalc_literal(struct rofftbl *tbl, struct roffcol *col,
271 const struct tbl_dat *dp)
272 {
273 size_t sz;
274 const char *str;
275
276 str = dp->string ? dp->string : "";
277 sz = (*tbl->slen)(str, tbl->arg);
278
279 if (col->width < sz)
280 col->width = sz;
281 }
282
283 static void
tblcalc_number(struct rofftbl * tbl,struct roffcol * col,const struct tbl_opts * opts,const struct tbl_dat * dp)284 tblcalc_number(struct rofftbl *tbl, struct roffcol *col,
285 const struct tbl_opts *opts, const struct tbl_dat *dp)
286 {
287 int i;
288 size_t sz, psz, ssz, d;
289 const char *str;
290 char *cp;
291 char buf[2];
292
293 /*
294 * First calculate number width and decimal place (last + 1 for
295 * non-decimal numbers). If the stored decimal is subsequent to
296 * ours, make our size longer by that difference
297 * (right-"shifting"); similarly, if ours is subsequent the
298 * stored, then extend the stored size by the difference.
299 * Finally, re-assign the stored values.
300 */
301
302 str = dp->string ? dp->string : "";
303 sz = (*tbl->slen)(str, tbl->arg);
304
305 /* FIXME: TBL_DATA_HORIZ et al.? */
306
307 buf[0] = opts->decimal;
308 buf[1] = '\0';
309
310 psz = (*tbl->slen)(buf, tbl->arg);
311
312 if (NULL != (cp = strrchr(str, opts->decimal))) {
313 buf[1] = '\0';
314 for (ssz = 0, i = 0; cp != &str[i]; i++) {
315 buf[0] = str[i];
316 ssz += (*tbl->slen)(buf, tbl->arg);
317 }
318 d = ssz + psz;
319 } else
320 d = sz + psz;
321
322 /* Adjust the settings for this column. */
323
324 if (col->decimal > d) {
325 sz += col->decimal - d;
326 d = col->decimal;
327 } else
328 col->width += d - col->decimal;
329
330 if (sz > col->width)
331 col->width = sz;
332 if (d > col->decimal)
333 col->decimal = d;
334 }
335