-/* $Id: mdoc_term.c,v 1.1 2009/03/26 14:38:11 kristaps Exp $ */
+/* $Id: mdoc_term.c,v 1.28 2009/07/12 17:25:07 kristaps Exp $ */
/*
- * Copyright (c) 2008, 2009 Kristaps Dzonsons <kristaps@openbsd.org>
+ * Copyright (c) 2008, 2009 Kristaps Dzonsons <kristaps@kth.se>
*
* Permission to use, copy, modify, and distribute this software for any
- * purpose with or without fee is hereby granted, provided that the
- * above copyright notice and this permission notice appear in all
- * copies.
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
*
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
- * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
- * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
- * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
- * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
- * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
- * PERFORMANCE OF THIS SOFTWARE.
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#include <sys/types.h>
TERMP_BOLD /* TTYPE_LIST */
};
-/* XXX - clean this up. */
-
+/*
+ * This is used to preserve a style of value across a macro, instead of
+ * losing it while the body is processed.
+ */
struct termpair {
struct termpair *ppair;
- int type;
-#define TERMPAIR_FLAG (1 << 0)
- int flag;
- size_t offset;
- size_t rmargin;
- int count;
+ int flag; /* Whether being used. */
+ size_t offset; /* Left margin. */
+ size_t rmargin; /* Right margin. */
+ int count; /* Enum count. */
};
-#define TERMPAIR_SETFLAG(termp, p, fl) \
- do { \
- assert(! (TERMPAIR_FLAG & (p)->type)); \
- (termp)->flags |= (fl); \
- (p)->flag = (fl); \
- (p)->type |= TERMPAIR_FLAG; \
- } while ( /* CONSTCOND */ 0)
-
#define DECL_ARGS \
struct termp *p, struct termpair *pair, \
const struct mdoc_meta *meta, \
DECL_PRE(termp_ar);
DECL_PRE(termp_at);
DECL_PRE(termp_bf);
-DECL_PRE(termp_bsx);
DECL_PRE(termp_bt);
DECL_PRE(termp_cd);
DECL_PRE(termp_cm);
-DECL_PRE(termp_dx);
DECL_PRE(termp_em);
DECL_PRE(termp_ex);
DECL_PRE(termp_fa);
DECL_PRE(termp_fl);
-DECL_PRE(termp_fx);
DECL_PRE(termp_ic);
DECL_PRE(termp_lk);
DECL_PRE(termp_ms);
DECL_PRE(termp_nd);
DECL_PRE(termp_nm);
DECL_PRE(termp_ns);
-DECL_PRE(termp_nx);
-DECL_PRE(termp_ox);
+DECL_PRE(termp_xx);
DECL_PRE(termp_pa);
DECL_PRE(termp_pp);
DECL_PRE(termp_rs);
DECL_PRE(termp_sx);
DECL_PRE(termp_sy);
DECL_PRE(termp_ud);
-DECL_PRE(termp_ux);
DECL_PRE(termp_va);
DECL_PRE(termp_xr);
};
static const struct termact termacts[MDOC_MAX] = {
- { NULL, NULL }, /* \" */
+ { termp_ap_pre, NULL }, /* Ap */
{ NULL, NULL }, /* Dd */
{ NULL, NULL }, /* Dt */
{ NULL, NULL }, /* Os */
{ termp_bf_pre, NULL }, /* Bf */
{ termp_bq_pre, termp_bq_post }, /* Bo */
{ termp_bq_pre, termp_bq_post }, /* Bq */
- { termp_bsx_pre, NULL }, /* Bsx */
+ { termp_xx_pre, NULL }, /* Bsx */
{ NULL, termp_bx_post }, /* Bx */
{ NULL, NULL }, /* Db */
{ NULL, NULL }, /* Dc */
{ NULL, NULL }, /* Ef */
{ termp_em_pre, NULL }, /* Em */
{ NULL, NULL }, /* Eo */
- { termp_fx_pre, NULL }, /* Fx */
+ { termp_xx_pre, NULL }, /* Fx */
{ termp_ms_pre, NULL }, /* Ms */
{ NULL, NULL }, /* No */
{ termp_ns_pre, NULL }, /* Ns */
- { termp_nx_pre, NULL }, /* Nx */
- { termp_ox_pre, NULL }, /* Ox */
+ { termp_xx_pre, NULL }, /* Nx */
+ { termp_xx_pre, NULL }, /* Ox */
{ NULL, NULL }, /* Pc */
{ termp_pf_pre, termp_pf_post }, /* Pf */
{ termp_pq_pre, termp_pq_post }, /* Po */
{ termp_sx_pre, NULL }, /* Sx */
{ termp_sy_pre, NULL }, /* Sy */
{ NULL, NULL }, /* Tn */
- { termp_ux_pre, NULL }, /* Ux */
+ { termp_xx_pre, NULL }, /* Ux */
{ NULL, NULL }, /* Xc */
{ NULL, NULL }, /* Xo */
{ termp_fo_pre, termp_fo_post }, /* Fo */
{ NULL, NULL }, /* Fr */
{ termp_ud_pre, NULL }, /* Ud */
{ termp_lb_pre, termp_lb_post }, /* Lb */
- { termp_ap_pre, NULL }, /* Lb */
- { termp_pp_pre, NULL }, /* Pp */
+ { termp_pp_pre, NULL }, /* Lp */
{ termp_lk_pre, NULL }, /* Lk */
{ termp_mt_pre, NULL }, /* Mt */
{ termp_brq_pre, termp_brq_post }, /* Brq */
{ NULL, NULL }, /* %C */
{ NULL, NULL }, /* Es */
{ NULL, NULL }, /* En */
- { termp_dx_pre, NULL }, /* Dx */
+ { termp_xx_pre, NULL }, /* Dx */
{ NULL, NULL }, /* %Q */
};
+#ifdef __linux__
+extern size_t strlcpy(char *, const char *, size_t);
+extern size_t strlcat(char *, const char *, size_t);
+#endif
+
static int arg_hasattr(int, const struct mdoc_node *);
static int arg_getattrs(const int *, int *, size_t,
const struct mdoc_node *);
static int fmt_block_vspace(struct termp *,
const struct mdoc_node *,
const struct mdoc_node *);
-static int print_node(DECL_ARGS);
-static int print_head(struct termp *,
+static void print_node(DECL_ARGS);
+static void print_head(struct termp *,
const struct mdoc_meta *);
-static int print_body(DECL_ARGS);
-static int print_foot(struct termp *,
+static void print_body(DECL_ARGS);
+static void print_foot(struct termp *,
const struct mdoc_meta *);
-static void sanity(const struct mdoc_node *);
int
mdoc_run(struct termp *p, const struct mdoc *m)
{
+ /*
+ * Main output function. When this is called, assume that the
+ * tree is properly formed.
+ */
- if ( ! print_head(p, mdoc_meta(m)))
- return(0);
- if ( ! print_body(p, NULL, mdoc_meta(m), mdoc_node(m)))
- return(0);
- return(print_foot(p, mdoc_meta(m)));
+ print_head(p, mdoc_meta(m));
+ assert(mdoc_node(m));
+ assert(MDOC_ROOT == mdoc_node(m)->type);
+ if (mdoc_node(m)->child)
+ print_body(p, NULL, mdoc_meta(m), mdoc_node(m)->child);
+ print_foot(p, mdoc_meta(m));
+ return(1);
}
-static int
+static void
print_body(DECL_ARGS)
{
- if ( ! print_node(p, pair, meta, node))
- return(0);
+ print_node(p, pair, meta, node);
if ( ! node->next)
- return(1);
- return(print_body(p, pair, meta, node->next));
+ return;
+ print_body(p, pair, meta, node->next);
}
-static int
+static void
print_node(DECL_ARGS)
{
int dochild;
struct termpair npair;
- /* Some quick sanity-checking. */
-
- sanity(node);
-
/* Pre-processing. */
dochild = 1;
npair.ppair = pair;
- npair.type = 0;
npair.offset = npair.rmargin = 0;
npair.flag = 0;
npair.count = 0;
/* Children. */
- if (TERMPAIR_FLAG & npair.type)
- p->flags |= npair.flag;
+ p->flags |= npair.flag;
if (dochild && node->child)
print_body(p, &npair, meta, node->child);
- if (TERMPAIR_FLAG & npair.type)
- p->flags &= ~npair.flag;
+ p->flags &= ~npair.flag;
/* Post-processing. */
if (MDOC_TEXT != node->type)
if (termacts[node->tok].post)
(*termacts[node->tok].post)(p, &npair, meta, node);
-
- return(1);
}
-static int
+static void
print_foot(struct termp *p, const struct mdoc_meta *meta)
{
struct tm *tm;
char *buf, *os;
+ /*
+ * Output the footer in new-groff style, that is, three columns
+ * with the middle being the manual date and flanking columns
+ * being the operating system:
+ *
+ * SYSTEM DATE SYSTEM
+ */
+
if (NULL == (buf = malloc(p->rmargin)))
err(1, "malloc");
if (NULL == (os = malloc(p->rmargin)))
tm = localtime(&meta->date);
-#ifdef __OpenBSD__
- if (NULL == strftime(buf, p->rmargin, "%B %d, %Y", tm))
-#else
if (0 == strftime(buf, p->rmargin, "%B %d, %Y", tm))
-#endif
err(1, "strftime");
(void)strlcpy(os, meta->os, p->rmargin);
- /*
- * This is /slightly/ different from regular groff output
- * because we don't have page numbers. Print the following:
- *
- * OS MDOCDATE
- */
-
term_vspace(p);
- p->flags |= TERMP_NOSPACE | TERMP_NOBREAK;
- p->rmargin = p->maxrmargin - strlen(buf);
p->offset = 0;
+ p->rmargin = (p->maxrmargin - strlen(buf) + 1) / 2;
+ p->flags |= TERMP_NOSPACE | TERMP_NOBREAK;
term_word(p, os);
term_flushln(p);
+ p->offset = p->rmargin;
+ p->rmargin = p->maxrmargin - strlen(os);
p->flags |= TERMP_NOLPAD | TERMP_NOSPACE;
+
+ term_word(p, buf);
+ term_flushln(p);
+
p->offset = p->rmargin;
p->rmargin = p->maxrmargin;
p->flags &= ~TERMP_NOBREAK;
+ p->flags |= TERMP_NOLPAD | TERMP_NOSPACE;
- term_word(p, buf);
+ term_word(p, os);
term_flushln(p);
+ p->offset = 0;
+ p->rmargin = p->maxrmargin;
+ p->flags = 0;
+
free(buf);
free(os);
-
- return(1);
}
-static int
+static void
print_head(struct termp *p, const struct mdoc_meta *meta)
{
char *buf, *title;
meta->title, meta->msec);
p->offset = 0;
- p->rmargin = (p->maxrmargin - strlen(buf)) / 2;
+ p->rmargin = (p->maxrmargin - strlen(buf) + 1) / 2;
p->flags |= TERMP_NOBREAK | TERMP_NOSPACE;
term_word(p, title);
term_flushln(p);
- p->flags |= TERMP_NOLPAD | TERMP_NOSPACE;
p->offset = p->rmargin;
p->rmargin = p->maxrmargin - strlen(title);
+ p->flags |= TERMP_NOLPAD | TERMP_NOSPACE;
term_word(p, buf);
term_flushln(p);
term_word(p, title);
term_flushln(p);
- p->rmargin = p->maxrmargin;
p->offset = 0;
+ p->rmargin = p->maxrmargin;
p->flags &= ~TERMP_NOSPACE;
free(title);
free(buf);
-
- return(1);
-}
-
-
-static void
-sanity(const struct mdoc_node *n)
-{
- char *p;
-
- p = "regular form violated";
-
- switch (n->type) {
- case (MDOC_TEXT):
- if (n->child)
- errx(1, p);
- if (NULL == n->parent)
- errx(1, p);
- if (NULL == n->string)
- errx(1, p);
- switch (n->parent->type) {
- case (MDOC_TEXT):
- /* FALLTHROUGH */
- case (MDOC_ROOT):
- errx(1, p);
- /* NOTREACHED */
- default:
- break;
- }
- break;
- case (MDOC_ELEM):
- if (NULL == n->parent)
- errx(1, p);
- switch (n->parent->type) {
- case (MDOC_TAIL):
- /* FALLTHROUGH */
- case (MDOC_BODY):
- /* FALLTHROUGH */
- case (MDOC_HEAD):
- break;
- default:
- errx(1, p);
- /* NOTREACHED */
- }
- if (n->child) switch (n->child->type) {
- case (MDOC_TEXT):
- break;
- default:
- errx(1, p);
- /* NOTREACHED */
- }
- break;
- case (MDOC_HEAD):
- /* FALLTHROUGH */
- case (MDOC_BODY):
- /* FALLTHROUGH */
- case (MDOC_TAIL):
- if (NULL == n->parent)
- errx(1, p);
- if (MDOC_BLOCK != n->parent->type)
- errx(1, p);
- if (n->child) switch (n->child->type) {
- case (MDOC_BLOCK):
- /* FALLTHROUGH */
- case (MDOC_ELEM):
- /* FALLTHROUGH */
- case (MDOC_TEXT):
- break;
- default:
- errx(1, p);
- /* NOTREACHED */
- }
- break;
- case (MDOC_BLOCK):
- if (NULL == n->parent)
- errx(1, p);
- if (NULL == n->child)
- errx(1, p);
- switch (n->parent->type) {
- case (MDOC_ROOT):
- /* FALLTHROUGH */
- case (MDOC_HEAD):
- /* FALLTHROUGH */
- case (MDOC_BODY):
- /* FALLTHROUGH */
- case (MDOC_TAIL):
- break;
- default:
- errx(1, p);
- /* NOTREACHED */
- }
- switch (n->child->type) {
- case (MDOC_ROOT):
- /* FALLTHROUGH */
- case (MDOC_ELEM):
- errx(1, p);
- /* NOTREACHED */
- default:
- break;
- }
- break;
- case (MDOC_ROOT):
- if (n->parent)
- errx(1, p);
- if (NULL == n->child)
- errx(1, p);
- switch (n->child->type) {
- case (MDOC_BLOCK):
- break;
- default:
- errx(1, p);
- /* NOTREACHED */
- }
- break;
- }
}
assert(pos < (int)arg->sz && pos >= 0);
assert(arg->value[pos]);
- if (0 == strcmp(arg->value[pos], "indent"))
- return(INDENT);
- if (0 == strcmp(arg->value[pos], "indent-two"))
- return(INDENT * 2);
if (0 == (len = (int)strlen(arg->value[pos])))
return(0);
break;
if (i == len - 1) {
- if ('n' == arg->value[pos][len - 1]) {
+ if ('n' == arg->value[pos][len - 1] ||
+ 'm' == arg->value[pos][len - 1]) {
v = (size_t)atoi(arg->value[pos]);
- return(v);
+ return(v + 2);
}
}
- return(strlen(arg->value[pos]) + 1);
+ return(strlen(arg->value[pos]) + 2);
}
break;
}
+ /* FIXME: mandated by parser. */
+
errx(1, "list type not supported");
/* NOTREACHED */
}
{
assert(*arg->value);
+ if (0 == strcmp(*arg->value, "left"))
+ return(0);
if (0 == strcmp(*arg->value, "indent"))
- return(INDENT);
+ return(INDENT + 1);
if (0 == strcmp(*arg->value, "indent-two"))
- return(INDENT * 2);
+ return((INDENT + 1) * 2);
+
+ /* FIXME: needs to support field-widths (10n, etc.). */
+
return(strlen(*arg->value));
}
{
const struct mdoc_node *bl, *n;
char buf[7];
- int i, type, keys[3], vals[3];
+ int i, type, keys[3], vals[3], sv;
size_t width, offset;
if (MDOC_BLOCK == node->type)
if (vals[0] >= 0)
width = arg_width(&bl->args->argv[vals[0]], 0);
if (vals[1] >= 0)
- offset = arg_offset(&bl->args->argv[vals[1]]);
+ offset += arg_offset(&bl->args->argv[vals[1]]);
break;
}
/* FALLTHROUGH */
case (MDOC_Dash):
/* FALLTHROUGH */
- case (MDOC_Enum):
- /* FALLTHROUGH */
case (MDOC_Hyphen):
if (width < 4)
width = 4;
break;
+ case (MDOC_Enum):
+ if (width < 5)
+ width = 5;
+ break;
case (MDOC_Tag):
if (0 == width)
width = 10;
}
/*
- * Whitespace control. Inset bodies need an initial space.
+ * Whitespace control. Inset bodies need an initial space,
+ * while diagonal bodies need two.
*/
switch (type) {
case (MDOC_Diag):
+ term_word(p, "\\ ");
/* FALLTHROUGH */
case (MDOC_Inset):
if (MDOC_BODY == node->type)
/*
* The dash, hyphen, bullet and enum lists all have a special
- * HEAD character. Print it now.
+ * HEAD character (temporarily bold, in some cases).
*/
+ sv = p->flags;
if (MDOC_HEAD == node->type)
switch (type) {
case (MDOC_Bullet):
+ p->flags |= TERMP_BOLD;
term_word(p, "\\[bu]");
break;
case (MDOC_Dash):
/* FALLTHROUGH */
case (MDOC_Hyphen):
- term_word(p, "\\-");
+ p->flags |= TERMP_BOLD;
+ term_word(p, "\\(hy");
break;
case (MDOC_Enum):
(pair->ppair->ppair->count)++;
break;
}
+ p->flags = sv; /* Restore saved flags. */
+
/*
* If we're not going to process our children, indicate so here.
*/
if (SEC_SYNOPSIS == node->sec)
term_newln(p);
- TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_PROG]);
+ pair->flag |= ttypes[TTYPE_PROG];
+ p->flags |= ttypes[TTYPE_PROG];
+
if (NULL == node->child)
term_word(p, meta->name);
termp_fl_pre(DECL_ARGS)
{
- TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_CMD_FLAG]);
+ pair->flag |= ttypes[TTYPE_CMD_FLAG];
+ p->flags |= ttypes[TTYPE_CMD_FLAG];
term_word(p, "\\-");
p->flags |= TERMP_NOSPACE;
return(1);
termp_ar_pre(DECL_ARGS)
{
- TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_CMD_ARG]);
+ pair->flag |= ttypes[TTYPE_CMD_ARG];
return(1);
}
{
int i;
+ /* FIXME: mandated by parser. */
+
if (-1 == (i = arg_getattr(MDOC_Std, node)))
errx(1, "expected -std argument");
if (1 != node->args->argv[i].sz)
{
int i;
+ /* FIXME: mandated by parser? */
+
if (-1 == (i = arg_getattr(MDOC_Std, node)))
errx(1, "expected -std argument");
if (1 != node->args->argv[i].sz)
termp_nd_pre(DECL_ARGS)
{
+ if (MDOC_BODY != node->type)
+ return(1);
+ /*
+ * XXX: signed off by jmc@openbsd.org. This technically
+ * produces a minus sign after the Nd, which is wrong, but is
+ * consistent with the historic OpenBSD tmac file.
+ */
+#if defined(__OpenBSD__) || defined(__linux__)
term_word(p, "\\-");
+#else
+ term_word(p, "\\(em");
+#endif
return(1);
}
{
const struct mdoc_node *n;
- if (NULL == (n = node->child))
- errx(1, "expected text line argument");
+ assert(node->child && MDOC_TEXT == node->child->type);
+ n = node->child;
+
term_word(p, n->string);
if (NULL == (n = n->next))
return(0);
{
/* FIXME: this can be "type name". */
- TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_VAR_DECL]);
+ pair->flag |= TTYPE_VAR_DECL;
return(1);
}
termp_fd_pre(DECL_ARGS)
{
- /*
- * FIXME: this naming is bad. This value is used, in general,
- * for the #include header or other preprocessor statement.
- */
- TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_FUNC_DECL]);
+ pair->flag |= TTYPE_FUNC_DECL;
return(1);
}
switch (node->type) {
case (MDOC_HEAD):
term_vspace(p);
- TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_SECTION]);
+ pair->flag |= ttypes[TTYPE_SECTION];
break;
case (MDOC_BODY):
p->offset = INDENT;
{
const char *lb;
- if (NULL == node->child)
- errx(1, "expected text line argument");
- if ((lb = mdoc_a2lib(node->child->string))) {
+ assert(node->child && MDOC_TEXT == node->child->type);
+ lb = mdoc_a2lib(node->child->string);
+ if (lb) {
term_word(p, lb);
return(0);
}
termp_d1_pre(DECL_ARGS)
{
- if (MDOC_BODY != node->type)
+ if (MDOC_BLOCK != node->type)
return(1);
term_newln(p);
- p->offset += (pair->offset = INDENT);
+ pair->offset = INDENT + 1;
+ p->offset += pair->offset;
return(1);
}
termp_d1_post(DECL_ARGS)
{
- if (MDOC_BODY != node->type)
+ if (MDOC_BLOCK != node->type)
return;
term_newln(p);
p->offset -= pair->offset;
if (SEC_SYNOPSIS == node->sec)
if (node->prev && MDOC_Fo == node->prev->tok)
term_vspace(p);
- TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_FUNC_TYPE]);
+ pair->flag |= ttypes[TTYPE_FUNC_TYPE];
return(1);
}
{
const struct mdoc_node *n;
- if (NULL == node->child)
- errx(1, "expected text line arguments");
+ assert(node->child && MDOC_TEXT == node->child->type);
/* FIXME: can be "type funcname" "type varname"... */
if (node->sec == SEC_SYNOPSIS && node->next)
term_vspace(p);
-
}
termp_sx_pre(DECL_ARGS)
{
- TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_LINK]);
+ pair->flag |= ttypes[TTYPE_LINK];
return(1);
}
struct mdoc_node *n;
if (node->parent->tok != MDOC_Fo) {
- TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_FUNC_ARG]);
+ pair->flag |= ttypes[TTYPE_FUNC_ARG];
return(1);
}
termp_va_pre(DECL_ARGS)
{
- TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_VAR_DECL]);
+ pair->flag |= ttypes[TTYPE_VAR_DECL];
return(1);
}
else if (MDOC_BODY != node->type)
return(1);
+ /* FIXME: display type should be mandated by parser. */
+
if (NULL == node->parent->args)
errx(1, "missing display type");
}
-/* ARGSUSED */
-static int
-termp_bsx_pre(DECL_ARGS)
-{
-
- term_word(p, "BSDI BSD/OS");
- return(1);
-}
-
-
/* ARGSUSED */
static void
termp_bx_post(DECL_ARGS)
/* ARGSUSED */
static int
-termp_ox_pre(DECL_ARGS)
-{
-
- term_word(p, "OpenBSD");
- return(1);
-}
-
-
-/* ARGSUSED */
-static int
-termp_dx_pre(DECL_ARGS)
+termp_xx_pre(DECL_ARGS)
{
+ const char *pp;
- term_word(p, "DragonFly");
- return(1);
-}
-
-
-/* ARGSUSED */
-static int
-termp_ux_pre(DECL_ARGS)
-{
-
- term_word(p, "UNIX");
- return(1);
-}
-
-
-/* ARGSUSED */
-static int
-termp_fx_pre(DECL_ARGS)
-{
-
- term_word(p, "FreeBSD");
- return(1);
-}
-
-
-/* ARGSUSED */
-static int
-termp_nx_pre(DECL_ARGS)
-{
+ pp = NULL;
+ switch (node->tok) {
+ case (MDOC_Bsx):
+ pp = "BSDI BSD/OS";
+ break;
+ case (MDOC_Dx):
+ pp = "DragonFlyBSD";
+ break;
+ case (MDOC_Fx):
+ pp = "FreeBSD";
+ break;
+ case (MDOC_Nx):
+ pp = "NetBSD";
+ break;
+ case (MDOC_Ox):
+ pp = "OpenBSD";
+ break;
+ case (MDOC_Ux):
+ pp = "UNIX";
+ break;
+ default:
+ break;
+ }
- term_word(p, "NetBSD");
+ assert(pp);
+ term_word(p, pp);
return(1);
}
term_vspace(p);
break;
case (MDOC_HEAD):
- TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_SSECTION]);
- p->offset = INDENT / 2;
+ pair->flag |= ttypes[TTYPE_SSECTION];
+ p->offset = HALFINDENT;
break;
default:
break;
termp_pa_pre(DECL_ARGS)
{
- TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_FILE]);
+ pair->flag |= ttypes[TTYPE_FILE];
return(1);
}
termp_em_pre(DECL_ARGS)
{
- TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_EMPH]);
+ pair->flag |= ttypes[TTYPE_EMPH];
return(1);
}
termp_cd_pre(DECL_ARGS)
{
- TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_CONFIG]);
+ pair->flag |= ttypes[TTYPE_CONFIG];
term_newln(p);
return(1);
}
termp_cm_pre(DECL_ARGS)
{
- TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_CMD_FLAG]);
+ pair->flag |= ttypes[TTYPE_CMD_FLAG];
return(1);
}
termp_ic_pre(DECL_ARGS)
{
- TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_CMD]);
+ pair->flag |= ttypes[TTYPE_CMD];
return(1);
}
termp_in_pre(DECL_ARGS)
{
- TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_INCLUDE]);
- term_word(p, "#include");
+ pair->flag |= ttypes[TTYPE_INCLUDE];
+ p->flags |= ttypes[TTYPE_INCLUDE];
+
+ if (SEC_SYNOPSIS == node->sec)
+ term_word(p, "#include");
+
term_word(p, "<");
p->flags |= TERMP_NOSPACE;
return(1);
p->flags |= TERMP_NOSPACE;
term_word(p, ">");
- term_newln(p);
if (SEC_SYNOPSIS != node->sec)
return;
+
+ term_newln(p);
+ /*
+ * XXX Not entirely correct. If `.In foo bar' is specified in
+ * the SYNOPSIS section, then it produces a single break after
+ * the <foo>; mandoc asserts a vertical space. Since this
+ * construction is rarely used, I think it's fine.
+ */
if (node->next && MDOC_In != node->next->tok)
term_vspace(p);
}
p->flags |= ttypes[TTYPE_FUNC_NAME];
for (n = node->child; n; n = n->next) {
- if (MDOC_TEXT != n->type)
- errx(1, "expected text line argument");
+ assert(MDOC_TEXT == n->type);
term_word(p, n->string);
}
p->flags &= ~ttypes[TTYPE_FUNC_NAME];
{
const struct mdoc_node *n;
- if (MDOC_HEAD == node->type) {
+ if (MDOC_HEAD == node->type)
return(0);
- } else if (MDOC_BLOCK != node->type)
+ else if (MDOC_BLOCK != node->type)
return(1);
if (NULL == (n = node->head->child)) {
if (arg_hasattr(MDOC_Emphasis, node))
- TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_EMPH]);
+ pair->flag |= ttypes[TTYPE_EMPH];
else if (arg_hasattr(MDOC_Symbolic, node))
- TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_SYMB]);
+ pair->flag |= ttypes[TTYPE_SYMB];
return(1);
}
- if (MDOC_TEXT != n->type)
- errx(1, "expected text line arguments");
-
+ assert(MDOC_TEXT == n->type);
if (0 == strcmp("Em", n->string))
- TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_EMPH]);
+ pair->flag |= ttypes[TTYPE_EMPH];
else if (0 == strcmp("Sy", n->string))
- TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_EMPH]);
+ pair->flag |= ttypes[TTYPE_SYMB];
return(1);
}
termp_sy_pre(DECL_ARGS)
{
- TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_SYMB]);
+ pair->flag |= ttypes[TTYPE_SYMB];
return(1);
}
termp_ms_pre(DECL_ARGS)
{
- TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_SYMBOL]);
+ pair->flag |= ttypes[TTYPE_SYMBOL];
return(1);
}
termp_sm_pre(DECL_ARGS)
{
- if (NULL == node->child || MDOC_TEXT != node->child->type)
- errx(1, "expected boolean line argument");
-
+ assert(node->child && MDOC_TEXT == node->child->type);
if (0 == strcmp("on", node->child->string)) {
p->flags &= ~TERMP_NONOSPACE;
p->flags &= ~TERMP_NOSPACE;
termp__j_pre(DECL_ARGS)
{
- TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_REF_JOURNAL]);
+ pair->flag |= ttypes[TTYPE_REF_JOURNAL];
return(1);
}
{
const struct mdoc_node *n;
- if (NULL == (n = node->child))
- errx(1, "expected line argument");
+ assert(node->child);
+ n = node->child;
+
+ if (NULL == n->next) {
+ pair->flag |= ttypes[TTYPE_LINK_ANCHOR];
+ return(1);
+ }
p->flags |= ttypes[TTYPE_LINK_ANCHOR];
term_word(p, n->string);
- p->flags &= ~ttypes[TTYPE_LINK_ANCHOR];
p->flags |= TERMP_NOSPACE;
term_word(p, ":");
+ p->flags &= ~ttypes[TTYPE_LINK_ANCHOR];
p->flags |= ttypes[TTYPE_LINK_TEXT];
- for ( ; n; n = n->next) {
+ for (n = n->next; n; n = n->next)
term_word(p, n->string);
- }
- p->flags &= ~ttypes[TTYPE_LINK_TEXT];
+ p->flags &= ~ttypes[TTYPE_LINK_TEXT];
return(0);
}
termp_mt_pre(DECL_ARGS)
{
- TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_LINK_ANCHOR]);
+ pair->flag |= ttypes[TTYPE_LINK_ANCHOR];
return(1);
}
git.ckatri.com / mandoc.git / blobdiff