Annotation of docbook2mdoc/docbook2mdoc.c, Revision 1.110
1.110 ! schwarze 1: /* $Id: docbook2mdoc.c,v 1.109 2019/04/12 10:34:48 schwarze Exp $ */
1.1 kristaps 2: /*
3: * Copyright (c) 2014 Kristaps Dzonsons <kristaps@bsd.lv>
1.50 schwarze 4: * Copyright (c) 2019 Ingo Schwarze <schwarze@openbsd.org>
1.1 kristaps 5: *
6: * Permission to use, copy, modify, and distribute this software for any
7: * purpose with or without fee is hereby granted, provided that the above
8: * copyright notice and this permission notice appear in all copies.
9: *
10: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHORS DISCLAIM ALL WARRANTIES
11: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR
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.
17: */
18: #include <assert.h>
19: #include <ctype.h>
20: #include <stdio.h>
21: #include <stdlib.h>
1.103 schwarze 22: #include <string.h>
1.1 kristaps 23:
1.74 schwarze 24: #include "node.h"
1.75 schwarze 25: #include "macro.h"
1.74 schwarze 26: #include "format.h"
27:
28: /*
29: * The implementation of the mdoc(7) formatter.
30: */
1.12 kristaps 31:
1.74 schwarze 32: static void pnode_print(struct format *, struct pnode *);
1.25 kristaps 33:
1.37 kristaps 34:
1.54 schwarze 35: static void
1.93 schwarze 36: pnode_printtext(struct format *f, struct pnode *n)
37: {
1.94 schwarze 38: struct pnode *nn;
1.93 schwarze 39: char *cp;
1.103 schwarze 40: int accept_arg;
1.93 schwarze 41:
1.103 schwarze 42: cp = n->b;
43: accept_arg = f->flags & FMT_ARG;
1.107 schwarze 44: if (f->linestate == LINE_MACRO && !n->spc && !accept_arg) {
1.103 schwarze 45: for (;;) {
46: if (*cp == '\0')
47: return;
48: if (strchr("!),.:;?]", *cp) == NULL)
49: break;
50: printf(" %c", *cp++);
51: }
52: if (isspace((unsigned char)*cp)) {
53: while (isspace((unsigned char)*cp))
54: cp++;
55: macro_close(f);
56: } else {
57: fputs(" Ns", stdout);
58: f->flags &= FMT_IMPL;
59: accept_arg = 1;
60: }
1.94 schwarze 61: }
1.103 schwarze 62: if (f->linestate == LINE_MACRO && !accept_arg &&
63: (f->flags & (FMT_CHILD | FMT_IMPL)) == 0)
64: macro_close(f);
1.94 schwarze 65:
66: /*
67: * Text preceding a macro without intervening whitespace
68: * requires a .Pf macro.
69: * Set the spacing flag to avoid a redundant .Ns macro.
70: */
71:
72: if (f->linestate != LINE_MACRO &&
73: (nn = TAILQ_NEXT(n, child)) != NULL && nn->spc == 0 &&
74: (nn->node != NODE_TEXT && nn->node != NODE_ESCAPE)) {
75: macro_open(f, "Pf");
1.103 schwarze 76: accept_arg = 1;
77: f->flags |= FMT_CHILD;
1.94 schwarze 78: nn->spc = 1;
1.93 schwarze 79: }
80:
1.103 schwarze 81: switch (f->linestate) {
1.107 schwarze 82: case LINE_NEW:
83: break;
1.103 schwarze 84: case LINE_TEXT:
1.105 schwarze 85: if (n->spc) {
1.107 schwarze 86: if (n->node == NODE_TEXT)
87: macro_close(f);
88: else
89: putchar(' ');
1.105 schwarze 90: }
1.103 schwarze 91: break;
92: case LINE_MACRO:
1.107 schwarze 93: if (accept_arg)
1.93 schwarze 94: putchar(' ');
1.107 schwarze 95: else
96: macro_close(f);
1.103 schwarze 97: break;
1.93 schwarze 98: }
99:
100: if (n->node == NODE_ESCAPE) {
101: fputs(n->b, stdout);
1.107 schwarze 102: if (f->linestate == LINE_NEW)
103: f->linestate = LINE_TEXT;
1.93 schwarze 104: return;
105: }
106:
107: /*
108: * Remove the prefix '-' from <option> elements
109: * because the arguments of .Fl macros do not need it.
110: */
111:
112: if (n->parent != NULL && n->parent->node == NODE_OPTION && *cp == '-')
113: cp++;
114:
1.107 schwarze 115: if (f->linestate == LINE_MACRO)
116: macro_addarg(f, cp, 0);
117: else
118: print_text(f, cp, 0);
1.93 schwarze 119: }
120:
121: static void
1.101 schwarze 122: pnode_printpara(struct format *f, struct pnode *n)
1.54 schwarze 123: {
1.101 schwarze 124: struct pnode *np;
1.54 schwarze 125:
1.101 schwarze 126: if (n->parent == NULL)
1.54 schwarze 127: return;
128:
1.101 schwarze 129: if ((np = TAILQ_PREV(n, pnodeq, child)) == NULL)
130: np = n->parent;
1.97 schwarze 131:
1.103 schwarze 132: f->flags = 0;
133:
1.101 schwarze 134: switch (np->node) {
1.61 schwarze 135: case NODE_ENTRY:
1.99 schwarze 136: case NODE_GLOSSTERM:
1.61 schwarze 137: case NODE_LISTITEM:
1.99 schwarze 138: case NODE_TERM:
1.61 schwarze 139: return;
1.100 schwarze 140: case NODE_APPENDIX:
141: case NODE_LEGALNOTICE:
1.61 schwarze 142: case NODE_PREFACE:
143: case NODE_SECTION:
1.101 schwarze 144: if (f->level < 3)
1.61 schwarze 145: return;
146: break;
147: default:
148: break;
149: }
1.101 schwarze 150: macro_line(f, "Pp");
1.54 schwarze 151: }
152:
1.110 ! schwarze 153: static void
! 154: pnode_printrefnamediv(struct format *f, struct pnode *n)
! 155: {
! 156: struct pnode *nc, *nn;
! 157: int comma;
! 158:
! 159: macro_line(f, "Sh NAME");
! 160: comma = 0;
! 161: TAILQ_FOREACH_SAFE(nc, &n->childq, child, nn) {
! 162: if (nc->node != NODE_REFNAME)
! 163: continue;
! 164: if (comma)
! 165: macro_addarg(f, ",", ARG_SPACE);
! 166: macro_open(f, "Nm");
! 167: macro_addnode(f, nc, ARG_SPACE);
! 168: pnode_unlink(nc);
! 169: comma = 1;
! 170: }
! 171: macro_close(f);
! 172: }
! 173:
1.37 kristaps 174: /*
1.10 kristaps 175: * If the SYNOPSIS macro has a superfluous title, kill it.
1.8 kristaps 176: */
1.1 kristaps 177: static void
1.101 schwarze 178: pnode_printrefsynopsisdiv(struct format *f, struct pnode *n)
1.6 kristaps 179: {
1.101 schwarze 180: struct pnode *nc, *nn;
1.6 kristaps 181:
1.101 schwarze 182: TAILQ_FOREACH_SAFE(nc, &n->childq, child, nn)
183: if (nc->node == NODE_TITLE)
184: pnode_unlink(nc);
1.71 schwarze 185:
1.101 schwarze 186: macro_line(f, "Sh SYNOPSIS");
1.6 kristaps 187: }
188:
1.8 kristaps 189: /*
190: * Start a hopefully-named `Sh' section.
191: */
1.6 kristaps 192: static void
1.101 schwarze 193: pnode_printrefsect(struct format *f, struct pnode *n)
1.1 kristaps 194: {
1.101 schwarze 195: struct pnode *nc;
1.52 schwarze 196: const char *title;
197: int flags, level;
198:
1.101 schwarze 199: if (n->parent == NULL)
1.56 schwarze 200: return;
201:
1.101 schwarze 202: level = ++f->level;
1.72 schwarze 203: flags = ARG_SPACE;
204: if (level == 1)
205: flags |= ARG_UPPER;
1.64 schwarze 206: if (level < 3) {
1.101 schwarze 207: switch (n->node) {
1.62 schwarze 208: case NODE_CAUTION:
209: case NODE_NOTE:
210: case NODE_TIP:
211: case NODE_WARNING:
1.52 schwarze 212: level = 3;
213: break;
214: default:
215: break;
216: }
217: }
1.1 kristaps 218:
1.101 schwarze 219: TAILQ_FOREACH(nc, &n->childq, child)
220: if (nc->node == NODE_TITLE)
1.1 kristaps 221: break;
222:
1.101 schwarze 223: if (nc == NULL) {
224: switch (n->node) {
1.62 schwarze 225: case NODE_PREFACE:
1.52 schwarze 226: title = "Preface";
227: break;
1.100 schwarze 228: case NODE_APPENDIX:
229: title = "Appendix";
230: break;
231: case NODE_LEGALNOTICE:
232: title = "Legal Notice";
233: break;
1.62 schwarze 234: case NODE_CAUTION:
1.52 schwarze 235: title = "Caution";
236: break;
1.62 schwarze 237: case NODE_NOTE:
1.52 schwarze 238: title = "Note";
239: break;
1.62 schwarze 240: case NODE_TIP:
1.52 schwarze 241: title = "Tip";
242: break;
1.62 schwarze 243: case NODE_WARNING:
1.52 schwarze 244: title = "Warning";
245: break;
246: default:
247: title = "Unknown";
248: break;
249: }
250: }
251:
252: switch (level) {
1.62 schwarze 253: case 1:
1.101 schwarze 254: macro_close(f);
255: macro_open(f, "Sh");
1.29 kristaps 256: break;
1.62 schwarze 257: case 2:
1.101 schwarze 258: macro_close(f);
259: macro_open(f, "Ss");
1.29 kristaps 260: break;
1.52 schwarze 261: default:
1.101 schwarze 262: pnode_printpara(f, n);
263: macro_open(f, "Sy");
1.29 kristaps 264: break;
265: }
1.20 kristaps 266:
1.101 schwarze 267: if (nc != NULL) {
268: macro_addnode(f, nc, flags);
269: pnode_unlink(nc);
1.52 schwarze 270: } else
1.101 schwarze 271: macro_addarg(f, title, flags | ARG_QUOTED);
272: macro_close(f);
1.1 kristaps 273: }
274:
1.8 kristaps 275: /*
276: * Start a reference, extracting the title and volume.
277: */
1.1 kristaps 278: static void
1.101 schwarze 279: pnode_printciterefentry(struct format *f, struct pnode *n)
1.1 kristaps 280: {
1.101 schwarze 281: struct pnode *nc, *title, *manvol;
1.1 kristaps 282:
283: title = manvol = NULL;
1.101 schwarze 284: TAILQ_FOREACH(nc, &n->childq, child) {
285: if (nc->node == NODE_MANVOLNUM)
286: manvol = nc;
287: else if (nc->node == NODE_REFENTRYTITLE)
288: title = nc;
1.69 schwarze 289: }
1.101 schwarze 290: macro_open(f, "Xr");
1.69 schwarze 291: if (title == NULL)
1.101 schwarze 292: macro_addarg(f, "unknown", ARG_SPACE);
1.69 schwarze 293: else
1.101 schwarze 294: macro_addnode(f, title, ARG_SPACE | ARG_SINGLE);
1.69 schwarze 295: if (manvol == NULL)
1.101 schwarze 296: macro_addarg(f, "1", ARG_SPACE);
1.64 schwarze 297: else
1.101 schwarze 298: macro_addnode(f, manvol, ARG_SPACE | ARG_SINGLE);
299: pnode_unlinksub(n);
1.1 kristaps 300: }
301:
302: static void
1.101 schwarze 303: pnode_printrefmeta(struct format *f, struct pnode *n)
1.1 kristaps 304: {
1.101 schwarze 305: struct pnode *nc, *title, *manvol;
1.1 kristaps 306:
307: title = manvol = NULL;
1.101 schwarze 308: TAILQ_FOREACH(nc, &n->childq, child) {
309: if (nc->node == NODE_MANVOLNUM)
310: manvol = nc;
311: else if (nc->node == NODE_REFENTRYTITLE)
312: title = nc;
1.69 schwarze 313: }
1.101 schwarze 314: macro_close(f);
315: macro_open(f, "Dt");
1.69 schwarze 316: if (title == NULL)
1.101 schwarze 317: macro_addarg(f, "UNKNOWN", ARG_SPACE);
1.69 schwarze 318: else
1.101 schwarze 319: macro_addnode(f, title, ARG_SPACE | ARG_SINGLE | ARG_UPPER);
1.69 schwarze 320: if (manvol == NULL)
1.101 schwarze 321: macro_addarg(f, "1", ARG_SPACE);
1.13 kristaps 322: else
1.101 schwarze 323: macro_addnode(f, manvol, ARG_SPACE | ARG_SINGLE);
324: macro_close(f);
325: pnode_unlink(n);
1.1 kristaps 326: }
327:
1.3 kristaps 328: static void
1.86 schwarze 329: pnode_printfuncdef(struct format *f, struct pnode *n)
1.3 kristaps 330: {
1.86 schwarze 331: struct pnode *nc;
1.3 kristaps 332:
1.86 schwarze 333: nc = TAILQ_FIRST(&n->childq);
334: if (nc != NULL && nc->node == NODE_TEXT) {
335: macro_argline(f, "Ft", nc->b);
336: pnode_unlink(nc);
1.13 kristaps 337: }
1.86 schwarze 338: macro_nodeline(f, "Fo", n, ARG_SINGLE);
339: pnode_unlinksub(n);
1.3 kristaps 340: }
341:
1.40 kristaps 342: /*
1.41 kristaps 343: * The <mml:mfenced> node is a little peculiar.
344: * First, it can have arbitrary open and closing tokens, which default
345: * to parentheses.
346: * Second, >1 arguments are separated by commas.
347: */
348: static void
1.101 schwarze 349: pnode_printmathfenced(struct format *f, struct pnode *n)
1.41 kristaps 350: {
1.101 schwarze 351: struct pnode *nc;
1.41 kristaps 352:
1.101 schwarze 353: printf("left %s ", pnode_getattr_raw(n, ATTRKEY_OPEN, "("));
1.41 kristaps 354:
1.101 schwarze 355: nc = TAILQ_FIRST(&n->childq);
356: pnode_print(f, nc);
1.41 kristaps 357:
1.101 schwarze 358: while ((nc = TAILQ_NEXT(nc, child)) != NULL) {
1.41 kristaps 359: putchar(',');
1.101 schwarze 360: pnode_print(f, nc);
1.41 kristaps 361: }
1.101 schwarze 362: printf("right %s ", pnode_getattr_raw(n, ATTRKEY_CLOSE, ")"));
363: pnode_unlinksub(n);
1.41 kristaps 364: }
365:
366: /*
1.40 kristaps 367: * These math nodes require special handling because they have infix
368: * syntax, instead of the usual prefix or prefix.
369: * So we need to break up the first and second child node with a
370: * particular eqn(7) word.
371: */
372: static void
1.101 schwarze 373: pnode_printmath(struct format *f, struct pnode *n)
1.40 kristaps 374: {
1.101 schwarze 375: struct pnode *nc;
1.40 kristaps 376:
1.101 schwarze 377: nc = TAILQ_FIRST(&n->childq);
378: pnode_print(f, nc);
1.40 kristaps 379:
1.101 schwarze 380: switch (n->node) {
1.62 schwarze 381: case NODE_MML_MSUP:
1.42 kristaps 382: fputs(" sup ", stdout);
1.40 kristaps 383: break;
1.62 schwarze 384: case NODE_MML_MFRAC:
1.42 kristaps 385: fputs(" over ", stdout);
1.40 kristaps 386: break;
1.62 schwarze 387: case NODE_MML_MSUB:
1.42 kristaps 388: fputs(" sub ", stdout);
1.40 kristaps 389: break;
390: default:
391: break;
392: }
393:
1.101 schwarze 394: nc = TAILQ_NEXT(nc, child);
395: pnode_print(f, nc);
396: pnode_unlinksub(n);
1.40 kristaps 397: }
398:
1.3 kristaps 399: static void
1.101 schwarze 400: pnode_printfuncprototype(struct format *f, struct pnode *n)
1.3 kristaps 401: {
1.101 schwarze 402: struct pnode *nc, *fdef;
1.3 kristaps 403:
1.101 schwarze 404: TAILQ_FOREACH(fdef, &n->childq, child)
1.64 schwarze 405: if (fdef->node == NODE_FUNCDEF)
1.3 kristaps 406: break;
407:
1.86 schwarze 408: if (fdef != NULL) {
1.101 schwarze 409: pnode_printfuncdef(f, fdef);
1.86 schwarze 410: pnode_unlink(fdef);
411: } else
1.101 schwarze 412: macro_line(f, "Fo UNKNOWN");
1.3 kristaps 413:
1.101 schwarze 414: TAILQ_FOREACH(nc, &n->childq, child)
415: macro_nodeline(f, "Fa", nc, ARG_SINGLE);
1.3 kristaps 416:
1.101 schwarze 417: macro_line(f, "Fc");
418: pnode_unlinksub(n);
1.3 kristaps 419: }
420:
1.44 schwarze 421: /*
1.10 kristaps 422: * The <arg> element is more complicated than it should be because text
423: * nodes are treated like ".Ar foo", but non-text nodes need to be
424: * re-sent into the printer (i.e., without the preceding ".Ar").
1.12 kristaps 425: * This also handles the case of "repetition" (or in other words, the
426: * ellipsis following an argument) and optionality.
1.10 kristaps 427: */
1.4 kristaps 428: static void
1.101 schwarze 429: pnode_printarg(struct format *f, struct pnode *n)
1.4 kristaps 430: {
1.101 schwarze 431: struct pnode *nc;
432: struct pattr *a;
1.103 schwarze 433: int isop, isrep, was_impl;
1.12 kristaps 434:
435: isop = 1;
1.103 schwarze 436: isrep = was_impl = 0;
1.101 schwarze 437: TAILQ_FOREACH(a, &n->attrq, child) {
438: if (a->key == ATTRKEY_CHOICE &&
439: (a->val == ATTRVAL_PLAIN || a->val == ATTRVAL_REQ))
1.12 kristaps 440: isop = 0;
1.101 schwarze 441: else if (a->key == ATTRKEY_REP && a->val == ATTRVAL_REPEAT)
1.12 kristaps 442: isrep = 1;
443: }
1.103 schwarze 444: if (isop) {
445: if (f->flags & FMT_IMPL) {
446: was_impl = 1;
447: macro_open(f, "Oo");
448: } else {
449: macro_open(f, "Op");
450: f->flags |= FMT_IMPL;
451: }
452: }
1.4 kristaps 453:
1.101 schwarze 454: TAILQ_FOREACH(nc, &n->childq, child) {
455: if (nc->node == NODE_TEXT)
456: macro_open(f, "Ar");
457: pnode_print(f, nc);
458: if (isrep && nc->node == NODE_TEXT)
459: macro_addarg(f, "...", ARG_SPACE);
1.10 kristaps 460: }
1.103 schwarze 461: if (isop) {
462: if (was_impl)
463: macro_open(f, "Oc");
464: else
465: f->flags &= ~FMT_IMPL;
466: }
1.101 schwarze 467: pnode_unlinksub(n);
1.4 kristaps 468: }
469:
1.24 kristaps 470: static void
1.101 schwarze 471: pnode_printgroup(struct format *f, struct pnode *n)
1.24 kristaps 472: {
1.101 schwarze 473: struct pnode *nc, *nn;
474: struct pattr *a;
1.24 kristaps 475: int isop, sv;
476:
477: isop = 1;
1.101 schwarze 478: TAILQ_FOREACH(a, &n->attrq, child)
479: if (a->key == ATTRKEY_CHOICE &&
480: (a->val == ATTRVAL_PLAIN || a->val == ATTRVAL_REQ)) {
1.24 kristaps 481: isop = 0;
482: break;
483: }
484:
1.44 schwarze 485: /*
1.24 kristaps 486: * Make sure we're on a macro line.
487: * This will prevent pnode_print() for putting us on a
488: * subsequent line.
489: */
1.101 schwarze 490: sv = f->linestate == LINE_NEW;
1.44 schwarze 491: if (isop)
1.101 schwarze 492: macro_open(f, "Op");
1.24 kristaps 493: else if (sv)
1.101 schwarze 494: macro_open(f, "No");
1.103 schwarze 495: f->flags |= FMT_IMPL;
1.24 kristaps 496:
497: /*
498: * Keep on printing text separated by the vertical bar as long
499: * as we're within the same origin node as the group.
500: * This is kind of a nightmare.
501: * Eh, DocBook...
502: * FIXME: if there's a "Fl", we don't cut off the leading "-"
503: * like we do in pnode_print().
504: */
1.101 schwarze 505: TAILQ_FOREACH(nc, &n->childq, child) {
506: pnode_print(f, nc);
507: nn = TAILQ_NEXT(nc, child);
508: while (nn != NULL) {
509: if (nc->node != nn->node)
1.24 kristaps 510: break;
1.101 schwarze 511: macro_addarg(f, "|", ARG_SPACE);
512: macro_addnode(f, nn, ARG_SPACE);
513: nc = nn;
514: nn = TAILQ_NEXT(nn, child);
1.24 kristaps 515: }
516: }
1.69 schwarze 517: if (sv)
1.101 schwarze 518: macro_close(f);
1.103 schwarze 519: f->flags &= ~FMT_IMPL;
1.101 schwarze 520: pnode_unlinksub(n);
1.24 kristaps 521: }
522:
1.7 kristaps 523: static void
1.78 schwarze 524: pnode_printauthor(struct format *f, struct pnode *n)
525: {
1.101 schwarze 526: struct pnode *nc, *nn;
1.78 schwarze 527: int have_contrib, have_name;
528:
529: /*
530: * Print <contrib> children up front, before the .An scope,
531: * and figure out whether we a name of a person.
532: */
533:
534: have_contrib = have_name = 0;
1.101 schwarze 535: TAILQ_FOREACH_SAFE(nc, &n->childq, child, nn) {
1.78 schwarze 536: switch (nc->node) {
537: case NODE_CONTRIB:
538: if (have_contrib)
539: print_text(f, ",", 0);
540: print_textnode(f, nc);
541: pnode_unlink(nc);
542: have_contrib = 1;
543: break;
544: case NODE_PERSONNAME:
545: have_name = 1;
546: break;
547: default:
548: break;
549: }
550: }
551: if (TAILQ_FIRST(&n->childq) == NULL)
552: return;
553:
554: if (have_contrib)
555: print_text(f, ":", 0);
556:
557: /*
558: * If we have a name, print it in the .An scope and leave
559: * all other content for child handlers, to print after the
560: * scope. Otherwise, print everything in the scope.
561: */
562:
563: macro_open(f, "An");
1.101 schwarze 564: TAILQ_FOREACH_SAFE(nc, &n->childq, child, nn) {
1.78 schwarze 565: if (nc->node == NODE_PERSONNAME || have_name == 0) {
566: macro_addnode(f, nc, ARG_SPACE);
567: pnode_unlink(nc);
568: }
1.80 schwarze 569: }
570:
571: /*
572: * If there is an email address,
573: * print it on the same macro line.
574: */
575:
576: if ((nc = pnode_findfirst(n, NODE_EMAIL)) != NULL) {
1.103 schwarze 577: f->flags |= FMT_CHILD;
1.80 schwarze 578: pnode_print(f, nc);
579: pnode_unlink(nc);
1.78 schwarze 580: }
581:
582: /*
583: * If there are still unprinted children, end the scope
584: * with a comma. Otherwise, leave the scope open in case
585: * a text node follows that starts with closing punctuation.
586: */
587:
588: if (TAILQ_FIRST(&n->childq) != NULL) {
589: macro_addarg(f, ",", ARG_SPACE);
590: macro_close(f);
591: }
592: }
593:
594: static void
1.96 schwarze 595: pnode_printlink(struct format *f, struct pnode *n)
596: {
1.109 schwarze 597: struct pnode *nc;
1.96 schwarze 598: const char *uri, *text;
599:
600: uri = pnode_getattr_raw(n, ATTRKEY_LINKEND, NULL);
601: if (uri != NULL) {
602: if (TAILQ_FIRST(&n->childq) != NULL) {
1.109 schwarze 603: TAILQ_FOREACH(nc, &n->childq, child)
604: pnode_print(f, nc);
1.96 schwarze 605: text = "";
1.109 schwarze 606: } else if ((text = pnode_getattr_raw(n,
607: ATTRKEY_ENDTERM, NULL)) != NULL) {
608: if (f->linestate == LINE_MACRO && f->flags & FMT_ARG)
609: macro_addarg(f, text, ARG_SPACE);
610: else
1.96 schwarze 611: print_text(f, text, ARG_SPACE);
612: }
1.103 schwarze 613: if (text != NULL) {
1.109 schwarze 614: if (f->flags & FMT_IMPL)
615: macro_open(f, "Po");
616: else {
617: macro_open(f, "Pq");
618: f->flags |= FMT_CHILD;
619: }
1.103 schwarze 620: }
1.96 schwarze 621: macro_open(f, "Sx");
622: macro_addarg(f, uri, ARG_SPACE);
1.109 schwarze 623: if (text != NULL && f->flags & FMT_IMPL)
624: macro_open(f, "Pc");
1.96 schwarze 625: pnode_unlinksub(n);
626: return;
627: }
628: uri = pnode_getattr_raw(n, ATTRKEY_XLINK_HREF, NULL);
629: if (uri == NULL)
630: uri = pnode_getattr_raw(n, ATTRKEY_URL, NULL);
631: if (uri != NULL) {
632: macro_open(f, "Lk");
633: macro_addarg(f, uri, ARG_SPACE | ARG_SINGLE);
634: if (TAILQ_FIRST(&n->childq) != NULL)
635: macro_addnode(f, n, ARG_SPACE | ARG_SINGLE);
636: pnode_unlinksub(n);
637: return;
638: }
639: }
640:
641: static void
1.101 schwarze 642: pnode_printprologue(struct format *f, struct ptree *tree)
1.7 kristaps 643: {
1.74 schwarze 644: struct pnode *refmeta;
1.7 kristaps 645:
1.74 schwarze 646: refmeta = tree->root == NULL ? NULL :
647: pnode_findfirst(tree->root, NODE_REFMETA);
1.9 kristaps 648:
1.101 schwarze 649: macro_line(f, "Dd $Mdocdate" "$");
1.74 schwarze 650: if (refmeta == NULL) {
1.101 schwarze 651: macro_open(f, "Dt");
652: macro_addarg(f,
1.74 schwarze 653: pnode_getattr_raw(tree->root, ATTRKEY_ID, "UNKNOWN"),
1.72 schwarze 654: ARG_SPACE | ARG_SINGLE | ARG_UPPER);
1.101 schwarze 655: macro_addarg(f, "1", ARG_SPACE);
656: macro_close(f);
1.74 schwarze 657: } else
1.101 schwarze 658: pnode_printrefmeta(f, refmeta);
659: macro_line(f, "Os");
1.43 kristaps 660:
1.74 schwarze 661: if (tree->flags & TREE_EQN) {
1.101 schwarze 662: macro_line(f, "EQ");
663: print_text(f, "delim $$", 0);
664: macro_line(f, "EN");
1.43 kristaps 665: }
1.7 kristaps 666: }
667:
1.42 kristaps 668: /*
669: * We can have multiple <term> elements within a <varlistentry>, which
670: * we should comma-separate as list headers.
671: */
1.13 kristaps 672: static void
1.101 schwarze 673: pnode_printvarlistentry(struct format *f, struct pnode *n)
1.13 kristaps 674: {
1.108 schwarze 675: struct pnode *nc, *nn;
1.42 kristaps 676: int first = 1;
1.13 kristaps 677:
1.101 schwarze 678: macro_open(f, "It");
1.103 schwarze 679: f->flags |= FMT_IMPL;
1.108 schwarze 680: TAILQ_FOREACH_SAFE(nc, &n->childq, child, nn) {
1.101 schwarze 681: if (nc->node != NODE_TERM && nc->node != NODE_GLOSSTERM)
1.69 schwarze 682: continue;
1.108 schwarze 683: if (first == 0) {
684: switch (f->linestate) {
685: case LINE_NEW:
686: break;
687: case LINE_TEXT:
688: print_text(f, ",", 0);
689: break;
690: case LINE_MACRO:
691: macro_addarg(f, ",", 0);
692: break;
693: }
694: }
1.101 schwarze 695: pnode_print(f, nc);
1.108 schwarze 696: pnode_unlink(nc);
1.69 schwarze 697: first = 0;
698: }
1.101 schwarze 699: macro_close(f);
1.108 schwarze 700: while ((nc = TAILQ_FIRST(&n->childq)) != NULL) {
701: pnode_print(f, nc);
702: pnode_unlink(nc);
703: }
704: macro_close(f);
1.71 schwarze 705: }
706:
707: static void
1.101 schwarze 708: pnode_printtitle(struct format *f, struct pnode *n)
1.71 schwarze 709: {
1.101 schwarze 710: struct pnode *nc, *nn;
1.71 schwarze 711:
1.101 schwarze 712: TAILQ_FOREACH_SAFE(nc, &n->childq, child, nn) {
713: if (nc->node == NODE_TITLE) {
714: pnode_printpara(f, nc);
715: pnode_print(f, nc);
716: pnode_unlink(nc);
1.71 schwarze 717: }
718: }
1.13 kristaps 719: }
720:
721: static void
1.101 schwarze 722: pnode_printrow(struct format *f, struct pnode *n)
1.25 kristaps 723: {
1.101 schwarze 724: struct pnode *nc;
1.25 kristaps 725:
1.101 schwarze 726: macro_line(f, "Bl -dash -compact");
727: TAILQ_FOREACH(nc, &n->childq, child) {
728: macro_line(f, "It");
729: pnode_print(f, nc);
1.25 kristaps 730: }
1.101 schwarze 731: macro_line(f, "El");
732: pnode_unlink(n);
1.25 kristaps 733: }
734:
735: static void
1.83 schwarze 736: pnode_printtgroup1(struct format *f, struct pnode *n)
1.16 kristaps 737: {
1.82 schwarze 738: struct pnode *nc;
739:
1.83 schwarze 740: macro_line(f, "Bl -bullet -compact");
1.82 schwarze 741: while ((nc = pnode_findfirst(n, NODE_ENTRY)) != NULL) {
1.83 schwarze 742: macro_line(f, "It");
743: pnode_print(f, nc);
1.82 schwarze 744: pnode_unlink(nc);
745: }
1.83 schwarze 746: macro_line(f, "El");
747: pnode_unlinksub(n);
748: }
749:
750: static void
751: pnode_printtgroup2(struct format *f, struct pnode *n)
752: {
753: struct pnode *nr, *ne;
754:
755: macro_line(f, "Bl -tag -width Ds");
756: while ((nr = pnode_findfirst(n, NODE_ROW)) != NULL) {
757: if ((ne = pnode_findfirst(n, NODE_ENTRY)) == NULL)
758: break;
759: macro_open(f, "It");
1.103 schwarze 760: f->flags |= FMT_IMPL;
1.83 schwarze 761: pnode_print(f, ne);
1.84 schwarze 762: macro_close(f);
1.83 schwarze 763: pnode_unlink(ne);
764: pnode_print(f, nr);
765: pnode_unlink(nr);
766: }
767: macro_line(f, "El");
1.82 schwarze 768: pnode_unlinksub(n);
769: }
770:
771: static void
1.83 schwarze 772: pnode_printtgroup(struct format *f, struct pnode *n)
1.82 schwarze 773: {
774: struct pnode *nc;
775:
776: switch (atoi(pnode_getattr_raw(n, ATTRKEY_COLS, "0"))) {
777: case 1:
1.83 schwarze 778: pnode_printtgroup1(f, n);
779: return;
780: case 2:
781: pnode_printtgroup2(f, n);
1.82 schwarze 782: return;
783: default:
784: break;
785: }
1.16 kristaps 786:
1.83 schwarze 787: macro_line(f, "Bl -ohang");
1.82 schwarze 788: while ((nc = pnode_findfirst(n, NODE_ROW)) != NULL) {
1.83 schwarze 789: macro_line(f, "It Table Row");
790: pnode_printrow(f, nc);
1.25 kristaps 791: }
1.83 schwarze 792: macro_line(f, "El");
1.82 schwarze 793: pnode_unlinksub(n);
1.25 kristaps 794: }
795:
796: static void
1.101 schwarze 797: pnode_printlist(struct format *f, struct pnode *n)
1.25 kristaps 798: {
1.101 schwarze 799: struct pnode *nc;
1.16 kristaps 800:
1.101 schwarze 801: pnode_printtitle(f, n);
802: macro_argline(f, "Bl",
803: n->node == NODE_ORDEREDLIST ? "-enum" : "-bullet");
804: TAILQ_FOREACH(nc, &n->childq, child) {
805: macro_line(f, "It");
806: pnode_print(f, nc);
1.16 kristaps 807: }
1.101 schwarze 808: macro_line(f, "El");
809: pnode_unlinksub(n);
1.16 kristaps 810: }
811:
812: static void
1.101 schwarze 813: pnode_printvariablelist(struct format *f, struct pnode *n)
1.13 kristaps 814: {
1.101 schwarze 815: struct pnode *nc;
1.13 kristaps 816:
1.101 schwarze 817: pnode_printtitle(f, n);
818: macro_line(f, "Bl -tag -width Ds");
819: TAILQ_FOREACH(nc, &n->childq, child) {
820: if (nc->node == NODE_VARLISTENTRY)
821: pnode_printvarlistentry(f, nc);
1.69 schwarze 822: else
1.101 schwarze 823: macro_nodeline(f, "It", nc, 0);
1.69 schwarze 824: }
1.101 schwarze 825: macro_line(f, "El");
826: pnode_unlinksub(n);
1.13 kristaps 827: }
828:
1.1 kristaps 829: /*
830: * Print a parsed node (or ignore it--whatever).
831: * This is a recursive function.
1.23 kristaps 832: * FIXME: if we're in a literal context (<screen> or <programlisting> or
833: * whatever), don't print inline macros.
1.1 kristaps 834: */
835: static void
1.101 schwarze 836: pnode_print(struct format *f, struct pnode *n)
1.1 kristaps 837: {
1.102 schwarze 838: struct pnode *nc, *nn;
1.69 schwarze 839: enum linestate sv;
1.1 kristaps 840:
1.101 schwarze 841: if (n == NULL)
1.1 kristaps 842: return;
843:
1.101 schwarze 844: sv = f->linestate;
1.103 schwarze 845: if (n->spc)
846: f->flags &= ~FMT_NOSPC;
847: else
848: f->flags |= FMT_NOSPC;
1.1 kristaps 849:
1.101 schwarze 850: switch (n->node) {
1.62 schwarze 851: case NODE_APPLICATION:
1.101 schwarze 852: macro_open(f, "Nm");
1.27 kristaps 853: break;
1.62 schwarze 854: case NODE_ARG:
1.101 schwarze 855: pnode_printarg(f, n);
1.4 kristaps 856: break;
1.62 schwarze 857: case NODE_AUTHOR:
1.101 schwarze 858: pnode_printauthor(f, n);
1.50 schwarze 859: break;
1.62 schwarze 860: case NODE_AUTHORGROUP:
1.101 schwarze 861: macro_line(f, "An -split");
1.50 schwarze 862: break;
1.98 schwarze 863: case NODE_BLOCKQUOTE:
1.101 schwarze 864: macro_line(f, "Bd -ragged -offset indent");
1.98 schwarze 865: break;
1.62 schwarze 866: case NODE_BOOKINFO:
1.101 schwarze 867: macro_line(f, "Sh NAME");
1.50 schwarze 868: break;
1.62 schwarze 869: case NODE_CITEREFENTRY:
1.101 schwarze 870: pnode_printciterefentry(f, n);
1.1 kristaps 871: break;
1.68 schwarze 872: case NODE_CITETITLE:
1.101 schwarze 873: macro_open(f, "%T");
1.68 schwarze 874: break;
1.62 schwarze 875: case NODE_COMMAND:
1.101 schwarze 876: macro_open(f, "Nm");
1.13 kristaps 877: break;
1.62 schwarze 878: case NODE_CONSTANT:
1.101 schwarze 879: macro_open(f, "Dv");
1.33 kristaps 880: break;
1.62 schwarze 881: case NODE_EDITOR:
1.101 schwarze 882: print_text(f, "editor:", ARG_SPACE);
1.92 schwarze 883: sv = LINE_TEXT;
1.101 schwarze 884: macro_open(f, "An");
1.50 schwarze 885: break;
1.65 schwarze 886: case NODE_EMAIL:
1.101 schwarze 887: macro_open(f, "Aq Mt");
1.65 schwarze 888: break;
1.62 schwarze 889: case NODE_EMPHASIS:
890: case NODE_FIRSTTERM:
1.99 schwarze 891: case NODE_GLOSSTERM:
1.101 schwarze 892: macro_open(f, "Em");
1.1 kristaps 893: break;
1.62 schwarze 894: case NODE_ENVAR:
1.101 schwarze 895: macro_open(f, "Ev");
1.79 schwarze 896: break;
1.90 schwarze 897: case NODE_ERRORNAME:
1.101 schwarze 898: macro_open(f, "Er");
1.90 schwarze 899: break;
1.62 schwarze 900: case NODE_FILENAME:
1.101 schwarze 901: macro_open(f, "Pa");
1.17 kristaps 902: break;
1.62 schwarze 903: case NODE_FUNCTION:
1.101 schwarze 904: macro_open(f, "Fn");
1.3 kristaps 905: break;
1.62 schwarze 906: case NODE_FUNCPROTOTYPE:
1.101 schwarze 907: pnode_printfuncprototype(f, n);
1.3 kristaps 908: break;
1.62 schwarze 909: case NODE_FUNCSYNOPSISINFO:
1.101 schwarze 910: macro_open(f, "Fd");
1.16 kristaps 911: break;
1.62 schwarze 912: case NODE_INFORMALEQUATION:
1.101 schwarze 913: macro_line(f, "EQ");
1.43 kristaps 914: break;
1.62 schwarze 915: case NODE_INLINEEQUATION:
1.101 schwarze 916: if (f->linestate == LINE_NEW)
917: f->linestate = LINE_TEXT;
1.69 schwarze 918: putchar('$');
1.43 kristaps 919: break;
1.62 schwarze 920: case NODE_ITEMIZEDLIST:
1.101 schwarze 921: pnode_printlist(f, n);
1.24 kristaps 922: break;
1.62 schwarze 923: case NODE_GROUP:
1.101 schwarze 924: pnode_printgroup(f, n);
1.10 kristaps 925: break;
1.67 schwarze 926: case NODE_KEYSYM:
1.101 schwarze 927: macro_open(f, "Sy");
1.67 schwarze 928: break;
1.62 schwarze 929: case NODE_LINK:
1.101 schwarze 930: pnode_printlink(f, n);
1.96 schwarze 931: break;
1.62 schwarze 932: case NODE_LITERAL:
1.101 schwarze 933: macro_open(f, "Ql");
1.19 kristaps 934: break;
1.62 schwarze 935: case NODE_LITERALLAYOUT:
1.101 schwarze 936: macro_close(f);
937: macro_argline(f, "Bd", pnode_getattr(n, ATTRKEY_CLASS) ==
1.66 schwarze 938: ATTRVAL_MONOSPACED ? "-literal" : "-unfilled");
1.60 schwarze 939: break;
1.106 schwarze 940: case NODE_MARKUP:
941: macro_open(f, "Ic");
942: break;
1.62 schwarze 943: case NODE_MML_MFENCED:
1.101 schwarze 944: pnode_printmathfenced(f, n);
1.40 kristaps 945: break;
1.62 schwarze 946: case NODE_MML_MROW:
947: case NODE_MML_MI:
948: case NODE_MML_MN:
949: case NODE_MML_MO:
1.101 schwarze 950: if (TAILQ_EMPTY(&n->childq))
1.43 kristaps 951: break;
952: fputs(" { ", stdout);
1.40 kristaps 953: break;
1.62 schwarze 954: case NODE_MML_MFRAC:
955: case NODE_MML_MSUB:
956: case NODE_MML_MSUP:
1.101 schwarze 957: pnode_printmath(f, n);
1.40 kristaps 958: break;
1.62 schwarze 959: case NODE_OPTION:
1.101 schwarze 960: macro_open(f, "Fl");
1.1 kristaps 961: break;
1.62 schwarze 962: case NODE_ORDEREDLIST:
1.101 schwarze 963: pnode_printlist(f, n);
1.25 kristaps 964: break;
1.62 schwarze 965: case NODE_PARA:
1.101 schwarze 966: pnode_printpara(f, n);
1.3 kristaps 967: break;
1.87 schwarze 968: case NODE_PARAMDEF:
1.62 schwarze 969: case NODE_PARAMETER:
1.104 schwarze 970: /* More often, these appear inside NODE_FUNCPROTOTYPE. */
971: macro_open(f, "Fa");
972: macro_addnode(f, n, ARG_SPACE | ARG_SINGLE);
1.101 schwarze 973: pnode_unlinksub(n);
1.1 kristaps 974: break;
1.62 schwarze 975: case NODE_QUOTE:
1.101 schwarze 976: macro_open(f, "Qo");
1.28 kristaps 977: break;
1.62 schwarze 978: case NODE_PROGRAMLISTING:
979: case NODE_SCREEN:
1.88 schwarze 980: case NODE_SYNOPSIS:
1.101 schwarze 981: macro_line(f, "Bd -literal");
1.15 kristaps 982: break;
1.62 schwarze 983: case NODE_REFENTRYINFO:
1.15 kristaps 984: /* Suppress. */
1.101 schwarze 985: pnode_unlinksub(n);
1.1 kristaps 986: break;
1.62 schwarze 987: case NODE_REFNAME:
1.110 ! schwarze 988: /* More often, these appear inside NODE_REFNAMEDIV. */
1.101 schwarze 989: macro_open(f, "Nm");
1.10 kristaps 990: break;
1.62 schwarze 991: case NODE_REFNAMEDIV:
1.110 ! schwarze 992: pnode_printrefnamediv(f, n);
1.1 kristaps 993: break;
1.62 schwarze 994: case NODE_REFPURPOSE:
1.101 schwarze 995: macro_open(f, "Nd");
1.10 kristaps 996: break;
1.62 schwarze 997: case NODE_REFSYNOPSISDIV:
1.101 schwarze 998: pnode_printrefsynopsisdiv(f, n);
1.1 kristaps 999: break;
1.62 schwarze 1000: case NODE_PREFACE:
1001: case NODE_SECTION:
1.100 schwarze 1002: case NODE_APPENDIX:
1003: case NODE_LEGALNOTICE:
1.62 schwarze 1004: case NODE_NOTE:
1005: case NODE_TIP:
1006: case NODE_CAUTION:
1007: case NODE_WARNING:
1.101 schwarze 1008: pnode_printrefsect(f, n);
1.1 kristaps 1009: break;
1.62 schwarze 1010: case NODE_REPLACEABLE:
1.101 schwarze 1011: macro_open(f, "Ar");
1.13 kristaps 1012: break;
1.62 schwarze 1013: case NODE_SBR:
1.101 schwarze 1014: macro_line(f, "br");
1.25 kristaps 1015: break;
1.62 schwarze 1016: case NODE_TEXT:
1.93 schwarze 1017: case NODE_ESCAPE:
1.101 schwarze 1018: pnode_printtext(f, n);
1.1 kristaps 1019: break;
1.82 schwarze 1020: case NODE_TGROUP:
1.101 schwarze 1021: pnode_printtgroup(f, n);
1.82 schwarze 1022: break;
1.62 schwarze 1023: case NODE_TITLE:
1.101 schwarze 1024: if (n->parent != NULL &&
1025: n->parent->node == NODE_BOOKINFO) {
1026: macro_open(f, "Nd");
1.82 schwarze 1027: break;
1028: }
1.101 schwarze 1029: pnode_printpara(f, n);
1030: macro_nodeline(f, "Sy", n, 0);
1031: pnode_unlinksub(n);
1.50 schwarze 1032: break;
1.62 schwarze 1033: case NODE_TYPE:
1.101 schwarze 1034: macro_open(f, "Vt");
1.39 kristaps 1035: break;
1.62 schwarze 1036: case NODE_VARIABLELIST:
1.101 schwarze 1037: pnode_printvariablelist(f, n);
1.13 kristaps 1038: break;
1.62 schwarze 1039: case NODE_VARNAME:
1.101 schwarze 1040: macro_open(f, "Va");
1.23 kristaps 1041: break;
1.1 kristaps 1042: default:
1043: break;
1044: }
1045:
1.102 schwarze 1046: TAILQ_FOREACH(nc, &n->childq, child)
1047: pnode_print(f, nc);
1.1 kristaps 1048:
1.101 schwarze 1049: switch (n->node) {
1.103 schwarze 1050: case NODE_ESCAPE:
1051: case NODE_TERM:
1052: case NODE_TEXT:
1053: /* Accept more arguments to the previous macro. */
1054: return;
1.62 schwarze 1055: case NODE_INFORMALEQUATION:
1.101 schwarze 1056: macro_line(f, "EN");
1.40 kristaps 1057: break;
1.62 schwarze 1058: case NODE_INLINEEQUATION:
1.43 kristaps 1059: fputs("$ ", stdout);
1.101 schwarze 1060: f->linestate = sv;
1.43 kristaps 1061: break;
1.91 schwarze 1062: case NODE_MEMBER:
1.102 schwarze 1063: if ((nn = TAILQ_NEXT(n, child)) != NULL &&
1064: nn->node != NODE_MEMBER)
1065: nn = NULL;
1.101 schwarze 1066: switch (f->linestate) {
1.91 schwarze 1067: case LINE_TEXT:
1.102 schwarze 1068: if (nn != NULL)
1.101 schwarze 1069: print_text(f, ",", 0);
1.91 schwarze 1070: break;
1071: case LINE_MACRO:
1.102 schwarze 1072: if (nn != NULL)
1.101 schwarze 1073: macro_addarg(f, ",", ARG_SPACE);
1074: macro_close(f);
1.91 schwarze 1075: break;
1076: case LINE_NEW:
1077: break;
1078: }
1079: break;
1.62 schwarze 1080: case NODE_MML_MROW:
1081: case NODE_MML_MI:
1082: case NODE_MML_MN:
1083: case NODE_MML_MO:
1.101 schwarze 1084: if (TAILQ_EMPTY(&n->childq))
1.43 kristaps 1085: break;
1086: fputs(" } ", stdout);
1.40 kristaps 1087: break;
1.62 schwarze 1088: case NODE_QUOTE:
1.69 schwarze 1089: if (sv == LINE_NEW)
1.101 schwarze 1090: macro_close(f);
1091: sv = f->linestate;
1092: macro_open(f, "Qc");
1.69 schwarze 1093: if (sv == LINE_NEW)
1.101 schwarze 1094: macro_close(f);
1.52 schwarze 1095: break;
1.62 schwarze 1096: case NODE_PREFACE:
1097: case NODE_SECTION:
1.100 schwarze 1098: case NODE_APPENDIX:
1099: case NODE_LEGALNOTICE:
1.62 schwarze 1100: case NODE_NOTE:
1101: case NODE_TIP:
1102: case NODE_CAUTION:
1103: case NODE_WARNING:
1.101 schwarze 1104: f->level--;
1.12 kristaps 1105: break;
1.98 schwarze 1106: case NODE_BLOCKQUOTE:
1.62 schwarze 1107: case NODE_LITERALLAYOUT:
1108: case NODE_PROGRAMLISTING:
1109: case NODE_SCREEN:
1.88 schwarze 1110: case NODE_SYNOPSIS:
1.101 schwarze 1111: macro_line(f, "Ed");
1.50 schwarze 1112: break;
1.62 schwarze 1113: case NODE_TITLE:
1.101 schwarze 1114: if (n->parent != NULL &&
1115: n->parent->node == NODE_BOOKINFO)
1116: macro_line(f, "Sh AUTHORS");
1.1 kristaps 1117: break;
1118: default:
1119: break;
1120: }
1.103 schwarze 1121: f->flags &= ~FMT_ARG;
1.1 kristaps 1122: }
1123:
1.74 schwarze 1124: void
1125: ptree_print(struct ptree *tree)
1126: {
1127: struct format formatter;
1.1 kristaps 1128:
1.74 schwarze 1129: formatter.level = 0;
1130: formatter.linestate = LINE_NEW;
1131: pnode_printprologue(&formatter, tree);
1132: pnode_print(&formatter, tree->root);
1133: if (formatter.linestate != LINE_NEW)
1134: putchar('\n');
1.1 kristaps 1135: }
CVSweb
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to docbook2mdoc.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [cvsweb.bsd.lv] / docbook2mdoc