*** empty log message ***

[mandoc.git] / mdocml.c

diff --git a/mdocml.c b/mdocml.c
index 60bf8943773beb4d4c8372af3341e2bc00dbfc9d..5fd519907a6ebd6992ab0f2b650430936ea0726a 100644 (file)
--- a/mdocml.c
+++ b/mdocml.c
@@ -1,4 +1,4 @@
-/* $Id: mdocml.c,v 1.22 2008/12/15 02:23:12 kristaps Exp $ */
+/* $Id: mdocml.c,v 1.35 2009/01/05 17:57:08 kristaps Exp $ */

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


@@ -181,13 +181,21 @@ buf_begin(struct md_parse *p)
 static void
 print_node(const struct mdoc_node *n, int indent)
 {
 static void
 print_node(const struct mdoc_node *n, int indent)
 {

-       const char      *p, *t;
-       int              i;
+       const char       *p, *t;
+       int               i, j;
+       size_t            argc, sz;
+       char            **params;
+       struct mdoc_arg  *argv;
+
+       argv = NULL;
+       argc = 0;
+       params = NULL;
+       sz = 0;

 
        switch (n->type) {
        case (MDOC_TEXT):
                assert(NULL == n->child);
 
        switch (n->type) {
        case (MDOC_TEXT):
                assert(NULL == n->child);

-               p = "<text>";
+               p = n->data.text.string;

                t = "text";
                break;
        case (MDOC_BODY):
                t = "text";
                break;
        case (MDOC_BODY):


@@ -198,14 +206,23 @@ print_node(const struct mdoc_node *n, int indent)
                p = mdoc_macronames[n->data.head.tok];
                t = "block-head";
                break;
                p = mdoc_macronames[n->data.head.tok];
                t = "block-head";
                break;

+       case (MDOC_TAIL):
+               p = mdoc_macronames[n->data.tail.tok];
+               t = "block-tail";
+               break;

        case (MDOC_ELEM):
        case (MDOC_ELEM):

-               assert(NULL == n->child);

                p = mdoc_macronames[n->data.elem.tok];
                t = "element";
                p = mdoc_macronames[n->data.elem.tok];
                t = "element";

+               argv = n->data.elem.argv;
+               argc = n->data.elem.argc;
+               params = n->data.elem.args;
+               sz = n->data.elem.sz;

                break;
        case (MDOC_BLOCK):
                p = mdoc_macronames[n->data.block.tok];
                t = "block";
                break;
        case (MDOC_BLOCK):
                p = mdoc_macronames[n->data.block.tok];
                t = "block";

+               argv = n->data.block.argv;
+               argc = n->data.block.argc;

                break;
        default:
                abort();
                break;
        default:
                abort();


@@ -214,7 +231,18 @@ print_node(const struct mdoc_node *n, int indent)
 
        for (i = 0; i < indent; i++)
                (void)printf("    ");
 
        for (i = 0; i < indent; i++)
                (void)printf("    ");

-       (void)printf("%s (%s)\n", p, t);
+       (void)printf("%s (%s)", p, t);
+
+       for (i = 0; i < (int)argc; i++) {
+               (void)printf(" -%s", mdoc_argnames[argv[i].arg]);
+               for (j = 0; j < (int)argv[i].sz; j++)
+                       (void)printf(" \"%s\"", argv[i].value[j]);
+       }
+
+       for (i = 0; i < (int)sz; i++)
+               (void)printf(" \"%s\"", params[i]);
+
+       (void)printf("\n");

 
        if (n->child)
                print_node(n->child, indent + 1);
 
        if (n->child)
                print_node(n->child, indent + 1);


@@ -265,9 +293,9 @@ parse_begin(struct md_parse *p)
                for (i = 0; i < sz; i++) {
                        if ('\n' != p->buf[i]) {
                                if (pos < sizeof(line)) {
                for (i = 0; i < sz; i++) {
                        if ('\n' != p->buf[i]) {
                                if (pos < sizeof(line)) {

-                                       /* LINTED */
-                                       sv[pos] = p->buf[i];
-                                       line[pos++] = p->buf[i];
+                                       sv[(int)pos] = p->buf[(int)i];
+                                       line[(int)pos++] = 
+                                               p->buf[(int)i];

                                        continue;
                                }
                                warnx("%s: line %d too long", 
                                        continue;
                                }
                                warnx("%s: line %d too long", 


@@ -300,25 +328,94 @@ msg_err(void *arg, int tok, int col, enum mdoc_err type)
        fmt = lit = NULL;
 
        switch (type) {
        fmt = lit = NULL;
 
        switch (type) {

+       case (ERR_SYNTAX_NOTEXT):
+               lit = "syntax: context-free text disallowed";
+               break;

        case (ERR_SYNTAX_QUOTE):
        case (ERR_SYNTAX_QUOTE):

+               lit = "syntax: disallowed argument quotation";
+               break;
+       case (ERR_SYNTAX_UNQUOTE):

                lit = "syntax: unterminated quotation";
                break;
        case (ERR_SYNTAX_WS):
                lit = "syntax: whitespace in argument";
                break;
                lit = "syntax: unterminated quotation";
                break;
        case (ERR_SYNTAX_WS):
                lit = "syntax: whitespace in argument";
                break;

+       case (ERR_SYNTAX_ARGFORM):
+               fmt = "syntax: macro `%s' arguments malformed";
+               break;
+       case (ERR_SYNTAX_NOPUNCT):
+               fmt = "syntax: macro `%s' doesn't understand punctuation";
+               break;
+       case (ERR_SYNTAX_ARG):
+               fmt = "syntax: unknown argument for macro `%s'";
+               break;

        case (ERR_SCOPE_BREAK):
                /* Which scope is broken? */
        case (ERR_SCOPE_BREAK):
                /* Which scope is broken? */

-               fmt = "macro `%s' breaks prior explicit scope";
+               fmt = "scope: macro `%s' breaks prior explicit scope";
+               break;
+       case (ERR_SCOPE_NOCTX):
+               fmt = "scope: closure macro `%s' has no context";
+               break;
+       case (ERR_SCOPE_NONEST):
+               fmt = "scope: macro `%s' may not be nested in the current context";

                break;
        case (ERR_MACRO_NOTSUP):
                break;
        case (ERR_MACRO_NOTSUP):

-               fmt = "macro `%s' not supported";
+               lit = "macro not supported";

                break;
        case (ERR_MACRO_NOTCALL):
                fmt = "macro `%s' not callable";
                break;
                break;
        case (ERR_MACRO_NOTCALL):
                fmt = "macro `%s' not callable";
                break;

+       case (ERR_SEC_PROLOGUE):
+               fmt = "macro `%s' cannot be called in the prologue";
+               break;
+       case (ERR_SEC_NPROLOGUE):
+               fmt = "macro `%s' called outside of prologue";
+               break;
+       case (ERR_ARGS_EQ0):
+               fmt = "macro `%s' expects zero arguments";
+               break;
+       case (ERR_ARGS_EQ1):
+               fmt = "macro `%s' expects one argument";
+               break;

        case (ERR_ARGS_GE1):
                fmt = "macro `%s' expects one or more arguments";
                break;
        case (ERR_ARGS_GE1):
                fmt = "macro `%s' expects one or more arguments";
                break;

+       case (ERR_ARGS_LE2):
+               fmt = "macro `%s' expects two or fewer arguments";
+               break;
+       case (ERR_ARGS_MANY):
+               fmt = "macro `%s' has too many arguments";
+               break;
+       case (ERR_SEC_PROLOGUE_OO):
+               fmt = "prologue macro `%s' is out-of-order";
+               break;
+       case (ERR_SEC_PROLOGUE_REP):
+               fmt = "prologue macro `%s' repeated";
+               break;
+       case (ERR_SEC_NAME):
+               lit = "`NAME' section must be first";
+               break;
+       case (ERR_SYNTAX_ARGVAL):
+               lit = "syntax: expected value for macro argument";
+               break;
+       case (ERR_SYNTAX_ARGBAD):
+               lit = "syntax: invalid value for macro argument";
+               break;
+       case (ERR_SYNTAX_ARGMANY):
+               lit = "syntax: too many values for macro argument";
+               break;
+       case (ERR_SYNTAX_CHILDHEAD):
+               lit = "syntax: expected only block-header section";
+               break;
+       case (ERR_SYNTAX_CHILDBODY):
+               lit = "syntax: expected only a block-body section";
+               break;
+       case (ERR_SYNTAX_EMPTYHEAD):
+               lit = "syntax: block-header section may not be empty";
+               break;
+       case (ERR_SYNTAX_EMPTYBODY):
+               lit = "syntax: block-body section may not be empty";
+               break;

        default:
                abort();
                /* NOTREACHED */
        default:
                abort();
                /* NOTREACHED */


@@ -333,7 +430,11 @@ msg_err(void *arg, int tok, int col, enum mdoc_err type)
                                p->name, p->lnn, lit);
 
        if (p->dbg < 1) {
                                p->name, p->lnn, lit);
 
        if (p->dbg < 1) {

-               (void)fprintf(stderr, " (column %d)\n", col);
+               if (-1 != col)
+                       (void)fprintf(stderr, " (column %d)\n", col);
+               return(0);
+       } else if (-1 == col) {
+               (void)fprintf(stderr, "\nFrom: %s", p->line);

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


@@ -360,7 +461,11 @@ msg_msg(void *arg, int col, const char *msg)
        (void)printf("%s:%d: %s", p->name, p->lnn, msg);
 
        if (p->dbg < 3) {
        (void)printf("%s:%d: %s", p->name, p->lnn, msg);
 
        if (p->dbg < 3) {

-               (void)printf(" (column %d)\n", col);
+               if (-1 != col)
+                       (void)printf(" (column %d)\n", col);
+               return;
+       } else if (-1 == col) {
+               (void)printf("\nFrom %s\n", p->line);

                return;
        }
 
                return;
        }
 


@@ -390,12 +495,39 @@ msg_warn(void *arg, int tok, int col, enum mdoc_warn type)
        case (WARN_SYNTAX_WS_EOLN):
                lit = "syntax: whitespace at end-of-line";
                break;
        case (WARN_SYNTAX_WS_EOLN):
                lit = "syntax: whitespace at end-of-line";
                break;

+       case (WARN_SYNTAX_QUOTED):
+               lit = "syntax: quotation mark starting string";
+               break;

        case (WARN_SYNTAX_MACLIKE):
                lit = "syntax: macro-like argument";
                break;
        case (WARN_SYNTAX_MACLIKE):
                lit = "syntax: macro-like argument";
                break;

+       case (WARN_SYNTAX_ARGLIKE):
+               lit = "syntax: argument-like value";
+               break;
+       case (WARN_SYNTAX_EMPTYBODY):
+               lit = "syntax: empty block-body section";
+               break;
+       case (WARN_SEC_OO):
+               lit = "section is out of conventional order";
+               break;

        case (WARN_ARGS_GE1):
                fmt = "macro `%s' suggests one or more arguments";
                break;
        case (WARN_ARGS_GE1):
                fmt = "macro `%s' suggests one or more arguments";
                break;

+       case (WARN_ARGS_EQ0):
+               fmt = "macro `%s' suggests zero arguments";
+               break;
+       case (WARN_IGN_AFTER_BLK):
+               fmt = "ignore: macro `%s' ignored after block macro";
+               break;
+       case (WARN_IGN_OBSOLETE):
+               fmt = "ignore: macro `%s' is obsolete";
+               break;
+       case (WARN_IGN_BEFORE_BLK):
+               fmt = "ignore: macro before block macro `%s' ignored";
+               break;
+       case (WARN_COMPAT_TROFF):
+               fmt = "compat: macro `%s' behaves differently in troff and nroff";
+               break;

        default:
                abort();
                /* NOTREACHED */
        default:
                abort();
                /* NOTREACHED */