mandoc/mdoc_term.c - diff

Return to mdoc_term.c CVS log

Up to [cvsweb.bsd.lv] / mandoc

Diff for /mandoc/mdoc_term.c between version 1.360 and 1.370

version 1.360, 2017/06/04 18:50:35

version 1.370, 2018/12/13 11:55:47

Line 1

/* $Id$ */

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

Line 29

#include <string.h>

#include "mandoc_aux.h"

#include "mandoc.h"

#include "roff.h"

#include "mdoc.h"

#include "out.h"

Line 47 struct termpair {

Line 46 struct termpair {

const struct roff_meta *meta, \

struct roff_node *n

struct termact {

struct mdoc_term_act {

int (*pre)(DECL_ARGS);

void (*post)(DECL_ARGS);

};

Line 84 static void termp_xx_post(DECL_ARGS);

Line 83 static void termp_xx_post(DECL_ARGS);

static int termp__a_pre(DECL_ARGS);

static int termp__t_pre(DECL_ARGS);

static int termp_abort_pre(DECL_ARGS);

static int termp_an_pre(DECL_ARGS);

static int termp_ap_pre(DECL_ARGS);

static int termp_bd_pre(DECL_ARGS);

Line 124 static int termp_vt_pre(DECL_ARGS);

static int termp_xr_pre(DECL_ARGS);

static int termp_xx_pre(DECL_ARGS);

static const struct termact __termacts[MDOC_MAX - MDOC_Dd] = {

static const struct mdoc_term_act mdoc_term_acts[MDOC_MAX - MDOC_Dd] = {

{ NULL, NULL }, /* Dd */

{ NULL, NULL }, /* Dt */

{ NULL, NULL }, /* Os */

Line 159 static const struct termact __termacts[MDOC_MAX - MDOC

{ termp_nd_pre, NULL }, /* Nd */

{ termp_nm_pre, termp_nm_post }, /* Nm */

{ termp_quote_pre, termp_quote_post }, /* Op */

{ termp_ft_pre, NULL }, /* Ot */

{ termp_abort_pre, NULL }, /* Ot */

{ termp_under_pre, NULL }, /* Pa */

{ termp_ex_pre, NULL }, /* Rv */

{ NULL, NULL }, /* St */

Line 232 static const struct termact __termacts[MDOC_MAX - MDOC

{ termp_under_pre, NULL }, /* Fr */

{ NULL, NULL }, /* Ud */

{ NULL, termp_lb_post }, /* Lb */

{ termp_pp_pre, NULL }, /* Lp */

{ termp_abort_pre, NULL }, /* Lp */

{ termp_lk_pre, NULL }, /* Lk */

{ termp_under_pre, NULL }, /* Mt */

{ termp_quote_pre, termp_quote_post }, /* Brq */

Line 246 static const struct termact __termacts[MDOC_MAX - MDOC

{ NULL, termp____post }, /* %U */

{ NULL, NULL }, /* Ta */

};

static const struct termact *const termacts = __termacts - MDOC_Dd;

static int fn_prio;

Line 259 terminal_mdoc(void *arg, const struct roff_man *mdoc)

Line 258 terminal_mdoc(void *arg, const struct roff_man *mdoc)

size_t save_defindent;

p = (struct termp *)arg;

p->rmargin = p->maxrmargin = p->defrmargin;

p->tcol->rmargin = p->maxrmargin = p->defrmargin;

term_tab_set(p, NULL);

term_tab_set(p, "T");

term_tab_set(p, ".5i");

Line 283 terminal_mdoc(void *arg, const struct roff_man *mdoc)

Line 282 terminal_mdoc(void *arg, const struct roff_man *mdoc)

p->defindent = 5;

term_begin(p, print_mdoc_head, print_mdoc_foot,

&mdoc->meta);

while (n != NULL && n->flags & NODE_NOPRT)

while (n != NULL &&

(n->type == ROFFT_COMMENT ||

n->flags & NODE_NOPRT))

n = n->next;

if (n != NULL) {

if (n->tok != MDOC_Sh)

Line 308 print_mdoc_nodelist(DECL_ARGS)

Line 309 print_mdoc_nodelist(DECL_ARGS)

static void

print_mdoc_node(DECL_ARGS)

{

int chld;

const struct mdoc_term_act *act;

struct termpair npair;

size_t offset, rmargin;

int chld;

if (n->flags & NODE_NOPRT)

if (n->type == ROFFT_COMMENT || n->flags & NODE_NOPRT)

return;

chld = 1;

offset = p->offset;

offset = p->tcol->offset;

rmargin = p->rmargin;

rmargin = p->tcol->rmargin;

n->flags &= ~NODE_ENDED;

n->prev_font = p->fonti;

Line 368 print_mdoc_node(DECL_ARGS)

Line 370 print_mdoc_node(DECL_ARGS)

return;

}

assert(n->tok >= MDOC_Dd && n->tok < MDOC_MAX);

if (termacts[n->tok].pre != NULL &&

act = mdoc_term_acts + (n->tok - MDOC_Dd);

if (act->pre != NULL &&

(n->end == ENDBODY_NOT || n->child != NULL))

chld = (*termacts[n->tok].pre)

chld = (*act->pre)(p, &npair, meta, n);

(p, &npair, meta, n);

break;

}

Line 389 print_mdoc_node(DECL_ARGS)

Line 391 print_mdoc_node(DECL_ARGS)

case ROFFT_EQN:

break;

default:

if (termacts[n->tok].post == NULL || n->flags & NODE_ENDED)

if (act->post == NULL || n->flags & NODE_ENDED)

break;

(void)(*termacts[n->tok].post)(p, &npair, meta, n);

(void)(*act->post)(p, &npair, meta, n);

* Explicit end tokens not only call the post

Line 407 print_mdoc_node(DECL_ARGS)

Line 409 print_mdoc_node(DECL_ARGS)

p->flags |= TERMP_SENTENCE;

if (n->type != ROFFT_TEXT)

p->offset = offset;

p->tcol->offset = offset;

p->rmargin = rmargin;

p->tcol->rmargin = rmargin;

}

static void

Line 428 print_mdoc_foot(struct termp *p, const struct roff_met

Line 430 print_mdoc_foot(struct termp *p, const struct roff_met

term_vspace(p);

p->offset = 0;

p->tcol->offset = 0;

sz = term_strlen(p, meta->date);

p->rmargin = p->maxrmargin > sz ?

p->tcol->rmargin = p->maxrmargin > sz ?

(p->maxrmargin + term_len(p, 1) - sz) / 2 : 0;

p->trailspace = 1;

p->flags |= TERMP_NOSPACE | TERMP_NOBREAK;

Line 438 print_mdoc_foot(struct termp *p, const struct roff_met

Line 440 print_mdoc_foot(struct termp *p, const struct roff_met

term_word(p, meta->os);

term_flushln(p);

p->offset = p->rmargin;

p->tcol->offset = p->tcol->rmargin;

sz = term_strlen(p, meta->os);

p->rmargin = p->maxrmargin > sz ? p->maxrmargin - sz : 0;

p->tcol->rmargin = p->maxrmargin > sz ? p->maxrmargin - sz : 0;

p->flags |= TERMP_NOSPACE;

term_word(p, meta->date);

term_flushln(p);

p->offset = p->rmargin;

p->tcol->offset = p->tcol->rmargin;

p->rmargin = p->maxrmargin;

p->tcol->rmargin = p->maxrmargin;

p->trailspace = 0;

p->flags &= ~TERMP_NOBREAK;

p->flags |= TERMP_NOSPACE;

Line 455 print_mdoc_foot(struct termp *p, const struct roff_met

Line 457 print_mdoc_foot(struct termp *p, const struct roff_met

term_word(p, meta->os);

term_flushln(p);

p->offset = 0;

p->tcol->offset = 0;

p->rmargin = p->maxrmargin;

p->tcol->rmargin = p->maxrmargin;

p->flags = 0;

}

Line 496 print_mdoc_head(struct termp *p, const struct roff_met

Line 498 print_mdoc_head(struct termp *p, const struct roff_met

p->flags |= TERMP_NOBREAK | TERMP_NOSPACE;

p->trailspace = 1;

p->offset = 0;

p->tcol->offset = 0;

p->rmargin = 2 * (titlen+1) + vollen < p->maxrmargin ?

p->tcol->rmargin = 2 * (titlen+1) + vollen < p->maxrmargin ?

(p->maxrmargin - vollen + term_len(p, 1)) / 2 :

vollen < p->maxrmargin ? p->maxrmargin - vollen : 0;

Line 505 print_mdoc_head(struct termp *p, const struct roff_met

Line 507 print_mdoc_head(struct termp *p, const struct roff_met

term_flushln(p);

p->flags |= TERMP_NOSPACE;

p->offset = p->rmargin;

p->tcol->offset = p->tcol->rmargin;

p->rmargin = p->offset + vollen + titlen < p->maxrmargin ?

p->tcol->rmargin = p->tcol->offset + vollen + titlen <

p->maxrmargin - titlen : p->maxrmargin;

p->maxrmargin ? p->maxrmargin - titlen : p->maxrmargin;

term_word(p, volume);

term_flushln(p);

p->flags &= ~TERMP_NOBREAK;

p->trailspace = 0;

if (p->rmargin + titlen <= p->maxrmargin) {

if (p->tcol->rmargin + titlen <= p->maxrmargin) {

p->flags |= TERMP_NOSPACE;

p->offset = p->rmargin;

p->tcol->offset = p->tcol->rmargin;

p->rmargin = p->maxrmargin;

p->tcol->rmargin = p->maxrmargin;

term_word(p, title);

term_flushln(p);

}

p->flags &= ~TERMP_NOSPACE;

p->offset = 0;

p->tcol->offset = 0;

p->rmargin = p->maxrmargin;

p->tcol->rmargin = p->maxrmargin;

free(title);

free(volume);

}

Line 533 static int

Line 535 static int

a2width(const struct termp *p, const char *v)

{

struct roffsu su;

const char *end;

if (a2roffsu(v, &su, SCALE_MAX) < 2) {

end = a2roffsu(v, &su, SCALE_MAX);

if (end == NULL || *end != '\0') {

SCALE_HS_INIT(&su, term_strlen(p, v));

su.scale /= term_strlen(p, "0");

}

return term_hspan(p, &su) / 24;

return term_hen(p, &su);

}

Line 565 print_bvspace(struct termp *p,

Line 569 print_bvspace(struct termp *p,

/* Do not vspace directly after Ss/Sh. */

nn = n;

while (nn->prev != NULL && nn->prev->flags & NODE_NOPRT)

while (nn->prev != NULL &&

(nn->prev->type == ROFFT_COMMENT ||

nn->prev->flags & NODE_NOPRT))

nn = nn->prev;

while (nn->prev == NULL) {

do {

Line 649 termp_it_pre(DECL_ARGS)

Line 655 termp_it_pre(DECL_ARGS)

if (bl->norm->Bl.offs != NULL) {

offset = a2width(p, bl->norm->Bl.offs);

if (offset < 0 && (size_t)(-offset) > p->offset)

if (offset < 0 && (size_t)(-offset) > p->tcol->offset)

offset = -p->offset;

offset = -p->tcol->offset;

else if (offset > SHRT_MAX)

offset = 0;

}

Line 684 termp_it_pre(DECL_ARGS)

Line 690 termp_it_pre(DECL_ARGS)

SCALE_HS_INIT(&su,

term_strlen(p, bl->norm->Bl.cols[i]));

su.scale /= term_strlen(p, "0");

offset += term_hspan(p, &su) / 24 + dcol;

offset += term_hen(p, &su) + dcol;

}

Line 702 termp_it_pre(DECL_ARGS)

Line 708 termp_it_pre(DECL_ARGS)

SCALE_HS_INIT(&su, term_strlen(p, bl->norm->Bl.cols[i]));

su.scale /= term_strlen(p, "0");

width = term_hspan(p, &su) / 24 + dcol;

width = term_hen(p, &su) + dcol;

break;

default:

if (NULL == bl->norm->Bl.width)

Line 714 termp_it_pre(DECL_ARGS)

Line 720 termp_it_pre(DECL_ARGS)

* handling for column for how this changes.

width = a2width(p, bl->norm->Bl.width) + term_len(p, 2);

if (width < 0 && (size_t)(-width) > p->offset)

if (width < 0 && (size_t)(-width) > p->tcol->offset)

width = -p->offset;

width = -p->tcol->offset;

else if (width > SHRT_MAX)

width = 0;

break;

Line 815 termp_it_pre(DECL_ARGS)

Line 821 termp_it_pre(DECL_ARGS)

* necessarily lengthened. Everybody gets the offset.

p->offset += offset;

p->tcol->offset += offset;

switch (type) {

case LIST_bullet:

Line 825 termp_it_pre(DECL_ARGS)

Line 831 termp_it_pre(DECL_ARGS)

case LIST_hang:

case LIST_tag:

if (n->type == ROFFT_HEAD)

p->rmargin = p->offset + width;

p->tcol->rmargin = p->tcol->offset + width;

else

p->offset += width;

p->tcol->offset += width;

break;

case LIST_column:

assert(width);

p->rmargin = p->offset + width;

p->tcol->rmargin = p->tcol->offset + width;

* XXX - this behaviour is not documented: the

* right-most column is filled to the right margin.

if (n->type == ROFFT_HEAD)

break;

if (NULL == n->next && p->rmargin < p->maxrmargin)

if (n->next == NULL && p->tcol->rmargin < p->maxrmargin)

p->rmargin = p->maxrmargin;

p->tcol->rmargin = p->maxrmargin;

break;

default:

break;

Line 945 termp_nm_pre(DECL_ARGS)

Line 951 termp_nm_pre(DECL_ARGS)

}

if (n->type == ROFFT_BODY) {

if (NULL == n->child)

if (n->child == NULL)

return 0;

p->flags |= TERMP_NOSPACE;

cp = NULL;

Line 954 termp_nm_pre(DECL_ARGS)

Line 960 termp_nm_pre(DECL_ARGS)

if (cp == NULL)

cp = meta->name;

if (cp == NULL)

p->offset += term_len(p, 6);

p->tcol->offset += term_len(p, 6);

else

p->offset += term_len(p, 1) + term_strlen(p, cp);

p->tcol->offset += term_len(p, 1) +

term_strlen(p, cp);

return 1;

}

Line 967 termp_nm_pre(DECL_ARGS)

Line 974 termp_nm_pre(DECL_ARGS)

synopsis_pre(p, n->parent);

if (n->type == ROFFT_HEAD &&

NULL != n->next && NULL != n->next->child) {

n->next != NULL && n->next->child != NULL) {

p->flags |= TERMP_NOSPACE | TERMP_NOBREAK | TERMP_BRIND;

p->trailspace = 1;

p->rmargin = p->offset + term_len(p, 1);

p->tcol->rmargin = p->tcol->offset + term_len(p, 1);

if (NULL == n->child) {

if (n->child == NULL)

p->rmargin += term_strlen(p, meta->name);

p->tcol->rmargin += term_strlen(p, meta->name);

} else if (n->child->type == ROFFT_TEXT) {

else if (n->child->type == ROFFT_TEXT) {

p->rmargin += term_strlen(p, n->child->string);

p->tcol->rmargin += term_strlen(p, n->child->string);

if (n->child->next)

if (n->child->next != NULL)

p->flags |= TERMP_HANG;

} else {

p->rmargin += term_len(p, 5);

p->tcol->rmargin += term_len(p, 5);

p->flags |= TERMP_HANG;

}

Line 1250 termp_sh_pre(DECL_ARGS)

Line 1257 termp_sh_pre(DECL_ARGS)

term_fontpush(p, TERMFONT_BOLD);

break;

case ROFFT_BODY:

p->offset = term_len(p, p->defindent);

p->tcol->offset = term_len(p, p->defindent);

term_tab_set(p, NULL);

term_tab_set(p, "T");

term_tab_set(p, ".5i");

Line 1281 termp_sh_post(DECL_ARGS)

Line 1288 termp_sh_post(DECL_ARGS)

break;

case ROFFT_BODY:

term_newln(p);

p->offset = 0;

p->tcol->offset = 0;

break;

default:

break;

Line 1303 termp_d1_pre(DECL_ARGS)

Line 1310 termp_d1_pre(DECL_ARGS)

if (n->type != ROFFT_BLOCK)

return 1;

term_newln(p);

p->offset += term_len(p, p->defindent + 1);

p->tcol->offset += term_len(p, p->defindent + 1);

term_tab_set(p, NULL);

term_tab_set(p, "T");

term_tab_set(p, ".5i");

Line 1334 termp_fn_pre(DECL_ARGS)

Line 1341 termp_fn_pre(DECL_ARGS)

return 0;

if (pretty) {

rmargin = p->rmargin;

rmargin = p->tcol->rmargin;

p->rmargin = p->offset + term_len(p, 4);

p->tcol->rmargin = p->tcol->offset + term_len(p, 4);

p->flags |= TERMP_NOBREAK | TERMP_BRIND | TERMP_HANG;

}

Line 1351 termp_fn_pre(DECL_ARGS)

Line 1358 termp_fn_pre(DECL_ARGS)

term_flushln(p);

p->flags &= ~(TERMP_NOBREAK | TERMP_BRIND | TERMP_HANG);

p->flags |= TERMP_NOPAD;

p->offset = p->rmargin;

p->tcol->offset = p->tcol->rmargin;

p->rmargin = rmargin;

p->tcol->rmargin = rmargin;

}

p->flags |= TERMP_NOSPACE;

Line 1413 termp_fa_pre(DECL_ARGS)

Line 1420 termp_fa_pre(DECL_ARGS)

static int

termp_bd_pre(DECL_ARGS)

{

size_t lm, len, rm, rmax;

size_t lm, len;

struct roff_node *nn;

int offset;

Line 1429 termp_bd_pre(DECL_ARGS)

Line 1436 termp_bd_pre(DECL_ARGS)

! strcmp(n->norm->Bd.offs, "left"))

/* nothing */;

else if ( ! strcmp(n->norm->Bd.offs, "indent"))

p->offset += term_len(p, p->defindent + 1);

p->tcol->offset += term_len(p, p->defindent + 1);

else if ( ! strcmp(n->norm->Bd.offs, "indent-two"))

p->offset += term_len(p, (p->defindent + 1) * 2);

p->tcol->offset += term_len(p, (p->defindent + 1) * 2);

else {

offset = a2width(p, n->norm->Bd.offs);

if (offset < 0 && (size_t)(-offset) > p->offset)

if (offset < 0 && (size_t)(-offset) > p->tcol->offset)

p->offset = 0;

p->tcol->offset = 0;

else if (offset < SHRT_MAX)

p->offset += offset;

p->tcol->offset += offset;

}

Line 1448 termp_bd_pre(DECL_ARGS)

Line 1455 termp_bd_pre(DECL_ARGS)

* lines are allowed.

if (DISP_literal != n->norm->Bd.type &&

if (n->norm->Bd.type != DISP_literal &&

DISP_unfilled != n->norm->Bd.type &&

n->norm->Bd.type != DISP_unfilled &&

DISP_centered != n->norm->Bd.type)

n->norm->Bd.type != DISP_centered)

return 1;

if (n->norm->Bd.type == DISP_literal) {

Line 1459 termp_bd_pre(DECL_ARGS)

Line 1466 termp_bd_pre(DECL_ARGS)

term_tab_set(p, "8n");

}

lm = p->offset;

lm = p->tcol->offset;

rm = p->rmargin;

p->flags |= TERMP_BRNEVER;

rmax = p->maxrmargin;

for (nn = n->child; nn != NULL; nn = nn->next) {

p->rmargin = p->maxrmargin = TERM_MAXMARGIN;

if (n->norm->Bd.type == DISP_centered) {

for (nn = n->child; nn; nn = nn->next) {

if (DISP_centered == n->norm->Bd.type) {

if (nn->type == ROFFT_TEXT) {

len = term_strlen(p, nn->string);

p->offset = len >= rm ? 0 :

p->tcol->offset = len >= p->tcol->rmargin ?

lm + len >= rm ? rm - len :

0 : lm + len >= p->tcol->rmargin ?

(lm + rm - len) / 2;

p->tcol->rmargin - len :

(lm + p->tcol->rmargin - len) / 2;

} else

p->offset = lm;

p->tcol->offset = lm;

}

print_mdoc_node(p, pair, meta, nn);

Line 1488 termp_bd_pre(DECL_ARGS)

Line 1493 termp_bd_pre(DECL_ARGS)

case MDOC_Bl:

case MDOC_D1:

case MDOC_Dl:

case MDOC_Lp:

case MDOC_Pp:

continue;

default:

Line 1500 termp_bd_pre(DECL_ARGS)

Line 1504 termp_bd_pre(DECL_ARGS)

term_flushln(p);

p->flags |= TERMP_NOSPACE;

}

p->flags &= ~TERMP_BRNEVER;

p->rmargin = rm;

p->maxrmargin = rmax;

return 0;

}

static void

termp_bd_post(DECL_ARGS)

{

size_t rm, rmax;

if (n->type != ROFFT_BODY)

return;

rm = p->rmargin;

rmax = p->maxrmargin;

if (DISP_literal == n->norm->Bd.type ||

DISP_unfilled == n->norm->Bd.type)

p->rmargin = p->maxrmargin = TERM_MAXMARGIN;

p->flags |= TERMP_BRNEVER;

p->flags |= TERMP_NOSPACE;

term_newln(p);

p->flags &= ~TERMP_BRNEVER;

p->rmargin = rm;

p->maxrmargin = rmax;

}

static int

Line 1560 termp_ss_pre(DECL_ARGS)

Line 1553 termp_ss_pre(DECL_ARGS)

case ROFFT_BLOCK:

term_newln(p);

for (nn = n->prev; nn != NULL; nn = nn->prev)

if ((nn->flags & NODE_NOPRT) == 0)

if (nn->type != ROFFT_COMMENT &&

(nn->flags & NODE_NOPRT) == 0)

break;

if (nn != NULL)

term_vspace(p);

break;

case ROFFT_HEAD:

term_fontpush(p, TERMFONT_BOLD);

p->offset = term_len(p, (p->defindent+1)/2);

p->tcol->offset = term_len(p, (p->defindent+1)/2);

break;

case ROFFT_BODY:

p->offset = term_len(p, p->defindent);

p->tcol->offset = term_len(p, p->defindent);

term_tab_set(p, NULL);

term_tab_set(p, "T");

term_tab_set(p, ".5i");

Line 1674 termp_quote_pre(DECL_ARGS)

Line 1668 termp_quote_pre(DECL_ARGS)

/* FALLTHROUGH */

case MDOC_Do:

case MDOC_Dq:

term_word(p, "\\(Lq");

term_word(p, "\\(lq");

break;

case MDOC_En:

if (NULL == n->norm->Es ||

Line 1732 termp_quote_post(DECL_ARGS)

Line 1726 termp_quote_post(DECL_ARGS)

/* FALLTHROUGH */

case MDOC_Do:

case MDOC_Dq:

term_word(p, "\\(Rq");

term_word(p, "\\(rq");

break;

case MDOC_En:

if (n->norm->Es == NULL ||

Line 1817 termp_fo_pre(DECL_ARGS)

Line 1811 termp_fo_pre(DECL_ARGS)

return 1;

} else if (n->type == ROFFT_BODY) {

if (pretty) {

rmargin = p->rmargin;

rmargin = p->tcol->rmargin;

p->rmargin = p->offset + term_len(p, 4);

p->tcol->rmargin = p->tcol->offset + term_len(p, 4);

p->flags |= TERMP_NOBREAK | TERMP_BRIND |

TERMP_HANG;

}

Line 1830 termp_fo_pre(DECL_ARGS)

Line 1824 termp_fo_pre(DECL_ARGS)

p->flags &= ~(TERMP_NOBREAK | TERMP_BRIND |

TERMP_HANG);

p->flags |= TERMP_NOPAD;

p->offset = p->rmargin;

p->tcol->offset = p->tcol->rmargin;

p->rmargin = rmargin;

p->tcol->rmargin = rmargin;

}

return 1;

}

Line 1950 static int

Line 1944 static int

termp_lk_pre(DECL_ARGS)

{

const struct roff_node *link, *descr, *punct;

int display;

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

return 0;

Line 1976 termp_lk_pre(DECL_ARGS)

Line 1969 termp_lk_pre(DECL_ARGS)

}

/* Link target. */

display = term_strlen(p, link->string) >= 26;

if (display) {

term_newln(p);

p->offset += term_len(p, p->defindent + 1);

}

term_fontpush(p, TERMFONT_BOLD);

term_word(p, link->string);

term_fontpop(p);

Line 1991 termp_lk_pre(DECL_ARGS)

Line 1979 termp_lk_pre(DECL_ARGS)

term_word(p, punct->string);

punct = punct->next;

}

if (display)

term_newln(p);

return 0;

}

Line 2110 termp_tag_pre(DECL_ARGS)

Line 2096 termp_tag_pre(DECL_ARGS)

n->parent->parent->parent->tok == MDOC_It)))

tag_put(n->child->string, 1, p->line);

return 1;

}

static int

termp_abort_pre(DECL_ARGS)

{

abort();

}

CVSweb