Strings abstracted into dynamically-created C files.

[mandoc.git] / macro.c

diff --git a/macro.c b/macro.c
index c18cfe630a9076cf31bb2bea229df0031b9cd195..939ac3bdc3bc20dafb9a1b301e3645d10ce7bcd0 100644 (file)
--- a/macro.c
+++ b/macro.c
@@ -1,4 +1,4 @@
-/* $Id: macro.c,v 1.48 2009/01/20 20:56:21 kristaps Exp $ */
+/* $Id: macro.c,v 1.57 2009/03/06 14:13:47 kristaps Exp $ */

 /*
  * Copyright (c) 2008 Kristaps Dzonsons <kristaps@kth.se>
  *
 /*
  * Copyright (c) 2008 Kristaps Dzonsons <kristaps@kth.se>
  *


@@ -28,58 +28,29 @@
 /*
  * This has scanning/parsing routines, each of which extract a macro and
  * its arguments and parameters, then know how to progress to the next
 /*
  * This has scanning/parsing routines, each of which extract a macro and
  * its arguments and parameters, then know how to progress to the next

- * macro.  Macros are parsed according as follows:
- *
- *   ELEMENT:    TEXT | epsilon
- *   BLOCK:      HEAD PUNCT BODY PUNCT BLOCK_TAIL PUNCT
- *   BLOCK_TAIL:  TAIL | epsilon
- *   HEAD:       ELEMENT | TEXT | BLOCK | epsilon
- *   BODY:       ELEMENT | TEXT | BLOCK | epsilon
- *   TAIL:       TEXT | epsilon
- *   PUNCT:      TEXT (delimiters) | epsilon
- *
- * These are arranged into a parse tree, an example of which follows:
- *
- *   ROOT
- *       BLOCK (.Sh)
- *           HEAD
- *               TEXT (`NAME')
- *           BODY
- *               ELEMENT (.Nm)
- *                   TEXT (`mdocml')
- *               ELEMENT (.Nd)
- *                   TEXT (`mdoc macro compiler')
- *               BLOCK (.Op)
- *                   HEAD
- *                       ELEMENT (.Fl)
- *                           TEXT (`v')
- *               BLOCK (.Op)
- *                   HEAD
- *                       ELEMENT (.Fl)
- *                           TEXT (`v')
- *                       ELEMENT (.Fl)
- *                           TEXT (`W')
- *                       ELEMENT (.Ns)
- *                       ELEMENT (.Ar)
- *                           TEXT (`err...')
- *
- * These types are always per-line except for block bodies, which may
- * span multiple lines.  Macros are assigned a parsing routine, which
- * corresponds to the type, in the mdoc_macros table.
- *
- * Note that types are general:  there can be several parsing routines
- * corresponding to a single type.  The macro_text function, for
- * example, parses an ELEMENT type (see the function definition for
- * details) that may be interrupted by further macros; the
- * macro_constant function, on the other hand, parses an ELEMENT type
- * spanning a single line.
+ * macro. 
+ */
+
+/* 
+ * FIXME: don't use static mdoc_argv values, as they require us to do a
+ * complicated copy-over when actually assigning them to dynamic memory.

  */
 
 #include "private.h"
 
  */
 
 #include "private.h"
 

+static int       macro_obsolete(MACRO_PROT_ARGS);
+static int       macro_constant(MACRO_PROT_ARGS);
+static int       macro_constant_scoped(MACRO_PROT_ARGS);
+static int       macro_constant_delimited(MACRO_PROT_ARGS);
+static int       macro_text(MACRO_PROT_ARGS);
+static int       macro_scoped(MACRO_PROT_ARGS);
+static int       macro_scoped_close(MACRO_PROT_ARGS);
+static int       macro_scoped_line(MACRO_PROT_ARGS);
+

 #define        REWIND_REWIND   (1 << 0)
 #define        REWIND_NOHALT   (1 << 1)
 #define        REWIND_HALT     (1 << 2)
 #define        REWIND_REWIND   (1 << 0)
 #define        REWIND_NOHALT   (1 << 1)
 #define        REWIND_HALT     (1 << 2)

+

 static int       rewind_dohalt(int, enum mdoc_type, 
                        const struct mdoc_node *);
 static int       rewind_alt(int);
 static int       rewind_dohalt(int, enum mdoc_type, 
                        const struct mdoc_node *);
 static int       rewind_alt(int);


@@ -92,6 +63,179 @@ static      int       rewind_subblock(enum mdoc_type,
 static int       rewind_last(struct mdoc *, struct mdoc_node *);
 static int       append_delims(struct mdoc *, int, int *, char *);
 static int       lookup(struct mdoc *, int, int, int, const char *);
 static int       rewind_last(struct mdoc *, struct mdoc_node *);
 static int       append_delims(struct mdoc *, int, int *, char *);
 static int       lookup(struct mdoc *, int, int, int, const char *);

+static int       pwarn(struct mdoc *, int, int, int);
+static int       perr(struct mdoc *, int, int, int);
+
+#define        WMACPARM        (1)
+#define        WOBS            (2)
+
+#define        ENOCTX          (1)
+#define        ENOPARMS        (2)
+#define        EARGVLIM        (3)
+
+/* Central table of library: who gets parsed how. */
+
+const  struct mdoc_macro __mdoc_macros[MDOC_MAX] = {
+       { NULL, 0 }, /* \" */
+       { macro_constant, MDOC_PROLOGUE }, /* Dd */
+       { macro_constant, MDOC_PROLOGUE }, /* Dt */
+       { macro_constant, MDOC_PROLOGUE }, /* Os */
+       { macro_scoped, 0 }, /* Sh */
+       { macro_scoped, 0 }, /* Ss */ 
+       { macro_text, 0 }, /* Pp */ 
+       { macro_scoped_line, MDOC_PARSED }, /* D1 */
+       { macro_scoped_line, MDOC_PARSED }, /* Dl */
+       { macro_scoped, MDOC_EXPLICIT }, /* Bd */
+       { macro_scoped_close, MDOC_EXPLICIT }, /* Ed */
+       { macro_scoped, MDOC_EXPLICIT }, /* Bl */
+       { macro_scoped_close, MDOC_EXPLICIT }, /* El */
+       { macro_scoped, MDOC_PARSED }, /* It */
+       { macro_text, MDOC_CALLABLE | MDOC_PARSED }, /* Ad */ 
+       { macro_text, MDOC_PARSED }, /* An */
+       { macro_text, MDOC_CALLABLE | MDOC_PARSED }, /* Ar */
+       { macro_constant, 0 }, /* Cd */
+       { macro_text, MDOC_CALLABLE | MDOC_PARSED }, /* Cm */
+       { macro_text, MDOC_CALLABLE | MDOC_PARSED }, /* Dv */ 
+       { macro_text, MDOC_CALLABLE | MDOC_PARSED }, /* Er */ 
+       { macro_text, MDOC_CALLABLE | MDOC_PARSED }, /* Ev */ 
+       { macro_constant, 0 }, /* Ex */
+       { macro_text, MDOC_CALLABLE | MDOC_PARSED }, /* Fa */ 
+       { macro_constant, 0 }, /* Fd */ 
+       { macro_text, MDOC_CALLABLE | MDOC_PARSED }, /* Fl */
+       { macro_text, MDOC_CALLABLE | MDOC_PARSED }, /* Fn */ 
+       { macro_text, MDOC_PARSED }, /* Ft */ 
+       { macro_text, MDOC_CALLABLE | MDOC_PARSED }, /* Ic */ 
+       { macro_constant, 0 }, /* In */ 
+       { macro_text, MDOC_CALLABLE | MDOC_PARSED }, /* Li */
+       { macro_constant, 0 }, /* Nd */ 
+       { macro_text, MDOC_CALLABLE | MDOC_PARSED }, /* Nm */ 
+       { macro_scoped_line, MDOC_CALLABLE | MDOC_PARSED }, /* Op */
+       { macro_obsolete, 0 }, /* Ot */
+       { macro_text, MDOC_CALLABLE | MDOC_PARSED }, /* Pa */
+       { macro_constant, 0 }, /* Rv */
+       /* XXX - .St supposed to be (but isn't) callable. */
+       { macro_constant_delimited, MDOC_PARSED }, /* St */ 
+       { macro_text, MDOC_CALLABLE | MDOC_PARSED }, /* Va */
+       { macro_text, MDOC_CALLABLE | MDOC_PARSED }, /* Vt */ 
+       { macro_text, MDOC_CALLABLE | MDOC_PARSED }, /* Xr */
+       { macro_constant, 0 }, /* %A */
+       { macro_constant, 0 }, /* %B */
+       { macro_constant, 0 }, /* %D */
+       { macro_constant, 0 }, /* %I */
+       { macro_constant, 0 }, /* %J */
+       { macro_constant, 0 }, /* %N */
+       { macro_constant, 0 }, /* %O */
+       { macro_constant, 0 }, /* %P */
+       { macro_constant, 0 }, /* %R */
+       { macro_constant, 0 }, /* %T */
+       { macro_constant, 0 }, /* %V */
+       { macro_scoped_close, MDOC_EXPLICIT | MDOC_CALLABLE | MDOC_PARSED }, /* Ac */
+       { macro_constant_scoped, MDOC_CALLABLE | MDOC_PARSED | MDOC_EXPLICIT }, /* Ao */
+       { macro_scoped_line, MDOC_CALLABLE | MDOC_PARSED }, /* Aq */
+       { macro_constant_delimited, 0 }, /* At */
+       { macro_scoped_close, MDOC_EXPLICIT | MDOC_CALLABLE | MDOC_PARSED }, /* Bc */
+       { macro_scoped, MDOC_EXPLICIT }, /* Bf */ 
+       { macro_constant_scoped, MDOC_CALLABLE | MDOC_PARSED | MDOC_EXPLICIT }, /* Bo */
+       { macro_scoped_line, MDOC_CALLABLE | MDOC_PARSED }, /* Bq */
+       { macro_constant_delimited, MDOC_PARSED }, /* Bsx */
+       { macro_constant_delimited, MDOC_PARSED }, /* Bx */
+       { macro_constant, 0 }, /* Db */
+       { macro_scoped_close, MDOC_EXPLICIT | MDOC_CALLABLE | MDOC_PARSED }, /* Dc */
+       { macro_constant_scoped, MDOC_CALLABLE | MDOC_PARSED | MDOC_EXPLICIT }, /* Do */
+       { macro_scoped_line, MDOC_CALLABLE | MDOC_PARSED }, /* Dq */
+       { macro_scoped_close, MDOC_EXPLICIT | MDOC_CALLABLE | MDOC_PARSED }, /* Ec */
+       { macro_scoped_close, MDOC_EXPLICIT }, /* Ef */
+       { macro_text, MDOC_CALLABLE | MDOC_PARSED }, /* Em */ 
+       { macro_constant_scoped, MDOC_CALLABLE | MDOC_PARSED | MDOC_EXPLICIT }, /* Eo */
+       { macro_constant_delimited, MDOC_PARSED }, /* Fx */
+       { macro_text, MDOC_PARSED }, /* Ms */
+       { macro_constant_delimited, MDOC_CALLABLE | MDOC_PARSED }, /* No */
+       { macro_constant_delimited, MDOC_CALLABLE | MDOC_PARSED }, /* Ns */
+       { macro_constant_delimited, MDOC_PARSED }, /* Nx */
+       { macro_constant_delimited, MDOC_PARSED }, /* Ox */
+       { macro_scoped_close, MDOC_EXPLICIT | MDOC_CALLABLE | MDOC_PARSED }, /* Pc */
+       { macro_constant_delimited, MDOC_PARSED }, /* Pf */
+       { macro_constant_scoped, MDOC_CALLABLE | MDOC_PARSED | MDOC_EXPLICIT }, /* Po */
+       { macro_scoped_line, MDOC_CALLABLE | MDOC_PARSED }, /* Pq */
+       { macro_scoped_close, MDOC_EXPLICIT | MDOC_CALLABLE | MDOC_PARSED }, /* Qc */
+       { macro_scoped_line, MDOC_CALLABLE | MDOC_PARSED }, /* Ql */
+       { macro_constant_scoped, MDOC_CALLABLE | MDOC_PARSED | MDOC_EXPLICIT }, /* Qo */
+       { macro_scoped_line, MDOC_CALLABLE | MDOC_PARSED }, /* Qq */
+       { macro_scoped_close, MDOC_EXPLICIT }, /* Re */
+       { macro_scoped, MDOC_EXPLICIT }, /* Rs */
+       { macro_scoped_close, MDOC_EXPLICIT | MDOC_CALLABLE | MDOC_PARSED }, /* Sc */
+       { macro_constant_scoped, MDOC_CALLABLE | MDOC_PARSED | MDOC_EXPLICIT }, /* So */
+       { macro_scoped_line, MDOC_CALLABLE | MDOC_PARSED }, /* Sq */
+       { macro_constant, 0 }, /* Sm */
+       { macro_text, MDOC_CALLABLE | MDOC_PARSED }, /* Sx */
+       { macro_text, MDOC_CALLABLE | MDOC_PARSED }, /* Sy */
+       { macro_text, MDOC_CALLABLE | MDOC_PARSED }, /* Tn */
+       { macro_constant_delimited, MDOC_PARSED }, /* Ux */
+       { macro_scoped_close, MDOC_EXPLICIT | MDOC_CALLABLE | MDOC_PARSED }, /* Xc */
+       { macro_constant_scoped, MDOC_CALLABLE | MDOC_PARSED | MDOC_EXPLICIT }, /* Xo */
+       /* XXX - .Fo supposed to be (but isn't) callable. */
+       { macro_scoped, MDOC_EXPLICIT }, /* Fo */ 
+       { macro_scoped_close, MDOC_EXPLICIT | MDOC_CALLABLE | MDOC_PARSED }, /* Fc */ 
+       { macro_constant_scoped, MDOC_CALLABLE | MDOC_PARSED | MDOC_EXPLICIT }, /* Oo */
+       { macro_scoped_close, MDOC_EXPLICIT | MDOC_CALLABLE | MDOC_PARSED }, /* Oc */
+       { macro_scoped, MDOC_EXPLICIT }, /* Bk */
+       { macro_scoped_close, MDOC_EXPLICIT }, /* Ek */
+       { macro_constant, 0 }, /* Bt */
+       { macro_constant, 0 }, /* Hf */
+       { macro_obsolete, 0 }, /* Fr */
+       { macro_constant, 0 }, /* Ud */
+       { macro_constant, 0 }, /* Lb */
+};
+
+const  struct mdoc_macro * const mdoc_macros = __mdoc_macros;
+
+
+static int
+perr(struct mdoc *mdoc, int line, int pos, int type)
+{
+       int              c;
+
+       switch (type) {
+       case (ENOCTX):
+               c = mdoc_perr(mdoc, line, pos, 
+                               "closing macro has prior context");
+               break;
+       case (ENOPARMS):
+               c = mdoc_perr(mdoc, line, pos, 
+                               "macro doesn't expect parameters");
+               break;
+       case (EARGVLIM):
+               c = mdoc_perr(mdoc, line, pos, 
+                               "argument hard-limit %d reached",
+                               MDOC_LINEARG_MAX);
+               break;
+       default:
+               abort();
+               /* NOTREACHED */
+       }
+       return(c);
+}
+
+static int
+pwarn(struct mdoc *mdoc, int line, int pos, int type)
+{
+       int              c;
+
+       switch (type) {
+       case (WMACPARM):
+               c = mdoc_pwarn(mdoc, line, pos, WARN_SYNTAX,
+                               "macro-like parameter");
+               break;
+       case (WOBS):
+               c = mdoc_pwarn(mdoc, line, pos, WARN_SYNTAX,
+                               "macro is marked obsolete");
+               break;
+       default:
+               abort();
+               /* NOTREACHED */
+       }
+       return(c);
+}

 
 
 static int
 
 
 static int


@@ -104,7 +248,7 @@ lookup(struct mdoc *mdoc, int line, int pos, int from, const char *p)
                return(res);
        if (MDOC_MAX == res)
                return(res);
                return(res);
        if (MDOC_MAX == res)
                return(res);

-       if ( ! mdoc_pwarn(mdoc, line, pos, WARN_SYNTAX, "macro-like parameter"))
+       if ( ! pwarn(mdoc, line, pos, WMACPARM))

                return(-1);
        return(MDOC_MAX);
 }
                return(-1);
        return(MDOC_MAX);
 }


@@ -117,6 +261,7 @@ rewind_last(struct mdoc *mdoc, struct mdoc_node *to)
        assert(to);
        mdoc->next = MDOC_NEXT_SIBLING;
 
        assert(to);
        mdoc->next = MDOC_NEXT_SIBLING;
 

+       /* LINTED */

        while (mdoc->last != to) {
                if ( ! mdoc_valid_post(mdoc))
                        return(0);
        while (mdoc->last != to) {
                if ( ! mdoc_valid_post(mdoc))
                        return(0);


@@ -378,7 +523,9 @@ rewind_subblock(enum mdoc_type type, struct mdoc *mdoc,
                        break;
                else if (rewind_dobreak(tok, n))
                        continue;
                        break;
                else if (rewind_dobreak(tok, n))
                        continue;

-               return(mdoc_perr(mdoc, line, ppos, "scope breaks prior %s", mdoc_node2a(n)));
+               return(mdoc_perr(mdoc, line, ppos, 
+                       "scope breaks %s", MDOC_ROOT == n->type ?
+                       "<root>" : mdoc_macronames[n->tok]));

        }
 
        assert(n);
        }
 
        assert(n);


@@ -396,12 +543,14 @@ rewind_expblock(struct mdoc *mdoc, int tok, int line, int ppos)
        for (n = mdoc->last; n; n = n->parent) {
                c = rewind_dohalt(tok, MDOC_BLOCK, n);
                if (REWIND_HALT == c)
        for (n = mdoc->last; n; n = n->parent) {
                c = rewind_dohalt(tok, MDOC_BLOCK, n);
                if (REWIND_HALT == c)

-                       return(mdoc_perr(mdoc, line, ppos, "closing macro has no context"));
+                       return(perr(mdoc, line, ppos, ENOCTX));

                if (REWIND_REWIND == c)
                        break;
                else if (rewind_dobreak(tok, n))
                        continue;
                if (REWIND_REWIND == c)
                        break;
                else if (rewind_dobreak(tok, n))
                        continue;

-               return(mdoc_perr(mdoc, line, ppos, "scope breaks prior %s", mdoc_node2a(n)));
+               return(mdoc_perr(mdoc, line, ppos, 
+                       "scope breaks %s", MDOC_ROOT == n->type ?
+                       "<root>" : mdoc_macronames[n->tok]));

        }
 
        assert(n);
        }
 
        assert(n);


@@ -424,7 +573,9 @@ rewind_impblock(struct mdoc *mdoc, int tok, int line, int ppos)
                        break;
                else if (rewind_dobreak(tok, n))
                        continue;
                        break;
                else if (rewind_dobreak(tok, n))
                        continue;

-               return(mdoc_perr(mdoc, line, ppos, "scope breaks prior %s", mdoc_node2a(n)));
+               return(mdoc_perr(mdoc, line, ppos, 
+                       "scope breaks %s", MDOC_ROOT == n->type ?
+                       "<root>" : mdoc_macronames[n->tok]));

        }
 
        assert(n);
        }
 
        assert(n);


@@ -444,6 +595,8 @@ append_delims(struct mdoc *mdoc, int line, int *pos, char *buf)
        for (;;) {
                lastarg = *pos;
                c = mdoc_args(mdoc, line, pos, buf, 0, &p);
        for (;;) {
                lastarg = *pos;
                c = mdoc_args(mdoc, line, pos, buf, 0, &p);

+               assert(ARGS_PHRASE != c);
+

                if (ARGS_ERROR == c)
                        return(0);
                else if (ARGS_EOLN == c)
                if (ARGS_ERROR == c)
                        return(0);
                else if (ARGS_EOLN == c)


@@ -462,7 +615,7 @@ append_delims(struct mdoc *mdoc, int line, int *pos, char *buf)
  * Close out an explicit scope.  This optionally parses a TAIL type with
  * a set number of TEXT children.
  */
  * Close out an explicit scope.  This optionally parses a TAIL type with
  * a set number of TEXT children.
  */

-int
+static int

 macro_scoped_close(MACRO_PROT_ARGS)
 {
        int              tt, j, c, lastarg, maxargs, flushed;
 macro_scoped_close(MACRO_PROT_ARGS)
 {
        int              tt, j, c, lastarg, maxargs, flushed;


@@ -484,11 +637,12 @@ macro_scoped_close(MACRO_PROT_ARGS)
 
        if ( ! (MDOC_CALLABLE & mdoc_macros[tok].flags)) {
                if (0 == buf[*pos]) {
 
        if ( ! (MDOC_CALLABLE & mdoc_macros[tok].flags)) {
                if (0 == buf[*pos]) {

-                       if ( ! rewind_subblock(MDOC_BODY, mdoc, tok, line, ppos))
+                       if ( ! rewind_subblock(MDOC_BODY, mdoc, 
+                                               tok, line, ppos))

                                return(0);
                        return(rewind_expblock(mdoc, tok, line, ppos));
                }
                                return(0);
                        return(rewind_expblock(mdoc, tok, line, ppos));
                }

-               return(mdoc_perr(mdoc, line, ppos, "macro expects no parameters"));
+               return(perr(mdoc, line, ppos, ENOPARMS));

        }
 
        if ( ! rewind_subblock(MDOC_BODY, mdoc, tok, line, ppos))
        }
 
        if ( ! rewind_subblock(MDOC_BODY, mdoc, tok, line, ppos))


@@ -513,6 +667,8 @@ macro_scoped_close(MACRO_PROT_ARGS)
                }
 
                c = mdoc_args(mdoc, line, pos, buf, tok, &p);
                }
 
                c = mdoc_args(mdoc, line, pos, buf, tok, &p);

+               assert(ARGS_PHRASE != c);
+

                if (ARGS_ERROR == c)
                        return(0);
                if (ARGS_PUNCT == c)
                if (ARGS_ERROR == c)
                        return(0);
                if (ARGS_PUNCT == c)


@@ -524,7 +680,8 @@ macro_scoped_close(MACRO_PROT_ARGS)
                        return(0);
                else if (MDOC_MAX != c) {
                        if ( ! flushed) {
                        return(0);
                else if (MDOC_MAX != c) {
                        if ( ! flushed) {

-                               if ( ! rewind_expblock(mdoc, tok, line, ppos))
+                               if ( ! rewind_expblock(mdoc, tok, 
+                                                       line, ppos))

                                        return(0);
                                flushed = 1;
                        }
                                        return(0);
                                flushed = 1;
                        }


@@ -571,7 +728,7 @@ macro_scoped_close(MACRO_PROT_ARGS)
  *    TEXT (`;')
  *    TEXT (`;')
  */
  *    TEXT (`;')
  *    TEXT (`;')
  */

-int
+static int

 macro_text(MACRO_PROT_ARGS)
 {
        int               la, lastpunct, c, w, argc;
 macro_text(MACRO_PROT_ARGS)
 {
        int               la, lastpunct, c, w, argc;


@@ -598,10 +755,11 @@ macro_text(MACRO_PROT_ARGS)
 
        if (MDOC_LINEARG_MAX == argc) {
                mdoc_argv_free(argc - 1, argv);
 
        if (MDOC_LINEARG_MAX == argc) {
                mdoc_argv_free(argc - 1, argv);

-               return(mdoc_perr(mdoc, line, ppos, "parameter hard-limit exceeded"));
+               return(perr(mdoc, line, ppos, EARGVLIM));

        }
 
        }
 

-       c = mdoc_elem_alloc(mdoc, line, ppos, tok, argc, argv);
+       c = mdoc_elem_alloc(mdoc, line, ppos, 
+                       tok, (size_t)argc, argv);

 
        if (0 == c) {
                mdoc_argv_free(argc, argv);
 
        if (0 == c) {
                mdoc_argv_free(argc, argv);


@@ -614,6 +772,8 @@ macro_text(MACRO_PROT_ARGS)
        for (;;) {
                la = *pos;
                w = mdoc_args(mdoc, line, pos, buf, tok, &p);
        for (;;) {
                la = *pos;
                w = mdoc_args(mdoc, line, pos, buf, tok, &p);

+               assert(ARGS_PHRASE != c);
+

                if (ARGS_ERROR == w) {
                        mdoc_argv_free(argc, argv);
                        return(0);
                if (ARGS_ERROR == w) {
                        mdoc_argv_free(argc, argv);
                        return(0);


@@ -644,6 +804,8 @@ macro_text(MACRO_PROT_ARGS)
                        return(0);
                }
 
                        return(0);
                }
 

+               /* FIXME: .Fl and .Ar handling of `|'. */
+

                if (ARGS_QWORD != w && mdoc_isdelim(p)) {
                        if (0 == lastpunct && ! rewind_elem(mdoc, tok)) {
                                mdoc_argv_free(argc, argv);
                if (ARGS_QWORD != w && mdoc_isdelim(p)) {
                        if (0 == lastpunct && ! rewind_elem(mdoc, tok)) {
                                mdoc_argv_free(argc, argv);


@@ -651,8 +813,8 @@ macro_text(MACRO_PROT_ARGS)
                        }
                        lastpunct = 1;
                } else if (lastpunct) {
                        }
                        lastpunct = 1;
                } else if (lastpunct) {

-                       c = mdoc_elem_alloc(mdoc, line, 
-                                       ppos, tok, argc, argv);
+                       c = mdoc_elem_alloc(mdoc, line, ppos, 
+                                       tok, (size_t)argc, argv);

                        if (0 == c) {
                                mdoc_argv_free(argc, argv);
                                return(0);
                        if (0 == c) {
                                mdoc_argv_free(argc, argv);
                                return(0);


@@ -700,7 +862,7 @@ macro_text(MACRO_PROT_ARGS)
  * Note that the `.It' macro, possibly the most difficult (as it has
  * embedded scope, etc.) is handled by this routine.
  */
  * Note that the `.It' macro, possibly the most difficult (as it has
  * embedded scope, etc.) is handled by this routine.
  */

-int
+static int

 macro_scoped(MACRO_PROT_ARGS)
 {
        int               c, lastarg, argc;
 macro_scoped(MACRO_PROT_ARGS)
 {
        int               c, lastarg, argc;


@@ -736,7 +898,7 @@ macro_scoped(MACRO_PROT_ARGS)
 
        if (MDOC_LINEARG_MAX == argc) {
                mdoc_argv_free(argc - 1, argv);
 
        if (MDOC_LINEARG_MAX == argc) {
                mdoc_argv_free(argc - 1, argv);

-               return(mdoc_perr(mdoc, line, ppos, "parameter hard-limit exceeded"));
+               return(perr(mdoc, line, ppos, EARGVLIM));

        }
 
        c = mdoc_block_alloc(mdoc, line, ppos, 
        }
 
        c = mdoc_block_alloc(mdoc, line, ppos, 


@@ -751,7 +913,8 @@ macro_scoped(MACRO_PROT_ARGS)
        if (0 == buf[*pos]) {
                if ( ! mdoc_head_alloc(mdoc, line, ppos, tok))
                        return(0);
        if (0 == buf[*pos]) {
                if ( ! mdoc_head_alloc(mdoc, line, ppos, tok))
                        return(0);

-               if ( ! rewind_subblock(MDOC_HEAD, mdoc, tok, line, ppos))
+               if ( ! rewind_subblock(MDOC_HEAD, mdoc, 
+                                       tok, line, ppos))

                        return(0);
                if ( ! mdoc_body_alloc(mdoc, line, ppos, tok))
                        return(0);
                        return(0);
                if ( ! mdoc_body_alloc(mdoc, line, ppos, tok))
                        return(0);


@@ -766,13 +929,18 @@ macro_scoped(MACRO_PROT_ARGS)
        for (;;) {
                lastarg = *pos;
                c = mdoc_args(mdoc, line, pos, buf, tok, &p);
        for (;;) {
                lastarg = *pos;
                c = mdoc_args(mdoc, line, pos, buf, tok, &p);

-       
+

                if (ARGS_ERROR == c)
                        return(0);
                if (ARGS_ERROR == c)
                        return(0);

-               if (ARGS_PUNCT == c)
-                       break;

                if (ARGS_EOLN == c)
                        break;
                if (ARGS_EOLN == c)
                        break;

+               if (ARGS_PHRASE == c) {
+                       /*
+                       if ( ! mdoc_phrase(mdoc, line, lastarg, buf))
+                               return(0);
+                       */
+                       continue;
+               }

 
                /* FIXME: if .It -column, the lookup must be for a
                 * sub-line component.  BLAH. */
 
                /* FIXME: if .It -column, the lookup must be for a
                 * sub-line component.  BLAH. */


@@ -792,10 +960,10 @@ macro_scoped(MACRO_PROT_ARGS)
                break;
        }
        
                break;
        }
        

-       if ( ! rewind_subblock(MDOC_HEAD, mdoc, tok, line, ppos))
-               return(0);

        if (1 == ppos && ! append_delims(mdoc, line, pos, buf))
                return(0);
        if (1 == ppos && ! append_delims(mdoc, line, pos, buf))
                return(0);

+       if ( ! rewind_subblock(MDOC_HEAD, mdoc, tok, line, ppos))
+               return(0);

 
        if ( ! mdoc_body_alloc(mdoc, line, ppos, tok))
                return(0);
 
        if ( ! mdoc_body_alloc(mdoc, line, ppos, tok))
                return(0);


@@ -824,7 +992,7 @@ macro_scoped(MACRO_PROT_ARGS)
  *         TEXT (`;')
  *         TEXT (`;')
  */
  *         TEXT (`;')
  *         TEXT (`;')
  */

-int
+static int

 macro_scoped_line(MACRO_PROT_ARGS)
 {
        int               lastarg, c;
 macro_scoped_line(MACRO_PROT_ARGS)
 {
        int               lastarg, c;


@@ -847,6 +1015,7 @@ macro_scoped_line(MACRO_PROT_ARGS)
        for (;;) {
                lastarg = *pos;
                c = mdoc_args(mdoc, line, pos, buf, tok, &p);
        for (;;) {
                lastarg = *pos;
                c = mdoc_args(mdoc, line, pos, buf, tok, &p);

+               assert(ARGS_PHRASE != c);

 
                if (ARGS_ERROR == c)
                        return(0);
 
                if (ARGS_ERROR == c)
                        return(0);


@@ -895,7 +1064,7 @@ macro_scoped_line(MACRO_PROT_ARGS)
  *             TEXT (`b')
  *     TEXT (';')
  */
  *             TEXT (`b')
  *     TEXT (';')
  */

-int
+static int

 macro_constant_scoped(MACRO_PROT_ARGS)
 {
        int               lastarg, flushed, j, c, maxargs;
 macro_constant_scoped(MACRO_PROT_ARGS)
 {
        int               lastarg, flushed, j, c, maxargs;


@@ -943,6 +1112,8 @@ macro_constant_scoped(MACRO_PROT_ARGS)
                }
 
                c = mdoc_args(mdoc, line, pos, buf, tok, &p);
                }
 
                c = mdoc_args(mdoc, line, pos, buf, tok, &p);

+               assert(ARGS_PHRASE != c);
+

                if (ARGS_ERROR == c)
                        return(0);
                if (ARGS_PUNCT == c)
                if (ARGS_ERROR == c)
                        return(0);
                if (ARGS_PUNCT == c)


@@ -954,20 +1125,24 @@ macro_constant_scoped(MACRO_PROT_ARGS)
                        return(0);
                else if (MDOC_MAX != c) {
                        if ( ! flushed) {
                        return(0);
                else if (MDOC_MAX != c) {
                        if ( ! flushed) {

-                               if ( ! rewind_subblock(MDOC_HEAD, mdoc, tok, line, ppos))
+                               if ( ! rewind_subblock(MDOC_HEAD, mdoc, 
+                                                       tok, line, ppos))

                                        return(0);
                                flushed = 1;
                                        return(0);
                                flushed = 1;

-                               if ( ! mdoc_body_alloc(mdoc, line, ppos, tok))
+                               if ( ! mdoc_body_alloc(mdoc, line, 
+                                                       ppos, tok))

                                        return(0);
                                mdoc->next = MDOC_NEXT_CHILD;
                        }
                                        return(0);
                                mdoc->next = MDOC_NEXT_CHILD;
                        }

-                       if ( ! mdoc_macro(mdoc, c, line, lastarg, pos, buf))
+                       if ( ! mdoc_macro(mdoc, c, line, lastarg, 
+                                               pos, buf))

                                return(0);
                        break;
                }
 
                if ( ! flushed && mdoc_isdelim(p)) {
                                return(0);
                        break;
                }
 
                if ( ! flushed && mdoc_isdelim(p)) {

-                       if ( ! rewind_subblock(MDOC_HEAD, mdoc, tok, line, ppos))
+                       if ( ! rewind_subblock(MDOC_HEAD, mdoc, 
+                                               tok, line, ppos))

                                return(0);
                        flushed = 1;
                        if ( ! mdoc_body_alloc(mdoc, line, ppos, tok))
                                return(0);
                        flushed = 1;
                        if ( ! mdoc_body_alloc(mdoc, line, ppos, tok))


@@ -1007,26 +1182,29 @@ macro_constant_scoped(MACRO_PROT_ARGS)
  *    ELEMENT (.No)
  *    TEXT (`b')
  */
  *    ELEMENT (.No)
  *    TEXT (`b')
  */

-int
+static int

 macro_constant_delimited(MACRO_PROT_ARGS)
 {
 macro_constant_delimited(MACRO_PROT_ARGS)
 {

-       int               lastarg, flushed, j, c, maxargs, argc;
+       int               lastarg, flushed, j, c, maxargs, argc,
+                         igndelim, ignargs;

        struct mdoc_arg   argv[MDOC_LINEARG_MAX];
        char             *p;
 
        lastarg = ppos;
        flushed = 0;
 
        struct mdoc_arg   argv[MDOC_LINEARG_MAX];
        char             *p;
 
        lastarg = ppos;
        flushed = 0;
 

+       
+       /* 
+        * Maximum arguments per macro.  Some of these have none and
+        * exit as soon as they're parsed.
+        */
+

        switch (tok) {
        case (MDOC_No):
                /* FALLTHROUGH */
        case (MDOC_Ns):
                /* FALLTHROUGH */
        switch (tok) {
        case (MDOC_No):
                /* FALLTHROUGH */
        case (MDOC_Ns):
                /* FALLTHROUGH */

-       case (MDOC_Pf):
-               /* FALLTHROUGH */

        case (MDOC_Ux):
        case (MDOC_Ux):

-               /* FALLTHROUGH */
-       case (MDOC_St):

                maxargs = 0;
                break;
        default:
                maxargs = 0;
                break;
        default:


@@ -1034,26 +1212,61 @@ macro_constant_delimited(MACRO_PROT_ARGS)
                break;
        }
 
                break;
        }
 

-       for (argc = 0; argc < MDOC_LINEARG_MAX; argc++) {
-               lastarg = *pos;
-               c = mdoc_argv(mdoc, line, tok, &argv[argc], pos, buf);
-               if (ARGV_EOLN == c)
-                       break;
-               if (ARGV_WORD == c) {
-                       *pos = lastarg;
-                       break;
-               } else if (ARGV_ARG == c)
-                       continue;
-               mdoc_argv_free(argc, argv);
-               return(0);
+       /* 
+        * Whether to ignore delimiter characters.  `Pf' accepts its
+        * first token as a parameter no matter what it looks like (if
+        * it's text).
+        */
+
+       switch (tok) {
+       case (MDOC_Pf):
+               igndelim = 1;
+               break;
+       default:
+               igndelim = 0;
+               break;
+       }
+
+       /* 
+        * Whether to ignore arguments: `St', for example, handles its
+        * argument-like parameters as regular parameters.
+        */
+
+       switch (tok) {
+       case (MDOC_St):
+               ignargs = 1;
+               break;
+       default:
+               ignargs = 0;
+               break;

        }
 
        }
 

+       argc = 0;
+
+       if ( ! ignargs)
+               for ( ; argc < MDOC_LINEARG_MAX; argc++) {
+                       lastarg = *pos;
+                       c = mdoc_argv(mdoc, line, tok, 
+                                       &argv[argc], pos, buf);
+                       if (ARGV_EOLN == c)
+                               break;
+                       if (ARGV_WORD == c) {
+                               *pos = lastarg;
+                               break;
+                       } else if (ARGV_ARG == c)
+                               continue;
+                       mdoc_argv_free(argc, argv);
+                       return(0);
+               }
+

        if (MDOC_LINEARG_MAX == argc) {
                mdoc_argv_free(argc - 1, argv);
        if (MDOC_LINEARG_MAX == argc) {
                mdoc_argv_free(argc - 1, argv);

-               return(mdoc_perr(mdoc, line, ppos, "parameter hard-limit exceeded"));
+               return(perr(mdoc, line, ppos, EARGVLIM));

        }
 
        }
 

-       c = mdoc_elem_alloc(mdoc, line, ppos, tok, argc, argv);
+       c = mdoc_elem_alloc(mdoc, line, ppos, 
+                       tok, (size_t)argc, argv);
+

        mdoc_argv_free(argc, argv);
 
        if (0 == c)
        mdoc_argv_free(argc, argv);
 
        if (0 == c)


@@ -1071,6 +1284,8 @@ macro_constant_delimited(MACRO_PROT_ARGS)
                }
 
                c = mdoc_args(mdoc, line, pos, buf, tok, &p);
                }
 
                c = mdoc_args(mdoc, line, pos, buf, tok, &p);

+               assert(ARGS_PHRASE != c);
+

                if (ARGS_ERROR == c)
                        return(0);
                if (ARGS_PUNCT == c)
                if (ARGS_ERROR == c)
                        return(0);
                if (ARGS_PUNCT == c)


@@ -1089,7 +1304,7 @@ macro_constant_delimited(MACRO_PROT_ARGS)
                        break;
                }
 
                        break;
                }
 

-               if ( ! flushed && mdoc_isdelim(p)) {
+               if ( ! flushed && mdoc_isdelim(p) && ! igndelim) {

                        if ( ! rewind_elem(mdoc, tok))
                                return(0);
                        flushed = 1;
                        if ( ! rewind_elem(mdoc, tok))
                                return(0);
                        flushed = 1;


@@ -1113,7 +1328,7 @@ macro_constant_delimited(MACRO_PROT_ARGS)
  * A constant macro is the simplest classification.  It spans an entire
  * line.  
  */
  * A constant macro is the simplest classification.  It spans an entire
  * line.  
  */

-int
+static int

 macro_constant(MACRO_PROT_ARGS)
 {
        int               c, w, la, argc;
 macro_constant(MACRO_PROT_ARGS)
 {
        int               c, w, la, argc;


@@ -1139,10 +1354,12 @@ macro_constant(MACRO_PROT_ARGS)
 
        if (MDOC_LINEARG_MAX == argc) {
                mdoc_argv_free(argc - 1, argv);
 
        if (MDOC_LINEARG_MAX == argc) {
                mdoc_argv_free(argc - 1, argv);

-               return(mdoc_perr(mdoc, line, ppos, "parameter hard-limit exceeded"));
+               return(perr(mdoc, line, ppos, EARGVLIM));

        }
 
        }
 

-       c = mdoc_elem_alloc(mdoc, line, ppos, tok, argc, argv);
+       c = mdoc_elem_alloc(mdoc, line, ppos, 
+                       tok, (size_t)argc, argv);
+

        mdoc_argv_free(argc, argv);
 
        if (0 == c)
        mdoc_argv_free(argc, argv);
 
        if (0 == c)


@@ -1153,6 +1370,8 @@ macro_constant(MACRO_PROT_ARGS)
        for (;;) {
                la = *pos;
                w = mdoc_args(mdoc, line, pos, buf, tok, &p);
        for (;;) {
                la = *pos;
                w = mdoc_args(mdoc, line, pos, buf, tok, &p);

+               assert(ARGS_PHRASE != c);
+

                if (ARGS_ERROR == w)
                        return(0);
                if (ARGS_EOLN == w)
                if (ARGS_ERROR == w)
                        return(0);
                if (ARGS_EOLN == w)


@@ -1178,11 +1397,11 @@ macro_constant(MACRO_PROT_ARGS)
 
 
 /* ARGSUSED */
 
 
 /* ARGSUSED */

-int
+static int

 macro_obsolete(MACRO_PROT_ARGS)
 {
 
 macro_obsolete(MACRO_PROT_ARGS)
 {
 

-       return(mdoc_pwarn(mdoc, line, ppos, WARN_SYNTAX, "macro is obsolete"));
+       return(pwarn(mdoc, line, ppos, WOBS));

 }
 
 
 }
 
 


@@ -1209,7 +1428,8 @@ macro_end(struct mdoc *mdoc)
                        continue;
                if ( ! (MDOC_EXPLICIT & mdoc_macros[n->tok].flags))
                        continue;
                        continue;
                if ( ! (MDOC_EXPLICIT & mdoc_macros[n->tok].flags))
                        continue;

-               return(mdoc_nerr(mdoc, n, "macro scope still open on exit"));
+               return(mdoc_nerr(mdoc, n, 
+                               "macro scope still open on exit"));

        }
 
        return(rewind_last(mdoc, mdoc->first));
        }
 
        return(rewind_last(mdoc, mdoc->first));