]> git.cameronkatri.com Git - mandoc.git/blobdiff - man_macro.c
The st_size member of struct stat is off_t, which is signed,
[mandoc.git] / man_macro.c
index c9ee79ddffb37407440c22b0ba493c3132bb19cd..c86ab6f13f01bcccf014c34e34dc3a492102d5d2 100644 (file)
@@ -1,7 +1,7 @@
-/*     $Id: man_macro.c,v 1.90 2014/11/03 23:18:39 schwarze Exp $ */
+/*     $Id: man_macro.c,v 1.98 2015/02/06 11:54:36 schwarze Exp $ */
 /*
  * Copyright (c) 2008, 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv>
- * Copyright (c) 2012, 2013, 2014 Ingo Schwarze <schwarze@openbsd.org>
+ * Copyright (c) 2012, 2013, 2014, 2015 Ingo Schwarze <schwarze@openbsd.org>
  * Copyright (c) 2013 Franco Fichtner <franco@lastsummer.de>
  *
  * Permission to use, copy, modify, and distribute this software for any
@@ -36,14 +36,14 @@ enum        rew {
        REW_HALT
 };
 
-static int              blk_close(MACRO_PROT_ARGS);
-static int              blk_exp(MACRO_PROT_ARGS);
-static int              blk_imp(MACRO_PROT_ARGS);
-static int              in_line_eoln(MACRO_PROT_ARGS);
+static void             blk_close(MACRO_PROT_ARGS);
+static void             blk_exp(MACRO_PROT_ARGS);
+static void             blk_imp(MACRO_PROT_ARGS);
+static void             in_line_eoln(MACRO_PROT_ARGS);
 static int              man_args(struct man *, int,
                                int *, char *, char **);
 
-static int              rew_scope(enum man_type,
+static void             rew_scope(enum man_type,
                                struct man *, enum mant);
 static enum rew         rew_dohalt(enum mant, enum man_type,
                                const struct man_node *);
@@ -72,11 +72,10 @@ const       struct man_macro __man_macros[MAN_MAX] = {
        { in_line_eoln, MAN_SCOPED | MAN_JOIN }, /* I */
        { in_line_eoln, 0 }, /* IR */
        { in_line_eoln, 0 }, /* RI */
-       { in_line_eoln, MAN_NSCOPED }, /* na */
        { in_line_eoln, MAN_NSCOPED }, /* sp */
        { in_line_eoln, MAN_BSCOPE }, /* nf */
        { in_line_eoln, MAN_BSCOPE }, /* fi */
-       { blk_close, 0 }, /* RE */
+       { blk_close, MAN_BSCOPE }, /* RE */
        { blk_exp, MAN_BSCOPE | MAN_EXPLICIT }, /* RS */
        { in_line_eoln, 0 }, /* DT */
        { in_line_eoln, 0 }, /* UC */
@@ -88,14 +87,14 @@ const       struct man_macro __man_macros[MAN_MAX] = {
        { in_line_eoln, MAN_BSCOPE }, /* EX */
        { in_line_eoln, MAN_BSCOPE }, /* EE */
        { blk_exp, MAN_BSCOPE | MAN_EXPLICIT }, /* UR */
-       { blk_close, 0 }, /* UE */
+       { blk_close, MAN_BSCOPE }, /* UE */
        { in_line_eoln, 0 }, /* ll */
 };
 
 const  struct man_macro * const man_macros = __man_macros;
 
 
-int
+void
 man_unscope(struct man *man, const struct man_node *to)
 {
        struct man_node *n;
@@ -141,8 +140,7 @@ man_unscope(struct man *man, const struct man_node *to)
 
                man->last = n;
                n = n->parent;
-               if ( ! man_valid_post(man))
-                       return(0);
+               man_valid_post(man);
        }
 
        /*
@@ -154,16 +152,14 @@ man_unscope(struct man *man, const struct man_node *to)
 
        man->next = (man->last == to) ?
            MAN_NEXT_CHILD : MAN_NEXT_SIBLING;
-
-       return(1);
 }
 
 static enum rew
 rew_block(enum mant ntok, enum man_type type, const struct man_node *n)
 {
 
-       if (MAN_BLOCK == type && ntok == n->parent->tok &&
-           MAN_BODY == n->parent->type)
+       if (type == MAN_BLOCK && ntok == n->parent->tok &&
+           n->parent->type == MAN_BODY)
                return(REW_REWIND);
        return(ntok == n->tok ? REW_HALT : REW_NOHALT);
 }
@@ -246,7 +242,7 @@ rew_dohalt(enum mant tok, enum man_type type, const struct man_node *n)
  * for example, the `SH' macro will close out any intervening `SS'
  * scopes.  When a scope is closed, it must be validated and actioned.
  */
-static int
+static void
 rew_scope(enum man_type type, struct man *man, enum mant tok)
 {
        struct man_node *n;
@@ -260,7 +256,7 @@ rew_scope(enum man_type type, struct man *man, enum mant tok)
                 */
                c = rew_dohalt(tok, type, n);
                if (REW_HALT == c)
-                       return(1);
+                       return;
                if (REW_REWIND == c)
                        break;
        }
@@ -269,24 +265,43 @@ rew_scope(enum man_type type, struct man *man, enum mant tok)
         * Rewind until the current point.  Warn if we're a roff
         * instruction that's mowing over explicit scopes.
         */
-       assert(n);
 
-       return(man_unscope(man, n));
+       man_unscope(man, n);
 }
 
 
 /*
  * Close out a generic explicit macro.
  */
-int
+void
 blk_close(MACRO_PROT_ARGS)
 {
        enum mant                ntok;
        const struct man_node   *nn;
+       char                    *p;
+       int                      nrew, target;
 
+       nrew = 1;
        switch (tok) {
        case MAN_RE:
                ntok = MAN_RS;
+               if ( ! man_args(man, line, pos, buf, &p))
+                       break;
+               for (nn = man->last->parent; nn; nn = nn->parent)
+                       if (nn->tok == ntok && nn->type == MAN_BLOCK)
+                               nrew++;
+               target = strtol(p, &p, 10);
+               if (*p != '\0')
+                       mandoc_vmsg(MANDOCERR_ARG_EXCESS, man->parse,
+                           line, p - buf, "RE ... %s", p);
+               if (target == 0)
+                       target = 1;
+               nrew -= target;
+               if (nrew < 1) {
+                       mandoc_vmsg(MANDOCERR_RE_NOTOPEN, man->parse,
+                           line, ppos, "RE %d", target);
+                       return;
+               }
                break;
        case MAN_UE:
                ntok = MAN_UR;
@@ -297,57 +312,51 @@ blk_close(MACRO_PROT_ARGS)
        }
 
        for (nn = man->last->parent; nn; nn = nn->parent)
-               if (ntok == nn->tok && MAN_BLOCK == nn->type)
+               if (nn->tok == ntok && nn->type == MAN_BLOCK && ! --nrew)
                        break;
 
-       if (NULL == nn) {
+       if (nn == NULL) {
                mandoc_msg(MANDOCERR_BLK_NOTOPEN, man->parse,
                    line, ppos, man_macronames[tok]);
-               if ( ! rew_scope(MAN_BLOCK, man, MAN_PP))
-                       return(0);
-       } else
+               rew_scope(MAN_BLOCK, man, MAN_PP);
+       } else {
+               line = man->last->line;
+               ppos = man->last->pos;
+               ntok = man->last->tok;
                man_unscope(man, nn);
 
-       return(1);
+               /* Move a trailing paragraph behind the block. */
+
+               if (ntok == MAN_LP || ntok == MAN_PP || ntok == MAN_P) {
+                       *pos = strlen(buf);
+                       blk_imp(man, ntok, line, ppos, pos, buf);
+               }
+       }
 }
 
-int
+void
 blk_exp(MACRO_PROT_ARGS)
 {
-       struct man_node *n;
-       int              la;
+       struct man_node *head;
        char            *p;
+       int              la;
 
-       /* Close out prior implicit scopes. */
-
-       if ( ! rew_scope(MAN_BLOCK, man, tok))
-               return(0);
-
-       if ( ! man_block_alloc(man, line, ppos, tok))
-               return(0);
-       if ( ! man_head_alloc(man, line, ppos, tok))
-               return(0);
+       rew_scope(MAN_BLOCK, man, tok);
+       man_block_alloc(man, line, ppos, tok);
+       man_head_alloc(man, line, ppos, tok);
+       head = man->last;
 
-       for (;;) {
-               la = *pos;
-               if ( ! man_args(man, line, pos, buf, &p))
-                       break;
-               if ( ! man_word_alloc(man, line, la, p))
-                       return(0);
-       }
+       la = *pos;
+       if (man_args(man, line, pos, buf, &p))
+               man_word_alloc(man, line, la, p);
 
-       assert(man);
-       assert(tok != MAN_MAX);
+       if (buf[*pos] != '\0')
+               mandoc_vmsg(MANDOCERR_ARG_EXCESS,
+                   man->parse, line, *pos, "%s ... %s",
+                   man_macronames[tok], buf + *pos);
 
-       for (n = man->last; n; n = n->parent) {
-               if (n->tok != tok)
-                       continue;
-               assert(MAN_HEAD == n->type);
-               man_unscope(man, n);
-               break;
-       }
-
-       return(man_body_alloc(man, line, ppos, tok));
+       man_unscope(man, head);
+       man_body_alloc(man, line, ppos, tok);
 }
 
 /*
@@ -356,27 +365,17 @@ blk_exp(MACRO_PROT_ARGS)
  * scopes, such as `SH' closing out an `SS', are defined in the rew
  * routines.
  */
-int
+void
 blk_imp(MACRO_PROT_ARGS)
 {
        int              la;
        char            *p;
        struct man_node *n;
 
-       /* Close out prior scopes. */
-
-       if ( ! rew_scope(MAN_BODY, man, tok))
-               return(0);
-       if ( ! rew_scope(MAN_BLOCK, man, tok))
-               return(0);
-
-       /* Allocate new block & head scope. */
-
-       if ( ! man_block_alloc(man, line, ppos, tok))
-               return(0);
-       if ( ! man_head_alloc(man, line, ppos, tok))
-               return(0);
-
+       rew_scope(MAN_BODY, man, tok);
+       rew_scope(MAN_BLOCK, man, tok);
+       man_block_alloc(man, line, ppos, tok);
+       man_head_alloc(man, line, ppos, tok);
        n = man->last;
 
        /* Add line arguments. */
@@ -385,49 +384,58 @@ blk_imp(MACRO_PROT_ARGS)
                la = *pos;
                if ( ! man_args(man, line, pos, buf, &p))
                        break;
-               if ( ! man_word_alloc(man, line, la, p))
-                       return(0);
+               man_word_alloc(man, line, la, p);
        }
 
        /* Close out head and open body (unless MAN_SCOPE). */
 
-       if (MAN_SCOPED & man_macros[tok].flags) {
+       if (man_macros[tok].flags & MAN_SCOPED) {
                /* If we're forcing scope (`TP'), keep it open. */
-               if (MAN_FSCOPED & man_macros[tok].flags) {
+               if (man_macros[tok].flags & MAN_FSCOPED) {
                        man->flags |= MAN_BLINE;
-                       return(1);
+                       return;
                } else if (n == man->last) {
                        man->flags |= MAN_BLINE;
-                       return(1);
+                       return;
                }
        }
-
-       if ( ! rew_scope(MAN_HEAD, man, tok))
-               return(0);
-       return(man_body_alloc(man, line, ppos, tok));
+       rew_scope(MAN_HEAD, man, tok);
+       man_body_alloc(man, line, ppos, tok);
 }
 
-int
+void
 in_line_eoln(MACRO_PROT_ARGS)
 {
        int              la;
        char            *p;
        struct man_node *n;
 
-       if ( ! man_elem_alloc(man, line, ppos, tok))
-               return(0);
-
+       man_elem_alloc(man, line, ppos, tok);
        n = man->last;
 
        for (;;) {
+               if (buf[*pos] != '\0' && (tok == MAN_br ||
+                   tok == MAN_fi || tok == MAN_nf)) {
+                       mandoc_vmsg(MANDOCERR_ARG_SKIP,
+                           man->parse, line, *pos, "%s %s",
+                           man_macronames[tok], buf + *pos);
+                       break;
+               }
+               if (buf[*pos] != '\0' && man->last != n &&
+                   (tok == MAN_PD || tok == MAN_ft || tok == MAN_sp)) {
+                       mandoc_vmsg(MANDOCERR_ARG_EXCESS,
+                           man->parse, line, *pos, "%s ... %s",
+                           man_macronames[tok], buf + *pos);
+                       break;
+               }
                la = *pos;
                if ( ! man_args(man, line, pos, buf, &p))
                        break;
                if (man_macros[tok].flags & MAN_JOIN &&
                    man->last->type == MAN_TEXT)
                        man_word_append(man, p);
-               else if ( ! man_word_alloc(man, line, la, p))
-                       return(0);
+               else
+                       man_word_alloc(man, line, la, p);
        }
 
        /*
@@ -445,13 +453,13 @@ in_line_eoln(MACRO_PROT_ARGS)
         * waiting for terms to load into our context.
         */
 
-       if (n == man->last && MAN_SCOPED & man_macros[tok].flags) {
-               assert( ! (MAN_NSCOPED & man_macros[tok].flags));
+       if (n == man->last && man_macros[tok].flags & MAN_SCOPED) {
+               assert( ! (man_macros[tok].flags & MAN_NSCOPED));
                man->flags |= MAN_ELINE;
-               return(1);
+               return;
        }
 
-       assert(MAN_ROOT != man->last->type);
+       assert(man->last->type != MAN_ROOT);
        man->next = MAN_NEXT_SIBLING;
 
        /*
@@ -465,8 +473,7 @@ in_line_eoln(MACRO_PROT_ARGS)
                        break;
                if (man->last->type == MAN_ROOT)
                        break;
-               if ( ! man_valid_post(man))
-                       return(0);
+               man_valid_post(man);
        }
 
        assert(man->last);
@@ -475,18 +482,16 @@ in_line_eoln(MACRO_PROT_ARGS)
         * Same here regarding whether we're back at the root.
         */
 
-       if (man->last->type != MAN_ROOT && ! man_valid_post(man))
-               return(0);
-
-       return(1);
+       if (man->last->type != MAN_ROOT)
+               man_valid_post(man);
 }
 
 
-int
+void
 man_macroend(struct man *man)
 {
 
-       return(man_unscope(man, man->first));
+       man_unscope(man, man->first);
 }
 
 static int