Removed superfluous XXX.

[mandoc.git] / man.c

diff --git a/man.c b/man.c
index e5a66be96eee57fd420e452fb85db3c5d7acbc33..5763c9ea948aebbe5dee427e8cab5164b6a2dadc 100644 (file)
--- a/man.c
+++ b/man.c
@@ -1,4 +1,4 @@
-/*     $Id: man.c,v 1.30 2009/08/19 09:14:50 kristaps Exp $ */
+/*     $Id: man.c,v 1.36 2009/08/21 13:18:32 kristaps Exp $ */
 /*
  * Copyright (c) 2008, 2009 Kristaps Dzonsons <kristaps@kth.se>
  *
@@ -41,7 +41,9 @@ const char *const __man_merrnames[WERRMAX] = {
        "unknown macro", /* WMACRO */
        "ill-formed macro", /* WMACROFORM */
        "scope open on exit", /* WEXITSCOPE */
-       "no scope context" /* WNOSCOPE */
+       "no scope context", /* WNOSCOPE */
+       "literal context already open", /* WOLITERAL */
+       "no literal context open" /* WNLITERAL */
 };
 
 const  char *const __man_macronames[MAN_MAX] = {                
@@ -52,7 +54,7 @@ const char *const __man_macronames[MAN_MAX] = {
        "R",            "B",            "I",            "IR",
        "RI",           "na",           "i",            "sp",
        "nf",           "fi",           "r",            "RE",
-       "RS"
+       "RS",           "DT"
        };
 
 const  char * const *man_macronames = __man_macronames;
@@ -65,6 +67,12 @@ static       int              man_ptext(struct man *, int, char *);
 static int              man_pmacro(struct man *, int, char *);
 static void             man_free1(struct man *);
 static int              man_alloc1(struct man *);
+static int              pstring(struct man *, int, int, 
+                               const char *, size_t);
+
+#ifdef __linux__
+extern size_t            strlcpy(char *, const char *, size_t);
+#endif
 
 
 const struct man_node *
@@ -318,23 +326,43 @@ man_block_alloc(struct man *m, int line, int pos, int tok)
 }
 
 
-int
-man_word_alloc(struct man *m, int line, int pos, const char *word)
+static int
+pstring(struct man *m, int line, int pos, 
+               const char *p, size_t len)
 {
-       struct man_node *p;
+       struct man_node *n;
+       size_t           sv;
 
-       p = man_node_alloc(line, pos, MAN_TEXT, -1);
-       if (NULL == p)
+       n = man_node_alloc(line, pos, MAN_TEXT, -1);
+       if (NULL == n)
                return(0);
-       if (NULL == (p->string = strdup(word)))
+
+       n->string = malloc(len + 1);
+       if (NULL == n->string) {
+               free(n);
                return(0);
-       if ( ! man_node_append(m, p))
+       }
+
+       sv = strlcpy(n->string, p, len + 1);
+
+       /* Prohibit truncation. */
+       assert(sv < len + 1);
+
+       if ( ! man_node_append(m, n))
                return(0);
        m->next = MAN_NEXT_SIBLING;
        return(1);
 }
 
 
+int
+man_word_alloc(struct man *m, int line, int pos, const char *word)
+{
+
+       return(pstring(m, line, pos, word, strlen(word)));
+}
+
+
 void
 man_node_free(struct man_node *p)
 {
@@ -364,14 +392,50 @@ man_node_freelist(struct man_node *p)
 static int
 man_ptext(struct man *m, int line, char *buf)
 {
+       int              i, j;
 
-       /* First allocate word. */
+       /* Literal free-form text whitespace is preserved. */
 
-       /* FIXME: dechunk words! */
+       if (MAN_LITERAL & m->flags) {
+               if ( ! man_word_alloc(m, line, 0, buf))
+                       return(0);
+               goto descope;
+       }
 
-       if ( ! man_word_alloc(m, line, 0, buf))
+       /* First de-chunk and allocate words. */
+
+       for (i = 0; ' ' == buf[i]; i++)
+               /* Skip leading whitespace. */ ;
+       if (0 == buf[i]) {
+               if ( ! pstring(m, line, 0, &buf[i], 0))
+                       return(0);
+               goto descope;
+       }
+
+       for (j = i; buf[i]; i++) {
+               if (' ' != buf[i])
+                       continue;
+
+               /* Escaped whitespace. */
+               if (i && ' ' == buf[i] && '\\' == buf[i - 1])
+                       continue;
+
+               buf[i++] = 0;
+               if ( ! pstring(m, line, j, &buf[j], (size_t)(i - j)))
+                       return(0);
+
+               for ( ; ' ' == buf[i]; i++)
+                       /* Skip trailing whitespace. */ ;
+
+               j = i;
+               if (0 == buf[i])
+                       break;
+       }
+
+       if (j != i && ! pstring(m, line, j, &buf[j], (size_t)(i - j)))
                return(0);
-       m->next = MAN_NEXT_SIBLING;
+
+descope:
 
        /*
         * Co-ordinate what happens with having a next-line scope open:
@@ -379,8 +443,6 @@ man_ptext(struct man *m, int line, char *buf)
         * out the block scope (also if applicable).
         */
 
-       /* XXX - this should be in man_action.c. */
-
        if (MAN_ELINE & m->flags) {
                m->flags &= ~MAN_ELINE;
                if ( ! man_unscope(m, m->last->parent))
@@ -400,8 +462,9 @@ man_ptext(struct man *m, int line, char *buf)
 int
 man_pmacro(struct man *m, int ln, char *buf)
 {
-       int               i, j, c, ppos, fl;
-       char              mac[5];
+       int              i, j, c, ppos, fl;
+       char             mac[5];
+       struct man_node *n;
 
        /* Comments and empties are quickly ignored. */
 
@@ -458,6 +521,29 @@ man_pmacro(struct man *m, int ln, char *buf)
        while (buf[i] && ' ' == buf[i])
                i++;
 
+       /* Remove prior ELINE macro, if applicable. */
+
+       if (m->flags & MAN_ELINE) {
+               n = m->last;
+               assert(NULL == n->child);
+               if ( ! man_nwarn(m, n, WLNSCOPE))
+                       return(0);
+
+               if (n->prev) {
+                       assert(n != n->parent->child);
+                       assert(n == n->prev->next);
+                       n->prev->next = NULL;
+                       m->last = n->prev;
+               } else {
+                       assert(n == n->parent->child);
+                       n->parent->child = NULL;
+                       m->last = n->parent;
+               }
+
+               man_node_free(n);
+               m->flags &= ~MAN_ELINE;
+       }
+
        /* Begin recursive parse sequence. */
 
        assert(man_macros[c].fp);
@@ -479,8 +565,6 @@ out:
 
        /* Close out the block scope opened in the prior line.  */
 
-       /* XXX - this should be in man_action.c. */
-
        assert(MAN_BLINE & m->flags);
        m->flags &= ~MAN_BLINE;