mdoc_man.c revision 698f87a48e2e945bfe5493ce168e0d0ae1cedd5c
/* $Id: mdoc_man.c,v 1.57 2013/12/25 22:00:45 schwarze Exp $ */
/*
* Copyright (c) 2011, 2012, 2013 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.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <assert.h>
#include <stdio.h>
#include <string.h>
#include "mandoc.h"
#include "out.h"
#include "man.h"
#include "mdoc.h"
#include "main.h"
const struct mdoc_node *n
struct manact {
const char *prefix; /* pre-node string constant */
const char *suffix; /* post-node string constant */
};
static void font_push(char);
static void font_pop(void);
static void mid_it(void);
static void post_percent(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 *);
static void print_width(const char *,
static void print_count(int *);
static void print_node(DECL_ARGS);
"\\fP\nutility exits 0 on success, and >0 if an error occurs."
}, /* Ex */
"\\fP\nfunction returns the value 0 if successful;\n"
"otherwise the value -1 is returned and the global\n"
"variable \\fIerrno\\fP is set to indicate the error."
}, /* Rv */
};
static int outflags;
#define BL_STACK_MAX 32
static int Bl_stack_len; /* number of nested Bl blocks */
static int TPremain; /* characters before tag is full */
static struct {
char *head;
char *tail;
} fontqueue;
static void
{
}
print_word("");
printf("\\f");
}
static void
font_pop(void)
{
print_word("");
printf("\\f");
}
static void
print_word(const char *s)
{
/*
* If we need a newline, print it now and start afresh.
*/
printf("\n.PD");
}
printf("\n.PD 0");
}
printf("\n.PP\n");
printf("\n.br\n");
putchar('\n');
if (1 == TPremain)
printf(".br\n");
TPremain = 0;
/*
* 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.
*/
! (MMAN_Bk_susp & outflags))
putchar('\\');
putchar(' ');
if (TPremain)
TPremain--;
}
}
/*
* Reassign needing space if we're not following opening
* punctuation.
*/
(('(' != s[0] && '[' != s[0]) || '\0' != s[1])))
else
for ( ; *s; s++) {
switch (*s) {
case (ASCII_NBRSP):
printf("\\ ");
break;
case (ASCII_HYPH):
putchar('-');
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)
{
print_word(s);
}
static void
print_block(const char *s, int newflags)
{
print_line(".PD", 0);
}
print_word(s);
}
static void
print_offs(const char *v)
{
char buf[24];
/* Convert v into a number (of characters). */
sz = 0;
else if (0 == strcmp(v, "indent"))
sz = 6;
else if (0 == strcmp(v, "indent-two"))
sz = 12;
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);
return;
}
} else
/*
* We are inside an enclosing list.
* Add the two indentations.
*/
if (Bl_stack_len)
}
/*
* Set up the indentation for a list item; used from pre_it().
*/
void
{
char buf[24];
numeric = 1;
remain = 0;
/* Convert v into a number (of characters). */
if (NULL == v)
else {
sz = 0;
numeric = 0;
}
} else
/* XXX Rough estimation, might have multiple parts. */
/* Maybe we are inside an enclosing list? */
mid_it();
/*
* Save our own indentation,
* such that child lists can use it.
*/
/* Set up the current list. */
print_block(".HP", 0);
else {
print_block(".TP", 0);
}
if (numeric) {
} else
print_word(v);
}
void
print_count(int *count)
{
char buf[12];
}
void
{
/*
* Dump the keep buffer.
* We're guaranteed by now that this exists (is non-NULL).
* Flush stdout afterward, just in case.
*/
}
void
{
const struct mdoc_node *n;
printf(".TH \"%s\" \"%s\" \"%s\" \"%s\" \"%s\"\n",
/* Disable hyphenation and if nroff, disable justification. */
printf(".nh\n.if n .ad l");
}
print_node(meta, n);
putchar('\n');
}
static void
{
/*
* Break the line if we were parsed subsequent the current node.
* This makes the page structure be more consistent.
*/
cond = 0;
do_sub = 1;
/*
* Make sure that we don't happen to start with a
* control character at the start of a line.
*/
'\'' == *n->string)) {
print_word("");
printf("\\&");
}
print_word(n->string);
} else {
/*
* Conditionally run the pre-node action handler for a
* node.
*/
}
/*
* 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)
/*
* Lastly, conditionally run the post-node handler.
*/
}
static int
{
}
static int
{
}
static int
{
const char *prefix;
return(1);
return(1);
}
static void
{
const char *suffix;
return;
}
static void
{
font_pop();
}
static void
{
font_pop();
if (n->next) {
print_word(",");
print_word("and");
} else {
print_word(".");
}
}
static int
{
print_word("");
putchar('\"');
} else
font_push('I');
return(1);
}
static void
{
print_word("");
putchar('\"');
} else
font_pop();
post_percent(meta, n);
}
/*
* Print before a section header.
*/
static int
{
print_word("");
putchar('\"');
}
return(1);
}
/*
* Print subsequent a section header.
*/
static void
{
return;
print_word("");
putchar('\"');
}
/* See mdoc_term.c, synopsis_pre() for comments. */
static void
{
return;
return;
}
case (MDOC_Fd):
/* FALLTHROUGH */
case (MDOC_Fn):
/* FALLTHROUGH */
case (MDOC_Fo):
/* FALLTHROUGH */
case (MDOC_In):
/* FALLTHROUGH */
case (MDOC_Vt):
break;
case (MDOC_Ft):
break;
}
/* FALLTHROUGH */
default:
break;
}
}
static int
{
case (AUTH_split):
outflags &= ~MMAN_An_nosplit;
return(0);
case (AUTH_nosplit):
outflags &= ~MMAN_An_split;
return(0);
default:
if (MMAN_An_split & outflags)
else if (SEC_AUTHORS == n->sec &&
! (MMAN_An_nosplit & outflags))
return(1);
}
}
static int
{
print_word("'");
return(0);
}
static int
{
print_line(".nf", 0);
return(1);
}
static void
{
/* Close out this display. */
/* Maybe we are inside an enclosing list? */
mid_it();
}
static int
{
switch (n->type) {
case (MDOC_BLOCK):
return(1);
case (MDOC_BODY):
break;
default:
return(0);
}
case (FONT_Em):
font_push('I');
break;
case (FONT_Sy):
font_push('B');
break;
default:
font_push('R');
break;
}
return(1);
}
static void
{
font_pop();
}
static int
{
switch (n->type) {
case (MDOC_BLOCK):
return(1);
case (MDOC_BODY):
return(1);
default:
return(0);
}
}
static void
{
}
static int
{
/*
* 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.
*/
Bl_stack[Bl_stack_len++] = 0;
}
case (LIST_enum):
return(1);
case (LIST_column):
break;
default:
return(1);
}
print_word("l");
print_word(".");
return(1);
}
static void
{
case (LIST_column):
print_line(".TE", 0);
break;
case (LIST_enum):
break;
default:
break;
}
Bl_stack_len--;
} else {
}
/* Maybe we are inside an enclosing list? */
mid_it();
}
static int
{
return(0);
}
static int
{
n = n->child;
if (n) {
print_word(n->string);
n = n->next;
}
print_word("BSD");
if (NULL == n)
return(0);
print_word("-");
print_word(n->string);
return(0);
}
static int
{
print_offs("6n");
return(1);
}
static void
{
/* Maybe we are inside an enclosing list? */
mid_it();
}
static int
{
font_push('I');
return(1);
}
static void
{
}
static int
{
int am_Fa;
if (am_Fa)
n = n->child;
while (NULL != n) {
font_push('I');
outflags |= MMAN_nbrword;
print_node(meta, n);
font_pop();
print_word(",");
}
return(0);
}
static void
{
print_word(",");
}
static int
{
pre_syn(n);
font_push('B');
return(1);
}
static void
{
font_pop();
}
static int
{
font_push('B');
print_word("\\-");
return(1);
}
static void
{
font_pop();
}
static int
{
pre_syn(n);
n = n->child;
if (NULL == n)
return(0);
if (MDOC_SYNPRETTY & n->flags)
font_push('B');
print_node(meta, n);
font_pop();
print_word("(");
n = n->next;
if (NULL != n)
return(0);
}
static void
{
print_word(")");
if (MDOC_SYNPRETTY & n->flags) {
print_word(";");
}
}
static int
{
switch (n->type) {
case (MDOC_BLOCK):
pre_syn(n);
break;
case (MDOC_HEAD):
if (MDOC_SYNPRETTY & n->flags)
font_push('B');
break;
case (MDOC_BODY):
print_word("(");
break;
default:
break;
}
return(1);
}
static void
{
switch (n->type) {
case (MDOC_HEAD):
font_pop();
break;
case (MDOC_BODY):
break;
default:
break;
}
}
static int
{
pre_syn(n);
font_push('I');
return(1);
}
static int
{
if (MDOC_SYNPRETTY & n->flags) {
pre_syn(n);
font_push('B');
print_word("#include <");
} else {
print_word("<");
font_push('I');
}
return(1);
}
static void
{
if (MDOC_SYNPRETTY & n->flags) {
print_word(">");
font_pop();
} else {
font_pop();
print_word(">");
}
}
static int
{
switch (n->type) {
case (MDOC_HEAD):
case (LIST_item):
return(0);
case (LIST_inset):
/* FALLTHROUGH */
case (LIST_diag):
/* FALLTHROUGH */
case (LIST_ohang):
print_line(".B \"", 0);
else
print_line(".R \"", 0);
return(1);
case (LIST_bullet):
/* FALLTHROUGH */
case (LIST_dash):
/* FALLTHROUGH */
case (LIST_hyphen):
TPremain = 0;
font_push('B');
print_word("o");
else
print_word("-");
font_pop();
break;
case (LIST_enum):
TPremain = 0;
break;
case (LIST_hang):
TPremain = 0;
break;
case (LIST_tag):
putchar('\n');
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. */
return;
/* The indentation has already been set up. */
return;
/* Restore the indentation of the enclosing list. */
/* Remeber to close out this .RS block later. */
}
static void
{
switch (n->type) {
case (MDOC_HEAD):
case (LIST_diag):
print_word("\\ ");
break;
case (LIST_ohang):
break;
default:
break;
}
break;
case (MDOC_BODY):
case (LIST_bullet):
/* FALLTHROUGH */
case (LIST_dash):
/* FALLTHROUGH */
case (LIST_hyphen):
/* FALLTHROUGH */
case (LIST_enum):
/* FALLTHROUGH */
case (LIST_hang):
/* FALLTHROUGH */
case (LIST_tag):
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]) {
Bl_stack_post[Bl_stack_len] = 0;
}
break;
case (LIST_column):
putchar('\t');
}
break;
default:
break;
}
break;
default:
break;
}
}
static void
{
if (SEC_LIBRARY == n->sec)
}
static int
{
return(0);
font_push('I');
}
print_word(":");
font_pop();
}
font_push('B');
font_pop();
return(0);
}
static int
{
font_push('R');
return(1);
}
static int
{
char *name;
if (MDOC_BLOCK == n->type) {
pre_syn(n);
}
return(1);
return(0);
print_block(".HP", 0);
}
font_push('B');
return(1);
}
static void
{
switch (n->type) {
case (MDOC_BLOCK):
break;
case (MDOC_HEAD):
/* FALLTHROUGH */
case (MDOC_ELEM):
font_pop();
break;
default:
break;
}
}
static int
{
return(1);
}
static int
{
return(0);
}
static void
{
}
static int
{
return(0);
}
static int
{
if (SEC_SEE_ALSO == n->sec) {
}
return(1);
}
static int
{
else
return(0);
}
static int
{
print_line(".PP", 0);
} else
print_line(".sp", 0);
return(1);
}
static void
{
}
static int
{
font_push('B');
return(1);
}
static int
{
if (MDOC_SYNPRETTY & n->flags) {
switch (n->type) {
case (MDOC_BLOCK):
pre_syn(n);
return(1);
case (MDOC_BODY):
break;
default:
return(0);
}
}
font_push('I');
return(1);
}
static void
{
return;
font_pop();
}
static int
{
n = n->child;
if (NULL == n)
return(0);
print_node(meta, n);
n = n->next;
if (NULL == n)
return(0);
print_word("(");
print_node(meta, n);
print_word(")");
return(0);
}
static int
{
return(0);
print_word("\\ ");
return(1);
}