In -Tman .Bl -compact, skip the blank line only before the first item

[mandoc.git] / tbl_layout.c

diff --git a/tbl_layout.c b/tbl_layout.c
index 477a677ad7c4aef9080cca09b9c559dfa0b677b4..6cce977fa2e74f9a8fd33a852818a61dc8a58d8b 100644 (file)
--- a/tbl_layout.c
+++ b/tbl_layout.c
@@ -1,6 +1,7 @@
-/*     $Id: tbl_layout.c,v 1.1 2010/12/29 14:38:14 kristaps Exp $ */
+/*     $Id: tbl_layout.c,v 1.23 2012/05/27 17:54:54 schwarze Exp $ */

 /*
 /*

- * Copyright (c) 2009, 2010 Kristaps Dzonsons <kristaps@bsd.lv>
+ * Copyright (c) 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv>
+ * Copyright (c) 2012 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,10 +15,15 @@
  * 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.
  */

+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+

 #include <assert.h>
 #include <ctype.h>
 #include <stdlib.h>
 #include <string.h>
 #include <assert.h>
 #include <ctype.h>
 #include <stdlib.h>
 #include <string.h>

+#include <time.h>

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


@@ -28,41 +34,55 @@ struct      tbl_phrase {
        enum tbl_cellt   key;
 };
 
        enum tbl_cellt   key;
 };
 

-#define        KEYS_MAX         17
+/*
+ * FIXME: we can make this parse a lot nicer by, when an error is
+ * encountered in a layout key, bailing to the next key (i.e. to the
+ * next whitespace then continuing).
+ */
+
+#define        KEYS_MAX         11

 
 static const struct tbl_phrase keys[KEYS_MAX] = {
        { 'c',           TBL_CELL_CENTRE },
 
 static const struct tbl_phrase keys[KEYS_MAX] = {
        { 'c',           TBL_CELL_CENTRE },

-       { 'C',           TBL_CELL_CENTRE },

        { 'r',           TBL_CELL_RIGHT },
        { 'r',           TBL_CELL_RIGHT },

-       { 'R',           TBL_CELL_RIGHT },

        { 'l',           TBL_CELL_LEFT },
        { 'l',           TBL_CELL_LEFT },

-       { 'L',           TBL_CELL_LEFT },

        { 'n',           TBL_CELL_NUMBER },
        { 'n',           TBL_CELL_NUMBER },

-       { 'N',           TBL_CELL_NUMBER },

        { 's',           TBL_CELL_SPAN },
        { 's',           TBL_CELL_SPAN },

-       { 'S',           TBL_CELL_SPAN },

        { 'a',           TBL_CELL_LONG },
        { 'a',           TBL_CELL_LONG },

-       { 'A',           TBL_CELL_LONG },

        { '^',           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 *, struct tbl_cell *, 
-                       int, const char *, int *);
-static int      cell(struct tbl *, struct tbl_row *, 
-                       int, const char *, int *);
-static void     row(struct tbl *, int, const char *, int *);
+static int              mods(struct tbl_node *, struct tbl_cell *, 
+                               int, const char *, int *);
+static int              cell(struct tbl_node *, struct tbl_row *, 
+                               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, int vert);

 
 static int
 
 static int

-mods(struct tbl *tbl, struct tbl_cell *cp, 
+mods(struct tbl_node *tbl, struct tbl_cell *cp, 

                int ln, const char *p, int *pos)
 {
        char             buf[5];
        int              i;
 
                int ln, const char *p, int *pos)
 {
        char             buf[5];
        int              i;
 

+       /* Not all types accept modifiers. */
+
+       switch (cp->pos) {
+       case (TBL_CELL_DOWN):
+               /* FALLTHROUGH */
+       case (TBL_CELL_HORIZ):
+               /* FALLTHROUGH */
+       case (TBL_CELL_DHORIZ):
+               return(1);
+       default:
+               break;
+       }
+

 mod:
        /* 
         * XXX: since, at least for now, modifiers are non-conflicting
 mod:
        /* 
         * XXX: since, at least for now, modifiers are non-conflicting


@@ -85,6 +105,21 @@ mod:
                break;
        }
 
                break;
        }
 

+       /* Throw away parenthesised expression. */
+
+       if ('(' == p[*pos]) {
+               (*pos)++;
+               while (p[*pos] && ')' != p[*pos])
+                       (*pos)++;
+               if (')' == p[*pos]) {
+                       (*pos)++;
+                       goto mod;
+               }
+               mandoc_msg(MANDOCERR_TBLLAYOUT, 
+                               tbl->parse, ln, *pos, NULL);
+               return(0);
+       }
+

        /* Parse numerical spacing from modifier string. */
 
        if (isdigit((unsigned char)p[*pos])) {
        /* Parse numerical spacing from modifier string. */
 
        if (isdigit((unsigned char)p[*pos])) {


@@ -98,12 +133,13 @@ mod:
                /* No greater than 4 digits. */
 
                if (4 == i) {
                /* No greater than 4 digits. */
 
                if (4 == i) {

-                       TBL_MSG(tbl, MANDOCERR_TBLLAYOUT, ln, *pos);
+                       mandoc_msg(MANDOCERR_TBLLAYOUT, tbl->parse,
+                                       ln, *pos, NULL);

                        return(0);
                }
 
                *pos += i;
                        return(0);
                }
 
                *pos += i;

-               cp->spacing = atoi(buf);
+               cp->spacing = (size_t)atoi(buf);

 
                goto mod;
                /* NOTREACHED */
 
                goto mod;
                /* NOTREACHED */


@@ -111,121 +147,143 @@ mod:
 
        /* TODO: GNU has many more extensions. */
 
 
        /* TODO: GNU has many more extensions. */
 

-       switch (p[(*pos)++]) {
+       switch (tolower((unsigned char)p[(*pos)++])) {

        case ('z'):
        case ('z'):

-               /* FALLTHROUGH */
-       case ('Z'):

                cp->flags |= TBL_CELL_WIGN;
                goto mod;
        case ('u'):
                cp->flags |= TBL_CELL_WIGN;
                goto mod;
        case ('u'):

-               /* FALLTHROUGH */
-       case ('U'):

                cp->flags |= TBL_CELL_UP;
                goto mod;
        case ('e'):
                cp->flags |= TBL_CELL_UP;
                goto mod;
        case ('e'):

-               /* FALLTHROUGH */
-       case ('E'):

                cp->flags |= TBL_CELL_EQUAL;
                goto mod;
        case ('t'):
                cp->flags |= TBL_CELL_EQUAL;
                goto mod;
        case ('t'):

-               /* FALLTHROUGH */
-       case ('T'):

                cp->flags |= TBL_CELL_TALIGN;
                goto mod;
        case ('d'):
                cp->flags |= TBL_CELL_TALIGN;
                goto mod;
        case ('d'):

-               /* FALLTHROUGH */
-       case ('D'):

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

+       case ('w'):  /* XXX for now, ignore minimal column width */
+               goto mod;

        case ('f'):
        case ('f'):

-               /* FALLTHROUGH */
-       case ('B'):
-               /* FALLTHROUGH */
-       case ('I'):
+               break;
+       case ('r'):

                /* FALLTHROUGH */
        case ('b'):
                /* FALLTHROUGH */
        case ('i'):
                /* FALLTHROUGH */
        case ('b'):
                /* FALLTHROUGH */
        case ('i'):

+               (*pos)--;

                break;
        default:
                break;
        default:

-               TBL_MSG(tbl, MANDOCERR_TBLLAYOUT, ln, *pos - 1);
+               mandoc_msg(MANDOCERR_TBLLAYOUT, tbl->parse,
+                               ln, *pos - 1, NULL);

                return(0);
        }
 
                return(0);
        }
 

-       switch (p[(*pos)++]) {
-       case ('b'):
+       switch (tolower((unsigned char)p[(*pos)++])) {
+       case ('3'):

                /* FALLTHROUGH */
                /* FALLTHROUGH */

-       case ('B'):
+       case ('b'):

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

-       case ('i'):
+       case ('2'):

                /* FALLTHROUGH */
                /* FALLTHROUGH */

-       case ('I'):
+       case ('i'):

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

+       case ('1'):
+               /* FALLTHROUGH */
+       case ('r'):
+               goto mod;

        default:
                break;
        }
 
        default:
                break;
        }
 

-       TBL_MSG(tbl, MANDOCERR_TBLLAYOUT, ln, *pos - 1);
+       mandoc_msg(MANDOCERR_TBLLAYOUT, tbl->parse,
+                       ln, *pos - 1, NULL);

        return(0);
 }
 
 static int
        return(0);
 }
 
 static int

-cell(struct tbl *tbl, struct tbl_row *rp, 
+cell(struct tbl_node *tbl, struct tbl_row *rp, 

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

-       struct tbl_cell *cp;
-       int              i;
+       int              vert, i;

        enum tbl_cellt   c;
 
        enum tbl_cellt   c;
 

-       /* Parse the column position (`r', `R', `|', ...). */
+       /* Handle vertical lines. */
+
+       for (vert = 0; '|' == p[*pos]; ++*pos)
+               vert++;
+       while (' ' == p[*pos])
+               (*pos)++;
+
+       /* Parse the column position (`c', `l', `r', ...). */

 
        for (i = 0; i < KEYS_MAX; i++)
 
        for (i = 0; i < KEYS_MAX; i++)

-               if (p[*pos] == keys[i].name)
+               if (tolower((unsigned char)p[*pos]) == keys[i].name)

                        break;
 
        if (KEYS_MAX == i) {
                        break;
 
        if (KEYS_MAX == i) {

-               TBL_MSG(tbl, MANDOCERR_TBLLAYOUT, ln, *pos);
+               mandoc_msg(MANDOCERR_TBLLAYOUT, tbl->parse, 
+                               ln, *pos, NULL);

                return(0);
        }
 
                return(0);
        }
 

-       (*pos)++;

        c = keys[i].key;
 
        c = keys[i].key;
 

-       /* Extra check for the double-vertical. */
+       /*
+        * If a span cell is found first, raise a warning and abort the
+        * parse.  If a span cell is found and the last layout element
+        * isn't a "normal" layout, bail.
+        *
+        * FIXME: recover from this somehow?
+        */

 
 

-       if (TBL_CELL_VERT == c && '|' == p[*pos]) {
-               (*pos)++;
-               c = TBL_CELL_DVERT;
-       } 
-       
-       /* Disallow adjacent spacers. */
+       if (TBL_CELL_SPAN == c) {
+               if (NULL == rp->first) {
+                       mandoc_msg(MANDOCERR_TBLLAYOUT, tbl->parse,
+                                       ln, *pos, NULL);
+                       return(0);
+               } else if (rp->last)
+                       switch (rp->last->pos) {
+                       case (TBL_CELL_HORIZ):
+                       case (TBL_CELL_DHORIZ):
+                               mandoc_msg(MANDOCERR_TBLLAYOUT, tbl->parse,
+                                               ln, *pos, NULL);
+                               return(0);
+                       default:
+                               break;
+                       }
+       }
+
+       /*
+        * If a vertical spanner is found, we may not be in the first
+        * row.
+        */

 
 

-       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);
+       if (TBL_CELL_DOWN == c && rp == tbl->first_row) {
+               mandoc_msg(MANDOCERR_TBLLAYOUT, tbl->parse, ln, *pos, NULL);

                return(0);
        }
 
                return(0);
        }
 

-       /* Allocate cell then parse its modifiers. */
+       (*pos)++;

 
 

-       cp = mandoc_calloc(1, sizeof(struct tbl_cell));
-       cp->pos = c;
+       /* Disallow adjacent spacers. */

 
 

-       if (rp->last) {
-               rp->last->next = cp;
-               rp->last = cp;
-       } else
-               rp->last = rp->first = cp;
+       if (vert > 2) {
+               mandoc_msg(MANDOCERR_TBLLAYOUT, tbl->parse, ln, *pos - 1, NULL);
+               return(0);
+       }

 
 

-       return(mods(tbl, cp, ln, p, pos));
+       /* Allocate cell then parse its modifiers. */
+
+       return(mods(tbl, cell_alloc(tbl, rp, c, vert), ln, p, pos));

 }
 
 
 static void
 }
 
 
 static void

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

 {
        struct tbl_row  *rp;
 
 {
        struct tbl_row  *rp;
 


@@ -240,11 +298,11 @@ row:      /*
         */
 
        rp = mandoc_calloc(1, sizeof(struct tbl_row));
         */
 
        rp = mandoc_calloc(1, sizeof(struct tbl_row));

-       if (tbl->last) {
-               tbl->last->next = rp;
-               tbl->last = rp;
-       } else
-               tbl->last = tbl->first = rp;
+       if (tbl->last_row)
+               tbl->last_row->next = rp;
+       else
+               tbl->first_row = rp;
+       tbl->last_row = rp;

 
 cell:
        while (isspace((unsigned char)p[*pos]))
 
 cell:
        while (isspace((unsigned char)p[*pos]))


@@ -254,8 +312,9 @@ cell:
 
        if ('.' == p[*pos]) {
                tbl->part = TBL_PART_DATA;
 
        if ('.' == p[*pos]) {
                tbl->part = TBL_PART_DATA;

-               if (NULL == tbl->first) 
-                       TBL_MSG(tbl, MANDOCERR_TBLNOLAYOUT, ln, *pos);
+               if (NULL == tbl->first_row) 
+                       mandoc_msg(MANDOCERR_TBLNOLAYOUT, tbl->parse, 
+                                       ln, *pos, NULL);

                (*pos)++;
                return;
        }
                (*pos)++;
                return;
        }


@@ -275,9 +334,8 @@ cell:
        /* NOTREACHED */
 }
 
        /* NOTREACHED */
 }
 

-

 int
 int

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

 {
        int              pos;
 
 {
        int              pos;
 


@@ -287,3 +345,46 @@ tbl_layout(struct tbl *tbl, int ln, const char *p)
        /* Always succeed. */
        return(1);
 }
        /* Always succeed. */
        return(1);
 }

+
+static struct tbl_cell *
+cell_alloc(struct tbl_node *tbl, struct tbl_row *rp, enum tbl_cellt pos,
+               int vert)
+{
+       struct tbl_cell *p, *pp;
+       struct tbl_head *h, *hp;
+
+       p = mandoc_calloc(1, sizeof(struct tbl_cell));
+
+       if (NULL != (pp = rp->last)) {
+               pp->next = p;
+               h = pp->head->next;
+       } else {
+               rp->first = p;
+               h = tbl->first_head;
+       }
+       rp->last = p;
+
+       p->pos = pos;
+       p->vert = vert;
+
+       /* Re-use header. */
+
+       if (h) {
+               p->head = h;
+               return(p);
+       }
+
+       hp = mandoc_calloc(1, sizeof(struct tbl_head));
+       hp->ident = tbl->opts.cols++;
+       hp->vert = vert;
+
+       if (tbl->last_head) {
+               hp->prev = tbl->last_head;
+               tbl->last_head->next = hp;
+       } else
+               tbl->first_head = hp;
+       tbl->last_head = hp;
+
+       p->head = hp;
+       return(p);
+}