POSIX make(1) does not support prerequisites on suffix rules.

[mandoc.git] / tbl_layout.c

diff --git a/tbl_layout.c b/tbl_layout.c
index d0a9c617011380c6a193c6f116e5f0d421d1484f..171a8dbb1b4904e834be975d0c3eeabef105c92b 100644 (file)
--- a/tbl_layout.c
+++ b/tbl_layout.c
@@ -1,6 +1,8 @@
-/*     $Id: tbl_layout.c,v 1.7 2011/01/02 12:04:23 kristaps Exp $ */
+/*     $Id: tbl_layout.c,v 1.50 2021/08/10 12:55:04 schwarze Exp $ */

 /*
 /*

- * Copyright (c) 2009, 2010 Kristaps Dzonsons <kristaps@bsd.lv>
+ * Copyright (c) 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv>
+ * Copyright (c) 2012, 2014, 2015, 2017, 2020, 2021
+ *               Ingo Schwarze <schwarze@openbsd.org>

  *
  * Permission to use, copy, modify, and distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
  *
  * Permission to use, copy, modify, and distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above


@@ -14,24 +16,29 @@
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */

-#include <assert.h>
+#include "config.h"
+
+#include <sys/types.h>
+

 #include <ctype.h>
 #include <ctype.h>

+#include <stdint.h>
+#include <stdio.h>

 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
 
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
 

+#include "mandoc_aux.h"

 #include "mandoc.h"
 #include "mandoc.h"

+#include "tbl.h"

 #include "libmandoc.h"
 #include "libmandoc.h"

-#include "libroff.h"
+#include "tbl_int.h"

 
 struct tbl_phrase {
        char             name;
        enum tbl_cellt   key;
 };
 
 
 struct tbl_phrase {
        char             name;
        enum tbl_cellt   key;
 };
 

-#define        KEYS_MAX         11
-
-static const struct tbl_phrase keys[KEYS_MAX] = {
+static const struct tbl_phrase keys[] = {

        { 'c',           TBL_CELL_CENTRE },
        { 'r',           TBL_CELL_RIGHT },
        { 'l',           TBL_CELL_LEFT },
        { 'c',           TBL_CELL_CENTRE },
        { 'r',           TBL_CELL_RIGHT },
        { 'l',           TBL_CELL_LEFT },


@@ -41,333 +48,329 @@ static    const struct tbl_phrase keys[KEYS_MAX] = {
        { '^',           TBL_CELL_DOWN },
        { '-',           TBL_CELL_HORIZ },
        { '_',           TBL_CELL_HORIZ },
        { '^',           TBL_CELL_DOWN },
        { '-',           TBL_CELL_HORIZ },
        { '_',           TBL_CELL_HORIZ },

-       { '=',           TBL_CELL_DHORIZ },
-       { '|',           TBL_CELL_VERT }
+       { '=',           TBL_CELL_DHORIZ }

 };
 
 };
 

-static int              mods(struct tbl_node *, struct tbl_cell *, 
+#define KEYS_MAX ((int)(sizeof(keys)/sizeof(keys[0])))
+
+static void             mods(struct tbl_node *, struct tbl_cell *,

                                int, const char *, int *);
                                int, const char *, int *);

-static int              cell(struct tbl_node *, struct tbl_row *, 
+static void             cell(struct tbl_node *, struct tbl_row *,

                                int, const char *, int *);
                                int, const char *, int *);

-static void             row(struct tbl_node *, int, const char *, int *);
-static struct tbl_cell *cell_alloc(struct tbl_node *, 
-                               struct tbl_row *, enum tbl_cellt);
-static void             head_adjust(const struct tbl_cell *, 
-                               struct tbl_head *);
-
-static int
-mods(struct tbl_node *tbl, struct tbl_cell *cp, 
+static struct tbl_cell *cell_alloc(struct tbl_node *, struct tbl_row *,
+                               enum tbl_cellt);
+
+
+static void
+mods(struct tbl_node *tbl, struct tbl_cell *cp,

                int ln, const char *p, int *pos)
 {
                int ln, const char *p, int *pos)
 {

-       char             buf[5];
-       int              i;
+       char            *endptr;
+       unsigned long    spacing;
+       size_t           sz;
+       int              isz;
+       enum mandoc_esc  fontesc;

 
 mod:
 
 mod:

-       /* 
-        * XXX: since, at least for now, modifiers are non-conflicting
-        * (are separable by value, regardless of position), we let
-        * modifiers come in any order.  The existing tbl doesn't let
-        * this happen.
-        */
-       switch (p[*pos]) {
-       case ('\0'):
-               /* FALLTHROUGH */
-       case (' '):
-               /* FALLTHROUGH */
-       case ('\t'):
-               /* FALLTHROUGH */
-       case (','):
-               /* FALLTHROUGH */
-       case ('.'):
-               return(1);
-       default:
-               break;
-       }
+       while (p[*pos] == ' ' || p[*pos] == '\t')
+               (*pos)++;

 
 

-       /* Parse numerical spacing from modifier string. */
+       /* Row delimiters and cell specifiers end modifier lists. */

 
 

-       if (isdigit((unsigned char)p[*pos])) {
-               for (i = 0; i < 4; i++) {
-                       if ( ! isdigit((unsigned char)p[*pos + i]))
-                               break;
-                       buf[i] = p[*pos + i];
-               }
-               buf[i] = '\0';
+       if (strchr(".,-=^_ACLNRSaclnrs", p[*pos]) != NULL)
+               return;

 
 

-               /* No greater than 4 digits. */
+       /* Throw away parenthesised expression. */

 
 

-               if (4 == i) {
-                       TBL_MSG(tbl, MANDOCERR_TBLLAYOUT, ln, *pos);
-                       return(0);
+       if ('(' == p[*pos]) {
+               (*pos)++;
+               while (p[*pos] && ')' != p[*pos])
+                       (*pos)++;
+               if (')' == p[*pos]) {
+                       (*pos)++;
+                       goto mod;

                }
                }

+               mandoc_msg(MANDOCERR_TBLLAYOUT_PAR, ln, *pos, NULL);
+               return;
+       }

 
 

-               *pos += i;
-               cp->spacing = atoi(buf);
+       /* Parse numerical spacing from modifier string. */

 
 

+       if (isdigit((unsigned char)p[*pos])) {
+               if ((spacing = strtoul(p + *pos, &endptr, 10)) > 9)
+                       mandoc_msg(MANDOCERR_TBLLAYOUT_SPC, ln, *pos,
+                           "%lu", spacing);
+               else
+                       cp->spacing = spacing;
+               *pos = endptr - p;

                goto mod;
                goto mod;

-               /* NOTREACHED */
-       } 
-
-       /* TODO: GNU has many more extensions. */
+       }

 
 

-       switch (tolower(p[(*pos)++])) {
-       case ('z'):
-               cp->flags |= TBL_CELL_WIGN;
+       switch (tolower((unsigned char)p[(*pos)++])) {
+       case 'b':
+               cp->font = ESCAPE_FONTBOLD;

                goto mod;
                goto mod;

-       case ('u'):
-               cp->flags |= TBL_CELL_UP;
+       case 'd':
+               cp->flags |= TBL_CELL_BALIGN;

                goto mod;
                goto mod;

-       case ('e'):
+       case 'e':

                cp->flags |= TBL_CELL_EQUAL;
                goto mod;
                cp->flags |= TBL_CELL_EQUAL;
                goto mod;

-       case ('t'):
+       case 'f':
+               break;
+       case 'i':
+               cp->font = ESCAPE_FONTITALIC;
+               goto mod;
+       case 'm':
+               mandoc_msg(MANDOCERR_TBLLAYOUT_MOD, ln, *pos, "m");
+               goto mod;
+       case 'p':
+       case 'v':
+               if (p[*pos] == '-' || p[*pos] == '+')
+                       (*pos)++;
+               while (isdigit((unsigned char)p[*pos]))
+                       (*pos)++;
+               goto mod;
+       case 't':

                cp->flags |= TBL_CELL_TALIGN;
                goto mod;
                cp->flags |= TBL_CELL_TALIGN;
                goto mod;

-       case ('d'):
-               cp->flags |= TBL_CELL_BALIGN;
+       case 'u':
+               cp->flags |= TBL_CELL_UP;
+               goto mod;
+       case 'w':
+               sz = 0;
+               if (p[*pos] == '(') {
+                       (*pos)++;
+                       while (p[*pos + sz] != '\0' && p[*pos + sz] != ')')
+                               sz++;
+               } else
+                       while (isdigit((unsigned char)p[*pos + sz]))
+                               sz++;
+               if (sz) {
+                       free(cp->wstr);
+                       cp->wstr = mandoc_strndup(p + *pos, sz);
+                       *pos += sz;
+                       if (p[*pos] == ')')
+                               (*pos)++;
+               }
+               goto mod;
+       case 'x':
+               cp->flags |= TBL_CELL_WMAX;
+               goto mod;
+       case 'z':
+               cp->flags |= TBL_CELL_WIGN;
+               goto mod;
+       case '|':
+               if (cp->vert < 2)
+                       cp->vert++;
+               else
+                       mandoc_msg(MANDOCERR_TBLLAYOUT_VERT,
+                           ln, *pos - 1, NULL);

                goto mod;
                goto mod;

-       case ('f'):
-               break;
-       case ('b'):
-               /* FALLTHROUGH */
-       case ('i'):
-               (*pos)--;
-               break;

        default:
        default:

-               TBL_MSG(tbl, MANDOCERR_TBLLAYOUT, ln, *pos - 1);
-               return(0);
+               mandoc_msg(MANDOCERR_TBLLAYOUT_CHAR,
+                   ln, *pos - 1, "%c", p[*pos - 1]);
+               goto mod;

        }
 
        }
 

-       switch (tolower(p[(*pos)++])) {
-       case ('b'):
-               cp->flags |= TBL_CELL_BOLD;
-               goto mod;
-       case ('i'):
-               cp->flags |= TBL_CELL_ITALIC;
+       while (p[*pos] == ' ' || p[*pos] == '\t')
+               (*pos)++;
+
+       /* Ignore parenthised font names for now. */
+
+       if (p[*pos] == '(')

                goto mod;
                goto mod;

+
+       isz = 0;
+       if (p[*pos] != '\0')
+               isz++;
+       if (strchr(" \t.", p[*pos + isz]) == NULL)
+               isz++;
+       
+       fontesc = mandoc_font(p + *pos, isz);
+
+       switch (fontesc) {
+       case ESCAPE_FONTPREV:
+       case ESCAPE_ERROR:
+               mandoc_msg(MANDOCERR_FT_BAD,
+                   ln, *pos, "TS %s", p + *pos - 1);
+               break;

        default:
        default:

+               cp->font = fontesc;

                break;
        }
                break;
        }

-
-       TBL_MSG(tbl, MANDOCERR_TBLLAYOUT, ln, *pos - 1);
-       return(0);
+       *pos += isz;
+       goto mod;

 }
 
 }
 

-static int
-cell(struct tbl_node *tbl, struct tbl_row *rp, 
+static void
+cell(struct tbl_node *tbl, struct tbl_row *rp,

                int ln, const char *p, int *pos)
 {
        int              i;
        enum tbl_cellt   c;
 
                int ln, const char *p, int *pos)
 {
        int              i;
        enum tbl_cellt   c;
 

-       /* Parse the column position (`r', `R', `|', ...). */
-
-       for (i = 0; i < KEYS_MAX; i++)
-               if (tolower(p[*pos]) == keys[i].name)
-                       break;
-
-       if (KEYS_MAX == i) {
-               TBL_MSG(tbl, MANDOCERR_TBLLAYOUT, ln, *pos);
-               return(0);
-       }
-
-       (*pos)++;
-       c = keys[i].key;
-
-       /* Extra check for the double-vertical. */
+       /* Handle leading vertical lines */

 
 

-       if (TBL_CELL_VERT == c && '|' == p[*pos]) {
+       while (p[*pos] == ' ' || p[*pos] == '\t' || p[*pos] == '|') {
+               if (p[*pos] == '|') {
+                       if (rp->vert < 2)
+                               rp->vert++;
+                       else
+                               mandoc_msg(MANDOCERR_TBLLAYOUT_VERT,
+                                   ln, *pos, NULL);
+               }

                (*pos)++;
                (*pos)++;

-               c = TBL_CELL_DVERT;
-       } 
-       
-       /* Disallow adjacent spacers. */
-
-       if (rp->last && (TBL_CELL_VERT == c || TBL_CELL_DVERT == c) &&
-                       (TBL_CELL_VERT == rp->last->pos || 
-                        TBL_CELL_DVERT == rp->last->pos)) {
-               TBL_MSG(tbl, MANDOCERR_TBLLAYOUT, ln, *pos - 1);
-               return(0);

        }
 
        }
 

-       /* Allocate cell then parse its modifiers. */
-
-       return(mods(tbl, cell_alloc(tbl, rp, c), ln, p, pos));
-}
-
-
-static void
-row(struct tbl_node *tbl, int ln, const char *p, int *pos)
-{
-       struct tbl_row  *rp;
+again:
+       while (p[*pos] == ' ' || p[*pos] == '\t')
+               (*pos)++;

 
 

-row:   /*
-        * EBNF describing this section:
-        *
-        * row          ::= row_list [:space:]* [.]?[\n]
-        * row_list     ::= [:space:]* row_elem row_tail
-        * row_tail     ::= [:space:]*[,] row_list |
-        *                  epsilon
-        * row_elem     ::= [\t\ ]*[:alpha:]+
-        */
-
-       rp = mandoc_calloc(1, sizeof(struct tbl_row));
-       if (tbl->last_row) {
-               tbl->last_row->next = rp;
-               tbl->last_row = rp;
-       } else
-               tbl->last_row = tbl->first_row = rp;
+       if (p[*pos] == '.' || p[*pos] == '\0')
+               return;

 
 

-cell:
-       while (isspace((unsigned char)p[*pos]))
-               (*pos)++;
+       /* Parse the column position (`c', `l', `r', ...). */

 
 

-       /* Safely exit layout context. */
+       for (i = 0; i < KEYS_MAX; i++)
+               if (tolower((unsigned char)p[*pos]) == keys[i].name)
+                       break;

 
 

-       if ('.' == p[*pos]) {
-               tbl->part = TBL_PART_DATA;
-               if (NULL == tbl->first_row) 
-                       TBL_MSG(tbl, MANDOCERR_TBLNOLAYOUT, ln, *pos);
+       if (i == KEYS_MAX) {
+               mandoc_msg(MANDOCERR_TBLLAYOUT_CHAR,
+                   ln, *pos, "%c", p[*pos]);

                (*pos)++;
                (*pos)++;

-               return;
+               goto again;

        }
        }

+       c = keys[i].key;

 
 

-       /* End (and possibly restart) a row. */
+       /* Special cases of spanners. */

 
 

-       if (',' == p[*pos]) {
-               (*pos)++;
-               goto row;
-       } else if ('\0' == p[*pos])
-               return;
+       if (c == TBL_CELL_SPAN) {
+               if (rp->last == NULL)
+                       mandoc_msg(MANDOCERR_TBLLAYOUT_SPAN, ln, *pos, NULL);
+               else if (rp->last->pos == TBL_CELL_HORIZ ||
+                   rp->last->pos == TBL_CELL_DHORIZ)
+                       c = rp->last->pos;
+       } else if (c == TBL_CELL_DOWN && rp == tbl->first_row)
+               mandoc_msg(MANDOCERR_TBLLAYOUT_DOWN, ln, *pos, NULL);

 
 

-       if ( ! cell(tbl, rp, ln, p, pos))
-               return;
+       (*pos)++;
+
+       /* Allocate cell then parse its modifiers. */

 
 

-       goto cell;
-       /* NOTREACHED */
+       mods(tbl, cell_alloc(tbl, rp, c), ln, p, pos);

 }
 
 }
 

-int
-tbl_layout(struct tbl_node *tbl, int ln, const char *p)
+void
+tbl_layout(struct tbl_node *tbl, int ln, const char *p, int pos)

 {
 {

-       int              pos;
+       struct tbl_row  *rp;

 
 

-       pos = 0;
-       row(tbl, ln, p, &pos);
+       rp = NULL;
+       for (;;) {
+               /* Skip whitespace before and after each cell. */
+
+               while (p[pos] == ' ' || p[pos] == '\t')
+                       pos++;
+
+               switch (p[pos]) {
+               case ',':  /* Next row on this input line. */
+                       pos++;
+                       rp = NULL;
+                       continue;
+               case '\0':  /* Next row on next input line. */
+                       return;
+               case '.':  /* End of layout. */
+                       pos++;
+                       tbl->part = TBL_PART_DATA;
+
+                       /*
+                        * When the layout is completely empty,
+                        * default to one left-justified column.
+                        */
+
+                       if (tbl->first_row == NULL) {
+                               tbl->first_row = tbl->last_row =
+                                   mandoc_calloc(1, sizeof(*rp));
+                       }
+                       if (tbl->first_row->first == NULL) {
+                               mandoc_msg(MANDOCERR_TBLLAYOUT_NONE,
+                                   ln, pos, NULL);
+                               cell_alloc(tbl, tbl->first_row,
+                                   TBL_CELL_LEFT);
+                               if (tbl->opts.lvert < tbl->first_row->vert)
+                                       tbl->opts.lvert = tbl->first_row->vert;
+                               return;
+                       }
+
+                       /*
+                        * Search for the widest line
+                        * along the left and right margins.
+                        */
+
+                       for (rp = tbl->first_row; rp; rp = rp->next) {
+                               if (tbl->opts.lvert < rp->vert)
+                                       tbl->opts.lvert = rp->vert;
+                               if (rp->last != NULL &&
+                                   rp->last->col + 1 == tbl->opts.cols &&
+                                   tbl->opts.rvert < rp->last->vert)
+                                       tbl->opts.rvert = rp->last->vert;
+
+                               /* If the last line is empty, drop it. */
+
+                               if (rp->next != NULL &&
+                                   rp->next->first == NULL) {
+                                       free(rp->next);
+                                       rp->next = NULL;
+                                       tbl->last_row = rp;
+                               }
+                       }
+                       return;
+               default:  /* Cell. */
+                       break;
+               }

 
 

-       /* Always succeed. */
-       return(1);
+               /*
+                * If the last line had at least one cell,
+                * start a new one; otherwise, continue it.
+                */
+
+               if (rp == NULL) {
+                       if (tbl->last_row == NULL ||
+                           tbl->last_row->first != NULL) {
+                               rp = mandoc_calloc(1, sizeof(*rp));
+                               if (tbl->last_row)
+                                       tbl->last_row->next = rp;
+                               else
+                                       tbl->first_row = rp;
+                               tbl->last_row = rp;
+                       } else
+                               rp = tbl->last_row;
+               }
+               cell(tbl, rp, ln, p, &pos);
+       }

 }
 
 static struct tbl_cell *
 cell_alloc(struct tbl_node *tbl, struct tbl_row *rp, enum tbl_cellt pos)
 {
        struct tbl_cell *p, *pp;
 }
 
 static struct tbl_cell *
 cell_alloc(struct tbl_node *tbl, struct tbl_row *rp, enum tbl_cellt pos)
 {
        struct tbl_cell *p, *pp;

-       struct tbl_head *h, *hp;
-
-       p = mandoc_calloc(1, sizeof(struct tbl_cell));
-
-       if (NULL != (pp = rp->last)) {
-               rp->last->next = p;
-               rp->last = p;
-       } else
-               rp->last = rp->first = p;

 
 

+       p = mandoc_calloc(1, sizeof(*p));
+       p->spacing = SIZE_MAX;
+       p->font = ESCAPE_FONTROMAN;

        p->pos = pos;
 
        p->pos = pos;
 

-       /*
-        * This is a little bit complicated.  Here we determine the
-        * header the corresponds to a cell.  We add headers dynamically
-        * when need be or re-use them, otherwise.  As an example, given
-        * the following:
-        *
-        *      1  c || l 
-        *      2  | c | l
-        *      3  l l
-        *      3  || c | l |.
-        *
-        * We first add the new headers (as there are none) in (1); then
-        * in (2) we insert the first spanner (as it doesn't match up
-        * with the header); then we re-use the prior data headers,
-        * skipping over the spanners; then we re-use everything and add
-        * a last spanner.  Note that VERT headers are made into DVERT
-        * ones.
-        */
-
-       h = pp ? pp->head->prev : tbl->first_head;
-
-       if (h) {
-               /* Re-use data header. */
-               if (TBL_HEAD_DATA == h->pos && 
-                               (TBL_CELL_VERT != p->pos &&
-                                TBL_CELL_DVERT != p->pos)) {
-                       p->head = h;
-                       return(p);
-               }
-
-               /* Re-use spanner header. */
-               if (TBL_HEAD_DATA != h->pos && 
-                               (TBL_CELL_VERT == p->pos ||
-                                TBL_CELL_DVERT == p->pos)) {
-                       head_adjust(p, h);
-                       p->head = h;
-                       return(p);
-               }
-
-               /* Right-shift headers with a new spanner. */
-               if (TBL_HEAD_DATA == h->pos && 
-                               (TBL_CELL_VERT == p->pos ||
-                                TBL_CELL_DVERT == p->pos)) {
-                       hp = mandoc_calloc(1, sizeof(struct tbl_head));
-                       hp->prev = h->prev;
-                       if (h->prev)
-                               h->prev->next = hp;
-                       if (h == tbl->first_head)
-                               tbl->first_head = hp;
-                       h->prev = hp;
-                       hp->next = h;
-                       head_adjust(p, hp);
-                       p->head = hp;
-                       return(p);
-               }
-
-               if (NULL != (h = h->next)) {
-                       head_adjust(p, h);
-                       p->head = h;
-                       return(p);
-               }
-
-               /* Fall through to default case... */
-       }
-
-       hp = mandoc_calloc(1, sizeof(struct tbl_head));
-
-       if (tbl->last_head) {
-               hp->prev = tbl->last_head;
-               tbl->last_head->next = hp;
-               tbl->last_head = hp;
+       if ((pp = rp->last) != NULL) {
+               pp->next = p;
+               p->col = pp->col + 1;

        } else
        } else

-               tbl->last_head = tbl->first_head = hp;
-
-       head_adjust(p, hp);
-       p->head = hp;
-       return(p);
-}
+               rp->first = p;
+       rp->last = p;

 
 

-static void
-head_adjust(const struct tbl_cell *cell, struct tbl_head *head)
-{
-       if (TBL_CELL_VERT != cell->pos &&
-                       TBL_CELL_DVERT != cell->pos) {
-               head->pos = TBL_HEAD_DATA;
-               return;
-       }
-
-       if (TBL_CELL_VERT == cell->pos)
-               if (TBL_HEAD_DVERT != head->pos)
-                       head->pos = TBL_HEAD_VERT;
+       if (tbl->opts.cols <= p->col)
+               tbl->opts.cols = p->col + 1;

 
 

-       if (TBL_CELL_DVERT == cell->pos)
-               head->pos = TBL_HEAD_DVERT;
+       return p;

 }
 }

-