Print this page
5051 import mdocml-1.12.3
Reviewed by: Yuri Pankov <yuri.pankov@nexenta.com>
Approved by: TBD

Split Close
Expand all
Collapse all
          --- old/usr/src/cmd/mandoc/out.c
          +++ new/usr/src/cmd/mandoc/out.c
   1      -/*      $Id: out.c,v 1.43 2011/09/20 23:05:49 schwarze Exp $ */
        1 +/*      $Id: out.c,v 1.46 2013/10/05 20:30:05 schwarze Exp $ */
   2    2  /*
   3    3   * Copyright (c) 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv>
   4    4   * Copyright (c) 2011 Ingo Schwarze <schwarze@openbsd.org>
   5    5   *
   6    6   * Permission to use, copy, modify, and distribute this software for any
   7    7   * purpose with or without fee is hereby granted, provided that the above
   8    8   * copyright notice and this permission notice appear in all copies.
   9    9   *
  10   10   * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  11   11   * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
↓ open down ↓ 13 lines elided ↑ open up ↑
  25   25  #include <ctype.h>
  26   26  #include <stdio.h>
  27   27  #include <stdlib.h>
  28   28  #include <string.h>
  29   29  #include <time.h>
  30   30  
  31   31  #include "mandoc.h"
  32   32  #include "out.h"
  33   33  
  34   34  static  void    tblcalc_data(struct rofftbl *, struct roffcol *,
  35      -                        const struct tbl *, const struct tbl_dat *);
       35 +                        const struct tbl_opts *, const struct tbl_dat *);
  36   36  static  void    tblcalc_literal(struct rofftbl *, struct roffcol *,
  37   37                          const struct tbl_dat *);
  38   38  static  void    tblcalc_number(struct rofftbl *, struct roffcol *,
  39      -                        const struct tbl *, const struct tbl_dat *);
       39 +                        const struct tbl_opts *, const struct tbl_dat *);
  40   40  
  41   41  /* 
  42   42   * Convert a `scaling unit' to a consistent form, or fail.  Scaling
  43   43   * units are documented in groff.7, mdoc.7, man.7.
  44   44   */
  45   45  int
  46   46  a2roffsu(const char *src, struct roffsu *dst, enum roffscale def)
  47   47  {
  48   48          char             buf[BUFSIZ], hasd;
  49   49          int              i;
↓ open down ↓ 85 lines elided ↑ open up ↑
 135  135  /*
 136  136   * Calculate the abstract widths and decimal positions of columns in a
 137  137   * table.  This routine allocates the columns structures then runs over
 138  138   * all rows and cells in the table.  The function pointers in "tbl" are
 139  139   * used for the actual width calculations.
 140  140   */
 141  141  void
 142  142  tblcalc(struct rofftbl *tbl, const struct tbl_span *sp)
 143  143  {
 144  144          const struct tbl_dat    *dp;
 145      -        const struct tbl_head   *hp;
 146  145          struct roffcol          *col;
 147  146          int                      spans;
 148  147  
 149  148          /*
 150  149           * Allocate the master column specifiers.  These will hold the
 151  150           * widths and decimal positions for all cells in the column.  It
 152  151           * must be freed and nullified by the caller.
 153  152           */
 154  153  
 155  154          assert(NULL == tbl->cols);
 156  155          tbl->cols = mandoc_calloc
 157      -                ((size_t)sp->tbl->cols, sizeof(struct roffcol));
      156 +                ((size_t)sp->opts->cols, sizeof(struct roffcol));
 158  157  
 159      -        hp = sp->head;
 160      -
 161  158          for ( ; sp; sp = sp->next) {
 162  159                  if (TBL_SPAN_DATA != sp->pos)
 163  160                          continue;
 164  161                  spans = 1;
 165  162                  /*
 166  163                   * Account for the data cells in the layout, matching it
 167  164                   * to data cells in the data section.
 168  165                   */
 169  166                  for (dp = sp->first; dp; dp = dp->next) {
 170  167                          /* Do not used spanned cells in the calculation. */
 171  168                          if (0 < --spans)
 172  169                                  continue;
 173  170                          spans = dp->spans;
 174  171                          if (1 < spans)
 175  172                                  continue;
 176  173                          assert(dp->layout);
 177  174                          col = &tbl->cols[dp->layout->head->ident];
 178      -                        tblcalc_data(tbl, col, sp->tbl, dp);
      175 +                        tblcalc_data(tbl, col, sp->opts, dp);
 179  176                  }
 180  177          }
 181      -
 182      -        /* 
 183      -         * Calculate width of the spanners.  These get one space for a
 184      -         * vertical line, two for a double-vertical line. 
 185      -         */
 186      -
 187      -        for ( ; hp; hp = hp->next) {
 188      -                col = &tbl->cols[hp->ident];
 189      -                switch (hp->pos) {
 190      -                case (TBL_HEAD_VERT):
 191      -                        col->width = (*tbl->len)(1, tbl->arg);
 192      -                        break;
 193      -                case (TBL_HEAD_DVERT):
 194      -                        col->width = (*tbl->len)(2, tbl->arg);
 195      -                        break;
 196      -                default:
 197      -                        break;
 198      -                }
 199      -        }
 200  178  }
 201  179  
 202  180  static void
 203  181  tblcalc_data(struct rofftbl *tbl, struct roffcol *col,
 204      -                const struct tbl *tp, const struct tbl_dat *dp)
      182 +                const struct tbl_opts *opts, const struct tbl_dat *dp)
 205  183  {
 206  184          size_t           sz;
 207  185  
 208  186          /* Branch down into data sub-types. */
 209  187  
 210  188          switch (dp->layout->pos) {
 211  189          case (TBL_CELL_HORIZ):
 212  190                  /* FALLTHROUGH */
 213  191          case (TBL_CELL_DHORIZ):
 214  192                  sz = (*tbl->len)(1, tbl->arg);
↓ open down ↓ 3 lines elided ↑ open up ↑
 218  196          case (TBL_CELL_LONG):
 219  197                  /* FALLTHROUGH */
 220  198          case (TBL_CELL_CENTRE):
 221  199                  /* FALLTHROUGH */
 222  200          case (TBL_CELL_LEFT):
 223  201                  /* FALLTHROUGH */
 224  202          case (TBL_CELL_RIGHT):
 225  203                  tblcalc_literal(tbl, col, dp);
 226  204                  break;
 227  205          case (TBL_CELL_NUMBER):
 228      -                tblcalc_number(tbl, col, tp, dp);
      206 +                tblcalc_number(tbl, col, opts, dp);
 229  207                  break;
 230  208          case (TBL_CELL_DOWN):
 231  209                  break;
 232  210          default:
 233  211                  abort();
 234  212                  /* NOTREACHED */
 235  213          }
 236  214  }
 237  215  
 238  216  static void
↓ open down ↓ 5 lines elided ↑ open up ↑
 244  222  
 245  223          str = dp->string ? dp->string : "";
 246  224          sz = (*tbl->slen)(str, tbl->arg);
 247  225  
 248  226          if (col->width < sz)
 249  227                  col->width = sz;
 250  228  }
 251  229  
 252  230  static void
 253  231  tblcalc_number(struct rofftbl *tbl, struct roffcol *col,
 254      -                const struct tbl *tp, const struct tbl_dat *dp)
      232 +                const struct tbl_opts *opts, const struct tbl_dat *dp)
 255  233  {
 256  234          int              i;
 257  235          size_t           sz, psz, ssz, d;
 258  236          const char      *str;
 259  237          char            *cp;
 260  238          char             buf[2];
 261  239  
 262  240          /*
 263  241           * First calculate number width and decimal place (last + 1 for
 264  242           * non-decimal numbers).  If the stored decimal is subsequent to
↓ open down ↓ 1 lines elided ↑ open up ↑
 266  244           * (right-"shifting"); similarly, if ours is subsequent the
 267  245           * stored, then extend the stored size by the difference.
 268  246           * Finally, re-assign the stored values.
 269  247           */
 270  248  
 271  249          str = dp->string ? dp->string : "";
 272  250          sz = (*tbl->slen)(str, tbl->arg);
 273  251  
 274  252          /* FIXME: TBL_DATA_HORIZ et al.? */
 275  253  
 276      -        buf[0] = tp->decimal;
      254 +        buf[0] = opts->decimal;
 277  255          buf[1] = '\0';
 278  256  
 279  257          psz = (*tbl->slen)(buf, tbl->arg);
 280  258  
 281      -        if (NULL != (cp = strrchr(str, tp->decimal))) {
      259 +        if (NULL != (cp = strrchr(str, opts->decimal))) {
 282  260                  buf[1] = '\0';
 283  261                  for (ssz = 0, i = 0; cp != &str[i]; i++) {
 284  262                          buf[0] = str[i];
 285  263                          ssz += (*tbl->slen)(buf, tbl->arg);
 286  264                  }
 287  265                  d = ssz + psz;
 288  266          } else
 289  267                  d = sz + psz;
 290  268  
 291  269          /* Adjust the settings for this column. */
↓ open down ↓ 12 lines elided ↑ open up ↑
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX