Annotation of src/usr.bin/mandoc/man_term.c, Revision 1.194
1.194 ! schwarze 1: /* $OpenBSD: man_term.c,v 1.193 2022/08/16 17:44:53 schwarze Exp $ */
1.1 kristaps 2: /*
1.190 schwarze 3: * Copyright (c) 2010-2015,2017-2020,2022 Ingo Schwarze <schwarze@openbsd.org>
1.84 schwarze 4: * Copyright (c) 2008-2012 Kristaps Dzonsons <kristaps@bsd.lv>
1.1 kristaps 5: *
6: * Permission to use, copy, modify, and distribute this software for any
1.2 schwarze 7: * purpose with or without fee is hereby granted, provided that the above
8: * copyright notice and this permission notice appear in all copies.
1.1 kristaps 9: *
1.124 schwarze 10: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHORS DISCLAIM ALL WARRANTIES
1.2 schwarze 11: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
1.124 schwarze 12: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR
1.2 schwarze 13: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16: * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
1.188 schwarze 17: *
18: * Plain text formatter for man(7), used by mandoc(1)
19: * for ASCII, UTF-8, PostScript, and PDF output.
1.1 kristaps 20: */
1.13 schwarze 21: #include <sys/types.h>
22:
1.1 kristaps 23: #include <assert.h>
1.11 schwarze 24: #include <ctype.h>
1.117 schwarze 25: #include <limits.h>
1.1 kristaps 26: #include <stdio.h>
27: #include <stdlib.h>
28: #include <string.h>
29:
1.124 schwarze 30: #include "mandoc_aux.h"
1.184 schwarze 31: #include "mandoc.h"
1.124 schwarze 32: #include "roff.h"
33: #include "man.h"
1.18 schwarze 34: #include "out.h"
1.1 kristaps 35: #include "term.h"
1.188 schwarze 36: #include "term_tag.h"
1.18 schwarze 37: #include "main.h"
1.10 schwarze 38:
1.70 schwarze 39: #define MAXMARGINS 64 /* maximum number of indented scopes */
1.1 kristaps 40:
1.11 schwarze 41: struct mtermp {
1.116 schwarze 42: int lmargin[MAXMARGINS]; /* margins (incl. vis. page) */
1.70 schwarze 43: int lmargincur; /* index of current margin */
44: int lmarginsz; /* actual number of nested margins */
45: size_t offset; /* default offset to visible page */
1.88 schwarze 46: int pardist; /* vert. space before par., unit: [v] */
1.11 schwarze 47: };
48:
1.100 schwarze 49: #define DECL_ARGS struct termp *p, \
1.11 schwarze 50: struct mtermp *mt, \
1.125 schwarze 51: struct roff_node *n, \
1.126 schwarze 52: const struct roff_meta *meta
1.1 kristaps 53:
1.167 schwarze 54: struct man_term_act {
1.1 kristaps 55: int (*pre)(DECL_ARGS);
56: void (*post)(DECL_ARGS);
1.26 schwarze 57: int flags;
58: #define MAN_NOTEXT (1 << 0) /* Never has text children. */
1.1 kristaps 59: };
60:
1.21 schwarze 61: static void print_man_nodelist(DECL_ARGS);
1.19 schwarze 62: static void print_man_node(DECL_ARGS);
1.126 schwarze 63: static void print_man_head(struct termp *,
64: const struct roff_meta *);
65: static void print_man_foot(struct termp *,
66: const struct roff_meta *);
1.100 schwarze 67: static void print_bvspace(struct termp *,
1.187 schwarze 68: struct roff_node *, int);
1.18 schwarze 69:
1.1 kristaps 70: static int pre_B(DECL_ARGS);
1.152 schwarze 71: static int pre_DT(DECL_ARGS);
1.11 schwarze 72: static int pre_HP(DECL_ARGS);
1.1 kristaps 73: static int pre_I(DECL_ARGS);
74: static int pre_IP(DECL_ARGS);
1.82 schwarze 75: static int pre_OP(DECL_ARGS);
1.88 schwarze 76: static int pre_PD(DECL_ARGS);
1.1 kristaps 77: static int pre_PP(DECL_ARGS);
1.13 schwarze 78: static int pre_RS(DECL_ARGS);
1.1 kristaps 79: static int pre_SH(DECL_ARGS);
80: static int pre_SS(DECL_ARGS);
1.168 schwarze 81: static int pre_SY(DECL_ARGS);
1.1 kristaps 82: static int pre_TP(DECL_ARGS);
1.91 schwarze 83: static int pre_UR(DECL_ARGS);
1.174 schwarze 84: static int pre_abort(DECL_ARGS);
1.82 schwarze 85: static int pre_alternate(DECL_ARGS);
1.14 schwarze 86: static int pre_ign(DECL_ARGS);
1.45 schwarze 87: static int pre_in(DECL_ARGS);
88: static int pre_literal(DECL_ARGS);
1.1 kristaps 89:
1.11 schwarze 90: static void post_IP(DECL_ARGS);
91: static void post_HP(DECL_ARGS);
1.13 schwarze 92: static void post_RS(DECL_ARGS);
1.1 kristaps 93: static void post_SH(DECL_ARGS);
1.168 schwarze 94: static void post_SY(DECL_ARGS);
1.11 schwarze 95: static void post_TP(DECL_ARGS);
1.91 schwarze 96: static void post_UR(DECL_ARGS);
1.1 kristaps 97:
1.167 schwarze 98: static const struct man_term_act man_term_acts[MAN_MAX - MAN_TH] = {
1.26 schwarze 99: { NULL, NULL, 0 }, /* TH */
100: { pre_SH, post_SH, 0 }, /* SH */
1.180 schwarze 101: { pre_SS, post_SH, 0 }, /* SS */
1.26 schwarze 102: { pre_TP, post_TP, 0 }, /* TP */
1.166 schwarze 103: { pre_TP, post_TP, 0 }, /* TQ */
1.174 schwarze 104: { pre_abort, NULL, 0 }, /* LP */
1.26 schwarze 105: { pre_PP, NULL, 0 }, /* PP */
1.174 schwarze 106: { pre_abort, NULL, 0 }, /* P */
1.26 schwarze 107: { pre_IP, post_IP, 0 }, /* IP */
1.100 schwarze 108: { pre_HP, post_HP, 0 }, /* HP */
1.26 schwarze 109: { NULL, NULL, 0 }, /* SM */
110: { pre_B, NULL, 0 }, /* SB */
1.51 schwarze 111: { pre_alternate, NULL, 0 }, /* BI */
112: { pre_alternate, NULL, 0 }, /* IB */
113: { pre_alternate, NULL, 0 }, /* BR */
114: { pre_alternate, NULL, 0 }, /* RB */
1.26 schwarze 115: { NULL, NULL, 0 }, /* R */
116: { pre_B, NULL, 0 }, /* B */
117: { pre_I, NULL, 0 }, /* I */
1.51 schwarze 118: { pre_alternate, NULL, 0 }, /* IR */
119: { pre_alternate, NULL, 0 }, /* RI */
1.26 schwarze 120: { NULL, NULL, 0 }, /* RE */
121: { pre_RS, post_RS, 0 }, /* RS */
1.190 schwarze 122: { pre_DT, NULL, MAN_NOTEXT }, /* DT */
1.111 schwarze 123: { pre_ign, NULL, MAN_NOTEXT }, /* UC */
1.88 schwarze 124: { pre_PD, NULL, MAN_NOTEXT }, /* PD */
1.190 schwarze 125: { pre_ign, NULL, MAN_NOTEXT }, /* AT */
1.45 schwarze 126: { pre_in, NULL, MAN_NOTEXT }, /* in */
1.168 schwarze 127: { pre_SY, post_SY, 0 }, /* SY */
128: { NULL, NULL, 0 }, /* YS */
1.82 schwarze 129: { pre_OP, NULL, 0 }, /* OP */
1.83 schwarze 130: { pre_literal, NULL, 0 }, /* EX */
131: { pre_literal, NULL, 0 }, /* EE */
1.91 schwarze 132: { pre_UR, post_UR, 0 }, /* UR */
133: { NULL, NULL, 0 }, /* UE */
1.161 bentley 134: { pre_UR, post_UR, 0 }, /* MT */
135: { NULL, NULL, 0 }, /* ME */
1.1 kristaps 136: };
1.167 schwarze 137: static const struct man_term_act *man_term_act(enum roff_tok);
1.11 schwarze 138:
1.1 kristaps 139:
1.167 schwarze 140: static const struct man_term_act *
141: man_term_act(enum roff_tok tok)
142: {
143: assert(tok >= MAN_TH && tok <= MAN_MAX);
144: return man_term_acts + (tok - MAN_TH);
145: }
146:
1.16 schwarze 147: void
1.176 schwarze 148: terminal_man(void *arg, const struct roff_meta *man)
1.1 kristaps 149: {
1.180 schwarze 150: struct mtermp mt;
1.18 schwarze 151: struct termp *p;
1.182 schwarze 152: struct roff_node *n, *nc, *nn;
1.142 schwarze 153: size_t save_defindent;
1.18 schwarze 154:
155: p = (struct termp *)arg;
1.159 schwarze 156: save_defindent = p->defindent;
157: if (p->synopsisonly == 0 && p->defindent == 0)
158: p->defindent = 7;
1.156 schwarze 159: p->tcol->rmargin = p->maxrmargin = p->defrmargin;
1.151 schwarze 160: term_tab_set(p, NULL);
161: term_tab_set(p, "T");
162: term_tab_set(p, ".5i");
1.18 schwarze 163:
1.180 schwarze 164: memset(&mt, 0, sizeof(mt));
1.77 schwarze 165: mt.lmargin[mt.lmargincur] = term_len(p, p->defindent);
166: mt.offset = term_len(p, p->defindent);
1.88 schwarze 167: mt.pardist = 1;
1.11 schwarze 168:
1.134 schwarze 169: n = man->first->child;
1.104 schwarze 170: if (p->synopsisonly) {
1.182 schwarze 171: for (nn = NULL; n != NULL; n = n->next) {
172: if (n->tok != MAN_SH)
173: continue;
174: nc = n->child->child;
175: if (nc->type != ROFFT_TEXT)
176: continue;
177: if (strcmp(nc->string, "SYNOPSIS") == 0)
1.104 schwarze 178: break;
1.182 schwarze 179: if (nn == NULL && strcmp(nc->string, "NAME") == 0)
180: nn = n;
1.104 schwarze 181: }
1.182 schwarze 182: if (n == NULL)
183: n = nn;
184: p->flags |= TERMP_NOSPACE;
185: if (n != NULL && (n = n->child->next->child) != NULL)
186: print_man_nodelist(p, &mt, n, man);
187: term_newln(p);
1.104 schwarze 188: } else {
1.176 schwarze 189: term_begin(p, print_man_head, print_man_foot, man);
1.104 schwarze 190: p->flags |= TERMP_NOSPACE;
191: if (n != NULL)
1.176 schwarze 192: print_man_nodelist(p, &mt, n, man);
1.104 schwarze 193: term_end(p);
194: }
1.159 schwarze 195: p->defindent = save_defindent;
1.1 kristaps 196: }
197:
1.69 schwarze 198: /*
199: * Printing leading vertical space before a block.
200: * This is used for the paragraph macros.
201: * The rules are pretty simple, since there's very little nesting going
202: * on here. Basically, if we're the first within another block (SS/SH),
203: * then don't emit vertical space. If we are (RS), then do. If not the
204: * first, print it.
205: */
1.18 schwarze 206: static void
1.187 schwarze 207: print_bvspace(struct termp *p, struct roff_node *n, int pardist)
1.18 schwarze 208: {
1.187 schwarze 209: struct roff_node *nch;
210: int i;
1.69 schwarze 211:
1.18 schwarze 212: term_newln(p);
1.64 schwarze 213:
1.187 schwarze 214: if (n->body != NULL &&
215: (nch = roff_node_child(n->body)) != NULL &&
216: nch->type == ROFFT_TBL)
217: return;
218:
219: if (n->parent->tok != MAN_RS && roff_node_prev(n) == NULL)
220: return;
1.11 schwarze 221:
1.88 schwarze 222: for (i = 0; i < pardist; i++)
223: term_vspace(p);
1.14 schwarze 224: }
225:
1.174 schwarze 226:
227: static int
228: pre_abort(DECL_ARGS)
229: {
230: abort();
231: }
1.100 schwarze 232:
1.14 schwarze 233: static int
234: pre_ign(DECL_ARGS)
235: {
1.138 schwarze 236: return 0;
1.11 schwarze 237: }
238:
1.1 kristaps 239: static int
240: pre_I(DECL_ARGS)
241: {
1.21 schwarze 242: term_fontrepl(p, TERMFONT_UNDER);
1.138 schwarze 243: return 1;
1.1 kristaps 244: }
245:
1.11 schwarze 246: static int
1.45 schwarze 247: pre_literal(DECL_ARGS)
1.11 schwarze 248: {
1.45 schwarze 249: term_newln(p);
1.53 schwarze 250:
1.72 schwarze 251: /*
252: * Unlike .IP and .TP, .HP does not have a HEAD.
253: * So in case a second call to term_flushln() is needed,
254: * indentation has to be set up explicitly.
255: */
1.156 schwarze 256: if (n->parent->tok == MAN_HP && p->tcol->rmargin < p->maxrmargin) {
257: p->tcol->offset = p->tcol->rmargin;
258: p->tcol->rmargin = p->maxrmargin;
1.93 schwarze 259: p->trailspace = 0;
1.99 schwarze 260: p->flags &= ~(TERMP_NOBREAK | TERMP_BRIND);
1.72 schwarze 261: p->flags |= TERMP_NOSPACE;
262: }
1.138 schwarze 263: return 0;
1.11 schwarze 264: }
265:
266: static int
1.88 schwarze 267: pre_PD(DECL_ARGS)
268: {
1.113 schwarze 269: struct roffsu su;
1.88 schwarze 270:
271: n = n->child;
1.113 schwarze 272: if (n == NULL) {
1.88 schwarze 273: mt->pardist = 1;
1.138 schwarze 274: return 0;
1.88 schwarze 275: }
1.124 schwarze 276: assert(n->type == ROFFT_TEXT);
1.157 schwarze 277: if (a2roffsu(n->string, &su, SCALE_VS) != NULL)
1.113 schwarze 278: mt->pardist = term_vspan(p, &su);
1.138 schwarze 279: return 0;
1.88 schwarze 280: }
281:
282: static int
1.51 schwarze 283: pre_alternate(DECL_ARGS)
1.1 kristaps 284: {
1.51 schwarze 285: enum termfont font[2];
1.125 schwarze 286: struct roff_node *nn;
1.178 schwarze 287: int i;
1.1 kristaps 288:
1.51 schwarze 289: switch (n->tok) {
1.100 schwarze 290: case MAN_RB:
1.51 schwarze 291: font[0] = TERMFONT_NONE;
292: font[1] = TERMFONT_BOLD;
293: break;
1.100 schwarze 294: case MAN_RI:
1.51 schwarze 295: font[0] = TERMFONT_NONE;
296: font[1] = TERMFONT_UNDER;
297: break;
1.100 schwarze 298: case MAN_BR:
1.51 schwarze 299: font[0] = TERMFONT_BOLD;
300: font[1] = TERMFONT_NONE;
301: break;
1.100 schwarze 302: case MAN_BI:
1.51 schwarze 303: font[0] = TERMFONT_BOLD;
304: font[1] = TERMFONT_UNDER;
305: break;
1.100 schwarze 306: case MAN_IR:
1.51 schwarze 307: font[0] = TERMFONT_UNDER;
308: font[1] = TERMFONT_NONE;
309: break;
1.100 schwarze 310: case MAN_IB:
1.51 schwarze 311: font[0] = TERMFONT_UNDER;
312: font[1] = TERMFONT_BOLD;
313: break;
314: default:
315: abort();
316: }
1.178 schwarze 317: for (i = 0, nn = n->child; nn != NULL; nn = nn->next, i = 1 - i) {
1.51 schwarze 318: term_fontrepl(p, font[i]);
1.132 schwarze 319: assert(nn->type == ROFFT_TEXT);
320: term_word(p, nn->string);
1.141 schwarze 321: if (nn->flags & NODE_EOS)
1.183 schwarze 322: p->flags |= TERMP_SENTENCE;
1.180 schwarze 323: if (nn->next != NULL)
1.1 kristaps 324: p->flags |= TERMP_NOSPACE;
325: }
1.138 schwarze 326: return 0;
1.1 kristaps 327: }
328:
329: static int
330: pre_B(DECL_ARGS)
331: {
1.21 schwarze 332: term_fontrepl(p, TERMFONT_BOLD);
1.138 schwarze 333: return 1;
1.82 schwarze 334: }
335:
336: static int
337: pre_OP(DECL_ARGS)
338: {
339: term_word(p, "[");
1.169 schwarze 340: p->flags |= TERMP_KEEP | TERMP_NOSPACE;
1.82 schwarze 341:
1.180 schwarze 342: if ((n = n->child) != NULL) {
1.82 schwarze 343: term_fontrepl(p, TERMFONT_BOLD);
344: term_word(p, n->string);
345: }
1.180 schwarze 346: if (n != NULL && n->next != NULL) {
1.82 schwarze 347: term_fontrepl(p, TERMFONT_UNDER);
348: term_word(p, n->next->string);
349: }
350: term_fontrepl(p, TERMFONT_NONE);
1.169 schwarze 351: p->flags &= ~TERMP_KEEP;
1.82 schwarze 352: p->flags |= TERMP_NOSPACE;
353: term_word(p, "]");
1.138 schwarze 354: return 0;
1.1 kristaps 355: }
356:
357: static int
1.45 schwarze 358: pre_in(DECL_ARGS)
1.11 schwarze 359: {
1.116 schwarze 360: struct roffsu su;
361: const char *cp;
1.45 schwarze 362: size_t v;
1.116 schwarze 363: int less;
1.45 schwarze 364:
365: term_newln(p);
366:
1.156 schwarze 367: if (n->child == NULL) {
368: p->tcol->offset = mt->offset;
1.138 schwarze 369: return 0;
1.45 schwarze 370: }
1.11 schwarze 371:
1.45 schwarze 372: cp = n->child->string;
373: less = 0;
1.11 schwarze 374:
1.180 schwarze 375: if (*cp == '-')
1.45 schwarze 376: less = -1;
1.180 schwarze 377: else if (*cp == '+')
1.45 schwarze 378: less = 1;
379: else
380: cp--;
381:
1.157 schwarze 382: if (a2roffsu(++cp, &su, SCALE_EN) == NULL)
1.138 schwarze 383: return 0;
1.45 schwarze 384:
1.158 schwarze 385: v = term_hen(p, &su);
1.45 schwarze 386:
387: if (less < 0)
1.156 schwarze 388: p->tcol->offset -= p->tcol->offset > v ? v : p->tcol->offset;
1.45 schwarze 389: else if (less > 0)
1.156 schwarze 390: p->tcol->offset += v;
1.100 schwarze 391: else
1.156 schwarze 392: p->tcol->offset = v;
393: if (p->tcol->offset > SHRT_MAX)
394: p->tcol->offset = term_len(p, p->defindent);
1.8 schwarze 395:
1.152 schwarze 396: return 0;
397: }
398:
399: static int
400: pre_DT(DECL_ARGS)
401: {
402: term_tab_set(p, NULL);
403: term_tab_set(p, "T");
404: term_tab_set(p, ".5i");
1.138 schwarze 405: return 0;
1.8 schwarze 406: }
407:
408: static int
1.11 schwarze 409: pre_HP(DECL_ARGS)
410: {
1.116 schwarze 411: struct roffsu su;
1.125 schwarze 412: const struct roff_node *nn;
1.116 schwarze 413: int len;
1.11 schwarze 414:
415: switch (n->type) {
1.124 schwarze 416: case ROFFT_BLOCK:
1.88 schwarze 417: print_bvspace(p, n, mt->pardist);
1.138 schwarze 418: return 1;
1.180 schwarze 419: case ROFFT_HEAD:
420: return 0;
1.124 schwarze 421: case ROFFT_BODY:
1.11 schwarze 422: break;
423: default:
1.180 schwarze 424: abort();
1.11 schwarze 425: }
426:
1.179 schwarze 427: if (n->child == NULL)
428: return 0;
429:
430: if ((n->child->flags & NODE_NOFILL) == 0) {
1.99 schwarze 431: p->flags |= TERMP_NOBREAK | TERMP_BRIND;
1.93 schwarze 432: p->trailspace = 2;
1.84 schwarze 433: }
434:
1.11 schwarze 435: /* Calculate offset. */
436:
1.116 schwarze 437: if ((nn = n->parent->head->child) != NULL &&
1.157 schwarze 438: a2roffsu(nn->string, &su, SCALE_EN) != NULL) {
1.158 schwarze 439: len = term_hen(p, &su);
1.117 schwarze 440: if (len < 0 && (size_t)(-len) > mt->offset)
441: len = -mt->offset;
442: else if (len > SHRT_MAX)
443: len = term_len(p, p->defindent);
1.116 schwarze 444: mt->lmargin[mt->lmargincur] = len;
445: } else
446: len = mt->lmargin[mt->lmargincur];
1.11 schwarze 447:
1.156 schwarze 448: p->tcol->offset = mt->offset;
449: p->tcol->rmargin = mt->offset + len;
1.138 schwarze 450: return 1;
1.11 schwarze 451: }
452:
453: static void
454: post_HP(DECL_ARGS)
455: {
456: switch (n->type) {
1.180 schwarze 457: case ROFFT_BLOCK:
458: case ROFFT_HEAD:
459: break;
1.124 schwarze 460: case ROFFT_BODY:
1.90 schwarze 461: term_newln(p);
1.127 schwarze 462:
463: /*
464: * Compatibility with a groff bug.
465: * The .HP macro uses the undocumented .tag request
466: * which causes a line break and cancels no-space
467: * mode even if there isn't any output.
468: */
469:
470: if (n->child == NULL)
471: term_vspace(p);
472:
1.99 schwarze 473: p->flags &= ~(TERMP_NOBREAK | TERMP_BRIND);
1.93 schwarze 474: p->trailspace = 0;
1.156 schwarze 475: p->tcol->offset = mt->offset;
476: p->tcol->rmargin = p->maxrmargin;
1.11 schwarze 477: break;
478: default:
1.180 schwarze 479: abort();
1.11 schwarze 480: }
481: }
482:
483: static int
1.1 kristaps 484: pre_PP(DECL_ARGS)
485: {
1.11 schwarze 486: switch (n->type) {
1.124 schwarze 487: case ROFFT_BLOCK:
1.77 schwarze 488: mt->lmargin[mt->lmargincur] = term_len(p, p->defindent);
1.88 schwarze 489: print_bvspace(p, n, mt->pardist);
1.11 schwarze 490: break;
1.180 schwarze 491: case ROFFT_HEAD:
492: return 0;
493: case ROFFT_BODY:
1.156 schwarze 494: p->tcol->offset = mt->offset;
1.11 schwarze 495: break;
1.180 schwarze 496: default:
497: abort();
1.11 schwarze 498: }
1.180 schwarze 499: return 1;
1.1 kristaps 500: }
501:
502: static int
503: pre_IP(DECL_ARGS)
504: {
1.116 schwarze 505: struct roffsu su;
1.125 schwarze 506: const struct roff_node *nn;
1.178 schwarze 507: int len;
1.11 schwarze 508:
509: switch (n->type) {
1.180 schwarze 510: case ROFFT_BLOCK:
511: print_bvspace(p, n, mt->pardist);
512: return 1;
1.124 schwarze 513: case ROFFT_HEAD:
1.11 schwarze 514: p->flags |= TERMP_NOBREAK;
1.93 schwarze 515: p->trailspace = 1;
1.11 schwarze 516: break;
1.180 schwarze 517: case ROFFT_BODY:
1.192 schwarze 518: p->flags |= TERMP_NOSPACE | TERMP_NONEWLINE;
1.180 schwarze 519: break;
1.11 schwarze 520: default:
1.180 schwarze 521: abort();
1.11 schwarze 522: }
523:
1.57 schwarze 524: /* Calculate the offset from the optional second argument. */
1.116 schwarze 525: if ((nn = n->parent->head->child) != NULL &&
526: (nn = nn->next) != NULL &&
1.157 schwarze 527: a2roffsu(nn->string, &su, SCALE_EN) != NULL) {
1.158 schwarze 528: len = term_hen(p, &su);
1.116 schwarze 529: if (len < 0 && (size_t)(-len) > mt->offset)
530: len = -mt->offset;
1.117 schwarze 531: else if (len > SHRT_MAX)
532: len = term_len(p, p->defindent);
533: mt->lmargin[mt->lmargincur] = len;
1.116 schwarze 534: } else
535: len = mt->lmargin[mt->lmargincur];
1.11 schwarze 536:
537: switch (n->type) {
1.124 schwarze 538: case ROFFT_HEAD:
1.156 schwarze 539: p->tcol->offset = mt->offset;
540: p->tcol->rmargin = mt->offset + len;
1.188 schwarze 541: if (n->child != NULL)
1.89 schwarze 542: print_man_node(p, mt, n->child, meta);
1.138 schwarze 543: return 0;
1.124 schwarze 544: case ROFFT_BODY:
1.156 schwarze 545: p->tcol->offset = mt->offset + len;
546: p->tcol->rmargin = p->maxrmargin;
1.11 schwarze 547: break;
548: default:
1.180 schwarze 549: abort();
1.11 schwarze 550: }
1.138 schwarze 551: return 1;
1.11 schwarze 552: }
1.1 kristaps 553:
1.11 schwarze 554: static void
555: post_IP(DECL_ARGS)
556: {
557: switch (n->type) {
1.180 schwarze 558: case ROFFT_BLOCK:
559: break;
1.124 schwarze 560: case ROFFT_HEAD:
1.11 schwarze 561: term_flushln(p);
562: p->flags &= ~TERMP_NOBREAK;
1.93 schwarze 563: p->trailspace = 0;
1.156 schwarze 564: p->tcol->rmargin = p->maxrmargin;
1.11 schwarze 565: break;
1.124 schwarze 566: case ROFFT_BODY:
1.57 schwarze 567: term_newln(p);
1.156 schwarze 568: p->tcol->offset = mt->offset;
1.11 schwarze 569: break;
570: default:
1.180 schwarze 571: abort();
1.11 schwarze 572: }
1.1 kristaps 573: }
574:
575: static int
576: pre_TP(DECL_ARGS)
577: {
1.116 schwarze 578: struct roffsu su;
1.125 schwarze 579: struct roff_node *nn;
1.178 schwarze 580: int len;
1.11 schwarze 581:
582: switch (n->type) {
1.180 schwarze 583: case ROFFT_BLOCK:
584: if (n->tok == MAN_TP)
585: print_bvspace(p, n, mt->pardist);
586: return 1;
1.124 schwarze 587: case ROFFT_HEAD:
1.137 schwarze 588: p->flags |= TERMP_NOBREAK | TERMP_BRTRSP;
1.93 schwarze 589: p->trailspace = 1;
1.11 schwarze 590: break;
1.124 schwarze 591: case ROFFT_BODY:
1.192 schwarze 592: p->flags |= TERMP_NOSPACE | TERMP_NONEWLINE;
1.11 schwarze 593: break;
594: default:
1.180 schwarze 595: abort();
1.11 schwarze 596: }
597:
598: /* Calculate offset. */
1.1 kristaps 599:
1.116 schwarze 600: if ((nn = n->parent->head->child) != NULL &&
1.141 schwarze 601: nn->string != NULL && ! (NODE_LINE & nn->flags) &&
1.157 schwarze 602: a2roffsu(nn->string, &su, SCALE_EN) != NULL) {
1.158 schwarze 603: len = term_hen(p, &su);
1.116 schwarze 604: if (len < 0 && (size_t)(-len) > mt->offset)
605: len = -mt->offset;
1.117 schwarze 606: else if (len > SHRT_MAX)
607: len = term_len(p, p->defindent);
608: mt->lmargin[mt->lmargincur] = len;
1.116 schwarze 609: } else
610: len = mt->lmargin[mt->lmargincur];
1.8 schwarze 611:
1.11 schwarze 612: switch (n->type) {
1.124 schwarze 613: case ROFFT_HEAD:
1.156 schwarze 614: p->tcol->offset = mt->offset;
615: p->tcol->rmargin = mt->offset + len;
1.11 schwarze 616:
617: /* Don't print same-line elements. */
1.95 schwarze 618: nn = n->child;
1.180 schwarze 619: while (nn != NULL && (nn->flags & NODE_LINE) == 0)
1.95 schwarze 620: nn = nn->next;
1.185 schwarze 621:
1.180 schwarze 622: while (nn != NULL) {
1.95 schwarze 623: print_man_node(p, mt, nn, meta);
624: nn = nn->next;
625: }
1.138 schwarze 626: return 0;
1.124 schwarze 627: case ROFFT_BODY:
1.156 schwarze 628: p->tcol->offset = mt->offset + len;
629: p->tcol->rmargin = p->maxrmargin;
1.93 schwarze 630: p->trailspace = 0;
1.137 schwarze 631: p->flags &= ~(TERMP_NOBREAK | TERMP_BRTRSP);
1.11 schwarze 632: break;
633: default:
1.180 schwarze 634: abort();
1.11 schwarze 635: }
1.138 schwarze 636: return 1;
1.11 schwarze 637: }
1.1 kristaps 638:
1.11 schwarze 639: static void
640: post_TP(DECL_ARGS)
641: {
642: switch (n->type) {
1.180 schwarze 643: case ROFFT_BLOCK:
644: break;
1.124 schwarze 645: case ROFFT_HEAD:
1.11 schwarze 646: term_flushln(p);
647: break;
1.124 schwarze 648: case ROFFT_BODY:
1.57 schwarze 649: term_newln(p);
1.156 schwarze 650: p->tcol->offset = mt->offset;
1.11 schwarze 651: break;
652: default:
1.180 schwarze 653: abort();
1.11 schwarze 654: }
1.1 kristaps 655: }
656:
657: static int
658: pre_SS(DECL_ARGS)
659: {
1.88 schwarze 660: int i;
1.1 kristaps 661:
1.11 schwarze 662: switch (n->type) {
1.124 schwarze 663: case ROFFT_BLOCK:
1.77 schwarze 664: mt->lmargin[mt->lmargincur] = term_len(p, p->defindent);
665: mt->offset = term_len(p, p->defindent);
1.111 schwarze 666:
667: /*
668: * No vertical space before the first subsection
669: * and after an empty subsection.
670: */
671:
1.187 schwarze 672: if ((n = roff_node_prev(n)) == NULL ||
673: (n->tok == MAN_SS && roff_node_child(n->body) == NULL))
1.11 schwarze 674: break;
1.111 schwarze 675:
1.88 schwarze 676: for (i = 0; i < mt->pardist; i++)
677: term_vspace(p);
1.11 schwarze 678: break;
1.124 schwarze 679: case ROFFT_HEAD:
1.21 schwarze 680: term_fontrepl(p, TERMFONT_BOLD);
1.156 schwarze 681: p->tcol->offset = term_len(p, 3);
682: p->tcol->rmargin = mt->offset;
1.129 schwarze 683: p->trailspace = mt->offset;
684: p->flags |= TERMP_NOBREAK | TERMP_BRIND;
1.11 schwarze 685: break;
1.124 schwarze 686: case ROFFT_BODY:
1.156 schwarze 687: p->tcol->offset = mt->offset;
688: p->tcol->rmargin = p->maxrmargin;
1.129 schwarze 689: p->trailspace = 0;
690: p->flags &= ~(TERMP_NOBREAK | TERMP_BRIND);
1.11 schwarze 691: break;
692: default:
693: break;
694: }
1.138 schwarze 695: return 1;
1.1 kristaps 696: }
697:
698: static int
699: pre_SH(DECL_ARGS)
700: {
1.88 schwarze 701: int i;
1.1 kristaps 702:
1.11 schwarze 703: switch (n->type) {
1.124 schwarze 704: case ROFFT_BLOCK:
1.77 schwarze 705: mt->lmargin[mt->lmargincur] = term_len(p, p->defindent);
706: mt->offset = term_len(p, p->defindent);
1.111 schwarze 707:
708: /*
709: * No vertical space before the first section
710: * and after an empty section.
711: */
712:
1.187 schwarze 713: if ((n = roff_node_prev(n)) == NULL ||
714: (n->tok == MAN_SH && roff_node_child(n->body) == NULL))
1.29 schwarze 715: break;
1.111 schwarze 716:
1.88 schwarze 717: for (i = 0; i < mt->pardist; i++)
718: term_vspace(p);
1.11 schwarze 719: break;
1.124 schwarze 720: case ROFFT_HEAD:
1.21 schwarze 721: term_fontrepl(p, TERMFONT_BOLD);
1.156 schwarze 722: p->tcol->offset = 0;
723: p->tcol->rmargin = mt->offset;
1.129 schwarze 724: p->trailspace = mt->offset;
725: p->flags |= TERMP_NOBREAK | TERMP_BRIND;
1.11 schwarze 726: break;
1.124 schwarze 727: case ROFFT_BODY:
1.156 schwarze 728: p->tcol->offset = mt->offset;
729: p->tcol->rmargin = p->maxrmargin;
1.129 schwarze 730: p->trailspace = 0;
731: p->flags &= ~(TERMP_NOBREAK | TERMP_BRIND);
1.11 schwarze 732: break;
733: default:
1.180 schwarze 734: abort();
1.11 schwarze 735: }
1.138 schwarze 736: return 1;
1.1 kristaps 737: }
738:
739: static void
740: post_SH(DECL_ARGS)
741: {
1.11 schwarze 742: switch (n->type) {
1.180 schwarze 743: case ROFFT_BLOCK:
744: break;
1.124 schwarze 745: case ROFFT_HEAD:
746: case ROFFT_BODY:
1.11 schwarze 747: term_newln(p);
748: break;
749: default:
1.180 schwarze 750: abort();
1.13 schwarze 751: }
752: }
753:
754: static int
755: pre_RS(DECL_ARGS)
756: {
1.116 schwarze 757: struct roffsu su;
1.13 schwarze 758:
759: switch (n->type) {
1.124 schwarze 760: case ROFFT_BLOCK:
1.13 schwarze 761: term_newln(p);
1.138 schwarze 762: return 1;
1.124 schwarze 763: case ROFFT_HEAD:
1.138 schwarze 764: return 0;
1.180 schwarze 765: case ROFFT_BODY:
766: break;
1.13 schwarze 767: default:
1.180 schwarze 768: abort();
1.13 schwarze 769: }
770:
1.118 schwarze 771: n = n->parent->head;
772: n->aux = SHRT_MAX + 1;
1.130 schwarze 773: if (n->child == NULL)
774: n->aux = mt->lmargin[mt->lmargincur];
1.157 schwarze 775: else if (a2roffsu(n->child->string, &su, SCALE_EN) != NULL)
1.158 schwarze 776: n->aux = term_hen(p, &su);
1.118 schwarze 777: if (n->aux < 0 && (size_t)(-n->aux) > mt->offset)
778: n->aux = -mt->offset;
779: else if (n->aux > SHRT_MAX)
780: n->aux = term_len(p, p->defindent);
1.13 schwarze 781:
1.118 schwarze 782: mt->offset += n->aux;
1.156 schwarze 783: p->tcol->offset = mt->offset;
784: p->tcol->rmargin = p->maxrmargin;
1.13 schwarze 785:
1.70 schwarze 786: if (++mt->lmarginsz < MAXMARGINS)
787: mt->lmargincur = mt->lmarginsz;
788:
1.131 schwarze 789: mt->lmargin[mt->lmargincur] = term_len(p, p->defindent);
1.138 schwarze 790: return 1;
1.13 schwarze 791: }
792:
793: static void
794: post_RS(DECL_ARGS)
795: {
796: switch (n->type) {
1.124 schwarze 797: case ROFFT_BLOCK:
798: case ROFFT_HEAD:
1.69 schwarze 799: return;
1.180 schwarze 800: case ROFFT_BODY:
801: break;
1.13 schwarze 802: default:
1.180 schwarze 803: abort();
1.11 schwarze 804: }
1.180 schwarze 805: term_newln(p);
1.118 schwarze 806: mt->offset -= n->parent->head->aux;
1.156 schwarze 807: p->tcol->offset = mt->offset;
1.70 schwarze 808: if (--mt->lmarginsz < MAXMARGINS)
809: mt->lmargincur = mt->lmarginsz;
1.168 schwarze 810: }
811:
812: static int
813: pre_SY(DECL_ARGS)
814: {
815: const struct roff_node *nn;
816: int len;
817:
818: switch (n->type) {
819: case ROFFT_BLOCK:
1.187 schwarze 820: if ((nn = roff_node_prev(n)) == NULL || nn->tok != MAN_SY)
1.170 schwarze 821: print_bvspace(p, n, mt->pardist);
1.168 schwarze 822: return 1;
823: case ROFFT_HEAD:
824: case ROFFT_BODY:
825: break;
826: default:
827: abort();
828: }
829:
830: nn = n->parent->head->child;
1.172 schwarze 831: len = nn == NULL ? 1 : term_strlen(p, nn->string) + 1;
1.168 schwarze 832:
833: switch (n->type) {
834: case ROFFT_HEAD:
835: p->tcol->offset = mt->offset;
836: p->tcol->rmargin = mt->offset + len;
1.181 schwarze 837: if (n->next->child == NULL ||
838: (n->next->child->flags & NODE_NOFILL) == 0)
839: p->flags |= TERMP_NOBREAK;
1.168 schwarze 840: term_fontrepl(p, TERMFONT_BOLD);
841: break;
842: case ROFFT_BODY:
843: mt->lmargin[mt->lmargincur] = len;
844: p->tcol->offset = mt->offset + len;
845: p->tcol->rmargin = p->maxrmargin;
846: p->flags |= TERMP_NOSPACE;
847: break;
848: default:
849: abort();
850: }
851: return 1;
852: }
853:
854: static void
855: post_SY(DECL_ARGS)
856: {
857: switch (n->type) {
1.180 schwarze 858: case ROFFT_BLOCK:
859: break;
1.168 schwarze 860: case ROFFT_HEAD:
861: term_flushln(p);
862: p->flags &= ~TERMP_NOBREAK;
863: break;
864: case ROFFT_BODY:
865: term_newln(p);
866: p->tcol->offset = mt->offset;
867: break;
868: default:
1.180 schwarze 869: abort();
1.168 schwarze 870: }
1.91 schwarze 871: }
872:
873: static int
874: pre_UR(DECL_ARGS)
875: {
1.138 schwarze 876: return n->type != ROFFT_HEAD;
1.91 schwarze 877: }
878:
879: static void
880: post_UR(DECL_ARGS)
881: {
1.124 schwarze 882: if (n->type != ROFFT_BLOCK)
1.91 schwarze 883: return;
884:
885: term_word(p, "<");
886: p->flags |= TERMP_NOSPACE;
887:
1.180 schwarze 888: if (n->child->child != NULL)
1.91 schwarze 889: print_man_node(p, mt, n->child->child, meta);
890:
891: p->flags |= TERMP_NOSPACE;
892: term_word(p, ">");
1.47 schwarze 893: }
894:
1.1 kristaps 895: static void
1.19 schwarze 896: print_man_node(DECL_ARGS)
1.1 kristaps 897: {
1.167 schwarze 898: const struct man_term_act *act;
899: int c;
1.1 kristaps 900:
1.192 schwarze 901: /*
902: * In no-fill mode, break the output line at the beginning
903: * of new input lines except after \c, and nowhere else.
904: */
905:
906: if (n->flags & NODE_NOFILL) {
907: if (n->flags & NODE_LINE &&
908: (p->flags & TERMP_NONEWLINE) == 0)
909: term_newln(p);
910: p->flags |= TERMP_BRNEVER;
1.193 schwarze 911: } else {
912: if (n->flags & NODE_LINE)
913: term_tab_ref(p);
1.192 schwarze 914: p->flags &= ~TERMP_BRNEVER;
1.193 schwarze 915: }
1.192 schwarze 916:
1.188 schwarze 917: if (n->flags & NODE_ID)
918: term_tag_write(n, p->line);
919:
1.1 kristaps 920: switch (n->type) {
1.124 schwarze 921: case ROFFT_TEXT:
1.61 schwarze 922: /*
923: * If we have a blank line, output a vertical space.
924: * If we have a space as the first character, break
925: * before printing the line's data.
926: */
1.153 schwarze 927: if (*n->string == '\0') {
1.160 schwarze 928: if (p->flags & TERMP_NONEWLINE)
929: term_newln(p);
930: else
931: term_vspace(p);
1.61 schwarze 932: return;
1.153 schwarze 933: } else if (*n->string == ' ' && n->flags & NODE_LINE &&
934: (p->flags & TERMP_NONEWLINE) == 0)
1.60 schwarze 935: term_newln(p);
1.165 schwarze 936: else if (n->flags & NODE_DELIMC)
937: p->flags |= TERMP_NOSPACE;
1.21 schwarze 938:
1.1 kristaps 939: term_word(p, n->string);
1.84 schwarze 940: goto out;
1.163 schwarze 941: case ROFFT_COMMENT:
942: return;
1.124 schwarze 943: case ROFFT_EQN:
1.141 schwarze 944: if ( ! (n->flags & NODE_LINE))
1.105 schwarze 945: p->flags |= TERMP_NOSPACE;
1.71 schwarze 946: term_eqn(p, n->eqn);
1.141 schwarze 947: if (n->next != NULL && ! (n->next->flags & NODE_LINE))
1.106 schwarze 948: p->flags |= TERMP_NOSPACE;
1.61 schwarze 949: return;
1.124 schwarze 950: case ROFFT_TBL:
1.122 schwarze 951: if (p->tbl.cols == NULL)
1.194 ! schwarze 952: term_newln(p);
1.58 schwarze 953: term_tbl(p, n->span);
1.61 schwarze 954: return;
1.1 kristaps 955: default:
956: break;
957: }
1.177 schwarze 958:
1.146 schwarze 959: if (n->tok < ROFF_MAX) {
1.147 schwarze 960: roff_term_pre(p, n);
1.146 schwarze 961: return;
962: }
963:
1.167 schwarze 964: act = man_term_act(n->tok);
1.173 schwarze 965: if ((act->flags & MAN_NOTEXT) == 0 && n->tok != MAN_SM)
1.61 schwarze 966: term_fontrepl(p, TERMFONT_NONE);
967:
968: c = 1;
1.167 schwarze 969: if (act->pre != NULL)
970: c = (*act->pre)(p, mt, n, meta);
1.61 schwarze 971:
1.180 schwarze 972: if (c && n->child != NULL)
1.89 schwarze 973: print_man_nodelist(p, mt, n->child, meta);
1.1 kristaps 974:
1.167 schwarze 975: if (act->post != NULL)
976: (*act->post)(p, mt, n, meta);
1.173 schwarze 977: if ((act->flags & MAN_NOTEXT) == 0 && n->tok != MAN_SM)
1.61 schwarze 978: term_fontrepl(p, TERMFONT_NONE);
1.30 schwarze 979:
1.84 schwarze 980: out:
1.192 schwarze 981: if (n->parent->tok == MAN_HP && n->parent->type == ROFFT_BODY &&
982: n->prev == NULL && n->flags & NODE_NOFILL) {
983: term_newln(p);
984: p->tcol->offset = p->tcol->rmargin;
985: p->tcol->rmargin = p->maxrmargin;
1.84 schwarze 986: }
1.180 schwarze 987: if (n->flags & NODE_EOS)
1.30 schwarze 988: p->flags |= TERMP_SENTENCE;
1.1 kristaps 989: }
990:
991: static void
1.21 schwarze 992: print_man_nodelist(DECL_ARGS)
1.1 kristaps 993: {
1.121 schwarze 994: while (n != NULL) {
995: print_man_node(p, mt, n, meta);
996: n = n->next;
997: }
1.1 kristaps 998: }
999:
1000: static void
1.126 schwarze 1001: print_man_foot(struct termp *p, const struct roff_meta *meta)
1.1 kristaps 1002: {
1.101 schwarze 1003: char *title;
1.109 schwarze 1004: size_t datelen, titlen;
1.41 schwarze 1005:
1.80 schwarze 1006: assert(meta->title);
1007: assert(meta->msec);
1008: assert(meta->date);
1.21 schwarze 1009:
1010: term_fontrepl(p, TERMFONT_NONE);
1.1 kristaps 1011:
1.103 schwarze 1012: if (meta->hasbody)
1013: term_vspace(p);
1.81 schwarze 1014:
1015: /*
1016: * Temporary, undocumented option to imitate mdoc(7) output.
1.126 schwarze 1017: * In the bottom right corner, use the operating system
1018: * instead of the title.
1.81 schwarze 1019: */
1020:
1.79 schwarze 1021: if ( ! p->mdocstyle) {
1.101 schwarze 1022: mandoc_asprintf(&title, "%s(%s)",
1023: meta->title, meta->msec);
1.180 schwarze 1024: } else if (meta->os != NULL) {
1.126 schwarze 1025: title = mandoc_strdup(meta->os);
1.79 schwarze 1026: } else {
1.101 schwarze 1027: title = mandoc_strdup("");
1.79 schwarze 1028: }
1.78 schwarze 1029: datelen = term_strlen(p, meta->date);
1.1 kristaps 1030:
1.126 schwarze 1031: /* Bottom left corner: operating system. */
1.81 schwarze 1032:
1.1 kristaps 1033: p->flags |= TERMP_NOSPACE | TERMP_NOBREAK;
1.93 schwarze 1034: p->trailspace = 1;
1.156 schwarze 1035: p->tcol->offset = 0;
1036: p->tcol->rmargin = p->maxrmargin > datelen ?
1.109 schwarze 1037: (p->maxrmargin + term_len(p, 1) - datelen) / 2 : 0;
1.1 kristaps 1038:
1.126 schwarze 1039: if (meta->os)
1040: term_word(p, meta->os);
1.1 kristaps 1041: term_flushln(p);
1042:
1.81 schwarze 1043: /* At the bottom in the middle: manual date. */
1044:
1.156 schwarze 1045: p->tcol->offset = p->tcol->rmargin;
1.109 schwarze 1046: titlen = term_strlen(p, title);
1.156 schwarze 1047: p->tcol->rmargin = p->maxrmargin > titlen ?
1048: p->maxrmargin - titlen : 0;
1.72 schwarze 1049: p->flags |= TERMP_NOSPACE;
1.78 schwarze 1050:
1051: term_word(p, meta->date);
1052: term_flushln(p);
1053:
1.81 schwarze 1054: /* Bottom right corner: manual title and section. */
1055:
1.78 schwarze 1056: p->flags &= ~TERMP_NOBREAK;
1057: p->flags |= TERMP_NOSPACE;
1.93 schwarze 1058: p->trailspace = 0;
1.156 schwarze 1059: p->tcol->offset = p->tcol->rmargin;
1060: p->tcol->rmargin = p->maxrmargin;
1.1 kristaps 1061:
1.78 schwarze 1062: term_word(p, title);
1.1 kristaps 1063: term_flushln(p);
1.164 schwarze 1064:
1065: /*
1066: * Reset the terminal state for more output after the footer:
1067: * Some output modes, in particular PostScript and PDF, print
1068: * the header and the footer into a buffer such that it can be
1069: * reused for multiple output pages, then go on to format the
1070: * main text.
1071: */
1072:
1073: p->tcol->offset = 0;
1074: p->flags = 0;
1075:
1.101 schwarze 1076: free(title);
1.1 kristaps 1077: }
1078:
1079: static void
1.126 schwarze 1080: print_man_head(struct termp *p, const struct roff_meta *meta)
1.1 kristaps 1081: {
1.102 schwarze 1082: const char *volume;
1.101 schwarze 1083: char *title;
1.102 schwarze 1084: size_t vollen, titlen;
1.41 schwarze 1085:
1.89 schwarze 1086: assert(meta->title);
1087: assert(meta->msec);
1.1 kristaps 1088:
1.102 schwarze 1089: volume = NULL == meta->vol ? "" : meta->vol;
1090: vollen = term_strlen(p, volume);
1.1 kristaps 1091:
1.81 schwarze 1092: /* Top left corner: manual title and section. */
1093:
1.101 schwarze 1094: mandoc_asprintf(&title, "%s(%s)", meta->title, meta->msec);
1.42 schwarze 1095: titlen = term_strlen(p, title);
1.1 kristaps 1096:
1.73 schwarze 1097: p->flags |= TERMP_NOBREAK | TERMP_NOSPACE;
1.93 schwarze 1098: p->trailspace = 1;
1.156 schwarze 1099: p->tcol->offset = 0;
1100: p->tcol->rmargin = 2 * (titlen+1) + vollen < p->maxrmargin ?
1.102 schwarze 1101: (p->maxrmargin - vollen + term_len(p, 1)) / 2 :
1.109 schwarze 1102: vollen < p->maxrmargin ? p->maxrmargin - vollen : 0;
1.1 kristaps 1103:
1104: term_word(p, title);
1105: term_flushln(p);
1106:
1.81 schwarze 1107: /* At the top in the middle: manual volume. */
1108:
1.72 schwarze 1109: p->flags |= TERMP_NOSPACE;
1.156 schwarze 1110: p->tcol->offset = p->tcol->rmargin;
1111: p->tcol->rmargin = p->tcol->offset + vollen + titlen <
1112: p->maxrmargin ? p->maxrmargin - titlen : p->maxrmargin;
1.1 kristaps 1113:
1.102 schwarze 1114: term_word(p, volume);
1.1 kristaps 1115: term_flushln(p);
1116:
1.81 schwarze 1117: /* Top right corner: title and section, again. */
1118:
1.1 kristaps 1119: p->flags &= ~TERMP_NOBREAK;
1.93 schwarze 1120: p->trailspace = 0;
1.156 schwarze 1121: if (p->tcol->rmargin + titlen <= p->maxrmargin) {
1.72 schwarze 1122: p->flags |= TERMP_NOSPACE;
1.156 schwarze 1123: p->tcol->offset = p->tcol->rmargin;
1124: p->tcol->rmargin = p->maxrmargin;
1.25 schwarze 1125: term_word(p, title);
1126: term_flushln(p);
1127: }
1.1 kristaps 1128:
1.73 schwarze 1129: p->flags &= ~TERMP_NOSPACE;
1.156 schwarze 1130: p->tcol->offset = 0;
1131: p->tcol->rmargin = p->maxrmargin;
1.29 schwarze 1132:
1.100 schwarze 1133: /*
1.81 schwarze 1134: * Groff prints three blank lines before the content.
1135: * Do the same, except in the temporary, undocumented
1136: * mode imitating mdoc(7) output.
1.29 schwarze 1137: */
1138:
1139: term_vspace(p);
1.101 schwarze 1140: free(title);
1.1 kristaps 1141: }
![[BACK]](/icons/back.gif){kind=icon}
Return to man_term.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / mandoc