tbl_term.c

   1 /*      $Id: tbl_term.c,v 1.50 2017/06/12 22:49:16 schwarze Exp $ */
   2 /*
   3  * Copyright (c) 2009, 2011 Kristaps Dzonsons <kristaps@bsd.lv>
   4  * Copyright (c) 2011,2012,2014,2015,2017 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 <stdio.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26
  27 #include "mandoc.h"
  28 #include "out.h"
  29 #include "term.h"
  30
  31 static  size_t  term_tbl_len(size_t, void *);
  32 static  size_t  term_tbl_strlen(const char *, void *);
  33 static  size_t  term_tbl_sulen(const struct roffsu *, void *);
  34 static  void    tbl_char(struct termp *, char, size_t);
  35 static  void    tbl_data(struct termp *, const struct tbl_opts *,
  36                         const struct tbl_dat *,
  37                         const struct roffcol *);
  38 static  void    tbl_literal(struct termp *, const struct tbl_dat *,
  39                         const struct roffcol *);
  40 static  void    tbl_number(struct termp *, const struct tbl_opts *,
  41                         const struct tbl_dat *,
  42                         const struct roffcol *);
  43 static  void    tbl_hrule(struct termp *, const struct tbl_span *, int);
  44 static  void    tbl_word(struct termp *, const struct tbl_dat *);
  45
  46
  47 static size_t
  48 term_tbl_sulen(const struct roffsu *su, void *arg)
  49 {
  50         return term_hspan((const struct termp *)arg, su) / 24;
  51 }
  52
  53 static size_t
  54 term_tbl_strlen(const char *p, void *arg)
  55 {
  56         return term_strlen((const struct termp *)arg, p);
  57 }
  58
  59 static size_t
  60 term_tbl_len(size_t sz, void *arg)
  61 {
  62         return term_len((const struct termp *)arg, sz);
  63 }
  64
  65 void
  66 term_tbl(struct termp *tp, const struct tbl_span *sp)
  67 {
  68         const struct tbl_cell   *cp;
  69         const struct tbl_dat    *dp;
  70         static size_t            offset;
  71         size_t                   coloff, tsz;
  72         int                      ic, horiz, spans, vert, more;
  73         char                     fc;
  74
  75         /* Inhibit printing of spaces: we do padding ourselves. */
  76
  77         tp->flags |= TERMP_NOSPACE | TERMP_NONOSPACE;
  78
  79         /*
  80          * The first time we're invoked for a given table block,
  81          * calculate the table widths and decimal positions.
  82          */
  83
  84         if (tp->tbl.cols == NULL) {
  85                 tp->tbl.len = term_tbl_len;
  86                 tp->tbl.slen = term_tbl_strlen;
  87                 tp->tbl.sulen = term_tbl_sulen;
  88                 tp->tbl.arg = tp;
  89
  90                 tblcalc(&tp->tbl, sp, tp->tcol->offset, tp->tcol->rmargin);
  91
  92                 /* Center the table as a whole. */
  93
  94                 offset = tp->tcol->offset;
  95                 if (sp->opts->opts & TBL_OPT_CENTRE) {
  96                         tsz = sp->opts->opts & (TBL_OPT_BOX | TBL_OPT_DBOX)
  97                             ? 2 : !!sp->opts->lvert + !!sp->opts->rvert;
  98                         for (ic = 0; ic < sp->opts->cols; ic++)
  99                                 tsz += tp->tbl.cols[ic].width + 3;
 100                         tsz -= 3;
 101                         if (offset + tsz > tp->tcol->rmargin)
 102                                 tsz -= 1;
 103                         tp->tcol->offset = offset + tp->tcol->rmargin > tsz ?
 104                             (offset + tp->tcol->rmargin - tsz) / 2 : 0;
 105                 }
 106
 107                 /* Horizontal frame at the start of boxed tables. */
 108
 109                 if (sp->opts->opts & TBL_OPT_DBOX)
 110                         tbl_hrule(tp, sp, 2);
 111                 if (sp->opts->opts & (TBL_OPT_DBOX | TBL_OPT_BOX))
 112                         tbl_hrule(tp, sp, 1);
 113         }
 114
 115         /* Set up the columns. */
 116
 117         tp->flags |= TERMP_MULTICOL;
 118         horiz = 0;
 119         switch (sp->pos) {
 120         case TBL_SPAN_HORIZ:
 121         case TBL_SPAN_DHORIZ:
 122                 horiz = 1;
 123                 term_setcol(tp, 1);
 124                 break;
 125         case TBL_SPAN_DATA:
 126                 term_setcol(tp, sp->opts->cols + 2);
 127                 coloff = tp->tcol->offset;
 128
 129                 /* Set up a column for a left vertical frame. */
 130
 131                 if (sp->opts->opts & (TBL_OPT_BOX | TBL_OPT_DBOX) ||
 132                     sp->opts->lvert)
 133                         coloff++;
 134                 tp->tcol->rmargin = coloff;
 135
 136                 /* Set up the data columns. */
 137
 138                 dp = sp->first;
 139                 spans = 0;
 140                 for (ic = 0; ic < sp->opts->cols; ic++) {
 141                         if (spans == 0) {
 142                                 tp->tcol++;
 143                                 tp->tcol->offset = coloff;
 144                         }
 145                         coloff += tp->tbl.cols[ic].width;
 146                         tp->tcol->rmargin = coloff;
 147                         coloff++;
 148                         if (ic + 1 < sp->opts->cols)
 149                                 coloff += 2;
 150                         if (spans) {
 151                                 spans--;
 152                                 continue;
 153                         }
 154                         if (dp == NULL)
 155                                 continue;
 156                         spans = dp->spans;
 157                         dp = dp->next;
 158                 }
 159
 160                 /* Set up a column for a right vertical frame. */
 161
 162                 tp->tcol++;
 163                 tp->tcol->offset = coloff;
 164                 if (sp->opts->opts & (TBL_OPT_BOX | TBL_OPT_DBOX) ||
 165                     sp->opts->rvert)
 166                         coloff++;
 167                 tp->tcol->rmargin = coloff;
 168
 169                 /* Spans may have reduced the number of columns. */
 170
 171                 tp->lasttcol = tp->tcol - tp->tcols;
 172
 173                 /* Fill the buffers for all data columns. */
 174
 175                 tp->tcol = tp->tcols;
 176                 dp = sp->first;
 177                 spans = 0;
 178                 for (ic = 0; ic < sp->opts->cols; ic++) {
 179                         if (spans) {
 180                                 spans--;
 181                                 continue;
 182                         }
 183                         tp->tcol++;
 184                         tp->col = 0;
 185                         tbl_data(tp, sp->opts, dp, tp->tbl.cols + ic);
 186                         if (dp == NULL)
 187                                 continue;
 188                         spans = dp->spans;
 189                         dp = dp->next;
 190                 }
 191                 break;
 192         }
 193
 194         do {
 195                 /* Print the vertical frame at the start of each row. */
 196
 197                 tp->tcol = tp->tcols;
 198                 fc = '\0';
 199                 if (sp->layout->vert ||
 200                     (sp->prev != NULL && sp->prev->layout->vert) ||
 201                     sp->opts->opts & (TBL_OPT_BOX | TBL_OPT_DBOX))
 202                         fc = horiz ? '+' : '|';
 203                 else if (horiz && sp->opts->lvert)
 204                         fc = '-';
 205                 if (fc != '\0') {
 206                         (*tp->advance)(tp, tp->tcols->offset);
 207                         (*tp->letter)(tp, fc);
 208                         tp->viscol = tp->tcol->offset + 1;
 209                 }
 210
 211                 /* Print the data cells. */
 212
 213                 more = 0;
 214                 if (horiz) {
 215                         tbl_hrule(tp, sp, 0);
 216                         term_flushln(tp);
 217                 } else {
 218                         cp = sp->layout->first;
 219                         dp = sp->first;
 220                         spans = 0;
 221                         for (ic = 0; ic < sp->opts->cols; ic++) {
 222                                 if (spans == 0) {
 223                                         tp->tcol++;
 224                                         if (dp != NULL) {
 225                                                 spans = dp->spans;
 226                                                 dp = dp->next;
 227                                         }
 228                                         if (tp->tcol->col < tp->tcol->lastcol)
 229                                                 term_flushln(tp);
 230                                         if (tp->tcol->col < tp->tcol->lastcol)
 231                                                 more = 1;
 232                                         if (tp->tcol + 1 ==
 233                                             tp->tcols + tp->lasttcol)
 234                                                 continue;
 235                                 } else
 236                                         spans--;
 237
 238                                 /* Vertical frames between data cells. */
 239
 240                                 if (cp != NULL) {
 241                                         vert = cp->vert;
 242                                         cp = cp->next;
 243                                 } else
 244                                         vert = 0;
 245                                 if (vert == 0 &&
 246                                     sp->opts->opts & TBL_OPT_ALLBOX)
 247                                         vert = 1;
 248                                 if (vert == 0)
 249                                         continue;
 250
 251                                 if (tp->tcol->rmargin + 1 > tp->viscol) {
 252                                         (*tp->advance)(tp, tp->tcol->rmargin
 253                                            + 1 - tp->viscol);
 254                                         tp->viscol = tp->tcol->rmargin + 1;
 255                                 }
 256                                 while (vert--) {
 257                                         (*tp->letter)(tp, '|');
 258                                         tp->viscol++;
 259                                 }
 260                         }
 261                 }
 262
 263                 /* Print the vertical frame at the end of each row. */
 264
 265                 fc = '\0';
 266                 if (sp->layout->last->vert ||
 267                     (sp->prev != NULL && sp->prev->layout->last->vert) ||
 268                     (sp->opts->opts & (TBL_OPT_BOX | TBL_OPT_DBOX)))
 269                         fc = horiz ? '+' : '|';
 270                 else if (horiz && sp->opts->rvert)
 271                         fc = '-';
 272                 if (fc != '\0') {
 273                         if (horiz == 0) {
 274                                 tp->tcol++;
 275                                 (*tp->advance)(tp,
 276                                     tp->tcol->offset > tp->viscol ?
 277                                     tp->tcol->offset - tp->viscol : 1);
 278                         }
 279                         (*tp->letter)(tp, fc);
 280                 }
 281                 (*tp->endline)(tp);
 282                 tp->viscol = 0;
 283         } while (more);
 284
 285         /*
 286          * If we're the last row, clean up after ourselves: clear the
 287          * existing table configuration and set it to NULL.
 288          */
 289
 290         term_setcol(tp, 1);
 291         tp->flags &= ~TERMP_MULTICOL;
 292         tp->tcol->rmargin = tp->maxrmargin;
 293         if (sp->next == NULL) {
 294                 if (sp->opts->opts & (TBL_OPT_DBOX | TBL_OPT_BOX)) {
 295                         tbl_hrule(tp, sp, 1);
 296                         tp->skipvsp = 1;
 297                 }
 298                 if (sp->opts->opts & TBL_OPT_DBOX) {
 299                         tbl_hrule(tp, sp, 2);
 300                         tp->skipvsp = 2;
 301                 }
 302                 assert(tp->tbl.cols);
 303                 free(tp->tbl.cols);
 304                 tp->tbl.cols = NULL;
 305                 tp->tcol->offset = offset;
 306         } else if (horiz == 0 && sp->opts->opts & TBL_OPT_ALLBOX &&
 307             (sp->next == NULL || sp->next->pos == TBL_SPAN_DATA ||
 308              sp->next->next != NULL))
 309                 tbl_hrule(tp, sp, 1);
 310
 311         tp->flags &= ~TERMP_NONOSPACE;
 312 }
 313
 314 /*
 315  * Kinds of horizontal rulers:
 316  * 0: inside the table (single or double line with crossings)
 317  * 1: inner frame (single line with crossings and ends)
 318  * 2: outer frame (single line without crossings with ends)
 319  */
 320 static void
 321 tbl_hrule(struct termp *tp, const struct tbl_span *sp, int kind)
 322 {
 323         const struct tbl_cell *c1, *c2;
 324         int      vert;
 325         char     line, cross;
 326
 327         line = (kind == 0 && TBL_SPAN_DHORIZ == sp->pos) ? '=' : '-';
 328         cross = (kind < 2) ? '+' : '-';
 329
 330         if (kind)
 331                 term_word(tp, "+");
 332         c1 = sp->layout->first;
 333         c2 = sp->prev == NULL ? NULL : sp->prev->layout->first;
 334         if (c2 == c1)
 335                 c2 = NULL;
 336         for (;;) {
 337                 tbl_char(tp, line, tp->tbl.cols[c1->col].width + 1);
 338                 vert = c1->vert;
 339                 if ((c1 = c1->next) == NULL)
 340                          break;
 341                 if (c2 != NULL) {
 342                         if (vert < c2->vert)
 343                                 vert = c2->vert;
 344                         c2 = c2->next;
 345                 }
 346                 if (sp->opts->opts & TBL_OPT_ALLBOX && !vert)
 347                         vert = 1;
 348                 if (vert)
 349                         tbl_char(tp, cross, vert);
 350                 if (vert < 2)
 351                         tbl_char(tp, line, 2 - vert);
 352         }
 353         if (kind) {
 354                 term_word(tp, "+");
 355                 term_flushln(tp);
 356         }
 357 }
 358
 359 static void
 360 tbl_data(struct termp *tp, const struct tbl_opts *opts,
 361         const struct tbl_dat *dp,
 362         const struct roffcol *col)
 363 {
 364
 365         if (dp == NULL) {
 366                 tbl_char(tp, ASCII_NBRSP, col->width);
 367                 return;
 368         }
 369
 370         switch (dp->pos) {
 371         case TBL_DATA_NONE:
 372                 tbl_char(tp, ASCII_NBRSP, col->width);
 373                 return;
 374         case TBL_DATA_HORIZ:
 375         case TBL_DATA_NHORIZ:
 376                 tbl_char(tp, '-', col->width);
 377                 return;
 378         case TBL_DATA_NDHORIZ:
 379         case TBL_DATA_DHORIZ:
 380                 tbl_char(tp, '=', col->width);
 381                 return;
 382         default:
 383                 break;
 384         }
 385
 386         switch (dp->layout->pos) {
 387         case TBL_CELL_HORIZ:
 388                 tbl_char(tp, '-', col->width);
 389                 break;
 390         case TBL_CELL_DHORIZ:
 391                 tbl_char(tp, '=', col->width);
 392                 break;
 393         case TBL_CELL_LONG:
 394         case TBL_CELL_CENTRE:
 395         case TBL_CELL_LEFT:
 396         case TBL_CELL_RIGHT:
 397                 tbl_literal(tp, dp, col);
 398                 break;
 399         case TBL_CELL_NUMBER:
 400                 tbl_number(tp, opts, dp, col);
 401                 break;
 402         case TBL_CELL_DOWN:
 403                 tbl_char(tp, ASCII_NBRSP, col->width);
 404                 break;
 405         default:
 406                 abort();
 407         }
 408 }
 409
 410 static void
 411 tbl_char(struct termp *tp, char c, size_t len)
 412 {
 413         size_t          i, sz;
 414         char            cp[2];
 415
 416         cp[0] = c;
 417         cp[1] = '\0';
 418
 419         sz = term_strlen(tp, cp);
 420
 421         for (i = 0; i < len; i += sz)
 422                 term_word(tp, cp);
 423 }
 424
 425 static void
 426 tbl_literal(struct termp *tp, const struct tbl_dat *dp,
 427                 const struct roffcol *col)
 428 {
 429         size_t           len, padl, padr, width;
 430         int              ic, spans;
 431
 432         assert(dp->string);
 433         len = term_strlen(tp, dp->string);
 434         width = col->width;
 435         ic = dp->layout->col;
 436         spans = dp->spans;
 437         while (spans--)
 438                 width += tp->tbl.cols[++ic].width + 3;
 439
 440         padr = width > len ? width - len : 0;
 441         padl = 0;
 442
 443         switch (dp->layout->pos) {
 444         case TBL_CELL_LONG:
 445                 padl = term_len(tp, 1);
 446                 padr = padr > padl ? padr - padl : 0;
 447                 break;
 448         case TBL_CELL_CENTRE:
 449                 if (2 > padr)
 450                         break;
 451                 padl = padr / 2;
 452                 padr -= padl;
 453                 break;
 454         case TBL_CELL_RIGHT:
 455                 padl = padr;
 456                 padr = 0;
 457                 break;
 458         default:
 459                 break;
 460         }
 461
 462         tbl_char(tp, ASCII_NBRSP, padl);
 463         tbl_word(tp, dp);
 464         tbl_char(tp, ASCII_NBRSP, padr);
 465 }
 466
 467 static void
 468 tbl_number(struct termp *tp, const struct tbl_opts *opts,
 469                 const struct tbl_dat *dp,
 470                 const struct roffcol *col)
 471 {
 472         char            *cp;
 473         char             buf[2];
 474         size_t           sz, psz, ssz, d, padl;
 475         int              i;
 476
 477         /*
 478          * See calc_data_number().  Left-pad by taking the offset of our
 479          * and the maximum decimal; right-pad by the remaining amount.
 480          */
 481
 482         assert(dp->string);
 483
 484         sz = term_strlen(tp, dp->string);
 485
 486         buf[0] = opts->decimal;
 487         buf[1] = '\0';
 488
 489         psz = term_strlen(tp, buf);
 490
 491         if ((cp = strrchr(dp->string, opts->decimal)) != NULL) {
 492                 for (ssz = 0, i = 0; cp != &dp->string[i]; i++) {
 493                         buf[0] = dp->string[i];
 494                         ssz += term_strlen(tp, buf);
 495                 }
 496                 d = ssz + psz;
 497         } else
 498                 d = sz + psz;
 499
 500         if (col->decimal > d && col->width > sz) {
 501                 padl = col->decimal - d;
 502                 if (padl + sz > col->width)
 503                         padl = col->width - sz;
 504                 tbl_char(tp, ASCII_NBRSP, padl);
 505         } else
 506                 padl = 0;
 507         tbl_word(tp, dp);
 508         if (col->width > sz + padl)
 509                 tbl_char(tp, ASCII_NBRSP, col->width - sz - padl);
 510 }
 511
 512 static void
 513 tbl_word(struct termp *tp, const struct tbl_dat *dp)
 514 {
 515         int              prev_font;
 516
 517         prev_font = tp->fonti;
 518         if (dp->layout->flags & TBL_CELL_BOLD)
 519                 term_fontpush(tp, TERMFONT_BOLD);
 520         else if (dp->layout->flags & TBL_CELL_ITALIC)
 521                 term_fontpush(tp, TERMFONT_UNDER);
 522
 523         term_word(tp, dp->string);
 524
 525         term_fontpopq(tp, prev_font);
 526 }