tbl_term.c

   1 /*      $Id: tbl_term.c,v 1.22 2012/05/27 17:54:54 schwarze Exp $ */
   2 /*
   3  * Copyright (c) 2009, 2011 Kristaps Dzonsons <kristaps@bsd.lv>
   4  * Copyright (c) 2011 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 #ifdef HAVE_CONFIG_H
  19 #include "config.h"
  20 #endif
  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  void    tbl_char(struct termp *, char, size_t);
  34 static  void    tbl_data(struct termp *, const struct tbl *,
  35                         const struct tbl_dat *,
  36                         const struct roffcol *);
  37 static  size_t  tbl_rulewidth(struct termp *, const struct tbl_head *);
  38 static  void    tbl_hframe(struct termp *, const struct tbl_span *, int);
  39 static  void    tbl_literal(struct termp *, const struct tbl_dat *,
  40                         const struct roffcol *);
  41 static  void    tbl_number(struct termp *, const struct tbl *,
  42                         const struct tbl_dat *,
  43                         const struct roffcol *);
  44 static  void    tbl_hrule(struct termp *, const struct tbl_span *);
  45 static  void    tbl_vrule(struct termp *, const struct tbl_head *);
  46
  47
  48 static size_t
  49 term_tbl_strlen(const char *p, void *arg)
  50 {
  51
  52         return(term_strlen((const struct termp *)arg, p));
  53 }
  54
  55 static size_t
  56 term_tbl_len(size_t sz, void *arg)
  57 {
  58
  59         return(term_len((const struct termp *)arg, sz));
  60 }
  61
  62 void
  63 term_tbl(struct termp *tp, const struct tbl_span *sp)
  64 {
  65         const struct tbl_head   *hp;
  66         const struct tbl_dat    *dp;
  67         struct roffcol          *col;
  68         int                      spans;
  69         size_t                   rmargin, maxrmargin;
  70
  71         rmargin = tp->rmargin;
  72         maxrmargin = tp->maxrmargin;
  73
  74         tp->rmargin = tp->maxrmargin = TERM_MAXMARGIN;
  75
  76         /* Inhibit printing of spaces: we do padding ourselves. */
  77
  78         tp->flags |= TERMP_NONOSPACE;
  79         tp->flags |= TERMP_NOSPACE;
  80
  81         /*
  82          * The first time we're invoked for a given table block,
  83          * calculate the table widths and decimal positions.
  84          */
  85
  86         if (TBL_SPAN_FIRST & sp->flags) {
  87                 term_flushln(tp);
  88
  89                 tp->tbl.len = term_tbl_len;
  90                 tp->tbl.slen = term_tbl_strlen;
  91                 tp->tbl.arg = tp;
  92
  93                 tblcalc(&tp->tbl, sp);
  94         }
  95
  96         /* Horizontal frame at the start of boxed tables. */
  97
  98         if (TBL_SPAN_FIRST & sp->flags) {
  99                 if (TBL_OPT_DBOX & sp->tbl->opts)
 100                         tbl_hframe(tp, sp, 1);
 101                 if (TBL_OPT_DBOX & sp->tbl->opts ||
 102                     TBL_OPT_BOX  & sp->tbl->opts)
 103                         tbl_hframe(tp, sp, 0);
 104         }
 105
 106         /* Vertical frame at the start of each row. */
 107
 108         if (TBL_OPT_BOX & sp->tbl->opts || TBL_OPT_DBOX & sp->tbl->opts)
 109                 term_word(tp, TBL_SPAN_HORIZ == sp->pos ||
 110                         TBL_SPAN_DHORIZ == sp->pos ? "+" : "|");
 111
 112         /*
 113          * Now print the actual data itself depending on the span type.
 114          * Spanner spans get a horizontal rule; data spanners have their
 115          * data printed by matching data to header.
 116          */
 117
 118         switch (sp->pos) {
 119         case (TBL_SPAN_HORIZ):
 120                 /* FALLTHROUGH */
 121         case (TBL_SPAN_DHORIZ):
 122                 tbl_hrule(tp, sp);
 123                 break;
 124         case (TBL_SPAN_DATA):
 125                 /* Iterate over template headers. */
 126                 dp = sp->first;
 127                 spans = 0;
 128                 for (hp = sp->head; hp; hp = hp->next) {
 129
 130                         /*
 131                          * If the current data header is invoked during
 132                          * a spanner ("spans" > 0), don't emit anything
 133                          * at all.
 134                          */
 135
 136                         if (--spans >= 0)
 137                                 continue;
 138
 139                         /* Separate columns. */
 140
 141                         if (NULL != hp->prev)
 142                                 tbl_vrule(tp, hp);
 143
 144                         col = &tp->tbl.cols[hp->ident];
 145                         tbl_data(tp, sp->tbl, dp, col);
 146
 147                         /*
 148                          * Go to the next data cell and assign the
 149                          * number of subsequent spans, if applicable.
 150                          */
 151
 152                         if (dp) {
 153                                 spans = dp->spans;
 154                                 dp = dp->next;
 155                         }
 156                 }
 157                 break;
 158         }
 159
 160         /* Vertical frame at the end of each row. */
 161
 162         if (TBL_OPT_BOX & sp->tbl->opts || TBL_OPT_DBOX & sp->tbl->opts)
 163                 term_word(tp, TBL_SPAN_HORIZ == sp->pos ||
 164                         TBL_SPAN_DHORIZ == sp->pos ? "+" : " |");
 165         term_flushln(tp);
 166
 167         /*
 168          * If we're the last row, clean up after ourselves: clear the
 169          * existing table configuration and set it to NULL.
 170          */
 171
 172         if (TBL_SPAN_LAST & sp->flags) {
 173                 if (TBL_OPT_DBOX & sp->tbl->opts ||
 174                     TBL_OPT_BOX  & sp->tbl->opts)
 175                         tbl_hframe(tp, sp, 0);
 176                 if (TBL_OPT_DBOX & sp->tbl->opts)
 177                         tbl_hframe(tp, sp, 1);
 178                 assert(tp->tbl.cols);
 179                 free(tp->tbl.cols);
 180                 tp->tbl.cols = NULL;
 181         }
 182
 183         tp->flags &= ~TERMP_NONOSPACE;
 184         tp->rmargin = rmargin;
 185         tp->maxrmargin = maxrmargin;
 186
 187 }
 188
 189 /*
 190  * Horizontal rules extend across the entire table.
 191  * Calculate the width by iterating over columns.
 192  */
 193 static size_t
 194 tbl_rulewidth(struct termp *tp, const struct tbl_head *hp)
 195 {
 196         size_t           width;
 197
 198         width = tp->tbl.cols[hp->ident].width;
 199
 200         /* Account for leading blanks. */
 201         if (hp->prev)
 202                 width += 2 - hp->vert;
 203
 204         /* Account for trailing blank. */
 205         width++;
 206
 207         return(width);
 208 }
 209
 210 /*
 211  * Rules inside the table can be single or double
 212  * and have crossings with vertical rules marked with pluses.
 213  */
 214 static void
 215 tbl_hrule(struct termp *tp, const struct tbl_span *sp)
 216 {
 217         const struct tbl_head *hp;
 218         char             c;
 219
 220         c = '-';
 221         if (TBL_SPAN_DHORIZ == sp->pos)
 222                 c = '=';
 223
 224         for (hp = sp->head; hp; hp = hp->next) {
 225                 if (hp->prev && hp->vert)
 226                         tbl_char(tp, '+', hp->vert);
 227                 tbl_char(tp, c, tbl_rulewidth(tp, hp));
 228         }
 229 }
 230
 231 /*
 232  * Rules above and below the table are always single
 233  * and have an additional plus at the beginning and end.
 234  * For double frames, this function is called twice,
 235  * and the outer one does not have crossings.
 236  */
 237 static void
 238 tbl_hframe(struct termp *tp, const struct tbl_span *sp, int outer)
 239 {
 240         const struct tbl_head *hp;
 241
 242         term_word(tp, "+");
 243         for (hp = sp->head; hp; hp = hp->next) {
 244                 if (hp->prev && hp->vert)
 245                         tbl_char(tp, (outer ? '-' : '+'), hp->vert);
 246                 tbl_char(tp, '-', tbl_rulewidth(tp, hp));
 247         }
 248         term_word(tp, "+");
 249         term_flushln(tp);
 250 }
 251
 252 static void
 253 tbl_data(struct termp *tp, const struct tbl *tbl,
 254                 const struct tbl_dat *dp,
 255                 const struct roffcol *col)
 256 {
 257
 258         if (NULL == dp) {
 259                 tbl_char(tp, ASCII_NBRSP, col->width);
 260                 return;
 261         }
 262         assert(dp->layout);
 263
 264         switch (dp->pos) {
 265         case (TBL_DATA_NONE):
 266                 tbl_char(tp, ASCII_NBRSP, col->width);
 267                 return;
 268         case (TBL_DATA_HORIZ):
 269                 /* FALLTHROUGH */
 270         case (TBL_DATA_NHORIZ):
 271                 tbl_char(tp, '-', col->width);
 272                 return;
 273         case (TBL_DATA_NDHORIZ):
 274                 /* FALLTHROUGH */
 275         case (TBL_DATA_DHORIZ):
 276                 tbl_char(tp, '=', col->width);
 277                 return;
 278         default:
 279                 break;
 280         }
 281
 282         switch (dp->layout->pos) {
 283         case (TBL_CELL_HORIZ):
 284                 tbl_char(tp, '-', col->width);
 285                 break;
 286         case (TBL_CELL_DHORIZ):
 287                 tbl_char(tp, '=', col->width);
 288                 break;
 289         case (TBL_CELL_LONG):
 290                 /* FALLTHROUGH */
 291         case (TBL_CELL_CENTRE):
 292                 /* FALLTHROUGH */
 293         case (TBL_CELL_LEFT):
 294                 /* FALLTHROUGH */
 295         case (TBL_CELL_RIGHT):
 296                 tbl_literal(tp, dp, col);
 297                 break;
 298         case (TBL_CELL_NUMBER):
 299                 tbl_number(tp, tbl, dp, col);
 300                 break;
 301         case (TBL_CELL_DOWN):
 302                 tbl_char(tp, ASCII_NBRSP, col->width);
 303                 break;
 304         default:
 305                 abort();
 306                 /* NOTREACHED */
 307         }
 308 }
 309
 310 static void
 311 tbl_vrule(struct termp *tp, const struct tbl_head *hp)
 312 {
 313
 314         tbl_char(tp, ASCII_NBRSP, 1);
 315         if (0 < hp->vert)
 316                 tbl_char(tp, '|', hp->vert);
 317         if (2 > hp->vert)
 318                 tbl_char(tp, ASCII_NBRSP, 2 - hp->vert);
 319 }
 320
 321 static void
 322 tbl_char(struct termp *tp, char c, size_t len)
 323 {
 324         size_t          i, sz;
 325         char            cp[2];
 326
 327         cp[0] = c;
 328         cp[1] = '\0';
 329
 330         sz = term_strlen(tp, cp);
 331
 332         for (i = 0; i < len; i += sz)
 333                 term_word(tp, cp);
 334 }
 335
 336 static void
 337 tbl_literal(struct termp *tp, const struct tbl_dat *dp,
 338                 const struct roffcol *col)
 339 {
 340         size_t           len, padl, padr;
 341
 342         assert(dp->string);
 343         len = term_strlen(tp, dp->string);
 344         padr = col->width > len ? col->width - len : 0;
 345         padl = 0;
 346
 347         switch (dp->layout->pos) {
 348         case (TBL_CELL_LONG):
 349                 padl = term_len(tp, 1);
 350                 padr = padr > padl ? padr - padl : 0;
 351                 break;
 352         case (TBL_CELL_CENTRE):
 353                 if (2 > padr)
 354                         break;
 355                 padl = padr / 2;
 356                 padr -= padl;
 357                 break;
 358         case (TBL_CELL_RIGHT):
 359                 padl = padr;
 360                 padr = 0;
 361                 break;
 362         default:
 363                 break;
 364         }
 365
 366         tbl_char(tp, ASCII_NBRSP, padl);
 367         term_word(tp, dp->string);
 368         tbl_char(tp, ASCII_NBRSP, padr);
 369 }
 370
 371 static void
 372 tbl_number(struct termp *tp, const struct tbl *tbl,
 373                 const struct tbl_dat *dp,
 374                 const struct roffcol *col)
 375 {
 376         char            *cp;
 377         char             buf[2];
 378         size_t           sz, psz, ssz, d, padl;
 379         int              i;
 380
 381         /*
 382          * See calc_data_number().  Left-pad by taking the offset of our
 383          * and the maximum decimal; right-pad by the remaining amount.
 384          */
 385
 386         assert(dp->string);
 387
 388         sz = term_strlen(tp, dp->string);
 389
 390         buf[0] = tbl->decimal;
 391         buf[1] = '\0';
 392
 393         psz = term_strlen(tp, buf);
 394
 395         if (NULL != (cp = strrchr(dp->string, tbl->decimal))) {
 396                 buf[1] = '\0';
 397                 for (ssz = 0, i = 0; cp != &dp->string[i]; i++) {
 398                         buf[0] = dp->string[i];
 399                         ssz += term_strlen(tp, buf);
 400                 }
 401                 d = ssz + psz;
 402         } else
 403                 d = sz + psz;
 404
 405         padl = col->decimal - d;
 406
 407         tbl_char(tp, ASCII_NBRSP, padl);
 408         term_word(tp, dp->string);
 409         if (col->width > sz + padl)
 410                 tbl_char(tp, ASCII_NBRSP, col->width - sz - padl);
 411 }
 412