=================================================================== RCS file: /cvs/mandoc/term.c,v retrieving revision 1.20 retrieving revision 1.39 diff -u -p -r1.20 -r1.39 --- mandoc/term.c 2009/02/25 13:30:53 1.20 +++ mandoc/term.c 2009/03/04 13:57:35 1.39 @@ -1,4 +1,4 @@ -/* $Id: term.c,v 1.20 2009/02/25 13:30:53 kristaps Exp $ */ +/* $Id: term.c,v 1.39 2009/03/04 13:57:35 kristaps Exp $ */ /* * Copyright (c) 2009 Kristaps Dzonsons * @@ -17,20 +17,20 @@ * PERFORMANCE OF THIS SOFTWARE. */ #include +#include +#include +#include #include #include #include "term.h" -#define INDENT 4 - /* * Performs actions on nodes of the abstract syntax tree. Both pre- and * post-fix operations are defined here. */ -/* FIXME: indent/tab. */ -/* FIXME: handle nested lists. */ +/* FIXME: macro arguments can be escaped. */ #define TTYPE_PROG 0 #define TTYPE_CMD_FLAG 1 @@ -50,7 +50,8 @@ #define TTYPE_INCLUDE 15 #define TTYPE_SYMB 16 #define TTYPE_SYMBOL 17 -#define TTYPE_NMAX 18 +#define TTYPE_DIAG 18 +#define TTYPE_NMAX 19 /* * These define "styles" for element types, like command arguments or @@ -58,6 +59,8 @@ * the same thing (like .Ex -std cmd and .Nm cmd). */ +/* TODO: abstract this into mdocterm.c. */ + const int ttypes[TTYPE_NMAX] = { TERMP_BOLD, /* TTYPE_PROG */ TERMP_BOLD, /* TTYPE_CMD_FLAG */ @@ -76,7 +79,8 @@ const int ttypes[TTYPE_NMAX] = { TERMP_BOLD, /* TTYPE_CMD */ TERMP_BOLD, /* TTYPE_INCLUDE */ TERMP_BOLD, /* TTYPE_SYMB */ - TERMP_BOLD /* TTYPE_SYMBOL */ + TERMP_BOLD, /* TTYPE_SYMBOL */ + TERMP_BOLD /* TTYPE_DIAG */ }; static int arg_hasattr(int, size_t, @@ -85,6 +89,7 @@ static int arg_getattr(int, size_t, const struct mdoc_arg *); static size_t arg_offset(const struct mdoc_arg *); static size_t arg_width(const struct mdoc_arg *); +static int arg_listtype(const struct mdoc_node *); /* * What follows describes prefix and postfix operations for the abstract @@ -105,6 +110,7 @@ static void name##_post(DECL_ARGS) DECL_PRE(name); \ DECL_POST(name); +DECL_PREPOST(termp__t); DECL_PREPOST(termp_aq); DECL_PREPOST(termp_bd); DECL_PREPOST(termp_bq); @@ -114,6 +120,7 @@ DECL_PREPOST(termp_fd); DECL_PREPOST(termp_fn); DECL_PREPOST(termp_fo); DECL_PREPOST(termp_ft); +DECL_PREPOST(termp_in); DECL_PREPOST(termp_it); DECL_PREPOST(termp_op); DECL_PREPOST(termp_pf); @@ -129,7 +136,6 @@ DECL_PRE(termp_at); DECL_PRE(termp_bf); DECL_PRE(termp_bsx); DECL_PRE(termp_bt); -DECL_PRE(termp_bx); DECL_PRE(termp_cd); DECL_PRE(termp_cm); DECL_PRE(termp_em); @@ -138,7 +144,6 @@ DECL_PRE(termp_fa); DECL_PRE(termp_fl); DECL_PRE(termp_fx); DECL_PRE(termp_ic); -DECL_PRE(termp_in); DECL_PRE(termp_ms); DECL_PRE(termp_nd); DECL_PRE(termp_nm); @@ -147,7 +152,9 @@ DECL_PRE(termp_nx); DECL_PRE(termp_ox); DECL_PRE(termp_pa); DECL_PRE(termp_pp); +DECL_PRE(termp_rs); DECL_PRE(termp_rv); +DECL_PRE(termp_sm); DECL_PRE(termp_st); DECL_PRE(termp_sx); DECL_PRE(termp_sy); @@ -156,7 +163,9 @@ DECL_PRE(termp_ux); DECL_PRE(termp_va); DECL_PRE(termp_xr); +DECL_POST(termp___); DECL_POST(termp_bl); +DECL_POST(termp_bx); const struct termact __termacts[MDOC_MAX] = { { NULL, NULL }, /* \" */ @@ -167,7 +176,7 @@ const struct termact __termacts[MDOC_MAX] = { { termp_ss_pre, termp_ss_post }, /* Ss */ { termp_pp_pre, NULL }, /* Pp */ { termp_d1_pre, termp_d1_post }, /* D1 */ - { NULL, NULL }, /* Dl */ + { termp_d1_pre, termp_d1_post }, /* Dl */ { termp_bd_pre, termp_bd_post }, /* Bd */ { NULL, NULL }, /* Ed */ { NULL, termp_bl_post }, /* Bl */ @@ -188,7 +197,7 @@ const struct termact __termacts[MDOC_MAX] = { { termp_fn_pre, termp_fn_post }, /* Fn */ { termp_ft_pre, termp_ft_post }, /* Ft */ { termp_ic_pre, NULL }, /* Ic */ - { termp_in_pre, NULL }, /* In */ + { termp_in_pre, termp_in_post }, /* In */ { NULL, NULL }, /* Li */ { termp_nd_pre, NULL }, /* Nd */ { termp_nm_pre, NULL }, /* Nm */ @@ -200,17 +209,17 @@ const struct termact __termacts[MDOC_MAX] = { { termp_va_pre, NULL }, /* Va */ { termp_vt_pre, termp_vt_post }, /* Vt */ { termp_xr_pre, NULL }, /* Xr */ - { NULL, NULL }, /* %A */ - { NULL, NULL }, /* %B */ - { NULL, NULL }, /* %D */ - { NULL, NULL }, /* %I */ - { NULL, NULL }, /* %J */ - { NULL, NULL }, /* %N */ - { NULL, NULL }, /* %O */ - { NULL, NULL }, /* %P */ - { NULL, NULL }, /* %R */ - { NULL, NULL }, /* %T */ - { NULL, NULL }, /* %V */ + { NULL, termp____post }, /* %A */ + { NULL, termp____post }, /* %B */ + { NULL, termp____post }, /* %D */ + { NULL, termp____post }, /* %I */ + { NULL, termp____post }, /* %J */ + { NULL, termp____post }, /* %N */ + { NULL, termp____post }, /* %O */ + { NULL, termp____post }, /* %P */ + { NULL, termp____post }, /* %R */ + { termp__t_pre, termp__t_post }, /* %T */ + { NULL, termp____post }, /* %V */ { NULL, NULL }, /* Ac */ { termp_aq_pre, termp_aq_post }, /* Ao */ { termp_aq_pre, termp_aq_post }, /* Aq */ @@ -220,7 +229,7 @@ const struct termact __termacts[MDOC_MAX] = { { termp_bq_pre, termp_bq_post }, /* Bo */ { termp_bq_pre, termp_bq_post }, /* Bq */ { termp_bsx_pre, NULL }, /* Bsx */ - { termp_bx_pre, NULL }, /* Bx */ + { NULL, termp_bx_post }, /* Bx */ { NULL, NULL }, /* Db */ { NULL, NULL }, /* Dc */ { termp_dq_pre, termp_dq_post }, /* Do */ @@ -244,11 +253,11 @@ const struct termact __termacts[MDOC_MAX] = { { termp_qq_pre, termp_qq_post }, /* Qo */ { termp_qq_pre, termp_qq_post }, /* Qq */ { NULL, NULL }, /* Re */ - { NULL, NULL }, /* Rs */ + { termp_rs_pre, NULL }, /* Rs */ { NULL, NULL }, /* Sc */ { termp_sq_pre, termp_sq_post }, /* So */ { termp_sq_pre, termp_sq_post }, /* Sq */ - { NULL, NULL }, /* Sm */ + { termp_sm_pre, NULL }, /* Sm */ { termp_sx_pre, NULL }, /* Sx */ { termp_sy_pre, NULL }, /* Sy */ { NULL, NULL }, /* Tn */ @@ -273,13 +282,71 @@ const struct termact *termacts = __termacts; static size_t arg_width(const struct mdoc_arg *arg) { + size_t v; + int i, len; - /* TODO */ assert(*arg->value); - return(strlen(*arg->value)); + if (0 == strcmp(*arg->value, "indent")) + return(INDENT); + if (0 == strcmp(*arg->value, "indent-two")) + return(INDENT * 2); + + len = (int)strlen(*arg->value); + assert(len > 0); + + for (i = 0; i < len - 1; i++) + if ( ! isdigit((int)(*arg->value)[i])) + break; + + if (i == len - 1) { + if ('n' == (*arg->value)[len - 1]) { + v = (size_t)atoi(*arg->value); + return(v); + } + + } + return(strlen(*arg->value) + 1); } +static int +arg_listtype(const struct mdoc_node *n) +{ + const struct mdoc_block *bl; + int i, len; + + bl = &n->data.block; + len = (int)bl->argc; + + for (i = 0; i < len; i++) + switch (bl->argv[i].arg) { + case (MDOC_Bullet): + /* FALLTHROUGH */ + case (MDOC_Dash): + /* FALLTHROUGH */ + case (MDOC_Enum): + /* FALLTHROUGH */ + case (MDOC_Hyphen): + /* FALLTHROUGH */ + case (MDOC_Tag): + /* FALLTHROUGH */ + case (MDOC_Inset): + /* FALLTHROUGH */ + case (MDOC_Diag): + /* FALLTHROUGH */ + case (MDOC_Item): + /* FALLTHROUGH */ + case (MDOC_Ohang): + return(bl->argv[i].arg); + default: + break; + } + + errx(1, "list type not supported"); + /* NOTREACHED */ +} + + static size_t arg_offset(const struct mdoc_arg *arg) { @@ -290,7 +357,6 @@ arg_offset(const struct mdoc_arg *arg) return(INDENT); if (0 == strcmp(*arg->value, "indent-two")) return(INDENT * 2); - return(strlen(*arg->value)); } @@ -344,73 +410,213 @@ termp_dq_post(DECL_ARGS) /* ARGSUSED */ static int +termp_it_pre_block(DECL_ARGS) +{ + const struct mdoc_node *n; + const struct mdoc_block *bl; + + n = node->parent->parent; + bl = &n->data.block; + + newln(p); + if ( ! arg_hasattr(MDOC_Compact, bl->argc, bl->argv)) + if (node->prev || n->prev) + vspace(p); + + return(1); +} + + +/* ARGSUSED */ +static int termp_it_pre(DECL_ARGS) { - const struct mdoc_node *n, *it; const struct mdoc_block *bl; - int i; + char buf[7]; + int i, type; size_t width, offset; - switch (node->type) { - case (MDOC_BODY): - /* FALLTHROUGH */ - case (MDOC_HEAD): - it = node->parent; - break; - case (MDOC_BLOCK): - it = node; - break; - default: - return(1); - } + if (MDOC_BLOCK == node->type) + return(termp_it_pre_block(p, pair, meta, node)); - assert(MDOC_BLOCK == it->type); - assert(MDOC_It == it->tok); + /* Get ptr to list block, type, etc. */ - n = it->parent; - assert(MDOC_BODY == n->type); - assert(MDOC_Bl == n->tok); - n = n->parent; - bl = &n->data.block; + bl = &node->parent->parent->parent->data.block; + type = arg_listtype(node->parent->parent->parent); - /* If `-compact', don't assert vertical space. */ + /* Save parent attributes. */ - if (MDOC_BLOCK == node->type) { - if (arg_hasattr(MDOC_Compact, bl->argc, bl->argv)) - newln(p); - else - vspace(p); - return(1); - } - pair->offset = p->offset; pair->rmargin = p->rmargin; + pair->flag = p->flags; - /* FIXME: auto-size. */ + /* Get list width and offset. */ + i = arg_getattr(MDOC_Width, bl->argc, bl->argv); - width = i >= 0 ? arg_width(&bl->argv[i]) : 10; + width = i >= 0 ? arg_width(&bl->argv[i]) : 0; i = arg_getattr(MDOC_Offset, bl->argc, bl->argv); offset = i >= 0 ? arg_offset(&bl->argv[i]) : 0; - assert(MDOC_HEAD == node->type || - MDOC_BODY == node->type); + /* + * List-type can override the width in the case of fixed-head + * values (bullet, dash/hyphen, enum). Tags need a non-zero + * offset. + */ - if (arg_hasattr(MDOC_Tag, bl->argc, bl->argv)) { + switch (type) { + case (MDOC_Bullet): + /* FALLTHROUGH */ + case (MDOC_Dash): + /* FALLTHROUGH */ + case (MDOC_Enum): + /* FALLTHROUGH */ + case (MDOC_Hyphen): + width = width > 4 ? width : 4; + break; + case (MDOC_Tag): + if (width) + break; + errx(1, "need non-zero %s for list type", + mdoc_argnames[MDOC_Width]); + default: + break; + } + + /* + * Whitespace control. Inset bodies need an initial space. + */ + + switch (type) { + case (MDOC_Diag): + /* FALLTHROUGH */ + case (MDOC_Inset): + if (MDOC_BODY == node->type) + p->flags &= ~TERMP_NOSPACE; + else + p->flags |= TERMP_NOSPACE; + break; + default: p->flags |= TERMP_NOSPACE; + break; + } - if (MDOC_HEAD == node->type) { + /* + * Style flags. Diagnostic heads need TTYPE_DIAG. + */ + + switch (type) { + case (MDOC_Diag): + if (MDOC_HEAD == node->type) + p->flags |= ttypes[TTYPE_DIAG]; + break; + default: + break; + } + + /* + * Pad and break control. This is the tricker part. Lists with + * set right-margins for the head get TERMP_NOBREAK because, if + * they overrun the margin, they wrap to the new margin. + * Correspondingly, the body for these types don't left-pad, as + * the head will pad out to to the right. + */ + + switch (type) { + case (MDOC_Bullet): + /* FALLTHROUGH */ + case (MDOC_Dash): + /* FALLTHROUGH */ + case (MDOC_Enum): + /* FALLTHROUGH */ + case (MDOC_Hyphen): + /* FALLTHROUGH */ + case (MDOC_Tag): + if (MDOC_HEAD == node->type) p->flags |= TERMP_NOBREAK; - p->offset += offset; - p->rmargin = p->offset + width; - } else { + else p->flags |= TERMP_NOLPAD; + break; + case (MDOC_Diag): + if (MDOC_HEAD == node->type) + p->flags |= TERMP_NOBREAK; + break; + default: + break; + } + + /* + * Margin control. Set-head-width lists have their right + * margins shortened. The body for these lists has the offset + * necessarily lengthened. Everybody gets the offset. + */ + + p->offset += offset; + + switch (type) { + case (MDOC_Bullet): + /* FALLTHROUGH */ + case (MDOC_Dash): + /* FALLTHROUGH */ + case (MDOC_Enum): + /* FALLTHROUGH */ + case (MDOC_Hyphen): + /* FALLTHROUGH */ + case (MDOC_Tag): + if (MDOC_HEAD == node->type) + p->rmargin = p->offset + width; + else p->offset += width; + /* FALLTHROUGH */ + default: + break; + } + + /* + * The dash, hyphen, bullet and enum lists all have a special + * HEAD character. Print it now. + */ + + if (MDOC_HEAD == node->type) + switch (type) { + case (MDOC_Bullet): + word(p, "\\[bu]"); + break; + case (MDOC_Dash): + /* FALLTHROUGH */ + case (MDOC_Hyphen): + word(p, "\\-"); + break; + case (MDOC_Enum): + /* TODO: have a wordfmt or something. */ + (pair->ppair->ppair->count)++; + (void)snprintf(buf, sizeof(buf), "%d.", + pair->ppair->ppair->count); + word(p, buf); + break; + default: + break; } - } else if (arg_hasattr(MDOC_Ohang, bl->argc, bl->argv)) { - p->flags |= TERMP_NOSPACE; - p->offset += offset; + /* + * If we're not going to process our header children, indicate + * so here. + */ + + if (MDOC_HEAD == node->type) + switch (type) { + case (MDOC_Bullet): + /* FALLTHROUGH */ + case (MDOC_Item): + /* FALLTHROUGH */ + case (MDOC_Dash): + /* FALLTHROUGH */ + case (MDOC_Hyphen): + /* FALLTHROUGH */ + case (MDOC_Enum): + return(0); + default: + break; } return(1); @@ -421,46 +627,31 @@ termp_it_pre(DECL_ARGS) static void termp_it_post(DECL_ARGS) { - const struct mdoc_node *n, *it; - const struct mdoc_block *bl; + int type; - switch (node->type) { - case (MDOC_BODY): - /* FALLTHROUGH */ - case (MDOC_HEAD): - break; - default: + if (MDOC_BODY != node->type && MDOC_HEAD != node->type) return; - } - it = node->parent; - assert(MDOC_BLOCK == it->type); - assert(MDOC_It == it->tok); + type = arg_listtype(node->parent->parent->parent); - n = it->parent; - assert(MDOC_BODY == n->type); - assert(MDOC_Bl == n->tok); - n = n->parent; - bl = &n->data.block; - - /* If `-tag', adjust our margins accordingly. */ - - if (arg_hasattr(MDOC_Tag, bl->argc, bl->argv)) { + switch (type) { + case (MDOC_Diag): + /* FALLTHROUGH */ + case (MDOC_Item): + /* FALLTHROUGH */ + case (MDOC_Inset): + if (MDOC_BODY != node->type) + break; flushln(p); - - if (MDOC_HEAD == node->type) { - p->rmargin = pair->rmargin; - p->offset = pair->offset; - p->flags &= ~TERMP_NOBREAK; - } else { - p->offset = pair->offset; - p->flags &= ~TERMP_NOLPAD; - } - - } else if (arg_hasattr(MDOC_Ohang, bl->argc, bl->argv)) { + break; + default: flushln(p); - p->offset = pair->offset; + break; } + + p->offset = pair->offset; + p->rmargin = pair->rmargin; + p->flags = pair->flag; } @@ -469,9 +660,13 @@ static int termp_nm_pre(DECL_ARGS) { - TERMPAIR_SETFLAG(pair, ttypes[TTYPE_PROG]); + if (SEC_SYNOPSIS == node->sec) + newln(p); + + TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_PROG]); if (NULL == node->child) word(p, meta->name); + return(1); } @@ -481,7 +676,7 @@ static int termp_fl_pre(DECL_ARGS) { - TERMPAIR_SETFLAG(pair, ttypes[TTYPE_CMD_FLAG]); + TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_CMD_FLAG]); word(p, "\\-"); p->flags |= TERMP_NOSPACE; return(1); @@ -493,9 +688,11 @@ static int termp_ar_pre(DECL_ARGS) { - TERMPAIR_SETFLAG(pair, ttypes[TTYPE_CMD_ARG]); - if (NULL == node->child) + TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_CMD_ARG]); + if (NULL == node->child) { + word(p, "file"); word(p, "..."); + } return(1); } @@ -537,6 +734,17 @@ termp_st_pre(DECL_ARGS) /* ARGSUSED */ static int +termp_rs_pre(DECL_ARGS) +{ + + if (MDOC_BLOCK == node->type && node->prev) + vspace(p); + return(1); +} + + +/* ARGSUSED */ +static int termp_rv_pre(DECL_ARGS) { int i; @@ -651,7 +859,7 @@ termp_vt_pre(DECL_ARGS) { /* FIXME: this can be "type name". */ - TERMPAIR_SETFLAG(pair, ttypes[TTYPE_VAR_DECL]); + TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_VAR_DECL]); return(1); } @@ -675,7 +883,7 @@ 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(pair, ttypes[TTYPE_FUNC_DECL]); + TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_FUNC_DECL]); return(1); } @@ -685,7 +893,10 @@ static void termp_fd_post(DECL_ARGS) { - if (node->sec == SEC_SYNOPSIS) + if (node->sec != SEC_SYNOPSIS) + return; + newln(p); + if (node->next && MDOC_Fd != node->next->tok) vspace(p); } @@ -698,7 +909,7 @@ termp_sh_pre(DECL_ARGS) switch (node->type) { case (MDOC_HEAD): vspace(p); - TERMPAIR_SETFLAG(pair, ttypes[TTYPE_SECTION]); + TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_SECTION]); break; case (MDOC_BODY): p->offset = INDENT; @@ -821,7 +1032,10 @@ static int termp_ft_pre(DECL_ARGS) { - TERMPAIR_SETFLAG(pair, ttypes[TTYPE_FUNC_TYPE]); + if (SEC_SYNOPSIS == node->sec) + if (node->prev && MDOC_Fo == node->prev->tok) + vspace(p); + TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_FUNC_TYPE]); return(1); } @@ -831,7 +1045,7 @@ static void termp_ft_post(DECL_ARGS) { - if (node->sec == SEC_SYNOPSIS) + if (SEC_SYNOPSIS == node->sec) newln(p); } @@ -877,7 +1091,7 @@ static void termp_fn_post(DECL_ARGS) { - if (node->sec == SEC_SYNOPSIS) + if (node->sec == SEC_SYNOPSIS && node->next) vspace(p); } @@ -888,7 +1102,7 @@ static int termp_sx_pre(DECL_ARGS) { - TERMPAIR_SETFLAG(pair, ttypes[TTYPE_LINK]); + TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_LINK]); return(1); } @@ -900,7 +1114,7 @@ termp_fa_pre(DECL_ARGS) struct mdoc_node *n; if (node->parent->tok != MDOC_Fo) { - TERMPAIR_SETFLAG(pair, ttypes[TTYPE_FUNC_ARG]); + TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_FUNC_ARG]); return(1); } @@ -927,7 +1141,7 @@ static int termp_va_pre(DECL_ARGS) { - TERMPAIR_SETFLAG(pair, ttypes[TTYPE_VAR_DECL]); + TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_VAR_DECL]); return(1); } @@ -937,43 +1151,65 @@ static int termp_bd_pre(DECL_ARGS) { const struct mdoc_block *bl; - const struct mdoc_node *n; - int i; + const struct mdoc_node *n; + int i, type; if (MDOC_BLOCK == node->type) { - vspace(p); + if (node->prev) + vspace(p); return(1); } else if (MDOC_BODY != node->type) return(1); - assert(MDOC_BLOCK == node->parent->type); pair->offset = p->offset; - bl = &node->parent->data.block; + for (type = -1, i = 0; i < (int)bl->argc; i++) { + switch (bl->argv[i].arg) { + case (MDOC_Ragged): + /* FALLTHROUGH */ + case (MDOC_Filled): + /* FALLTHROUGH */ + case (MDOC_Unfilled): + /* FALLTHROUGH */ + case (MDOC_Literal): + type = bl->argv[i].arg; + i = (int)bl->argc; + break; + default: + errx(1, "display type not supported"); + } + } + assert(-1 != type); + i = arg_getattr(MDOC_Offset, bl->argc, bl->argv); if (-1 != i) { assert(1 == bl->argv[i].sz); p->offset += arg_offset(&bl->argv[i]); } - if ( ! arg_hasattr(MDOC_Literal, bl->argc, bl->argv)) + + switch (type) { + case (MDOC_Literal): + /* FALLTHROUGH */ + case (MDOC_Unfilled): + break; + default: return(1); + } p->flags |= TERMP_LITERAL; for (n = node->child; n; n = n->next) { - assert(MDOC_TEXT == n->type); /* FIXME */ - if ((*n->data.text.string)) { - word(p, n->data.text.string); - flushln(p); - } else - vspace(p); - + if (MDOC_TEXT != n->type) { + warnx("non-text children not yet allowed"); + continue; + } + word(p, n->data.text.string); + flushln(p); } - p->flags &= ~TERMP_LITERAL; return(0); } @@ -985,7 +1221,11 @@ termp_bd_post(DECL_ARGS) if (MDOC_BODY != node->type) return; - newln(p); + + if ( ! (p->flags & TERMP_LITERAL)) + flushln(p); + + p->flags &= ~TERMP_LITERAL; p->offset = pair->offset; } @@ -1026,12 +1266,13 @@ termp_bsx_pre(DECL_ARGS) /* ARGSUSED */ -static int -termp_bx_pre(DECL_ARGS) +static void +termp_bx_post(DECL_ARGS) { + if (node->child) + p->flags |= TERMP_NOSPACE; word(p, "BSD"); - return(1); } @@ -1082,7 +1323,7 @@ termp_sq_pre(DECL_ARGS) if (MDOC_BODY != node->type) return(1); - word(p, "\'"); + word(p, "`"); p->flags |= TERMP_NOSPACE; return(1); } @@ -1128,7 +1369,7 @@ termp_ss_pre(DECL_ARGS) switch (node->type) { case (MDOC_HEAD): vspace(p); - TERMPAIR_SETFLAG(pair, ttypes[TTYPE_SSECTION]); + TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_SSECTION]); p->offset = INDENT / 2; break; default: @@ -1160,7 +1401,7 @@ static int termp_pa_pre(DECL_ARGS) { - TERMPAIR_SETFLAG(pair, ttypes[TTYPE_FILE]); + TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_FILE]); return(1); } @@ -1170,7 +1411,7 @@ static int termp_em_pre(DECL_ARGS) { - TERMPAIR_SETFLAG(pair, ttypes[TTYPE_EMPH]); + TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_EMPH]); return(1); } @@ -1180,7 +1421,8 @@ static int termp_cd_pre(DECL_ARGS) { - TERMPAIR_SETFLAG(pair, ttypes[TTYPE_CONFIG]); + TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_CONFIG]); + newln(p); return(1); } @@ -1190,7 +1432,7 @@ static int termp_cm_pre(DECL_ARGS) { - TERMPAIR_SETFLAG(pair, ttypes[TTYPE_CMD_FLAG]); + TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_CMD_FLAG]); return(1); } @@ -1200,7 +1442,7 @@ static int termp_ic_pre(DECL_ARGS) { - TERMPAIR_SETFLAG(pair, ttypes[TTYPE_CMD]); + TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_CMD]); return(1); } @@ -1210,12 +1452,31 @@ static int termp_in_pre(DECL_ARGS) { - TERMPAIR_SETFLAG(pair, ttypes[TTYPE_INCLUDE]); + TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_INCLUDE]); + word(p, "#include"); + word(p, "<"); + p->flags |= TERMP_NOSPACE; return(1); } /* ARGSUSED */ +static void +termp_in_post(DECL_ARGS) +{ + + p->flags |= TERMP_NOSPACE; + word(p, ">"); + + newln(p); + if (SEC_SYNOPSIS != node->sec) + return; + if (node->next && MDOC_In != node->next->tok) + vspace(p); +} + + +/* ARGSUSED */ static int termp_at_pre(DECL_ARGS) { @@ -1263,7 +1524,7 @@ termp_pq_pre(DECL_ARGS) if (MDOC_BODY != node->type) return(1); - word(p, "("); + word(p, "\\&("); p->flags |= TERMP_NOSPACE; return(1); } @@ -1337,9 +1598,9 @@ termp_bf_pre(DECL_ARGS) if (NULL == (n = b->head->child)) { if (arg_hasattr(MDOC_Emphasis, b->argc, b->argv)) - TERMPAIR_SETFLAG(pair, ttypes[TTYPE_EMPH]); + TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_EMPH]); else if (arg_hasattr(MDOC_Symbolic, b->argc, b->argv)) - TERMPAIR_SETFLAG(pair, ttypes[TTYPE_SYMB]); + TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_SYMB]); return(1); } @@ -1347,9 +1608,9 @@ termp_bf_pre(DECL_ARGS) assert(MDOC_TEXT == n->type); if (0 == strcmp("Em", n->data.text.string)) - TERMPAIR_SETFLAG(pair, ttypes[TTYPE_EMPH]); + TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_EMPH]); else if (0 == strcmp("Sy", n->data.text.string)) - TERMPAIR_SETFLAG(pair, ttypes[TTYPE_EMPH]); + TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_EMPH]); return(1); } @@ -1360,7 +1621,7 @@ static int termp_sy_pre(DECL_ARGS) { - TERMPAIR_SETFLAG(pair, ttypes[TTYPE_SYMB]); + TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_SYMB]); return(1); } @@ -1370,7 +1631,59 @@ static int termp_ms_pre(DECL_ARGS) { - TERMPAIR_SETFLAG(pair, ttypes[TTYPE_SYMBOL]); + TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_SYMBOL]); return(1); } + + +/* ARGSUSED */ +static int +termp_sm_pre(DECL_ARGS) +{ + +#if notyet + assert(node->child); + if (0 == strcmp("off", node->child->data.text.string)) { + p->flags &= ~TERMP_NONOSPACE; + p->flags &= ~TERMP_NOSPACE; + } else { + p->flags |= TERMP_NONOSPACE; + p->flags |= TERMP_NOSPACE; + } +#endif + + return(0); +} + + +/* ARGSUSED */ +static int +termp__t_pre(DECL_ARGS) +{ + + word(p, "\""); + p->flags |= TERMP_NOSPACE; + return(1); +} + + +/* ARGSUSED */ +static void +termp__t_post(DECL_ARGS) +{ + + p->flags |= TERMP_NOSPACE; + word(p, "\""); + word(p, node->next ? "," : "."); +} + + +/* ARGSUSED */ +static void +termp____post(DECL_ARGS) +{ + + p->flags |= TERMP_NOSPACE; + word(p, node->next ? "," : "."); +}