Break schwarze@'s release notes into sections. Ok schwarze@.

[mandoc.git] / man.c

diff --git a/man.c b/man.c
index fc5280a51cfe1315e6c3e65a335c87ed8346e479..52592d4a6ed4f469bf6c242fdfbc53a0faccabcd 100644 (file)
--- a/man.c
+++ b/man.c
@@ -1,4 +1,4 @@
-/*     $Id: man.c,v 1.104 2011/03/20 16:02:05 kristaps Exp $ */
+/*     $Id: man.c,v 1.111 2011/07/28 14:17:11 kristaps Exp $ */
 /*
  * Copyright (c) 2008, 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv>
  *
@@ -26,6 +26,7 @@
 #include <stdio.h>
 #include <string.h>
 
+#include "man.h"
 #include "mandoc.h"
 #include "libman.h"
 #include "libmandoc.h"
@@ -95,7 +96,7 @@ man_free(struct man *man)
 
 
 struct man *
-man_alloc(struct regset *regs, struct mparse *parse)
+man_alloc(struct roff *roff, struct mparse *parse)
 {
        struct man      *p;
 
@@ -103,7 +104,7 @@ man_alloc(struct regset *regs, struct mparse *parse)
 
        man_hash_init();
        p->parse = parse;
-       p->regs = regs;
+       p->roff = roff;
 
        man_alloc1(p);
        return(p);
@@ -129,7 +130,8 @@ man_parseln(struct man *m, int ln, char *buf, int offs)
        m->flags |= MAN_NEWLINE;
 
        assert( ! (MAN_HALT & m->flags));
-       return(('.' == buf[offs] || '\'' == buf[offs]) ? 
+
+       return (mandoc_getcontrol(buf, &offs) ?
                        man_pmacro(m, ln, buf, offs) : 
                        man_ptext(m, ln, buf, offs));
 }
@@ -202,6 +204,10 @@ man_node_append(struct man *man, struct man_node *p)
                assert(MAN_BLOCK == p->parent->type);
                p->parent->head = p;
                break;
+       case (MAN_TAIL):
+               assert(MAN_BLOCK == p->parent->type);
+               p->parent->tail = p;
+               break;
        case (MAN_BODY):
                assert(MAN_BLOCK == p->parent->type);
                p->parent->body = p;
@@ -259,6 +265,19 @@ man_elem_alloc(struct man *m, int line, int pos, enum mant tok)
 }
 
 
+int
+man_tail_alloc(struct man *m, int line, int pos, enum mant tok)
+{
+       struct man_node *p;
+
+       p = man_node_alloc(m, line, pos, MAN_TAIL, tok);
+       if ( ! man_node_append(m, p))
+               return(0);
+       m->next = MAN_NEXT_CHILD;
+       return(1);
+}
+
+
 int
 man_head_alloc(struct man *m, int line, int pos, enum mant tok)
 {
@@ -301,16 +320,9 @@ int
 man_word_alloc(struct man *m, int line, int pos, const char *word)
 {
        struct man_node *n;
-       size_t           sv, len;
-
-       len = strlen(word);
 
        n = man_node_alloc(m, line, pos, MAN_TEXT, MAN_MAX);
-       n->string = mandoc_malloc(len + 1);
-       sv = strlcpy(n->string, word, len + 1);
-
-       /* Prohibit truncation. */
-       assert(sv < len + 1);
+       n->string = roff_strdup(m->roff, word);
 
        if ( ! man_node_append(m, n))
                return(0);
@@ -352,14 +364,14 @@ man_addeqn(struct man *m, const struct eqn *ep)
 
        assert( ! (MAN_HALT & m->flags));
 
-       n = man_node_alloc(m, ep->line, ep->pos, MAN_EQN, MAN_MAX);
+       n = man_node_alloc(m, ep->ln, ep->pos, MAN_EQN, MAN_MAX);
        n->eqn = ep;
 
        if ( ! man_node_append(m, n))
                return(0);
 
        m->next = MAN_NEXT_SIBLING;
-       return(man_descope(m, ep->line, ep->pos));
+       return(man_descope(m, ep->ln, ep->pos));
 }
 
 int
@@ -403,21 +415,11 @@ man_descope(struct man *m, int line, int offs)
        return(man_body_alloc(m, line, offs, m->last->tok));
 }
 
-
 static int
 man_ptext(struct man *m, int line, char *buf, int offs)
 {
        int              i;
 
-       /* Ignore bogus comments. */
-
-       if ('\\' == buf[offs] && 
-                       '.' == buf[offs + 1] && 
-                       '"' == buf[offs + 2]) {
-               man_pmsg(m, line, offs, MANDOCERR_BADCOMMENT);
-               return(1);
-       }
-
        /* Literal free-form text whitespace is preserved. */
 
        if (MAN_LITERAL & m->flags) {
@@ -475,50 +477,36 @@ man_ptext(struct man *m, int line, char *buf, int offs)
        return(man_descope(m, line, offs));
 }
 
-
 static int
 man_pmacro(struct man *m, int ln, char *buf, int offs)
 {
-       int              i, j, ppos;
+       int              i, ppos;
        enum mant        tok;
        char             mac[5];
        struct man_node *n;
 
-       /* Comments and empties are quickly ignored. */
-
-       offs++;
-
-       if ('\0' == buf[offs])
+       if ('"' == buf[offs]) {
+               man_pmsg(m, ln, offs, MANDOCERR_BADCOMMENT);
+               return(1);
+       } else if ('\0' == buf[offs])
                return(1);
 
-       i = offs;
-
-       /*
-        * Skip whitespace between the control character and initial
-        * text.  "Whitespace" is both spaces and tabs.
-        */
-
-       if (' ' == buf[i] || '\t' == buf[i]) {
-               i++;
-               while (buf[i] && (' ' == buf[i] || '\t' == buf[i]))
-                       i++;
-               if ('\0' == buf[i])
-                       goto out;
-       }
-
-       ppos = i;
+       ppos = offs;
 
        /*
         * Copy the first word into a nil-terminated buffer.
         * Stop copying when a tab, space, or eoln is encountered.
         */
 
-       j = 0;
-       while (j < 4 && '\0' != buf[i] && ' ' != buf[i] && '\t' != buf[i])
-               mac[j++] = buf[i++];
-       mac[j] = '\0';
+       i = 0;
+       while (i < 4 && '\0' != buf[offs] && 
+                       ' ' != buf[offs] && '\t' != buf[offs])
+               mac[i++] = buf[offs++];
+
+       mac[i] = '\0';
+
+       tok = (i > 0 && i < 4) ? man_hash_find(mac) : MAN_MAX;
 
-       tok = (j > 0 && j < 4) ? man_hash_find(mac) : MAN_MAX;
        if (MAN_MAX == tok) {
                mandoc_vmsg(MANDOCERR_MACRO, m->parse, ln, 
                                ppos, "%s", buf + ppos - 1);
@@ -527,16 +515,16 @@ man_pmacro(struct man *m, int ln, char *buf, int offs)
 
        /* The macro is sane.  Jump to the next word. */
 
-       while (buf[i] && ' ' == buf[i])
-               i++;
+       while (buf[offs] && ' ' == buf[offs])
+               offs++;
 
        /* 
         * Trailing whitespace.  Note that tabs are allowed to be passed
         * into the parser as "text", so we only warn about spaces here.
         */
 
-       if ('\0' == buf[i] && ' ' == buf[i - 1])
-               man_pmsg(m, ln, i - 1, MANDOCERR_EOLNSPACE);
+       if ('\0' == buf[offs] && ' ' == buf[offs - 1])
+               man_pmsg(m, ln, offs - 1, MANDOCERR_EOLNSPACE);
 
        /* 
         * Remove prior ELINE macro, as it's being clobbered by a new
@@ -573,10 +561,9 @@ man_pmacro(struct man *m, int ln, char *buf, int offs)
        /* Call to handler... */
 
        assert(man_macros[tok].fp);
-       if ( ! (*man_macros[tok].fp)(m, tok, ln, ppos, &i, buf))
+       if ( ! (*man_macros[tok].fp)(m, tok, ln, ppos, &offs, buf))
                goto err;
 
-out:
        /* 
         * We weren't in a block-line scope when entering the
         * above-parsed macro, so return.
@@ -613,7 +600,7 @@ out:
 
        if ( ! man_unscope(m, m->last->parent, MANDOCERR_MAX))
                return(0);
-       return(man_body_alloc(m, ln, offs, m->last->tok));
+       return(man_body_alloc(m, ln, ppos, m->last->tok));
 
 err:   /* Error out. */