In .Bl -column, if some of the column width declarations are given

[mandoc.git] / eqn.c

diff --git a/eqn.c b/eqn.c
index 53a90294345503bfd3e8a98ddfe61218c8fba207..cda0db5d26e457eedb92dd5e504b288c4e060e70 100644 (file)
--- a/eqn.c
+++ b/eqn.c
@@ -1,4 +1,4 @@
-/*     $Id: eqn.c,v 1.28 2011/07/22 14:26:32 kristaps Exp $ */
+/*     $Id: eqn.c,v 1.44 2014/07/06 19:09:00 schwarze Exp $ */

 /*
  * Copyright (c) 2011 Kristaps Dzonsons <kristaps@bsd.lv>
  *
 /*
  * Copyright (c) 2011 Kristaps Dzonsons <kristaps@bsd.lv>
  *


@@ -26,6 +26,7 @@
 #include <time.h>
 
 #include "mandoc.h"
 #include <time.h>
 
 #include "mandoc.h"

+#include "mandoc_aux.h"

 #include "libmandoc.h"
 #include "libroff.h"
 
 #include "libmandoc.h"
 #include "libroff.h"
 


@@ -102,6 +103,21 @@ enum       eqn_symt {
        EQNSYM__MAX
 };
 
        EQNSYM__MAX
 };
 

+enum   eqnpartt {
+       EQN_DEFINE = 0,
+       EQN_NDEFINE,
+       EQN_TDEFINE,
+       EQN_SET,
+       EQN_UNDEF,
+       EQN_GFONT,
+       EQN_GSIZE,
+       EQN_BACK,
+       EQN_FWD,
+       EQN_UP,
+       EQN_DOWN,
+       EQN__MAX
+};
+

 struct eqnstr {
        const char      *name;
        size_t           sz;
 struct eqnstr {
        const char      *name;
        size_t           sz;


@@ -122,33 +138,40 @@ struct    eqnsym {
        const char      *sym;
 };
 
        const char      *sym;
 };
 

-enum   eqnpartt {
-       EQN_DEFINE = 0,
-       EQN_SET,
-       EQN_UNDEF,
-       EQN__MAX
-};
-

 static enum eqn_rest    eqn_box(struct eqn_node *, struct eqn_box *);
 static enum eqn_rest    eqn_box(struct eqn_node *, struct eqn_box *);

-static struct eqn_box  *eqn_box_alloc(struct eqn_box *);
+static struct eqn_box  *eqn_box_alloc(struct eqn_node *,
+                               struct eqn_box *);

 static void             eqn_box_free(struct eqn_box *);
 static void             eqn_box_free(struct eqn_box *);

-static struct eqn_def  *eqn_def_find(struct eqn_node *, 
+static struct eqn_def  *eqn_def_find(struct eqn_node *,

                                const char *, size_t);
                                const char *, size_t);

+static int              eqn_do_gfont(struct eqn_node *);
+static int              eqn_do_gsize(struct eqn_node *);

 static int              eqn_do_define(struct eqn_node *);
 static int              eqn_do_define(struct eqn_node *);

-static int              eqn_do_set(struct eqn_node *);
+static int              eqn_do_ign1(struct eqn_node *);
+static int              eqn_do_ign2(struct eqn_node *);
+static int              eqn_do_tdefine(struct eqn_node *);

 static int              eqn_do_undef(struct eqn_node *);
 static enum eqn_rest    eqn_eqn(struct eqn_node *, struct eqn_box *);
 static enum eqn_rest    eqn_list(struct eqn_node *, struct eqn_box *);
 static int              eqn_do_undef(struct eqn_node *);
 static enum eqn_rest    eqn_eqn(struct eqn_node *, struct eqn_box *);
 static enum eqn_rest    eqn_list(struct eqn_node *, struct eqn_box *);

+static enum eqn_rest    eqn_matrix(struct eqn_node *, struct eqn_box *);

 static const char      *eqn_nexttok(struct eqn_node *, size_t *);
 static const char      *eqn_nextrawtok(struct eqn_node *, size_t *);
 static const char      *eqn_nexttok(struct eqn_node *, size_t *);
 static const char      *eqn_nextrawtok(struct eqn_node *, size_t *);

-static const char      *eqn_next(struct eqn_node *, 
+static const char      *eqn_next(struct eqn_node *,

                                char, size_t *, int);
 static void             eqn_rewind(struct eqn_node *);
 
 static const struct eqnpart eqnparts[EQN__MAX] = {
        { { "define", 6 }, eqn_do_define }, /* EQN_DEFINE */
                                char, size_t *, int);
 static void             eqn_rewind(struct eqn_node *);
 
 static const struct eqnpart eqnparts[EQN__MAX] = {
        { { "define", 6 }, eqn_do_define }, /* EQN_DEFINE */

-       { { "set", 3 }, eqn_do_set }, /* EQN_SET */
+       { { "ndefine", 7 }, eqn_do_define }, /* EQN_NDEFINE */
+       { { "tdefine", 7 }, eqn_do_tdefine }, /* EQN_TDEFINE */
+       { { "set", 3 }, eqn_do_ign2 }, /* EQN_SET */

        { { "undef", 5 }, eqn_do_undef }, /* EQN_UNDEF */
        { { "undef", 5 }, eqn_do_undef }, /* EQN_UNDEF */

+       { { "gfont", 5 }, eqn_do_gfont }, /* EQN_GFONT */
+       { { "gsize", 5 }, eqn_do_gsize }, /* EQN_GSIZE */
+       { { "back", 4 }, eqn_do_ign1 }, /* EQN_BACK */
+       { { "fwd", 3 }, eqn_do_ign1 }, /* EQN_FWD */
+       { { "up", 2 }, eqn_do_ign1 }, /* EQN_UP */
+       { { "down", 4 }, eqn_do_ign1 }, /* EQN_DOWN */

 };
 
 static const struct eqnstr eqnmarks[EQNMARK__MAX] = {
 };
 
 static const struct eqnstr eqnmarks[EQNMARK__MAX] = {


@@ -167,6 +190,7 @@ static      const struct eqnstr eqnfonts[EQNFONT__MAX] = {
        { "", 0 }, /* EQNFONT_NONE */
        { "roman", 5 }, /* EQNFONT_ROMAN */
        { "bold", 4 }, /* EQNFONT_BOLD */
        { "", 0 }, /* EQNFONT_NONE */
        { "roman", 5 }, /* EQNFONT_ROMAN */
        { "bold", 4 }, /* EQNFONT_BOLD */

+       { "fat", 3 }, /* EQNFONT_FAT */

        { "italic", 6 }, /* EQNFONT_ITALIC */
 };
 
        { "italic", 6 }, /* EQNFONT_ITALIC */
 };
 


@@ -181,9 +205,14 @@ static     const struct eqnstr eqnposs[EQNPOS__MAX] = {
 
 static const struct eqnstr eqnpiles[EQNPILE__MAX] = {
        { "", 0 }, /* EQNPILE_NONE */
 
 static const struct eqnstr eqnpiles[EQNPILE__MAX] = {
        { "", 0 }, /* EQNPILE_NONE */

+       { "pile", 4 }, /* EQNPILE_PILE */

        { "cpile", 5 }, /* EQNPILE_CPILE */
        { "rpile", 5 }, /* EQNPILE_RPILE */
        { "lpile", 5 }, /* EQNPILE_LPILE */
        { "cpile", 5 }, /* EQNPILE_CPILE */
        { "rpile", 5 }, /* EQNPILE_RPILE */
        { "lpile", 5 }, /* EQNPILE_LPILE */

+       { "col", 3 }, /* EQNPILE_COL */
+       { "ccol", 4 }, /* EQNPILE_CCOL */
+       { "rcol", 4 }, /* EQNPILE_RCOL */
+       { "lcol", 4 }, /* EQNPILE_LCOL */

 };
 
 static const struct eqnsym eqnsyms[EQNSYM__MAX] = {
 };
 
 static const struct eqnsym eqnsyms[EQNSYM__MAX] = {


@@ -248,9 +277,9 @@ static      const struct eqnsym eqnsyms[EQNSYM__MAX] = {
        { { ">=", 2 }, ">=" }, /* EQNSYM_moreequal */
 };
 
        { { ">=", 2 }, ">=" }, /* EQNSYM_moreequal */
 };
 

-/* ARGSUSED */
+

 enum rofferr
 enum rofferr

-eqn_read(struct eqn_node **epp, int ln, 
+eqn_read(struct eqn_node **epp, int ln,

                const char *p, int pos, int *offs)
 {
        size_t           sz;
                const char *p, int pos, int *offs)
 {
        size_t           sz;


@@ -264,9 +293,15 @@ eqn_read(struct eqn_node **epp, int ln,
         * validate the full equation.
         */
 
         * validate the full equation.
         */
 

-       if (0 == strcmp(p, ".EN")) {
-               er = eqn_end(ep);
-               *epp = NULL;
+       if (0 == strncmp(p, ".EN", 3)) {
+               er = eqn_end(epp);
+               p += 3;
+               while (' ' == *p || '\t' == *p)
+                       p++;
+               if ('\0' == *p)
+                       return(er);
+               mandoc_vmsg(MANDOCERR_ARG_SKIP, ep->parse,
+                   ln, pos, "EN %s", p);

                return(er);
        }
 
                return(er);
        }
 


@@ -290,24 +325,42 @@ eqn_read(struct eqn_node **epp, int ln,
 }
 
 struct eqn_node *
 }
 
 struct eqn_node *

-eqn_alloc(int pos, int line, struct mparse *parse)
+eqn_alloc(const char *name, int pos, int line, struct mparse *parse)

 {
        struct eqn_node *p;
 {
        struct eqn_node *p;

+       size_t           sz;
+       const char      *end;

 
        p = mandoc_calloc(1, sizeof(struct eqn_node));
 
        p = mandoc_calloc(1, sizeof(struct eqn_node));

+
+       if (name && '\0' != *name) {
+               sz = strlen(name);
+               assert(sz);
+               do {
+                       sz--;
+                       end = name + (int)sz;
+               } while (' ' == *end || '\t' == *end);
+               p->eqn.name = mandoc_strndup(name, sz + 1);
+       }
+

        p->parse = parse;
        p->eqn.ln = line;
        p->eqn.pos = pos;
        p->parse = parse;
        p->eqn.ln = line;
        p->eqn.pos = pos;

+       p->gsize = EQN_DEFSIZE;

 
        return(p);
 }
 
 enum rofferr
 
        return(p);
 }
 
 enum rofferr

-eqn_end(struct eqn_node *ep)
+eqn_end(struct eqn_node **epp)

 {
 {

+       struct eqn_node *ep;

        struct eqn_box  *root;
        enum eqn_rest    c;
 
        struct eqn_box  *root;
        enum eqn_rest    c;
 

+       ep = *epp;
+       *epp = NULL;
+

        ep->eqn.root = mandoc_calloc(1, sizeof(struct eqn_box));
 
        root = ep->eqn.root;
        ep->eqn.root = mandoc_calloc(1, sizeof(struct eqn_box));
 
        root = ep->eqn.root;


@@ -330,7 +383,7 @@ eqn_eqn(struct eqn_node *ep, struct eqn_box *last)
        struct eqn_box  *bp;
        enum eqn_rest    c;
 
        struct eqn_box  *bp;
        enum eqn_rest    c;
 

-       bp = eqn_box_alloc(last);
+       bp = eqn_box_alloc(ep, last);

        bp->type = EQN_SUBEXPR;
 
        while (EQN_OK == (c = eqn_box(ep, bp)))
        bp->type = EQN_SUBEXPR;
 
        while (EQN_OK == (c = eqn_box(ep, bp)))


@@ -339,6 +392,55 @@ eqn_eqn(struct eqn_node *ep, struct eqn_box *last)
        return(c);
 }
 
        return(c);
 }
 

+static enum eqn_rest
+eqn_matrix(struct eqn_node *ep, struct eqn_box *last)
+{
+       struct eqn_box  *bp;
+       const char      *start;
+       size_t           sz;
+       enum eqn_rest    c;
+
+       bp = eqn_box_alloc(ep, last);
+       bp->type = EQN_MATRIX;
+
+       if (NULL == (start = eqn_nexttok(ep, &sz))) {
+               EQN_MSG(MANDOCERR_EQNEOF, ep);
+               return(EQN_ERR);
+       }
+       if ( ! STRNEQ(start, sz, "{", 1)) {
+               EQN_MSG(MANDOCERR_EQNSYNT, ep);
+               return(EQN_ERR);
+       }
+
+       while (EQN_OK == (c = eqn_box(ep, bp)))
+               switch (bp->last->pile) {
+               case EQNPILE_LCOL:
+                       /* FALLTHROUGH */
+               case EQNPILE_CCOL:
+                       /* FALLTHROUGH */
+               case EQNPILE_RCOL:
+                       continue;
+               default:
+                       EQN_MSG(MANDOCERR_EQNSYNT, ep);
+                       return(EQN_ERR);
+               };
+
+       if (EQN_DESCOPE != c) {
+               if (EQN_EOF == c)
+                       EQN_MSG(MANDOCERR_EQNEOF, ep);
+               return(EQN_ERR);
+       }
+
+       eqn_rewind(ep);
+       start = eqn_nexttok(ep, &sz);
+       assert(start);
+       if (STRNEQ(start, sz, "}", 1))
+               return(EQN_OK);
+
+       EQN_MSG(MANDOCERR_EQNBADSCOPE, ep);
+       return(EQN_ERR);
+}
+

 static enum eqn_rest
 eqn_list(struct eqn_node *ep, struct eqn_box *last)
 {
 static enum eqn_rest
 eqn_list(struct eqn_node *ep, struct eqn_box *last)
 {


@@ -347,7 +449,7 @@ eqn_list(struct eqn_node *ep, struct eqn_box *last)
        size_t           sz;
        enum eqn_rest    c;
 
        size_t           sz;
        enum eqn_rest    c;
 

-       bp = eqn_box_alloc(last);
+       bp = eqn_box_alloc(ep, last);

        bp->type = EQN_LIST;
 
        if (NULL == (start = eqn_nexttok(ep, &sz))) {
        bp->type = EQN_LIST;
 
        if (NULL == (start = eqn_nexttok(ep, &sz))) {


@@ -365,7 +467,6 @@ eqn_list(struct eqn_node *ep, struct eqn_box *last)
                assert(start);
                if ( ! STRNEQ(start, sz, "above", 5))
                        break;
                assert(start);
                if ( ! STRNEQ(start, sz, "above", 5))
                        break;

-               bp->last->above = 1;

        }
 
        if (EQN_DESCOPE != c) {
        }
 
        if (EQN_DESCOPE != c) {


@@ -404,12 +505,16 @@ eqn_box(struct eqn_node *ep, struct eqn_box *last)
                return(EQN_DESCOPE);
        else if (STRNEQ(start, sz, "above", 5))
                return(EQN_DESCOPE);
                return(EQN_DESCOPE);
        else if (STRNEQ(start, sz, "above", 5))
                return(EQN_DESCOPE);

+       else if (STRNEQ(start, sz, "mark", 4))
+               return(EQN_OK);
+       else if (STRNEQ(start, sz, "lineup", 6))
+               return(EQN_OK);

 
        for (i = 0; i < (int)EQN__MAX; i++) {
                if ( ! EQNSTREQ(&eqnparts[i].str, start, sz))
                        continue;
                return((*eqnparts[i].fp)(ep) ? EQN_OK : EQN_ERR);
 
        for (i = 0; i < (int)EQN__MAX; i++) {
                if ( ! EQNSTREQ(&eqnparts[i].str, start, sz))
                        continue;
                return((*eqnparts[i].fp)(ep) ? EQN_OK : EQN_ERR);

-       } 
+       }

 
        if (STRNEQ(start, sz, "{", 1)) {
                if (EQN_DESCOPE != (c = eqn_eqn(ep, last))) {
 
        if (STRNEQ(start, sz, "{", 1)) {
                if (EQN_DESCOPE != (c = eqn_eqn(ep, last))) {


@@ -424,7 +529,7 @@ eqn_box(struct eqn_node *ep, struct eqn_box *last)
                        return(EQN_OK);
                EQN_MSG(MANDOCERR_EQNBADSCOPE, ep);
                return(EQN_ERR);
                        return(EQN_OK);
                EQN_MSG(MANDOCERR_EQNBADSCOPE, ep);
                return(EQN_ERR);

-       } 
+       }

 
        for (i = 0; i < (int)EQNPILE__MAX; i++) {
                if ( ! EQNSTREQ(&eqnpiles[i], start, sz))
 
        for (i = 0; i < (int)EQNPILE__MAX; i++) {
                if ( ! EQNSTREQ(&eqnpiles[i], start, sz))


@@ -434,6 +539,9 @@ eqn_box(struct eqn_node *ep, struct eqn_box *last)
                return(c);
        }
 
                return(c);
        }
 

+       if (STRNEQ(start, sz, "matrix", 6))
+               return(eqn_matrix(ep, last));
+

        if (STRNEQ(start, sz, "left", 4)) {
                if (NULL == (start = eqn_nexttok(ep, &sz))) {
                        EQN_MSG(MANDOCERR_EQNEOF, ep);
        if (STRNEQ(start, sz, "left", 4)) {
                if (NULL == (start = eqn_nexttok(ep, &sz))) {
                        EQN_MSG(MANDOCERR_EQNEOF, ep);


@@ -467,7 +575,7 @@ eqn_box(struct eqn_node *ep, struct eqn_box *last)
                if (NULL == last->last) {
                        EQN_MSG(MANDOCERR_EQNSYNT, ep);
                        return(EQN_ERR);
                if (NULL == last->last) {
                        EQN_MSG(MANDOCERR_EQNSYNT, ep);
                        return(EQN_ERR);

-               } 
+               }

                last->last->pos = (enum eqn_post)i;
                if (EQN_EOF == (c = eqn_box(ep, last))) {
                        EQN_MSG(MANDOCERR_EQNEOF, ep);
                last->last->pos = (enum eqn_post)i;
                if (EQN_EOF == (c = eqn_box(ep, last))) {
                        EQN_MSG(MANDOCERR_EQNEOF, ep);


@@ -482,7 +590,7 @@ eqn_box(struct eqn_node *ep, struct eqn_box *last)
                if (NULL == last->last) {
                        EQN_MSG(MANDOCERR_EQNSYNT, ep);
                        return(EQN_ERR);
                if (NULL == last->last) {
                        EQN_MSG(MANDOCERR_EQNSYNT, ep);
                        return(EQN_ERR);

-               } 
+               }

                last->last->mark = (enum eqn_markt)i;
                if (EQN_EOF == (c = eqn_box(ep, last))) {
                        EQN_MSG(MANDOCERR_EQNEOF, ep);
                last->last->mark = (enum eqn_markt)i;
                if (EQN_EOF == (c = eqn_box(ep, last))) {
                        EQN_MSG(MANDOCERR_EQNEOF, ep);


@@ -516,12 +624,12 @@ eqn_box(struct eqn_node *ep, struct eqn_box *last)
                last->last->size = size;
        }
 
                last->last->size = size;
        }
 

-       bp = eqn_box_alloc(last);
+       bp = eqn_box_alloc(ep, last);

        bp->type = EQN_TEXT;
        for (i = 0; i < (int)EQNSYM__MAX; i++)
                if (EQNSTREQ(&eqnsyms[i].str, start, sz)) {
                        sym[63] = '\0';
        bp->type = EQN_TEXT;
        for (i = 0; i < (int)EQNSYM__MAX; i++)
                if (EQNSTREQ(&eqnsyms[i].str, start, sz)) {
                        sym[63] = '\0';

-                       snprintf(sym, 62, "\\[%s]", eqnsyms[i].sym);
+                       (void)snprintf(sym, 62, "\\[%s]", eqnsyms[i].sym);

                        bp->text = mandoc_strdup(sym);
                        return(EQN_OK);
                }
                        bp->text = mandoc_strdup(sym);
                        return(EQN_OK);
                }


@@ -542,19 +650,20 @@ eqn_free(struct eqn_node *p)
                free(p->defs[i].val);
        }
 
                free(p->defs[i].val);
        }
 

+       free(p->eqn.name);

        free(p->data);
        free(p->defs);
        free(p);
 }
 
 static struct eqn_box *
        free(p->data);
        free(p->defs);
        free(p);
 }
 
 static struct eqn_box *

-eqn_box_alloc(struct eqn_box *parent)
+eqn_box_alloc(struct eqn_node *ep, struct eqn_box *parent)

 {
        struct eqn_box  *bp;
 
        bp = mandoc_calloc(1, sizeof(struct eqn_box));
        bp->parent = parent;
 {
        struct eqn_box  *bp;
 
        bp = mandoc_calloc(1, sizeof(struct eqn_box));
        bp->parent = parent;

-       bp->size = EQN_DEFSIZE;
+       bp->size = ep->gsize;

 
        if (NULL == parent->first)
                parent->first = bp;
 
        if (NULL == parent->first)
                parent->first = bp;


@@ -618,7 +727,7 @@ again:
        /* Prevent self-definitions. */
 
        if (lim >= EQN_NEST_MAX) {
        /* Prevent self-definitions. */
 
        if (lim >= EQN_NEST_MAX) {

-               EQN_MSG(MANDOCERR_EQNNEST, ep);
+               EQN_MSG(MANDOCERR_ROFFLOOP, ep);

                return(NULL);
        }
 
                return(NULL);
        }
 


@@ -640,7 +749,7 @@ again:
                if ('{' == *start || '}' == *start)
                        ssz = 1;
                else
                if ('{' == *start || '}' == *start)
                        ssz = 1;
                else

-                       ssz = strcspn(start + 1, " ~\"{}\t") + 1;
+                       ssz = strcspn(start + 1, " ^~\"{}\t") + 1;

                next = start + (int)ssz;
                if ('\0' == *next)
                        next = NULL;
                next = start + (int)ssz;
                if ('\0' == *next)
                        next = NULL;


@@ -653,12 +762,13 @@ again:
                if (q)
                        ep->cur++;
                while (' ' == ep->data[(int)ep->cur] ||
                if (q)
                        ep->cur++;
                while (' ' == ep->data[(int)ep->cur] ||

-                               '\t' == ep->data[(int)ep->cur] ||
-                               '~' == ep->data[(int)ep->cur])
+                   '\t' == ep->data[(int)ep->cur] ||
+                   '^' == ep->data[(int)ep->cur] ||
+                   '~' == ep->data[(int)ep->cur])

                        ep->cur++;
        } else {
                if (q)
                        ep->cur++;
        } else {
                if (q)

-                       EQN_MSG(MANDOCERR_BADQUOTE, ep);
+                       EQN_MSG(MANDOCERR_ARG_QUOTE, ep);

                next = strchr(start, '\0');
                *sz = (size_t)(next - start);
                ep->cur += *sz;
                next = strchr(start, '\0');
                *sz = (size_t)(next - start);
                ep->cur += *sz;


@@ -680,8 +790,8 @@ again:
                }
 
                diff = def->valsz - *sz;
                }
 
                diff = def->valsz - *sz;

-               memmove(start + *sz + diff, start + *sz, 
-                               (strlen(start) - *sz) + 1);
+               memmove(start + *sz + diff, start + *sz,
+                   (strlen(start) - *sz) + 1);

                memcpy(start, def->val, def->valsz);
                goto again;
        }
                memcpy(start, def->val, def->valsz);
                goto again;
        }


@@ -690,14 +800,39 @@ again:
 }
 
 static int
 }
 
 static int

-eqn_do_set(struct eqn_node *ep)
+eqn_do_ign1(struct eqn_node *ep)

 {
 {

-       const char      *start;

 
 

-       if (NULL == (start = eqn_nextrawtok(ep, NULL)))
-               EQN_MSG(MANDOCERR_EQNARGS, ep);
-       else if (NULL == (start = eqn_nextrawtok(ep, NULL)))
-               EQN_MSG(MANDOCERR_EQNARGS, ep);
+       if (NULL == eqn_nextrawtok(ep, NULL))
+               EQN_MSG(MANDOCERR_EQNEOF, ep);
+       else
+               return(1);
+
+       return(0);
+}
+
+static int
+eqn_do_ign2(struct eqn_node *ep)
+{
+
+       if (NULL == eqn_nextrawtok(ep, NULL))
+               EQN_MSG(MANDOCERR_EQNEOF, ep);
+       else if (NULL == eqn_nextrawtok(ep, NULL))
+               EQN_MSG(MANDOCERR_EQNEOF, ep);
+       else
+               return(1);
+
+       return(0);
+}
+
+static int
+eqn_do_tdefine(struct eqn_node *ep)
+{
+
+       if (NULL == eqn_nextrawtok(ep, NULL))
+               EQN_MSG(MANDOCERR_EQNEOF, ep);
+       else if (NULL == eqn_next(ep, ep->data[(int)ep->cur], NULL, 0))
+               EQN_MSG(MANDOCERR_EQNEOF, ep);

        else
                return(1);
 
        else
                return(1);
 


@@ -713,12 +848,12 @@ eqn_do_define(struct eqn_node *ep)
        int              i;
 
        if (NULL == (start = eqn_nextrawtok(ep, &sz))) {
        int              i;
 
        if (NULL == (start = eqn_nextrawtok(ep, &sz))) {

-               EQN_MSG(MANDOCERR_EQNARGS, ep);
+               EQN_MSG(MANDOCERR_EQNEOF, ep);

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

-       /* 
-        * Search for a key that already exists. 
+       /*
+        * Search for a key that already exists.

         * Create a new key if none is found.
         */
 
         * Create a new key if none is found.
         */
 


@@ -730,15 +865,14 @@ eqn_do_define(struct eqn_node *ep)
 
                if (i == (int)ep->defsz) {
                        ep->defsz++;
 
                if (i == (int)ep->defsz) {
                        ep->defsz++;

-                       ep->defs = mandoc_realloc
-                               (ep->defs, ep->defsz * 
-                                sizeof(struct eqn_def));
+                       ep->defs = mandoc_reallocarray(ep->defs,
+                           ep->defsz, sizeof(struct eqn_def));

                        ep->defs[i].key = ep->defs[i].val = NULL;
                }
 
                ep->defs[i].keysz = sz;
                        ep->defs[i].key = ep->defs[i].val = NULL;
                }
 
                ep->defs[i].keysz = sz;

-               ep->defs[i].key = mandoc_realloc
-                       (ep->defs[i].key, sz + 1);
+               ep->defs[i].key = mandoc_realloc(
+                   ep->defs[i].key, sz + 1);

 
                memcpy(ep->defs[i].key, start, sz);
                ep->defs[i].key[(int)sz] = '\0';
 
                memcpy(ep->defs[i].key, start, sz);
                ep->defs[i].key[(int)sz] = '\0';


@@ -748,7 +882,7 @@ eqn_do_define(struct eqn_node *ep)
        start = eqn_next(ep, ep->data[(int)ep->cur], &sz, 0);
 
        if (NULL == start) {
        start = eqn_next(ep, ep->data[(int)ep->cur], &sz, 0);
 
        if (NULL == start) {

-               EQN_MSG(MANDOCERR_EQNARGS, ep);
+               EQN_MSG(MANDOCERR_EQNEOF, ep);

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


@@ -759,6 +893,31 @@ eqn_do_define(struct eqn_node *ep)
        return(1);
 }
 
        return(1);
 }
 

+static int
+eqn_do_gfont(struct eqn_node *ep)
+{
+
+       if (NULL == eqn_nextrawtok(ep, NULL)) {
+               EQN_MSG(MANDOCERR_EQNEOF, ep);
+               return(0);
+       }
+       return(1);
+}
+
+static int
+eqn_do_gsize(struct eqn_node *ep)
+{
+       const char      *start;
+       size_t           sz;
+
+       if (NULL == (start = eqn_nextrawtok(ep, &sz))) {
+               EQN_MSG(MANDOCERR_EQNEOF, ep);
+               return(0);
+       }
+       ep->gsize = mandoc_strntoi(start, sz, 10);
+       return(1);
+}
+

 static int
 eqn_do_undef(struct eqn_node *ep)
 {
 static int
 eqn_do_undef(struct eqn_node *ep)
 {


@@ -767,7 +926,7 @@ eqn_do_undef(struct eqn_node *ep)
        size_t           sz;
 
        if (NULL == (start = eqn_nextrawtok(ep, &sz))) {
        size_t           sz;
 
        if (NULL == (start = eqn_nextrawtok(ep, &sz))) {

-               EQN_MSG(MANDOCERR_EQNARGS, ep);
+               EQN_MSG(MANDOCERR_EQNEOF, ep);

                return(0);
        } else if (NULL != (def = eqn_def_find(ep, start, sz)))
                def->keysz = 0;
                return(0);
        } else if (NULL != (def = eqn_def_find(ep, start, sz)))
                def->keysz = 0;


@@ -780,9 +939,9 @@ eqn_def_find(struct eqn_node *ep, const char *key, size_t sz)
 {
        int              i;
 
 {
        int              i;
 

-       for (i = 0; i < (int)ep->defsz; i++) 
-               if (ep->defs[i].keysz && STRNEQ(ep->defs[i].key, 
-                                       ep->defs[i].keysz, key, sz))
+       for (i = 0; i < (int)ep->defsz; i++)
+               if (ep->defs[i].keysz && STRNEQ(ep->defs[i].key,
+                   ep->defs[i].keysz, key, sz))

                        return(&ep->defs[i]);
 
        return(NULL);
                        return(&ep->defs[i]);
 
        return(NULL);