mandoc/mdoc_man.c - diff

Return to mdoc_man.c CVS log

Up to [cvsweb.bsd.lv] / mandoc

Diff for /mandoc/mdoc_man.c between version 1.79 and 1.90

version 1.79, 2014/12/23 10:09:44

version 1.90, 2015/04/02 22:48:17

Line 1

/* $Id$ */

* Permission to use, copy, modify, and distribute this software for any

* purpose with or without fee is hereby granted, provided that the above

Line 22

#include <stdio.h>

#include <string.h>

#include "mandoc.h"

#include "mandoc_aux.h"

#include "out.h"

#include "mandoc.h"

#include "man.h"

#include "roff.h"

#include "mdoc.h"

#include "man.h"

#include "out.h"

#include "main.h"

#define DECL_ARGS const struct mdoc_meta *meta, \

#define DECL_ARGS const struct mdoc_meta *meta, struct roff_node *n

const struct mdoc_node *n

struct manact {

int (*cond)(DECL_ARGS); /* DON'T run actions */

Line 108 static int pre_sm(DECL_ARGS);

static int pre_sp(DECL_ARGS);

static int pre_sect(DECL_ARGS);

static int pre_sy(DECL_ARGS);

static void pre_syn(const struct mdoc_node *);

static void pre_syn(const struct roff_node *);

static int pre_vt(DECL_ARGS);

static int pre_ux(DECL_ARGS);

static int pre_xr(DECL_ARGS);

Line 116 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 char *,

static void print_width(const struct mdoc_bl *,

const struct mdoc_node *, size_t);

const struct roff_node *);

static void print_count(int *);

static void print_node(DECL_ARGS);

Line 186 static const struct manact manacts[MDOC_MAX + 1] = {

{ NULL, pre_bx, NULL, 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" }, /* Do */

{ cond_body, pre_enc, post_enc, "\\(lq", "\\(rq" }, /* Dq */

{ 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 */

Line 265 static int outflags;

#define BL_STACK_MAX 32

static size_t Bl_stack[BL_STACK_MAX]; /* offsets [chars] */

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 */

Line 423 print_offs(const char *v, int keywords)

{

char buf[24];

struct roffsu su;

size_t sz;

int sz;

print_line(".RS", MMAN_Bk_susp);

Line 459 print_offs(const char *v, int keywords)

if (Bl_stack_len)

sz += Bl_stack[Bl_stack_len - 1];

(void)snprintf(buf, sizeof(buf), "%zun", sz);

(void)snprintf(buf, sizeof(buf), "%dn", sz);

print_word(buf);

outflags |= MMAN_nl;

}

Line 468 print_offs(const char *v, int keywords)

* Set up the indentation for a list item; used from pre_it().

static void

print_width(const char *v, const struct mdoc_node *child, size_t defsz)

print_width(const struct mdoc_bl *bl, const struct roff_node *child)

{

char buf[24];

struct roffsu su;

size_t sz, chsz;

int numeric, remain, sz, chsz;

int numeric, remain;

numeric = 1;

remain = 0;

/* Convert v into a number (of characters). */

/* Convert the width into a number (of characters). */

if (NULL == v)

if (bl->width == NULL)

sz = defsz;

sz = (bl->type == LIST_hang) ? 6 : 0;

else if (a2roffsu(v, &su, SCALE_MAX) > 1) {

else if (a2roffsu(bl->width, &su, SCALE_MAX) > 1) {

if (SCALE_EN == su.unit)

sz = su.scale;

else {

Line 489 print_width(const char *v, const struct mdoc_node *chi

Line 488 print_width(const char *v, const struct mdoc_node *chi

numeric = 0;

}

} else

sz = strlen(v);

sz = strlen(bl->width);

/* XXX Rough estimation, might have multiple parts. */

chsz = (NULL != child && MDOC_TEXT == child->type) ?

if (bl->type == LIST_enum)

strlen(child->string) : 0;

chsz = (bl->count > 8) + 1;

else if (child != NULL && child->type == ROFFT_TEXT)

chsz = strlen(child->string);

else

chsz = 0;

/* Maybe we are inside an enclosing list? */

mid_it();

Line 505 print_width(const char *v, const struct mdoc_node *chi

Line 508 print_width(const char *v, const struct mdoc_node *chi

Bl_stack[Bl_stack_len++] = sz + 2;

/* Set up the current list. */

if (defsz && chsz > sz)

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), "%zun", sz + 2);

(void)snprintf(buf, sizeof(buf), "%dn", sz + 2);

print_word(buf);

} else

print_word(v);

print_word(bl->width);

TPremain = remain;

}

Line 524 print_count(int *count)

Line 527 print_count(int *count)

{

char buf[24];

(void)snprintf(buf, sizeof(buf), "%d.", ++*count);

(void)snprintf(buf, sizeof(buf), "%d.\\&", ++*count);

print_word(buf);

}

Line 545 void

Line 548 void

man_mdoc(void *arg, const struct mdoc *mdoc)

{

const struct mdoc_meta *meta;

const struct mdoc_node *n;

struct roff_node *n;

meta = mdoc_meta(mdoc);

n = mdoc_node(mdoc);

n = mdoc_node(mdoc)->child;

printf(".TH \"%s\" \"%s\" \"%s\" \"%s\" \"%s\"\n",

meta->title,

Line 564 man_mdoc(void *arg, const struct mdoc *mdoc)

Line 567 man_mdoc(void *arg, const struct mdoc *mdoc)

fontqueue.head = fontqueue.tail = mandoc_malloc(8);

*fontqueue.tail = 'R';

}

print_node(meta, n);

while (n != NULL) {

print_node(meta, n);

n = n->next;

}

putchar('\n');

}

static void

print_node(DECL_ARGS)

{

const struct mdoc_node *sub;

const struct manact *act;

struct roff_node *sub;

int cond, do_sub;

Line 585 print_node(DECL_ARGS)

Line 591 print_node(DECL_ARGS)

act = NULL;

cond = 0;

do_sub = 1;

n->flags &= ~MDOC_ENDED;

if (MDOC_TEXT == n->type) {

if (n->type == ROFFT_TEXT) {

* Make sure that we don't happen to start with a

* control character at the start of a line.

Line 632 print_node(DECL_ARGS)

Line 639 print_node(DECL_ARGS)

(*act->post)(meta, n);

if (ENDBODY_NOT != n->end)

n->pending->flags |= MDOC_ENDED;

n->body->flags |= MDOC_ENDED;

if (ENDBODY_NOSPACE == n->end)

outflags &= ~(MMAN_spc | MMAN_nl);

Line 642 static int

Line 649 static int

cond_head(DECL_ARGS)

{

return(MDOC_HEAD == n->type);

return(n->type == ROFFT_HEAD);

}

static int

cond_body(DECL_ARGS)

{

return(MDOC_BODY == n->type);

return(n->type == ROFFT_BODY);

}

static int

Line 772 static int

Line 779 static int

pre_sect(DECL_ARGS)

{

if (MDOC_HEAD == n->type) {

if (n->type == ROFFT_HEAD) {

outflags |= MMAN_sp;

print_block(manacts[n->tok].prefix, 0);

print_word("");

Line 789 static void

Line 796 static void

post_sect(DECL_ARGS)

{

if (MDOC_HEAD != n->type)

if (n->type != ROFFT_HEAD)

return;

outflags &= ~MMAN_spc;

print_word("");

Line 801 post_sect(DECL_ARGS)

Line 808 post_sect(DECL_ARGS)

/* See mdoc_term.c, synopsis_pre() for comments. */

static void

pre_syn(const struct mdoc_node *n)

pre_syn(const struct roff_node *n)

{

if (NULL == n->prev || ! (MDOC_SYNPRETTY & n->flags))

Line 876 static int

Line 883 static int

pre_aq(DECL_ARGS)

{

print_word(n->parent->prev != NULL &&

print_word(n->nchild == 1 &&

n->parent->prev->tok == MDOC_An ? "<" : "\\(la");

n->child->tok == MDOC_Mt ? "<" : "\\(la");

outflags &= ~MMAN_spc;

return(1);

}

Line 887 post_aq(DECL_ARGS)

Line 894 post_aq(DECL_ARGS)

{

outflags &= ~(MMAN_spc | MMAN_nl);

print_word(n->parent->prev != NULL &&

print_word(n->nchild == 1 &&

n->parent->prev->tok == MDOC_An ? ">" : "\\(ra");

n->child->tok == MDOC_Mt ? ">" : "\\(ra");

}

static int

Line 926 pre_bf(DECL_ARGS)

Line 933 pre_bf(DECL_ARGS)

{

switch (n->type) {

case MDOC_BLOCK:

case ROFFT_BLOCK:

return(1);

case MDOC_BODY:

case ROFFT_BODY:

break;

default:

return(0);

Line 951 static void

Line 958 static void

post_bf(DECL_ARGS)

{

if (MDOC_BODY == n->type)

if (n->type == ROFFT_BODY)

font_pop();

}

Line 960 pre_bk(DECL_ARGS)

Line 967 pre_bk(DECL_ARGS)

{

switch (n->type) {

case MDOC_BLOCK:

case ROFFT_BLOCK:

return(1);

case MDOC_BODY:

case ROFFT_BODY:

outflags |= MMAN_Bk;

return(1);

default:

Line 974 static void

Line 981 static void

post_bk(DECL_ARGS)

{

if (MDOC_BODY == n->type)

if (n->type == ROFFT_BODY)

outflags &= ~MMAN_Bk;

}

Line 1003 pre_bl(DECL_ARGS)

Line 1010 pre_bl(DECL_ARGS)

return(1);

}

print_line(".TS", MMAN_nl);

if (n->nchild) {

for (icol = 0; icol < n->norm->Bl.ncols; icol++)

print_line(".TS", MMAN_nl);

print_word("l");

for (icol = 0; icol < n->norm->Bl.ncols; icol++)

print_word(".");

print_word("l");

print_word(".");

}

outflags |= MMAN_nl;

return(1);

}

Line 1017 post_bl(DECL_ARGS)

Line 1026 post_bl(DECL_ARGS)

switch (n->norm->Bl.type) {

case LIST_column:

print_line(".TE", 0);

if (n->nchild)

print_line(".TE", 0);

break;

case LIST_enum:

n->norm->Bl.count = 0;

Line 1128 static int

Line 1138 static int

pre_eo(DECL_ARGS)

{

outflags &= ~(MMAN_spc | MMAN_nl);

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_SPACE)

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

Line 1205 post_fl(DECL_ARGS)

Line 1236 post_fl(DECL_ARGS)

font_pop();

if ( ! (n->nchild ||

n->next == NULL ||

n->next->type == MDOC_TEXT ||

n->next->type == ROFFT_TEXT ||

n->next->flags & MDOC_LINE))

outflags &= ~MMAN_spc;

}

Line 1252 pre_fo(DECL_ARGS)

Line 1283 pre_fo(DECL_ARGS)

{

switch (n->type) {

case MDOC_BLOCK:

case ROFFT_BLOCK:

pre_syn(n);

break;

case MDOC_HEAD:

case ROFFT_HEAD:

if (n->child == NULL)

return(0);

if (MDOC_SYNPRETTY & n->flags)

print_block(".HP 4n", MMAN_nl);

font_push('B');

break;

case MDOC_BODY:

case ROFFT_BODY:

outflags &= ~MMAN_spc;

outflags &= ~(MMAN_spc | MMAN_nl);

print_word("(");

outflags &= ~MMAN_spc;

break;

Line 1276 post_fo(DECL_ARGS)

Line 1309 post_fo(DECL_ARGS)

{

switch (n->type) {

case MDOC_HEAD:

case ROFFT_HEAD:

font_pop();

if (n->child != NULL)

font_pop();

break;

case MDOC_BODY:

case ROFFT_BODY:

post_fn(meta, n);

break;

default:

Line 1332 post_in(DECL_ARGS)

Line 1366 post_in(DECL_ARGS)

static int

pre_it(DECL_ARGS)

{

const struct mdoc_node *bln;

const struct roff_node *bln;

switch (n->type) {

case MDOC_HEAD:

case ROFFT_HEAD:

outflags |= MMAN_PP | MMAN_nl;

bln = n->parent->parent;

if (0 == bln->norm->Bl.comp ||

Line 1362 pre_it(DECL_ARGS)

Line 1396 pre_it(DECL_ARGS)

case LIST_dash:

/* FALLTHROUGH */

case LIST_hyphen:

print_width(bln->norm->Bl.width, NULL, 0);

print_width(&bln->norm->Bl, NULL);

TPremain = 0;

outflags |= MMAN_nl;

font_push('B');

Line 1374 pre_it(DECL_ARGS)

Line 1408 pre_it(DECL_ARGS)

outflags |= MMAN_nl;

return(0);

case LIST_enum:

print_width(bln->norm->Bl.width, NULL, 0);

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.width, n->child, 6);

print_width(&bln->norm->Bl, n->child);

TPremain = 0;

outflags |= MMAN_nl;

return(1);

case LIST_tag:

print_width(bln->norm->Bl.width, n->child, 0);

print_width(&bln->norm->Bl, n->child);

putchar('\n');

outflags &= ~MMAN_spc;

return(1);

Line 1418 mid_it(void)

Line 1452 mid_it(void)

/* Restore the indentation of the enclosing list. */

print_line(".RS", MMAN_Bk_susp);

(void)snprintf(buf, sizeof(buf), "%zun",

(void)snprintf(buf, sizeof(buf), "%dn",

Bl_stack[Bl_stack_len - 1]);

print_word(buf);

Line 1429 mid_it(void)

Line 1463 mid_it(void)

static void

post_it(DECL_ARGS)

{

const struct mdoc_node *bln;

const struct roff_node *bln;

bln = n->parent->parent;

switch (n->type) {

case MDOC_HEAD:

case ROFFT_HEAD:

switch (bln->norm->Bl.type) {

case LIST_diag:

outflags &= ~MMAN_spc;

Line 1447 post_it(DECL_ARGS)

Line 1481 post_it(DECL_ARGS)

break;

}

break;

case MDOC_BODY:

case ROFFT_BODY:

switch (bln->norm->Bl.type) {

case LIST_bullet:

/* FALLTHROUGH */

Line 1499 post_lb(DECL_ARGS)

Line 1533 post_lb(DECL_ARGS)

static int

pre_lk(DECL_ARGS)

{

const struct mdoc_node *link, *descr;

const struct roff_node *link, *descr;

if (NULL == (link = n->child))

return(0);

Line 1541 pre_nm(DECL_ARGS)

Line 1575 pre_nm(DECL_ARGS)

{

char *name;

if (MDOC_BLOCK == n->type) {

if (n->type == ROFFT_BLOCK) {

outflags |= MMAN_Bk;

pre_syn(n);

}

if (MDOC_ELEM != n->type && MDOC_HEAD != n->type)

if (n->type != ROFFT_ELEM && n->type != ROFFT_HEAD)

return(1);

name = n->child ? n->child->string : meta->name;

if (NULL == name)

return(0);

if (MDOC_HEAD == n->type) {

if (n->type == ROFFT_HEAD) {

if (NULL == n->parent->prev)

outflags |= MMAN_sp;

print_block(".HP", 0);

Line 1568 post_nm(DECL_ARGS)

Line 1602 post_nm(DECL_ARGS)

{

switch (n->type) {

case MDOC_BLOCK:

case ROFFT_BLOCK:

outflags &= ~MMAN_Bk;

break;

case MDOC_HEAD:

case ROFFT_HEAD:

/* FALLTHROUGH */

case MDOC_ELEM:

case ROFFT_ELEM:

if (n->child != NULL || meta->name != NULL)

font_pop();

break;

Line 1737 pre_vt(DECL_ARGS)

Line 1771 pre_vt(DECL_ARGS)

if (MDOC_SYNPRETTY & n->flags) {

switch (n->type) {

case MDOC_BLOCK:

case ROFFT_BLOCK:

pre_syn(n);

return(1);

case MDOC_BODY:

case ROFFT_BODY:

break;

default:

return(0);

Line 1754 static void

Line 1788 static void

post_vt(DECL_ARGS)

{

if (MDOC_SYNPRETTY & n->flags && MDOC_BODY != n->type)

if (n->flags & MDOC_SYNPRETTY && n->type != ROFFT_BODY)

return;

font_pop();

}

CVSweb