tbl_layout.c

   1 /*      $Id: tbl_layout.c,v 1.49 2020/09/01 18:25:28 schwarze Exp $ */
   2 /*
   3  * Copyright (c) 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv>
   4  * Copyright (c) 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 <ctype.h>
  23 #include <stdint.h>
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <time.h>
  28
  29 #include "mandoc_aux.h"
  30 #include "mandoc.h"
  31 #include "tbl.h"
  32 #include "libmandoc.h"
  33 #include "tbl_int.h"
  34
  35 struct  tbl_phrase {
  36         char             name;
  37         enum tbl_cellt   key;
  38 };
  39
  40 static  const struct tbl_phrase keys[] = {
  41         { 'c',           TBL_CELL_CENTRE },
  42         { 'r',           TBL_CELL_RIGHT },
  43         { 'l',           TBL_CELL_LEFT },
  44         { 'n',           TBL_CELL_NUMBER },
  45         { 's',           TBL_CELL_SPAN },
  46         { 'a',           TBL_CELL_LONG },
  47         { '^',           TBL_CELL_DOWN },
  48         { '-',           TBL_CELL_HORIZ },
  49         { '_',           TBL_CELL_HORIZ },
  50         { '=',           TBL_CELL_DHORIZ }
  51 };
  52
  53 #define KEYS_MAX ((int)(sizeof(keys)/sizeof(keys[0])))
  54
  55 static  void             mods(struct tbl_node *, struct tbl_cell *,
  56                                 int, const char *, int *);
  57 static  void             cell(struct tbl_node *, struct tbl_row *,
  58                                 int, const char *, int *);
  59 static  struct tbl_cell *cell_alloc(struct tbl_node *, struct tbl_row *,
  60                                 enum tbl_cellt);
  61
  62
  63 static void
  64 mods(struct tbl_node *tbl, struct tbl_cell *cp,
  65                 int ln, const char *p, int *pos)
  66 {
  67         char            *endptr;
  68         unsigned long    spacing;
  69         size_t           sz;
  70
  71 mod:
  72         while (p[*pos] == ' ' || p[*pos] == '\t')
  73                 (*pos)++;
  74
  75         /* Row delimiters and cell specifiers end modifier lists. */
  76
  77         if (strchr(".,-=^_ACLNRSaclnrs", p[*pos]) != NULL)
  78                 return;
  79
  80         /* Throw away parenthesised expression. */
  81
  82         if ('(' == p[*pos]) {
  83                 (*pos)++;
  84                 while (p[*pos] && ')' != p[*pos])
  85                         (*pos)++;
  86                 if (')' == p[*pos]) {
  87                         (*pos)++;
  88                         goto mod;
  89                 }
  90                 mandoc_msg(MANDOCERR_TBLLAYOUT_PAR, ln, *pos, NULL);
  91                 return;
  92         }
  93
  94         /* Parse numerical spacing from modifier string. */
  95
  96         if (isdigit((unsigned char)p[*pos])) {
  97                 if ((spacing = strtoul(p + *pos, &endptr, 10)) > 9)
  98                         mandoc_msg(MANDOCERR_TBLLAYOUT_SPC, ln, *pos,
  99                             "%lu", spacing);
 100                 else
 101                         cp->spacing = spacing;
 102                 *pos = endptr - p;
 103                 goto mod;
 104         }
 105
 106         switch (tolower((unsigned char)p[(*pos)++])) {
 107         case 'b':
 108                 cp->flags |= TBL_CELL_BOLD;
 109                 goto mod;
 110         case 'd':
 111                 cp->flags |= TBL_CELL_BALIGN;
 112                 goto mod;
 113         case 'e':
 114                 cp->flags |= TBL_CELL_EQUAL;
 115                 goto mod;
 116         case 'f':
 117                 break;
 118         case 'i':
 119                 cp->flags |= TBL_CELL_ITALIC;
 120                 goto mod;
 121         case 'm':
 122                 mandoc_msg(MANDOCERR_TBLLAYOUT_MOD, ln, *pos, "m");
 123                 goto mod;
 124         case 'p':
 125         case 'v':
 126                 if (p[*pos] == '-' || p[*pos] == '+')
 127                         (*pos)++;
 128                 while (isdigit((unsigned char)p[*pos]))
 129                         (*pos)++;
 130                 goto mod;
 131         case 't':
 132                 cp->flags |= TBL_CELL_TALIGN;
 133                 goto mod;
 134         case 'u':
 135                 cp->flags |= TBL_CELL_UP;
 136                 goto mod;
 137         case 'w':
 138                 sz = 0;
 139                 if (p[*pos] == '(') {
 140                         (*pos)++;
 141                         while (p[*pos + sz] != '\0' && p[*pos + sz] != ')')
 142                                 sz++;
 143                 } else
 144                         while (isdigit((unsigned char)p[*pos + sz]))
 145                                 sz++;
 146                 if (sz) {
 147                         free(cp->wstr);
 148                         cp->wstr = mandoc_strndup(p + *pos, sz);
 149                         *pos += sz;
 150                         if (p[*pos] == ')')
 151                                 (*pos)++;
 152                 }
 153                 goto mod;
 154         case 'x':
 155                 cp->flags |= TBL_CELL_WMAX;
 156                 goto mod;
 157         case 'z':
 158                 cp->flags |= TBL_CELL_WIGN;
 159                 goto mod;
 160         case '|':
 161                 if (cp->vert < 2)
 162                         cp->vert++;
 163                 else
 164                         mandoc_msg(MANDOCERR_TBLLAYOUT_VERT,
 165                             ln, *pos - 1, NULL);
 166                 goto mod;
 167         default:
 168                 mandoc_msg(MANDOCERR_TBLLAYOUT_CHAR,
 169                     ln, *pos - 1, "%c", p[*pos - 1]);
 170                 goto mod;
 171         }
 172
 173         /* Ignore parenthised font names for now. */
 174
 175         if (p[*pos] == '(')
 176                 goto mod;
 177
 178         /* Support only one-character font-names for now. */
 179
 180         if (p[*pos] == '\0' || (p[*pos + 1] != ' ' && p[*pos + 1] != '.')) {
 181                 mandoc_msg(MANDOCERR_FT_BAD,
 182                     ln, *pos, "TS %s", p + *pos - 1);
 183                 if (p[*pos] != '\0')
 184                         (*pos)++;
 185                 if (p[*pos] != '\0')
 186                         (*pos)++;
 187                 goto mod;
 188         }
 189
 190         switch (p[(*pos)++]) {
 191         case '3':
 192         case 'B':
 193                 cp->flags |= TBL_CELL_BOLD;
 194                 goto mod;
 195         case '2':
 196         case 'I':
 197                 cp->flags |= TBL_CELL_ITALIC;
 198                 goto mod;
 199         case '1':
 200         case 'R':
 201                 goto mod;
 202         default:
 203                 mandoc_msg(MANDOCERR_FT_BAD,
 204                     ln, *pos - 1, "TS f%c", p[*pos - 1]);
 205                 goto mod;
 206         }
 207 }
 208
 209 static void
 210 cell(struct tbl_node *tbl, struct tbl_row *rp,
 211                 int ln, const char *p, int *pos)
 212 {
 213         int              i;
 214         enum tbl_cellt   c;
 215
 216         /* Handle leading vertical lines */
 217
 218         while (p[*pos] == ' ' || p[*pos] == '\t' || p[*pos] == '|') {
 219                 if (p[*pos] == '|') {
 220                         if (rp->vert < 2)
 221                                 rp->vert++;
 222                         else
 223                                 mandoc_msg(MANDOCERR_TBLLAYOUT_VERT,
 224                                     ln, *pos, NULL);
 225                 }
 226                 (*pos)++;
 227         }
 228
 229 again:
 230         while (p[*pos] == ' ' || p[*pos] == '\t')
 231                 (*pos)++;
 232
 233         if (p[*pos] == '.' || p[*pos] == '\0')
 234                 return;
 235
 236         /* Parse the column position (`c', `l', `r', ...). */
 237
 238         for (i = 0; i < KEYS_MAX; i++)
 239                 if (tolower((unsigned char)p[*pos]) == keys[i].name)
 240                         break;
 241
 242         if (i == KEYS_MAX) {
 243                 mandoc_msg(MANDOCERR_TBLLAYOUT_CHAR,
 244                     ln, *pos, "%c", p[*pos]);
 245                 (*pos)++;
 246                 goto again;
 247         }
 248         c = keys[i].key;
 249
 250         /* Special cases of spanners. */
 251
 252         if (c == TBL_CELL_SPAN) {
 253                 if (rp->last == NULL)
 254                         mandoc_msg(MANDOCERR_TBLLAYOUT_SPAN, ln, *pos, NULL);
 255                 else if (rp->last->pos == TBL_CELL_HORIZ ||
 256                     rp->last->pos == TBL_CELL_DHORIZ)
 257                         c = rp->last->pos;
 258         } else if (c == TBL_CELL_DOWN && rp == tbl->first_row)
 259                 mandoc_msg(MANDOCERR_TBLLAYOUT_DOWN, ln, *pos, NULL);
 260
 261         (*pos)++;
 262
 263         /* Allocate cell then parse its modifiers. */
 264
 265         mods(tbl, cell_alloc(tbl, rp, c), ln, p, pos);
 266 }
 267
 268 void
 269 tbl_layout(struct tbl_node *tbl, int ln, const char *p, int pos)
 270 {
 271         struct tbl_row  *rp;
 272
 273         rp = NULL;
 274         for (;;) {
 275                 /* Skip whitespace before and after each cell. */
 276
 277                 while (p[pos] == ' ' || p[pos] == '\t')
 278                         pos++;
 279
 280                 switch (p[pos]) {
 281                 case ',':  /* Next row on this input line. */
 282                         pos++;
 283                         rp = NULL;
 284                         continue;
 285                 case '\0':  /* Next row on next input line. */
 286                         return;
 287                 case '.':  /* End of layout. */
 288                         pos++;
 289                         tbl->part = TBL_PART_DATA;
 290
 291                         /*
 292                          * When the layout is completely empty,
 293                          * default to one left-justified column.
 294                          */
 295
 296                         if (tbl->first_row == NULL) {
 297                                 tbl->first_row = tbl->last_row =
 298                                     mandoc_calloc(1, sizeof(*rp));
 299                         }
 300                         if (tbl->first_row->first == NULL) {
 301                                 mandoc_msg(MANDOCERR_TBLLAYOUT_NONE,
 302                                     ln, pos, NULL);
 303                                 cell_alloc(tbl, tbl->first_row,
 304                                     TBL_CELL_LEFT);
 305                                 if (tbl->opts.lvert < tbl->first_row->vert)
 306                                         tbl->opts.lvert = tbl->first_row->vert;
 307                                 return;
 308                         }
 309
 310                         /*
 311                          * Search for the widest line
 312                          * along the left and right margins.
 313                          */
 314
 315                         for (rp = tbl->first_row; rp; rp = rp->next) {
 316                                 if (tbl->opts.lvert < rp->vert)
 317                                         tbl->opts.lvert = rp->vert;
 318                                 if (rp->last != NULL &&
 319                                     rp->last->col + 1 == tbl->opts.cols &&
 320                                     tbl->opts.rvert < rp->last->vert)
 321                                         tbl->opts.rvert = rp->last->vert;
 322
 323                                 /* If the last line is empty, drop it. */
 324
 325                                 if (rp->next != NULL &&
 326                                     rp->next->first == NULL) {
 327                                         free(rp->next);
 328                                         rp->next = NULL;
 329                                         tbl->last_row = rp;
 330                                 }
 331                         }
 332                         return;
 333                 default:  /* Cell. */
 334                         break;
 335                 }
 336
 337                 /*
 338                  * If the last line had at least one cell,
 339                  * start a new one; otherwise, continue it.
 340                  */
 341
 342                 if (rp == NULL) {
 343                         if (tbl->last_row == NULL ||
 344                             tbl->last_row->first != NULL) {
 345                                 rp = mandoc_calloc(1, sizeof(*rp));
 346                                 if (tbl->last_row)
 347                                         tbl->last_row->next = rp;
 348                                 else
 349                                         tbl->first_row = rp;
 350                                 tbl->last_row = rp;
 351                         } else
 352                                 rp = tbl->last_row;
 353                 }
 354                 cell(tbl, rp, ln, p, &pos);
 355         }
 356 }
 357
 358 static struct tbl_cell *
 359 cell_alloc(struct tbl_node *tbl, struct tbl_row *rp, enum tbl_cellt pos)
 360 {
 361         struct tbl_cell *p, *pp;
 362
 363         p = mandoc_calloc(1, sizeof(*p));
 364         p->spacing = SIZE_MAX;
 365         p->pos = pos;
 366
 367         if ((pp = rp->last) != NULL) {
 368                 pp->next = p;
 369                 p->col = pp->col + 1;
 370         } else
 371                 rp->first = p;
 372         rp->last = p;
 373
 374         if (tbl->opts.cols <= p->col)
 375                 tbl->opts.cols = p->col + 1;
 376
 377         return p;
 378 }