out.c

   1 /*      $Id: out.c,v 1.72 2018/08/18 20:18:14 schwarze Exp $ */
   2 /*
   3  * Copyright (c) 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv>
   4  * Copyright (c) 2011,2014,2015,2017,2018 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 <stdint.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include <time.h>
  27
  28 #include "mandoc_aux.h"
  29 #include "mandoc.h"
  30 #include "out.h"
  31
  32 static  void    tblcalc_data(struct rofftbl *, struct roffcol *,
  33                         const struct tbl_opts *, const struct tbl_dat *,
  34                         size_t);
  35 static  void    tblcalc_literal(struct rofftbl *, struct roffcol *,
  36                         const struct tbl_dat *, size_t);
  37 static  void    tblcalc_number(struct rofftbl *, struct roffcol *,
  38                         const struct tbl_opts *, const struct tbl_dat *);
  39
  40
  41 /*
  42  * Parse the *src string and store a scaling unit into *dst.
  43  * If the string doesn't specify the unit, use the default.
  44  * If no default is specified, fail.
  45  * Return a pointer to the byte after the last byte used,
  46  * or NULL on total failure.
  47  */
  48 const char *
  49 a2roffsu(const char *src, struct roffsu *dst, enum roffscale def)
  50 {
  51         char            *endptr;
  52
  53         dst->unit = def == SCALE_MAX ? SCALE_BU : def;
  54         dst->scale = strtod(src, &endptr);
  55         if (endptr == src)
  56                 return NULL;
  57
  58         switch (*endptr++) {
  59         case 'c':
  60                 dst->unit = SCALE_CM;
  61                 break;
  62         case 'i':
  63                 dst->unit = SCALE_IN;
  64                 break;
  65         case 'f':
  66                 dst->unit = SCALE_FS;
  67                 break;
  68         case 'M':
  69                 dst->unit = SCALE_MM;
  70                 break;
  71         case 'm':
  72                 dst->unit = SCALE_EM;
  73                 break;
  74         case 'n':
  75                 dst->unit = SCALE_EN;
  76                 break;
  77         case 'P':
  78                 dst->unit = SCALE_PC;
  79                 break;
  80         case 'p':
  81                 dst->unit = SCALE_PT;
  82                 break;
  83         case 'u':
  84                 dst->unit = SCALE_BU;
  85                 break;
  86         case 'v':
  87                 dst->unit = SCALE_VS;
  88                 break;
  89         default:
  90                 endptr--;
  91                 if (SCALE_MAX == def)
  92                         return NULL;
  93                 dst->unit = def;
  94                 break;
  95         }
  96         return endptr;
  97 }
  98
  99 /*
 100  * Calculate the abstract widths and decimal positions of columns in a
 101  * table.  This routine allocates the columns structures then runs over
 102  * all rows and cells in the table.  The function pointers in "tbl" are
 103  * used for the actual width calculations.
 104  */
 105 void
 106 tblcalc(struct rofftbl *tbl, const struct tbl_span *sp,
 107     size_t offset, size_t rmargin)
 108 {
 109         struct roffsu            su;
 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                         while (maxcol < icol)
 145                                 tbl->cols[++maxcol].spacing = SIZE_MAX;
 146                         col = tbl->cols + icol;
 147                         col->flags |= dp->layout->flags;
 148                         if (dp->layout->flags & TBL_CELL_WIGN)
 149                                 continue;
 150                         if (dp->layout->wstr != NULL &&
 151                             dp->layout->width == 0 &&
 152                             a2roffsu(dp->layout->wstr, &su, SCALE_EN)
 153                             != NULL)
 154                                 dp->layout->width =
 155                                     (*tbl->sulen)(&su, tbl->arg);
 156                         if (col->width < dp->layout->width)
 157                                 col->width = dp->layout->width;
 158                         if (dp->layout->spacing != SIZE_MAX &&
 159                             (col->spacing == SIZE_MAX ||
 160                              col->spacing < dp->layout->spacing))
 161                                 col->spacing = dp->layout->spacing;
 162                         tblcalc_data(tbl, col, opts, dp,
 163                             dp->block == 0 ? 0 :
 164                             dp->layout->width ? dp->layout->width :
 165                             rmargin ? (rmargin + sp->opts->cols / 2)
 166                             / (sp->opts->cols + 1) : 0);
 167                 }
 168         }
 169
 170         /*
 171          * Align numbers with text.
 172          * Count columns to equalize and columns to maximize.
 173          * Find maximum width of the columns to equalize.
 174          * Find total width of the columns *not* to maximize.
 175          */
 176
 177         necol = nxcol = 0;
 178         ewidth = xwidth = 0;
 179         for (icol = 0; icol <= maxcol; icol++) {
 180                 col = tbl->cols + icol;
 181                 if (col->width > col->nwidth)
 182                         col->decimal += (col->width - col->nwidth) / 2;
 183                 else
 184                         col->width = col->nwidth;
 185                 if (col->spacing == SIZE_MAX || icol == maxcol)
 186                         col->spacing = 3;
 187                 if (col->flags & TBL_CELL_EQUAL) {
 188                         necol++;
 189                         if (ewidth < col->width)
 190                                 ewidth = col->width;
 191                 }
 192                 if (col->flags & TBL_CELL_WMAX)
 193                         nxcol++;
 194                 else
 195                         xwidth += col->width;
 196         }
 197
 198         /*
 199          * Equalize columns, if requested for any of them.
 200          * Update total width of the columns not to maximize.
 201          */
 202
 203         if (necol) {
 204                 for (icol = 0; icol <= maxcol; icol++) {
 205                         col = tbl->cols + icol;
 206                         if ( ! (col->flags & TBL_CELL_EQUAL))
 207                                 continue;
 208                         if (col->width == ewidth)
 209                                 continue;
 210                         if (nxcol && rmargin)
 211                                 xwidth += ewidth - col->width;
 212                         col->width = ewidth;
 213                 }
 214         }
 215
 216         /*
 217          * If there are any columns to maximize, find the total
 218          * available width, deducting 3n margins between columns.
 219          * Distribute the available width evenly.
 220          */
 221
 222         if (nxcol && rmargin) {
 223                 xwidth += 3*maxcol +
 224                     (opts->opts & (TBL_OPT_BOX | TBL_OPT_DBOX) ?
 225                      2 : !!opts->lvert + !!opts->rvert);
 226                 if (rmargin <= offset + xwidth)
 227                         return;
 228                 xwidth = rmargin - offset - xwidth;
 229
 230                 /*
 231                  * Emulate a bug in GNU tbl width calculation that
 232                  * manifests itself for large numbers of x-columns.
 233                  * Emulating it for 5 x-columns gives identical
 234                  * behaviour for up to 6 x-columns.
 235                  */
 236
 237                 if (nxcol == 5) {
 238                         quirkcol = xwidth % nxcol + 2;
 239                         if (quirkcol != 3 && quirkcol != 4)
 240                                 quirkcol = -1;
 241                 } else
 242                         quirkcol = -1;
 243
 244                 necol = 0;
 245                 ewidth = 0;
 246                 for (icol = 0; icol <= maxcol; icol++) {
 247                         col = tbl->cols + icol;
 248                         if ( ! (col->flags & TBL_CELL_WMAX))
 249                                 continue;
 250                         col->width = (double)xwidth * ++necol / nxcol
 251                             - ewidth + 0.4995;
 252                         if (necol == quirkcol)
 253                                 col->width--;
 254                         ewidth += col->width;
 255                 }
 256         }
 257 }
 258
 259 static void
 260 tblcalc_data(struct rofftbl *tbl, struct roffcol *col,
 261     const struct tbl_opts *opts, const struct tbl_dat *dp, size_t mw)
 262 {
 263         size_t           sz;
 264
 265         /* Branch down into data sub-types. */
 266
 267         switch (dp->layout->pos) {
 268         case TBL_CELL_HORIZ:
 269         case TBL_CELL_DHORIZ:
 270                 sz = (*tbl->len)(1, tbl->arg);
 271                 if (col->width < sz)
 272                         col->width = sz;
 273                 break;
 274         case TBL_CELL_LONG:
 275         case TBL_CELL_CENTRE:
 276         case TBL_CELL_LEFT:
 277         case TBL_CELL_RIGHT:
 278                 tblcalc_literal(tbl, col, dp, mw);
 279                 break;
 280         case TBL_CELL_NUMBER:
 281                 tblcalc_number(tbl, col, opts, dp);
 282                 break;
 283         case TBL_CELL_DOWN:
 284                 break;
 285         default:
 286                 abort();
 287         }
 288 }
 289
 290 static void
 291 tblcalc_literal(struct rofftbl *tbl, struct roffcol *col,
 292     const struct tbl_dat *dp, size_t mw)
 293 {
 294         const char      *str;   /* Beginning of the first line. */
 295         const char      *beg;   /* Beginning of the current line. */
 296         char            *end;   /* End of the current line. */
 297         size_t           lsz;   /* Length of the current line. */
 298         size_t           wsz;   /* Length of the current word. */
 299
 300         if (dp->string == NULL || *dp->string == '\0')
 301                 return;
 302         str = mw ? mandoc_strdup(dp->string) : dp->string;
 303         lsz = 0;
 304         for (beg = str; beg != NULL && *beg != '\0'; beg = end) {
 305                 end = mw ? strchr(beg, ' ') : NULL;
 306                 if (end != NULL) {
 307                         *end++ = '\0';
 308                         while (*end == ' ')
 309                                 end++;
 310                 }
 311                 wsz = (*tbl->slen)(beg, tbl->arg);
 312                 if (mw && lsz && lsz + 1 + wsz <= mw)
 313                         lsz += 1 + wsz;
 314                 else
 315                         lsz = wsz;
 316                 if (col->width < lsz)
 317                         col->width = lsz;
 318         }
 319         if (mw)
 320                 free((void *)str);
 321 }
 322
 323 static void
 324 tblcalc_number(struct rofftbl *tbl, struct roffcol *col,
 325                 const struct tbl_opts *opts, const struct tbl_dat *dp)
 326 {
 327         int              i;
 328         size_t           sz, ssz, d;
 329         const char      *str;
 330         char            *cp;
 331         char             buf[2];
 332
 333         /*
 334          * First calculate number width and decimal place (last + 1 for
 335          * non-decimal numbers).  If the stored decimal is subsequent to
 336          * ours, make our size longer by that difference
 337          * (right-"shifting"); similarly, if ours is subsequent the
 338          * stored, then extend the stored size by the difference.
 339          * Finally, re-assign the stored values.
 340          */
 341
 342         str = dp->string ? dp->string : "";
 343         sz = (*tbl->slen)(str, tbl->arg);
 344
 345         /* FIXME: TBL_DATA_HORIZ et al.? */
 346
 347         buf[0] = opts->decimal;
 348         buf[1] = '\0';
 349
 350         if (NULL != (cp = strrchr(str, opts->decimal))) {
 351                 buf[1] = '\0';
 352                 for (ssz = 0, i = 0; cp != &str[i]; i++) {
 353                         buf[0] = str[i];
 354                         ssz += (*tbl->slen)(buf, tbl->arg);
 355                 }
 356                 d = ssz;
 357         } else
 358                 d = sz;
 359
 360         /* Adjust the settings for this column. */
 361
 362         if (col->decimal > d) {
 363                 sz += col->decimal - d;
 364                 d = col->decimal;
 365         } else
 366                 col->nwidth += d - col->decimal;
 367
 368         if (sz > col->nwidth)
 369                 col->nwidth = sz;
 370         if (d > col->decimal)
 371                 col->decimal = d;
 372 }