Aren/NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
b331def536
NetBSD/external/bsd/mdocml/dist/mdoc_man.c
christos 544c191c34 Changes in version 1.14.5, released on March 10, 2019 
--- MAJOR NEW FEATURES ---
 * apropos(1): improve POSIX compliance by accepting case-insensitive
   extended regular expressions by default
 * new -O tag[=term] output option (open a page at the definition of a term)
 * tbl(7) -T html: spanning and horizontal and vertical alignment of cells
 * tbl(7) -T html: draw lines on the edges of table cells
 * tbl(7) -T utf8: render lines with the Unicode box drawing characters
 * mandoc is now able to handle the manual pages of the groff package.
    --- MINOR NEW FEATURES ---
 * -T html: new option -O toc (table of contents)
 * -T html: second argument to -O man to support local and remote links
 * mdoc(7) .Bd -centered now fills the text contained in it
 * man-ext .SY and .YS macros (synopsis block)
 * man-ext .TQ macro (tagged paragraph without vertical space before it)
 * tbl(7) \& explicit alignment indicator
 * roff(7) .shift, .while, and .return requests
 * roff(7) .char request (output glyph definition)
 * roff(7) .nop request (no operation)
 * roff(7) .ft request: handle the CB, CI, and CR fonts
 * roff(7) .if c conditional (character available)
 * roff(7) \\$@ escape sequence (insert all macro arguments, quoted)
 * roff(7) \*(.T predefined string (interpolate output device name)
 * roff(7) \[charNNN] escape sequence (for printable ASCII characters)
 * roff(7) \# escape sequence (line continuation with comment)
    --- HTML OUTPUT SYNTAX CORRECTIONS ---
 * Render .br and \p as <br/>, not as an empty <div>.
 * Render .Pp and .PP as <p> and automatically close it when needed.
 * Stop writing empty list elements for non-compact .Bl -tag lists.
 * Do not put <p> inside <a> if .UR or .MT contain .PP.
 * Implement tooltips purely in CSS rather than abusing title= attributes.
    --- MINOR FUNCTIONAL IMPROVEMENTS ---
 * many improvements to the handling of fill and no-fill mode
 * tbl(7): better column widths in the presence of horizontal spans
 * several minor improvements to escape sequence handling
 * several minor improvements to manual font handling
 * portability: autodetect need for _GNU_SOURCE or _OPENBSD_SOURCE
 * portability: autodetect whether less(1) supports the -T option
 * large numbers of bugfixes of diverse kinds
    --- STRUCTURAL IMPROVEMENTS ---
 * Disentangle eqn(7) and tbl(7) from other parser header files,
   and clean up some parser data structures.
 * Substantially simplify error and warning message infrastructure.
    --- THANKS TO ---
 * John Gardner for crucial help implementing tooltips in CSS.
 * Alexander Bluhm, Raphael Graf, Ted Unangst (OpenBSD)
   and Daniel Sabogal (Alpine Linux) for patches.
 * Anthony Bentley and Jason McIntyre (OpenBSD) for documentation patches,
   suggesting new features, bug reports, and useful discussions.
 * Kyle Evans and Baptiste Daroussin (FreeBSD) for minor patches.
 * Pali Rohar for suggesting multiple new features and for reporting
   several bugs and missing features.
 * Klemens Nanni (OpenBSD) for suggesting multiple new features.
 * Kristaps Dzonsons (bsd.lv), Marc Espie (OpenBSD), Adam Kalisz,
   and Laura Morales for suggesting new features.
 * Wolfram Schneider and Yuri Pankov (FreeBSD) for reporting missing features.
 * Edward Tomasz Napierala (FreeBSD) for suggesting a feature improvement.
 * Thomas Klausner (NetBSD) and Sevan Janiyan (SmartOS)
   for bug reports and release testing.
 * Bryan Steele, Janne Johansson, Kurt Mosiejczuk, Mike Belopuhov, Theo
   Buehler, Todd Miller (OpenBSD), Andreas Gustafsson, Christos Zoulas,
   Robert Elz (NetBSD), Kurt Jaeger (FreeBSD), Fabio Scotoni, Kelvin
   Sherlock, Mark Harris, Orestis Ioannou, Raf Czlonka, and Sean Farrell
   for bug reports.
 * Ulrich Spoerlein (FreeBSD), Leah Neukirchen (Void Linux),
   Matej Cepl (openSUSE), and Jan Stary (MacOS X) for release testing.
 * Brian Callahan and Stuart Henderson (OpenBSD) for help
   with the OpenBSD groff port.
 * Bertrand Garrigues, Branden Robinson, Ralph Corderoy, and Werner
   Lemberg (GNU troff) for checking groff patches.
 * Scott Cheloha, Theo de Raadt (OpenBSD)
   and Natanael Copa (Alpine Linux) for useful discussions.
2019-03-10 22:28:56 +00:00

1827 lines
37 KiB
C
Raw Blame History

/* Id: mdoc_man.c,v 1.132 2019/01/04 03:17:36 schwarze Exp */
/*
* Copyright (c) 2011-2019 Ingo Schwarze <schwarze@openbsd.org>
*
* 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.
*
* 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 "config.h"
#include <sys/types.h>
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "mandoc_aux.h"
#include "mandoc.h"
#include "roff.h"
#include "mdoc.h"
#include "man.h"
#include "out.h"
#include "main.h"
#define DECL_ARGS const struct roff_meta *meta, struct roff_node *n
typedef int (*int_fp)(DECL_ARGS);
typedef void (*void_fp)(DECL_ARGS);
struct mdoc_man_act {
int_fp cond; /* DON'T run actions */
int_fp pre; /* pre-node action */
void_fp post; /* post-node action */
const char *prefix; /* pre-node string constant */
const char *suffix; /* post-node string constant */
};
static int cond_body(DECL_ARGS);
static int cond_head(DECL_ARGS);
static void font_push(char);
static void font_pop(void);
static int man_strlen(const char *);
static void mid_it(void);
static void post__t(DECL_ARGS);
static void post_aq(DECL_ARGS);
static void post_bd(DECL_ARGS);
static void post_bf(DECL_ARGS);
static void post_bk(DECL_ARGS);
static void post_bl(DECL_ARGS);
static void post_dl(DECL_ARGS);
static void post_en(DECL_ARGS);
static void post_enc(DECL_ARGS);
static void post_eo(DECL_ARGS);
static void post_fa(DECL_ARGS);
static void post_fd(DECL_ARGS);
static void post_fl(DECL_ARGS);
static void post_fn(DECL_ARGS);
static void post_fo(DECL_ARGS);
static void post_font(DECL_ARGS);
static void post_in(DECL_ARGS);
static void post_it(DECL_ARGS);
static void post_lb(DECL_ARGS);
static void post_nm(DECL_ARGS);
static void post_percent(DECL_ARGS);
static void post_pf(DECL_ARGS);
static void post_sect(DECL_ARGS);
static void post_vt(DECL_ARGS);
static int pre__t(DECL_ARGS);
static int pre_abort(DECL_ARGS);
static int pre_an(DECL_ARGS);
static int pre_ap(DECL_ARGS);
static int pre_aq(DECL_ARGS);
static int pre_bd(DECL_ARGS);
static int pre_bf(DECL_ARGS);
static int pre_bk(DECL_ARGS);
static int pre_bl(DECL_ARGS);
static void pre_br(DECL_ARGS);
static int pre_dl(DECL_ARGS);
static int pre_en(DECL_ARGS);
static int pre_enc(DECL_ARGS);
static int pre_em(DECL_ARGS);
static int pre_skip(DECL_ARGS);
static int pre_eo(DECL_ARGS);
static int pre_ex(DECL_ARGS);
static int pre_fa(DECL_ARGS);
static int pre_fd(DECL_ARGS);
static int pre_fl(DECL_ARGS);
static int pre_fn(DECL_ARGS);
static int pre_fo(DECL_ARGS);
static void pre_ft(DECL_ARGS);
static int pre_Ft(DECL_ARGS);
static int pre_in(DECL_ARGS);
static int pre_it(DECL_ARGS);
static int pre_lk(DECL_ARGS);
static int pre_li(DECL_ARGS);
static int pre_nm(DECL_ARGS);
static int pre_no(DECL_ARGS);
static void pre_noarg(DECL_ARGS);
static int pre_ns(DECL_ARGS);
static void pre_onearg(DECL_ARGS);
static int pre_pp(DECL_ARGS);
static int pre_rs(DECL_ARGS);
static int pre_sm(DECL_ARGS);
static void pre_sp(DECL_ARGS);
static int pre_sect(DECL_ARGS);
static int pre_sy(DECL_ARGS);
static void pre_syn(const struct roff_node *);
static void pre_ta(DECL_ARGS);
static int pre_vt(DECL_ARGS);
static int pre_xr(DECL_ARGS);
static void print_word(const char *);
static void print_line(const char *, int);
static void print_block(const char *, int);
static void print_offs(const char *, int);
static void print_width(const struct mdoc_bl *,
const struct roff_node *);
static void print_count(int *);
static void print_node(DECL_ARGS);
static const void_fp roff_man_acts[ROFF_MAX] = {
pre_br, /* br */
pre_onearg, /* ce */
pre_noarg, /* fi */
pre_ft, /* ft */
pre_onearg, /* ll */
pre_onearg, /* mc */
pre_noarg, /* nf */
pre_onearg, /* po */
pre_onearg, /* rj */
pre_sp, /* sp */
pre_ta, /* ta */
pre_onearg, /* ti */
};
static const struct mdoc_man_act mdoc_man_acts[MDOC_MAX - MDOC_Dd] = {
{ NULL, NULL, NULL, NULL, NULL }, /* Dd */
{ NULL, NULL, NULL, NULL, NULL }, /* Dt */
{ NULL, NULL, NULL, NULL, NULL }, /* Os */
{ NULL, pre_sect, post_sect, ".SH", NULL }, /* Sh */
{ NULL, pre_sect, post_sect, ".SS", NULL }, /* Ss */
{ NULL, pre_pp, NULL, NULL, NULL }, /* Pp */
{ cond_body, pre_dl, post_dl, NULL, NULL }, /* D1 */
{ cond_body, pre_dl, post_dl, NULL, NULL }, /* Dl */
{ cond_body, pre_bd, post_bd, NULL, NULL }, /* Bd */
{ NULL, NULL, NULL, NULL, NULL }, /* Ed */
{ cond_body, pre_bl, post_bl, NULL, NULL }, /* Bl */
{ NULL, NULL, NULL, NULL, NULL }, /* El */
{ NULL, pre_it, post_it, NULL, NULL }, /* It */
{ NULL, pre_em, post_font, NULL, NULL }, /* Ad */
{ NULL, pre_an, NULL, NULL, NULL }, /* An */
{ NULL, pre_ap, NULL, NULL, NULL }, /* Ap */
{ NULL, pre_em, post_font, NULL, NULL }, /* Ar */
{ NULL, pre_sy, post_font, NULL, NULL }, /* Cd */
{ NULL, pre_sy, post_font, NULL, NULL }, /* Cm */
{ NULL, pre_li, post_font, NULL, NULL }, /* Dv */
{ NULL, pre_li, post_font, NULL, NULL }, /* Er */
{ NULL, pre_li, post_font, NULL, NULL }, /* Ev */
{ NULL, pre_ex, NULL, NULL, NULL }, /* Ex */
{ NULL, pre_fa, post_fa, NULL, NULL }, /* Fa */
{ NULL, pre_fd, post_fd, NULL, NULL }, /* Fd */
{ NULL, pre_fl, post_fl, NULL, NULL }, /* Fl */
{ NULL, pre_fn, post_fn, NULL, NULL }, /* Fn */
{ NULL, pre_Ft, post_font, NULL, NULL }, /* Ft */
{ NULL, pre_sy, post_font, NULL, NULL }, /* Ic */
{ NULL, pre_in, post_in, NULL, NULL }, /* In */
{ NULL, pre_li, post_font, NULL, NULL }, /* Li */
{ cond_head, pre_enc, NULL, "\\- ", NULL }, /* Nd */
{ NULL, pre_nm, post_nm, NULL, NULL }, /* Nm */
{ cond_body, pre_enc, post_enc, "[", "]" }, /* Op */
{ NULL, pre_abort, NULL, NULL, NULL }, /* Ot */
{ NULL, pre_em, post_font, NULL, NULL }, /* Pa */
{ NULL, pre_ex, NULL, NULL, NULL }, /* Rv */
{ NULL, NULL, NULL, NULL, NULL }, /* St */
{ NULL, pre_em, post_font, NULL, NULL }, /* Va */
{ NULL, pre_vt, post_vt, NULL, NULL }, /* Vt */
{ NULL, pre_xr, NULL, NULL, NULL }, /* Xr */
{ NULL, NULL, post_percent, NULL, NULL }, /* %A */
{ NULL, pre_em, post_percent, NULL, NULL }, /* %B */
{ NULL, NULL, post_percent, NULL, NULL }, /* %D */
{ NULL, pre_em, post_percent, NULL, NULL }, /* %I */
{ NULL, pre_em, post_percent, NULL, NULL }, /* %J */
{ NULL, NULL, post_percent, NULL, NULL }, /* %N */
{ NULL, NULL, post_percent, NULL, NULL }, /* %O */
{ NULL, NULL, post_percent, NULL, NULL }, /* %P */
{ NULL, NULL, post_percent, NULL, NULL }, /* %R */
{ NULL, pre__t, post__t, NULL, NULL }, /* %T */
{ NULL, NULL, post_percent, NULL, NULL }, /* %V */
{ NULL, NULL, NULL, NULL, NULL }, /* Ac */
{ cond_body, pre_aq, post_aq, NULL, NULL }, /* Ao */
{ cond_body, pre_aq, post_aq, NULL, NULL }, /* Aq */
{ NULL, NULL, NULL, NULL, NULL }, /* At */
{ NULL, NULL, NULL, NULL, NULL }, /* Bc */
{ NULL, pre_bf, post_bf, NULL, NULL }, /* Bf */
{ cond_body, pre_enc, post_enc, "[", "]" }, /* Bo */
{ cond_body, pre_enc, post_enc, "[", "]" }, /* Bq */
{ NULL, pre_bk, post_bk, NULL, NULL }, /* Bsx */
{ NULL, pre_bk, post_bk, NULL, NULL }, /* Bx */
{ NULL, pre_skip, NULL, NULL, NULL }, /* Db */
{ NULL, NULL, NULL, NULL, NULL }, /* Dc */
{ cond_body, pre_enc, post_enc, "\\(lq", "\\(rq" }, /* Do */
{ cond_body, pre_enc, post_enc, "\\(lq", "\\(rq" }, /* Dq */
{ NULL, NULL, NULL, NULL, NULL }, /* Ec */
{ NULL, NULL, NULL, NULL, NULL }, /* Ef */
{ NULL, pre_em, post_font, NULL, NULL }, /* Em */
{ cond_body, pre_eo, post_eo, NULL, NULL }, /* Eo */
{ NULL, pre_bk, post_bk, NULL, NULL }, /* Fx */
{ NULL, pre_sy, post_font, NULL, NULL }, /* Ms */
{ NULL, pre_no, NULL, NULL, NULL }, /* No */
{ NULL, pre_ns, NULL, NULL, NULL }, /* Ns */
{ NULL, pre_bk, post_bk, NULL, NULL }, /* Nx */
{ NULL, pre_bk, post_bk, NULL, NULL }, /* Ox */
{ NULL, NULL, NULL, NULL, NULL }, /* Pc */
{ NULL, NULL, post_pf, NULL, NULL }, /* Pf */
{ cond_body, pre_enc, post_enc, "(", ")" }, /* Po */
{ cond_body, pre_enc, post_enc, "(", ")" }, /* Pq */
{ NULL, NULL, NULL, NULL, NULL }, /* Qc */
{ cond_body, pre_enc, post_enc, "\\(oq", "\\(cq" }, /* Ql */
{ cond_body, pre_enc, post_enc, "\"", "\"" }, /* Qo */
{ cond_body, pre_enc, post_enc, "\"", "\"" }, /* Qq */
{ NULL, NULL, NULL, NULL, NULL }, /* Re */
{ cond_body, pre_rs, NULL, NULL, NULL }, /* Rs */
{ NULL, NULL, NULL, NULL, NULL }, /* Sc */
{ cond_body, pre_enc, post_enc, "\\(oq", "\\(cq" }, /* So */
{ cond_body, pre_enc, post_enc, "\\(oq", "\\(cq" }, /* Sq */
{ NULL, pre_sm, NULL, NULL, NULL }, /* Sm */
{ NULL, pre_em, post_font, NULL, NULL }, /* Sx */
{ NULL, pre_sy, post_font, NULL, NULL }, /* Sy */
{ NULL, pre_li, post_font, NULL, NULL }, /* Tn */
{ NULL, NULL, NULL, NULL, NULL }, /* Ux */
{ NULL, NULL, NULL, NULL, NULL }, /* Xc */
{ NULL, NULL, NULL, NULL, NULL }, /* Xo */
{ NULL, pre_fo, post_fo, NULL, NULL }, /* Fo */
{ NULL, NULL, NULL, NULL, NULL }, /* Fc */
{ cond_body, pre_enc, post_enc, "[", "]" }, /* Oo */
{ NULL, NULL, NULL, NULL, NULL }, /* Oc */
{ NULL, pre_bk, post_bk, NULL, NULL }, /* Bk */
{ NULL, NULL, NULL, NULL, NULL }, /* Ek */
{ NULL, NULL, NULL, NULL, NULL }, /* Bt */
{ NULL, NULL, NULL, NULL, NULL }, /* Hf */
{ NULL, pre_em, post_font, NULL, NULL }, /* Fr */
{ NULL, NULL, NULL, NULL, NULL }, /* Ud */
{ NULL, NULL, post_lb, NULL, NULL }, /* Lb */
{ NULL, pre_abort, NULL, NULL, NULL }, /* Lp */
{ NULL, pre_lk, NULL, NULL, NULL }, /* Lk */
{ NULL, pre_em, post_font, NULL, NULL }, /* Mt */
{ cond_body, pre_enc, post_enc, "{", "}" }, /* Brq */
{ cond_body, pre_enc, post_enc, "{", "}" }, /* Bro */
{ NULL, NULL, NULL, NULL, NULL }, /* Brc */
{ NULL, NULL, post_percent, NULL, NULL }, /* %C */
{ NULL, pre_skip, NULL, NULL, NULL }, /* Es */
{ cond_body, pre_en, post_en, NULL, NULL }, /* En */
{ NULL, pre_bk, post_bk, NULL, NULL }, /* Dx */
{ NULL, NULL, post_percent, NULL, NULL }, /* %Q */
{ NULL, NULL, post_percent, NULL, NULL }, /* %U */
{ NULL, NULL, NULL, NULL, NULL }, /* Ta */
};
static const struct mdoc_man_act *mdoc_man_act(enum roff_tok);
static int outflags;
#define MMAN_spc (1 << 0) /* blank character before next word */
#define MMAN_spc_force (1 << 1) /* even before trailing punctuation */
#define MMAN_nl (1 << 2) /* break man(7) code line */
#define MMAN_br (1 << 3) /* break output line */
#define MMAN_sp (1 << 4) /* insert a blank output line */
#define MMAN_PP (1 << 5) /* reset indentation etc. */
#define MMAN_Sm (1 << 6) /* horizontal spacing mode */
#define MMAN_Bk (1 << 7) /* word keep mode */
#define MMAN_Bk_susp (1 << 8) /* suspend this (after a macro) */
#define MMAN_An_split (1 << 9) /* author mode is "split" */
#define MMAN_An_nosplit (1 << 10) /* author mode is "nosplit" */
#define MMAN_PD (1 << 11) /* inter-paragraph spacing disabled */
#define MMAN_nbrword (1 << 12) /* do not break the next word */
#define BL_STACK_MAX 32
static int Bl_stack[BL_STACK_MAX]; /* offsets [chars] */
static int Bl_stack_post[BL_STACK_MAX]; /* add final .RE */
static int Bl_stack_len; /* number of nested Bl blocks */
static int TPremain; /* characters before tag is full */
static struct {
char *head;
char *tail;
size_t size;
} fontqueue;
static const struct mdoc_man_act *
mdoc_man_act(enum roff_tok tok)
{
assert(tok >= MDOC_Dd && tok <= MDOC_MAX);
return mdoc_man_acts + (tok - MDOC_Dd);
}
static int
man_strlen(const char *cp)
{
size_t rsz;
int skip, sz;
sz = 0;
skip = 0;
for (;;) {
rsz = strcspn(cp, "\\");
if (rsz) {
cp += rsz;
if (skip) {
skip = 0;
rsz--;
}
sz += rsz;
}
if ('\0' == *cp)
break;
cp++;
switch (mandoc_escape(&cp, NULL, NULL)) {
case ESCAPE_ERROR:
return sz;
case ESCAPE_UNICODE:
case ESCAPE_NUMBERED:
case ESCAPE_SPECIAL:
case ESCAPE_UNDEF:
case ESCAPE_OVERSTRIKE:
if (skip)
skip = 0;
else
sz++;
break;
case ESCAPE_SKIPCHAR:
skip = 1;
break;
default:
break;
}
}
return sz;
}
static void
font_push(char newfont)
{
if (fontqueue.head + fontqueue.size <= ++fontqueue.tail) {
fontqueue.size += 8;
fontqueue.head = mandoc_realloc(fontqueue.head,
fontqueue.size);
}
*fontqueue.tail = newfont;
print_word("");
printf("\\f");
putchar(newfont);
outflags &= ~MMAN_spc;
}
static void
font_pop(void)
{
if (fontqueue.tail > fontqueue.head)
fontqueue.tail--;
outflags &= ~MMAN_spc;
print_word("");
printf("\\f");
putchar(*fontqueue.tail);
}
static void
print_word(const char *s)
{
if ((MMAN_PP | MMAN_sp | MMAN_br | MMAN_nl) & outflags) {
/*
* If we need a newline, print it now and start afresh.
*/
if (MMAN_PP & outflags) {
if (MMAN_sp & outflags) {
if (MMAN_PD & outflags) {
printf("\n.PD");
outflags &= ~MMAN_PD;
}
} else if ( ! (MMAN_PD & outflags)) {
printf("\n.PD 0");
outflags |= MMAN_PD;
}
printf("\n.PP\n");
} else if (MMAN_sp & outflags)
printf("\n.sp\n");
else if (MMAN_br & outflags)
printf("\n.br\n");
else if (MMAN_nl & outflags)
putchar('\n');
outflags &= ~(MMAN_PP|MMAN_sp|MMAN_br|MMAN_nl|MMAN_spc);
if (1 == TPremain)
printf(".br\n");
TPremain = 0;
} else if (MMAN_spc & outflags) {
/*
* If we need a space, only print it if
* (1) it is forced by `No' or
* (2) what follows is not terminating punctuation or
* (3) what follows is longer than one character.
*/
if (MMAN_spc_force & outflags || '\0' == s[0] ||
NULL == strchr(".,:;)]?!", s[0]) || '\0' != s[1]) {
if (MMAN_Bk & outflags &&
! (MMAN_Bk_susp & outflags))
putchar('\\');
putchar(' ');
if (TPremain)
TPremain--;
}
}
/*
* Reassign needing space if we're not following opening
* punctuation.
*/
if (MMAN_Sm & outflags && ('\0' == s[0] ||
(('(' != s[0] && '[' != s[0]) || '\0' != s[1])))
outflags |= MMAN_spc;
else
outflags &= ~MMAN_spc;
outflags &= ~(MMAN_spc_force | MMAN_Bk_susp);
for ( ; *s; s++) {
switch (*s) {
case ASCII_NBRSP:
printf("\\ ");
break;
case ASCII_HYPH:
putchar('-');
break;
case ASCII_BREAK:
printf("\\:");
break;
case ' ':
if (MMAN_nbrword & outflags) {
printf("\\ ");
break;
}
/* FALLTHROUGH */
default:
putchar((unsigned char)*s);
break;
}
if (TPremain)
TPremain--;
}
outflags &= ~MMAN_nbrword;
}
static void
print_line(const char *s, int newflags)
{
outflags |= MMAN_nl;
print_word(s);
outflags |= newflags;
}
static void
print_block(const char *s, int newflags)
{
outflags &= ~MMAN_PP;
if (MMAN_sp & outflags) {
outflags &= ~(MMAN_sp | MMAN_br);
if (MMAN_PD & outflags) {
print_line(".PD", 0);
outflags &= ~MMAN_PD;
}
} else if (! (MMAN_PD & outflags))
print_line(".PD 0", MMAN_PD);
outflags |= MMAN_nl;
print_word(s);
outflags |= MMAN_Bk_susp | newflags;
}
static void
print_offs(const char *v, int keywords)
{
char buf[24];
struct roffsu su;
const char *end;
int sz;
print_line(".RS", MMAN_Bk_susp);
/* Convert v into a number (of characters). */
if (NULL == v || '\0' == *v || (keywords && !strcmp(v, "left")))
sz = 0;
else if (keywords && !strcmp(v, "indent"))
sz = 6;
else if (keywords && !strcmp(v, "indent-two"))
sz = 12;
else {
end = a2roffsu(v, &su, SCALE_EN);
if (end == NULL || *end != '\0')
sz = man_strlen(v);
else if (SCALE_EN == su.unit)
sz = su.scale;
else {
/*
* XXX
* If we are inside an enclosing list,
* there is no easy way to add the two
* indentations because they are provided
* in terms of different units.
*/
print_word(v);
outflags |= MMAN_nl;
return;
}
}
/*
* We are inside an enclosing list.
* Add the two indentations.
*/
if (Bl_stack_len)
sz += Bl_stack[Bl_stack_len - 1];
(void)snprintf(buf, sizeof(buf), "%dn", sz);
print_word(buf);
outflags |= MMAN_nl;
}
/*
* Set up the indentation for a list item; used from pre_it().
*/
static void
print_width(const struct mdoc_bl *bl, const struct roff_node *child)
{
char buf[24];
struct roffsu su;
const char *end;
int numeric, remain, sz, chsz;
numeric = 1;
remain = 0;
/* Convert the width into a number (of characters). */
if (bl->width == NULL)
sz = (bl->type == LIST_hang) ? 6 : 0;
else {
end = a2roffsu(bl->width, &su, SCALE_MAX);
if (end == NULL || *end != '\0')
sz = man_strlen(bl->width);
else if (SCALE_EN == su.unit)
sz = su.scale;
else {
sz = 0;
numeric = 0;
}
}
/* XXX Rough estimation, might have multiple parts. */
if (bl->type == LIST_enum)
chsz = (bl->count > 8) + 1;
else if (child != NULL && child->type == ROFFT_TEXT)
chsz = man_strlen(child->string);
else
chsz = 0;
/* Maybe we are inside an enclosing list? */
mid_it();
/*
* Save our own indentation,
* such that child lists can use it.
*/
Bl_stack[Bl_stack_len++] = sz + 2;
/* Set up the current list. */
if (chsz > sz && bl->type != LIST_tag)
print_block(".HP", 0);
else {
print_block(".TP", 0);
remain = sz + 2;
}
if (numeric) {
(void)snprintf(buf, sizeof(buf), "%dn", sz + 2);
print_word(buf);
} else
print_word(bl->width);
TPremain = remain;
}
static void
print_count(int *count)
{
char buf[24];
(void)snprintf(buf, sizeof(buf), "%d.\\&", ++*count);
print_word(buf);
}
void
man_mdoc(void *arg, const struct roff_meta *mdoc)
{
struct roff_node *n;
printf(".\\\" Automatically generated from an mdoc input file."
" Do not edit.\n");
for (n = mdoc->first->child; n != NULL; n = n->next) {
if (n->type != ROFFT_COMMENT)
break;
printf(".\\\"%s\n", n->string);
}
printf(".TH \"%s\" \"%s\" \"%s\" \"%s\" \"%s\"\n",
mdoc->title, (mdoc->msec == NULL ? "" : mdoc->msec),
mdoc->date, mdoc->os, mdoc->vol);
/* Disable hyphenation and if nroff, disable justification. */
printf(".nh\n.if n .ad l");
outflags = MMAN_nl | MMAN_Sm;
if (0 == fontqueue.size) {
fontqueue.size = 8;
fontqueue.head = fontqueue.tail = mandoc_malloc(8);
*fontqueue.tail = 'R';
}
for (; n != NULL; n = n->next)
print_node(mdoc, n);
putchar('\n');
}
static void
print_node(DECL_ARGS)
{
const struct mdoc_man_act *act;
struct roff_node *sub;
int cond, do_sub;
if (n->flags & NODE_NOPRT)
return;
/*
* Break the line if we were parsed subsequent the current node.
* This makes the page structure be more consistent.
*/
if (MMAN_spc & outflags && NODE_LINE & n->flags)
outflags |= MMAN_nl;
act = NULL;
cond = 0;
do_sub = 1;
n->flags &= ~NODE_ENDED;
if (n->type == ROFFT_TEXT) {
/*
* Make sure that we don't happen to start with a
* control character at the start of a line.
*/
if (MMAN_nl & outflags &&
('.' == *n->string || '\'' == *n->string)) {
print_word("");
printf("\\&");
outflags &= ~MMAN_spc;
}
if (n->flags & NODE_DELIMC)
outflags &= ~(MMAN_spc | MMAN_spc_force);
else if (outflags & MMAN_Sm)
outflags |= MMAN_spc_force;
print_word(n->string);
if (n->flags & NODE_DELIMO)
outflags &= ~(MMAN_spc | MMAN_spc_force);
else if (outflags & MMAN_Sm)
outflags |= MMAN_spc;
} else if (n->tok < ROFF_MAX) {
(*roff_man_acts[n->tok])(meta, n);
return;
} else {
/*
* Conditionally run the pre-node action handler for a
* node.
*/
act = mdoc_man_act(n->tok);
cond = act->cond == NULL || (*act->cond)(meta, n);
if (cond && act->pre != NULL &&
(n->end == ENDBODY_NOT || n->child != NULL))
do_sub = (*act->pre)(meta, n);
}
/*
* Conditionally run all child nodes.
* Note that this iterates over children instead of using
* recursion. This prevents unnecessary depth in the stack.
*/
if (do_sub)
for (sub = n->child; sub; sub = sub->next)
print_node(meta, sub);
/*
* Lastly, conditionally run the post-node handler.
*/
if (NODE_ENDED & n->flags)
return;
if (cond && act->post)
(*act->post)(meta, n);
if (ENDBODY_NOT != n->end)
n->body->flags |= NODE_ENDED;
}
static int
cond_head(DECL_ARGS)
{
return n->type == ROFFT_HEAD;
}
static int
cond_body(DECL_ARGS)
{
return n->type == ROFFT_BODY;
}
static int
pre_abort(DECL_ARGS)
{
abort();
}
static int
pre_enc(DECL_ARGS)
{
const char *prefix;
prefix = mdoc_man_act(n->tok)->prefix;
if (NULL == prefix)
return 1;
print_word(prefix);
outflags &= ~MMAN_spc;
return 1;
}
static void
post_enc(DECL_ARGS)
{
const char *suffix;
suffix = mdoc_man_act(n->tok)->suffix;
if (NULL == suffix)
return;
outflags &= ~(MMAN_spc | MMAN_nl);
print_word(suffix);
}
static int
pre_ex(DECL_ARGS)
{
outflags |= MMAN_br | MMAN_nl;
return 1;
}
static void
post_font(DECL_ARGS)
{
font_pop();
}
static void
post_percent(DECL_ARGS)
{
if (mdoc_man_act(n->tok)->pre == pre_em)
font_pop();
if (n->next) {
print_word(",");
if (n->prev && n->prev->tok == n->tok &&
n->next->tok == n->tok)
print_word("and");
} else {
print_word(".");
outflags |= MMAN_nl;
}
}
static int
pre__t(DECL_ARGS)
{
if (n->parent->tok == MDOC_Rs && n->parent->norm->Rs.quote_T) {
print_word("\\(lq");
outflags &= ~MMAN_spc;
} else
font_push('I');
return 1;
}
static void
post__t(DECL_ARGS)
{
if (n->parent->tok == MDOC_Rs && n->parent->norm->Rs.quote_T) {
outflags &= ~MMAN_spc;
print_word("\\(rq");
} else
font_pop();
post_percent(meta, n);
}
/*
* Print before a section header.
*/
static int
pre_sect(DECL_ARGS)
{
if (n->type == ROFFT_HEAD) {
outflags |= MMAN_sp;
print_block(mdoc_man_act(n->tok)->prefix, 0);
print_word("");
putchar('\"');
outflags &= ~MMAN_spc;
}
return 1;
}
/*
* Print subsequent a section header.
*/
static void
post_sect(DECL_ARGS)
{
if (n->type != ROFFT_HEAD)
return;
outflags &= ~MMAN_spc;
print_word("");
putchar('\"');
outflags |= MMAN_nl;
if (MDOC_Sh == n->tok && SEC_AUTHORS == n->sec)
outflags &= ~(MMAN_An_split | MMAN_An_nosplit);
}
/* See mdoc_term.c, synopsis_pre() for comments. */
static void
pre_syn(const struct roff_node *n)
{
if (NULL == n->prev || ! (NODE_SYNPRETTY & n->flags))
return;
if (n->prev->tok == n->tok &&
MDOC_Ft != n->tok &&
MDOC_Fo != n->tok &&
MDOC_Fn != n->tok) {
outflags |= MMAN_br;
return;
}
switch (n->prev->tok) {
case MDOC_Fd:
case MDOC_Fn:
case MDOC_Fo:
case MDOC_In:
case MDOC_Vt:
outflags |= MMAN_sp;
break;
case MDOC_Ft:
if (MDOC_Fn != n->tok && MDOC_Fo != n->tok) {
outflags |= MMAN_sp;
break;
}
/* FALLTHROUGH */
default:
outflags |= MMAN_br;
break;
}
}
static int
pre_an(DECL_ARGS)
{
switch (n->norm->An.auth) {
case AUTH_split:
outflags &= ~MMAN_An_nosplit;
outflags |= MMAN_An_split;
return 0;
case AUTH_nosplit:
outflags &= ~MMAN_An_split;
outflags |= MMAN_An_nosplit;
return 0;
default:
if (MMAN_An_split & outflags)
outflags |= MMAN_br;
else if (SEC_AUTHORS == n->sec &&
! (MMAN_An_nosplit & outflags))
outflags |= MMAN_An_split;
return 1;
}
}
static int
pre_ap(DECL_ARGS)
{
outflags &= ~MMAN_spc;
print_word("'");
outflags &= ~MMAN_spc;
return 0;
}
static int
pre_aq(DECL_ARGS)
{
print_word(n->child != NULL && n->child->next == NULL &&
n->child->tok == MDOC_Mt ? "<" : "\\(la");
outflags &= ~MMAN_spc;
return 1;
}
static void
post_aq(DECL_ARGS)
{
outflags &= ~(MMAN_spc | MMAN_nl);
print_word(n->child != NULL && n->child->next == NULL &&
n->child->tok == MDOC_Mt ? ">" : "\\(ra");
}
static int
pre_bd(DECL_ARGS)
{
outflags &= ~(MMAN_PP | MMAN_sp | MMAN_br);
if (DISP_unfilled == n->norm->Bd.type ||
DISP_literal == n->norm->Bd.type)
print_line(".nf", 0);
if (0 == n->norm->Bd.comp && NULL != n->parent->prev)
outflags |= MMAN_sp;
print_offs(n->norm->Bd.offs, 1);
return 1;
}
static void
post_bd(DECL_ARGS)
{
enum roff_tok bef, now;
/* Close out this display. */
print_line(".RE", MMAN_nl);
bef = n->flags & NODE_NOFILL ? ROFF_nf : ROFF_fi;
if (n->last == NULL)
now = n->norm->Bd.type == DISP_unfilled ||
n->norm->Bd.type == DISP_literal ? ROFF_nf : ROFF_fi;
else if (n->last->tok == ROFF_nf)
now = ROFF_nf;
else if (n->last->tok == ROFF_fi)
now = ROFF_fi;
else
now = n->last->flags & NODE_NOFILL ? ROFF_nf : ROFF_fi;
if (bef != now) {
outflags |= MMAN_nl;
print_word(".");
outflags &= ~MMAN_spc;
print_word(roff_name[bef]);
outflags |= MMAN_nl;
}
/* Maybe we are inside an enclosing list? */
if (NULL != n->parent->next)
mid_it();
}
static int
pre_bf(DECL_ARGS)
{
switch (n->type) {
case ROFFT_BLOCK:
return 1;
case ROFFT_BODY:
break;
default:
return 0;
}
switch (n->norm->Bf.font) {
case FONT_Em:
font_push('I');
break;
case FONT_Sy:
font_push('B');
break;
default:
font_push('R');
break;
}
return 1;
}
static void
post_bf(DECL_ARGS)
{
if (n->type == ROFFT_BODY)
font_pop();
}
static int
pre_bk(DECL_ARGS)
{
switch (n->type) {
case ROFFT_BLOCK:
return 1;
case ROFFT_BODY:
case ROFFT_ELEM:
outflags |= MMAN_Bk;
return 1;
default:
return 0;
}
}
static void
post_bk(DECL_ARGS)
{
switch (n->type) {
case ROFFT_ELEM:
while ((n = n->parent) != NULL)
if (n->tok == MDOC_Bk)
return;
/* FALLTHROUGH */
case ROFFT_BODY:
outflags &= ~MMAN_Bk;
break;
default:
break;
}
}
static int
pre_bl(DECL_ARGS)
{
size_t icol;
/*
* print_offs() will increase the -offset to account for
* a possible enclosing .It, but any enclosed .It blocks
* just nest and do not add up their indentation.
*/
if (n->norm->Bl.offs) {
print_offs(n->norm->Bl.offs, 0);
Bl_stack[Bl_stack_len++] = 0;
}
switch (n->norm->Bl.type) {
case LIST_enum:
n->norm->Bl.count = 0;
return 1;
case LIST_column:
break;
default:
return 1;
}
if (n->child != NULL) {
print_line(".TS", MMAN_nl);
for (icol = 0; icol < n->norm->Bl.ncols; icol++)
print_word("l");
print_word(".");
}
outflags |= MMAN_nl;
return 1;
}
static void
post_bl(DECL_ARGS)
{
switch (n->norm->Bl.type) {
case LIST_column:
if (n->child != NULL)
print_line(".TE", 0);
break;
case LIST_enum:
n->norm->Bl.count = 0;
break;
default:
break;
}
if (n->norm->Bl.offs) {
print_line(".RE", MMAN_nl);
assert(Bl_stack_len);
Bl_stack_len--;
assert(0 == Bl_stack[Bl_stack_len]);
} else {
outflags |= MMAN_PP | MMAN_nl;
outflags &= ~(MMAN_sp | MMAN_br);
}
/* Maybe we are inside an enclosing list? */
if (NULL != n->parent->next)
mid_it();
}
static void
pre_br(DECL_ARGS)
{
outflags |= MMAN_br;
}
static int
pre_dl(DECL_ARGS)
{
print_offs("6n", 0);
return 1;
}
static void
post_dl(DECL_ARGS)
{
print_line(".RE", MMAN_nl);
/* Maybe we are inside an enclosing list? */
if (NULL != n->parent->next)
mid_it();
}
static int
pre_em(DECL_ARGS)
{
font_push('I');
return 1;
}
static int
pre_en(DECL_ARGS)
{
if (NULL == n->norm->Es ||
NULL == n->norm->Es->child)
return 1;
print_word(n->norm->Es->child->string);
outflags &= ~MMAN_spc;
return 1;
}
static void
post_en(DECL_ARGS)
{
if (NULL == n->norm->Es ||
NULL == n->norm->Es->child ||
NULL == n->norm->Es->child->next)
return;
outflags &= ~MMAN_spc;
print_word(n->norm->Es->child->next->string);
return;
}
static int
pre_eo(DECL_ARGS)
{
if (n->end == ENDBODY_NOT &&
n->parent->head->child == NULL &&
n->child != NULL &&
n->child->end != ENDBODY_NOT)
print_word("\\&");
else if (n->end != ENDBODY_NOT ? n->child != NULL :
n->parent->head->child != NULL && (n->child != NULL ||
(n->parent->tail != NULL && n->parent->tail->child != NULL)))
outflags &= ~(MMAN_spc | MMAN_nl);
return 1;
}
static void
post_eo(DECL_ARGS)
{
int body, tail;
if (n->end != ENDBODY_NOT) {
outflags |= MMAN_spc;
return;
}
body = n->child != NULL || n->parent->head->child != NULL;
tail = n->parent->tail != NULL && n->parent->tail->child != NULL;
if (body && tail)
outflags &= ~MMAN_spc;
else if ( ! (body || tail))
print_word("\\&");
else if ( ! tail)
outflags |= MMAN_spc;
}
static int
pre_fa(DECL_ARGS)
{
int am_Fa;
am_Fa = MDOC_Fa == n->tok;
if (am_Fa)
n = n->child;
while (NULL != n) {
font_push('I');
if (am_Fa || NODE_SYNPRETTY & n->flags)
outflags |= MMAN_nbrword;
print_node(meta, n);
font_pop();
if (NULL != (n = n->next))
print_word(",");
}
return 0;
}
static void
post_fa(DECL_ARGS)
{
if (NULL != n->next && MDOC_Fa == n->next->tok)
print_word(",");
}
static int
pre_fd(DECL_ARGS)
{
pre_syn(n);
font_push('B');
return 1;
}
static void
post_fd(DECL_ARGS)
{
font_pop();
outflags |= MMAN_br;
}
static int
pre_fl(DECL_ARGS)
{
font_push('B');
print_word("\\-");
if (n->child != NULL)
outflags &= ~MMAN_spc;
return 1;
}
static void
post_fl(DECL_ARGS)
{
font_pop();
if (!(n->child != NULL ||
n->next == NULL ||
n->next->type == ROFFT_TEXT ||
n->next->flags & NODE_LINE))
outflags &= ~MMAN_spc;
}
static int
pre_fn(DECL_ARGS)
{
pre_syn(n);
n = n->child;
if (NULL == n)
return 0;
if (NODE_SYNPRETTY & n->flags)
print_block(".HP 4n", MMAN_nl);
font_push('B');
print_node(meta, n);
font_pop();
outflags &= ~MMAN_spc;
print_word("(");
outflags &= ~MMAN_spc;
n = n->next;
if (NULL != n)
pre_fa(meta, n);
return 0;
}
static void
post_fn(DECL_ARGS)
{
print_word(")");
if (NODE_SYNPRETTY & n->flags) {
print_word(";");
outflags |= MMAN_PP;
}
}
static int
pre_fo(DECL_ARGS)
{
switch (n->type) {
case ROFFT_BLOCK:
pre_syn(n);
break;
case ROFFT_HEAD:
if (n->child == NULL)
return 0;
if (NODE_SYNPRETTY & n->flags)
print_block(".HP 4n", MMAN_nl);
font_push('B');
break;
case ROFFT_BODY:
outflags &= ~(MMAN_spc | MMAN_nl);
print_word("(");
outflags &= ~MMAN_spc;
break;
default:
break;
}
return 1;
}
static void
post_fo(DECL_ARGS)
{
switch (n->type) {
case ROFFT_HEAD:
if (n->child != NULL)
font_pop();
break;
case ROFFT_BODY:
post_fn(meta, n);
break;
default:
break;
}
}
static int
pre_Ft(DECL_ARGS)
{
pre_syn(n);
font_push('I');
return 1;
}
static void
pre_ft(DECL_ARGS)
{
print_line(".ft", 0);
print_word(n->child->string);
outflags |= MMAN_nl;
}
static int
pre_in(DECL_ARGS)
{
if (NODE_SYNPRETTY & n->flags) {
pre_syn(n);
font_push('B');
print_word("#include <");
outflags &= ~MMAN_spc;
} else {
print_word("<");
outflags &= ~MMAN_spc;
font_push('I');
}
return 1;
}
static void
post_in(DECL_ARGS)
{
if (NODE_SYNPRETTY & n->flags) {
outflags &= ~MMAN_spc;
print_word(">");
font_pop();
outflags |= MMAN_br;
} else {
font_pop();
outflags &= ~MMAN_spc;
print_word(">");
}
}
static int
pre_it(DECL_ARGS)
{
const struct roff_node *bln;
switch (n->type) {
case ROFFT_HEAD:
outflags |= MMAN_PP | MMAN_nl;
bln = n->parent->parent;
if (0 == bln->norm->Bl.comp ||
(NULL == n->parent->prev &&
NULL == bln->parent->prev))
outflags |= MMAN_sp;
outflags &= ~MMAN_br;
switch (bln->norm->Bl.type) {
case LIST_item:
return 0;
case LIST_inset:
case LIST_diag:
case LIST_ohang:
if (bln->norm->Bl.type == LIST_diag)
print_line(".B \"", 0);
else
print_line(".BR \\& \"", 0);
outflags &= ~MMAN_spc;
return 1;
case LIST_bullet:
case LIST_dash:
case LIST_hyphen:
print_width(&bln->norm->Bl, NULL);
TPremain = 0;
outflags |= MMAN_nl;
font_push('B');
if (LIST_bullet == bln->norm->Bl.type)
print_word("\\(bu");
else
print_word("-");
font_pop();
outflags |= MMAN_nl;
return 0;
case LIST_enum:
print_width(&bln->norm->Bl, NULL);
TPremain = 0;
outflags |= MMAN_nl;
print_count(&bln->norm->Bl.count);
outflags |= MMAN_nl;
return 0;
case LIST_hang:
print_width(&bln->norm->Bl, n->child);
TPremain = 0;
outflags |= MMAN_nl;
return 1;
case LIST_tag:
print_width(&bln->norm->Bl, n->child);
putchar('\n');
outflags &= ~MMAN_spc;
return 1;
default:
return 1;
}
default:
break;
}
return 1;
}
/*
* This function is called after closing out an indented block.
* If we are inside an enclosing list, restore its indentation.
*/
static void
mid_it(void)
{
char buf[24];
/* Nothing to do outside a list. */
if (0 == Bl_stack_len || 0 == Bl_stack[Bl_stack_len - 1])
return;
/* The indentation has already been set up. */
if (Bl_stack_post[Bl_stack_len - 1])
return;
/* Restore the indentation of the enclosing list. */
print_line(".RS", MMAN_Bk_susp);
(void)snprintf(buf, sizeof(buf), "%dn",
Bl_stack[Bl_stack_len - 1]);
print_word(buf);
/* Remeber to close out this .RS block later. */
Bl_stack_post[Bl_stack_len - 1] = 1;
}
static void
post_it(DECL_ARGS)
{
const struct roff_node *bln;
bln = n->parent->parent;
switch (n->type) {
case ROFFT_HEAD:
switch (bln->norm->Bl.type) {
case LIST_diag:
outflags &= ~MMAN_spc;
print_word("\\ ");
break;
case LIST_ohang:
outflags |= MMAN_br;
break;
default:
break;
}
break;
case ROFFT_BODY:
switch (bln->norm->Bl.type) {
case LIST_bullet:
case LIST_dash:
case LIST_hyphen:
case LIST_enum:
case LIST_hang:
case LIST_tag:
assert(Bl_stack_len);
Bl_stack[--Bl_stack_len] = 0;
/*
* Our indentation had to be restored
* after a child display or child list.
* Close out that indentation block now.
*/
if (Bl_stack_post[Bl_stack_len]) {
print_line(".RE", MMAN_nl);
Bl_stack_post[Bl_stack_len] = 0;
}
break;
case LIST_column:
if (NULL != n->next) {
putchar('\t');
outflags &= ~MMAN_spc;
}
break;
default:
break;
}
break;
default:
break;
}
}
static void
post_lb(DECL_ARGS)
{
if (SEC_LIBRARY == n->sec)
outflags |= MMAN_br;
}
static int
pre_lk(DECL_ARGS)
{
const struct roff_node *link, *descr, *punct;
if ((link = n->child) == NULL)
return 0;
/* Find beginning of trailing punctuation. */
punct = n->last;
while (punct != link && punct->flags & NODE_DELIMC)
punct = punct->prev;
punct = punct->next;
/* Link text. */
if ((descr = link->next) != NULL && descr != punct) {
font_push('I');
while (descr != punct) {
print_word(descr->string);
descr = descr->next;
}
font_pop();
print_word(":");
}
/* Link target. */
font_push('B');
print_word(link->string);
font_pop();
/* Trailing punctuation. */
while (punct != NULL) {
print_word(punct->string);
punct = punct->next;
}
return 0;
}
static void
pre_onearg(DECL_ARGS)
{
outflags |= MMAN_nl;
print_word(".");
outflags &= ~MMAN_spc;
print_word(roff_name[n->tok]);
if (n->child != NULL)
print_word(n->child->string);
outflags |= MMAN_nl;
if (n->tok == ROFF_ce)
for (n = n->child->next; n != NULL; n = n->next)
print_node(meta, n);
}
static int
pre_li(DECL_ARGS)
{
font_push('R');
return 1;
}
static int
pre_nm(DECL_ARGS)
{
char *name;
if (n->type == ROFFT_BLOCK) {
outflags |= MMAN_Bk;
pre_syn(n);
}
if (n->type != ROFFT_ELEM && n->type != ROFFT_HEAD)
return 1;
name = n->child == NULL ? NULL : n->child->string;
if (NULL == name)
return 0;
if (n->type == ROFFT_HEAD) {
if (NULL == n->parent->prev)
outflags |= MMAN_sp;
print_block(".HP", 0);
printf(" %dn", man_strlen(name) + 1);
outflags |= MMAN_nl;
}
font_push('B');
return 1;
}
static void
post_nm(DECL_ARGS)
{
switch (n->type) {
case ROFFT_BLOCK:
outflags &= ~MMAN_Bk;
break;
case ROFFT_HEAD:
case ROFFT_ELEM:
if (n->child != NULL && n->child->string != NULL)
font_pop();
break;
default:
break;
}
}
static int
pre_no(DECL_ARGS)
{
outflags |= MMAN_spc_force;
return 1;
}
static void
pre_noarg(DECL_ARGS)
{
outflags |= MMAN_nl;
print_word(".");
outflags &= ~MMAN_spc;
print_word(roff_name[n->tok]);
outflags |= MMAN_nl;
}
static int
pre_ns(DECL_ARGS)
{
outflags &= ~MMAN_spc;
return 0;
}
static void
post_pf(DECL_ARGS)
{
if ( ! (n->next == NULL || n->next->flags & NODE_LINE))
outflags &= ~MMAN_spc;
}
static int
pre_pp(DECL_ARGS)
{
if (MDOC_It != n->parent->tok)
outflags |= MMAN_PP;
outflags |= MMAN_sp | MMAN_nl;
outflags &= ~MMAN_br;
return 0;
}
static int
pre_rs(DECL_ARGS)
{
if (SEC_SEE_ALSO == n->sec) {
outflags |= MMAN_PP | MMAN_sp | MMAN_nl;
outflags &= ~MMAN_br;
}
return 1;
}
static int
pre_skip(DECL_ARGS)
{
return 0;
}
static int
pre_sm(DECL_ARGS)
{
if (NULL == n->child)
outflags ^= MMAN_Sm;
else if (0 == strcmp("on", n->child->string))
outflags |= MMAN_Sm;
else
outflags &= ~MMAN_Sm;
if (MMAN_Sm & outflags)
outflags |= MMAN_spc;
return 0;
}
static void
pre_sp(DECL_ARGS)
{
if (outflags & MMAN_PP) {
outflags &= ~MMAN_PP;
print_line(".PP", 0);
} else {
print_line(".sp", 0);
if (n->child != NULL)
print_word(n->child->string);
}
outflags |= MMAN_nl;
}
static int
pre_sy(DECL_ARGS)
{
font_push('B');
return 1;
}
static void
pre_ta(DECL_ARGS)
{
print_line(".ta", 0);
for (n = n->child; n != NULL; n = n->next)
print_word(n->string);
outflags |= MMAN_nl;
}
static int
pre_vt(DECL_ARGS)
{
if (NODE_SYNPRETTY & n->flags) {
switch (n->type) {
case ROFFT_BLOCK:
pre_syn(n);
return 1;
case ROFFT_BODY:
break;
default:
return 0;
}
}
font_push('I');
return 1;
}
static void
post_vt(DECL_ARGS)
{
if (n->flags & NODE_SYNPRETTY && n->type != ROFFT_BODY)
return;
font_pop();
}
static int
pre_xr(DECL_ARGS)
{
n = n->child;
if (NULL == n)
return 0;
print_node(meta, n);
n = n->next;
if (NULL == n)
return 0;
outflags &= ~MMAN_spc;
print_word("(");
print_node(meta, n);
print_word(")");
return 0;
}
Reference in New Issue View Git Blame Copy Permalink