usr/src/cmd/mandoc/out.c

   1 /*      $Id: out.c,v 1.62 2015/10/12 00:08:16 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
  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
 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
 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         case TBL_CELL_DHORIZ:
 244                 sz = (*tbl->len)(1, tbl->arg);
 245                 if (col->width < sz)
 246                         col->width = sz;
 247                 break;
 248         case TBL_CELL_LONG:
 249         case TBL_CELL_CENTRE:
 250         case TBL_CELL_LEFT:
 251         case TBL_CELL_RIGHT:
 252                 tblcalc_literal(tbl, col, dp);
 253                 break;
 254         case TBL_CELL_NUMBER:
 255                 tblcalc_number(tbl, col, opts, dp);
 256                 break;
 257         case TBL_CELL_DOWN:
 258                 break;
 259         default:
 260                 abort();
 261         }
 262 }
 263
 264 static void
 265 tblcalc_literal(struct rofftbl *tbl, struct roffcol *col,
 266                 const struct tbl_dat *dp)
 267 {
 268         size_t           sz;
 269         const char      *str;
 270
 271         str = dp->string ? dp->string : "";
 272         sz = (*tbl->slen)(str, tbl->arg);
 273
 274         if (col->width < sz)
 275                 col->width = sz;
 276 }
 277
 278 static void
 279 tblcalc_number(struct rofftbl *tbl, struct roffcol *col,
 280                 const struct tbl_opts *opts, const struct tbl_dat *dp)
 281 {
 282         int              i;
 283         size_t           sz, psz, ssz, d;
 284         const char      *str;
 285         char            *cp;
 286         char             buf[2];
 287
 288         /*
 289          * First calculate number width and decimal place (last + 1 for
 290          * non-decimal numbers).  If the stored decimal is subsequent to
 291          * ours, make our size longer by that difference
 292          * (right-"shifting"); similarly, if ours is subsequent the
 293          * stored, then extend the stored size by the difference.
 294          * Finally, re-assign the stored values.
 295          */
 296
 297         str = dp->string ? dp->string : "";
 298         sz = (*tbl->slen)(str, tbl->arg);
 299
 300         /* FIXME: TBL_DATA_HORIZ et al.? */
 301
 302         buf[0] = opts->decimal;
 303         buf[1] = '\0';
 304
 305         psz = (*tbl->slen)(buf, tbl->arg);
 306
 307         if (NULL != (cp = strrchr(str, opts->decimal))) {
 308                 buf[1] = '\0';
 309                 for (ssz = 0, i = 0; cp != &str[i]; i++) {
 310                         buf[0] = str[i];
 311                         ssz += (*tbl->slen)(buf, tbl->arg);
 312                 }
 313                 d = ssz + psz;
 314         } else
 315                 d = sz + psz;
 316
 317         /* Adjust the settings for this column. */
 318
 319         if (col->decimal > d) {
 320                 sz += col->decimal - d;
 321                 d = col->decimal;
 322         } else
 323                 col->width += d - col->decimal;
 324
 325         if (sz > col->width)
 326                 col->width = sz;
 327         if (d > col->decimal)
 328                 col->decimal = d;
 329 }