![[BACK]](/icons/back.gif){kind=icon}
Return to tree.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / mandoc|
Return to tree.c CVS log | Up to [local] / src / usr.bin / mandoc |
1.14 ! schwarze 1: /* $Id: tree.c,v 1.13 2011/02/10 00:06:30 schwarze Exp $ */
1.1 kristaps 2: /*
1.11 schwarze 3: * Copyright (c) 2008, 2009, 2011 Kristaps Dzonsons <kristaps@bsd.lv>
1.1 kristaps 4: *
5: * Permission to use, copy, modify, and distribute this software for any
1.2 schwarze 6: * purpose with or without fee is hereby granted, provided that the above
7: * copyright notice and this permission notice appear in all copies.
1.1 kristaps 8: *
1.2 schwarze 9: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15: * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
1.1 kristaps 16: */
17: #include <assert.h>
18: #include <stdio.h>
19: #include <stdlib.h>
1.6 schwarze 20: #include <time.h>
1.1 kristaps 21:
1.7 schwarze 22: #include "mandoc.h"
1.1 kristaps 23: #include "mdoc.h"
24: #include "man.h"
1.5 schwarze 25: #include "main.h"
1.1 kristaps 26:
27: static void print_mdoc(const struct mdoc_node *, int);
28: static void print_man(const struct man_node *, int);
1.11 schwarze 29: static void print_span(const struct tbl_span *, int);
1.1 kristaps 30:
31:
32: /* ARGSUSED */
1.4 schwarze 33: void
1.1 kristaps 34: tree_mdoc(void *arg, const struct mdoc *mdoc)
35: {
36:
37: print_mdoc(mdoc_node(mdoc), 0);
38: }
39:
40:
41: /* ARGSUSED */
1.4 schwarze 42: void
1.1 kristaps 43: tree_man(void *arg, const struct man *man)
44: {
45:
46: print_man(man_node(man), 0);
47: }
48:
49:
50: static void
51: print_mdoc(const struct mdoc_node *n, int indent)
52: {
53: const char *p, *t;
54: int i, j;
55: size_t argc, sz;
56: char **params;
57: struct mdoc_argv *argv;
58:
59: argv = NULL;
60: argc = sz = 0;
61: params = NULL;
62:
63: switch (n->type) {
64: case (MDOC_ROOT):
65: t = "root";
66: break;
67: case (MDOC_BLOCK):
68: t = "block";
69: break;
70: case (MDOC_HEAD):
71: t = "block-head";
72: break;
73: case (MDOC_BODY):
1.9 schwarze 74: if (n->end)
75: t = "body-end";
76: else
77: t = "block-body";
1.1 kristaps 78: break;
79: case (MDOC_TAIL):
80: t = "block-tail";
81: break;
82: case (MDOC_ELEM):
83: t = "elem";
84: break;
85: case (MDOC_TEXT):
86: t = "text";
87: break;
1.11 schwarze 88: case (MDOC_TBL):
89: t = "tbl";
90: break;
1.14 ! schwarze 91: case (MDOC_EQN):
! 92: t = "eqn";
! 93: break;
1.1 kristaps 94: default:
95: abort();
96: /* NOTREACHED */
97: }
98:
1.11 schwarze 99: p = NULL;
100:
1.1 kristaps 101: switch (n->type) {
102: case (MDOC_TEXT):
103: p = n->string;
104: break;
105: case (MDOC_BODY):
106: p = mdoc_macronames[n->tok];
107: break;
108: case (MDOC_HEAD):
109: p = mdoc_macronames[n->tok];
110: break;
111: case (MDOC_TAIL):
112: p = mdoc_macronames[n->tok];
113: break;
114: case (MDOC_ELEM):
115: p = mdoc_macronames[n->tok];
116: if (n->args) {
117: argv = n->args->argv;
118: argc = n->args->argc;
119: }
120: break;
121: case (MDOC_BLOCK):
122: p = mdoc_macronames[n->tok];
123: if (n->args) {
124: argv = n->args->argv;
125: argc = n->args->argc;
126: }
127: break;
1.11 schwarze 128: case (MDOC_TBL):
129: break;
1.14 ! schwarze 130: case (MDOC_EQN):
! 131: p = n->eqn->data;
! 132: break;
1.1 kristaps 133: case (MDOC_ROOT):
134: p = "root";
135: break;
136: default:
137: abort();
138: /* NOTREACHED */
139: }
140:
1.11 schwarze 141: if (n->span) {
142: assert(NULL == p);
143: print_span(n->span, indent);
144: } else {
145: for (i = 0; i < indent; i++)
146: putchar('\t');
147:
148: printf("%s (%s)", p, t);
149:
150: for (i = 0; i < (int)argc; i++) {
151: printf(" -%s", mdoc_argnames[argv[i].arg]);
152: if (argv[i].sz > 0)
153: printf(" [");
154: for (j = 0; j < (int)argv[i].sz; j++)
155: printf(" [%s]", argv[i].value[j]);
156: if (argv[i].sz > 0)
157: printf(" ]");
158: }
159:
160: for (i = 0; i < (int)sz; i++)
161: printf(" [%s]", params[i]);
1.1 kristaps 162:
1.11 schwarze 163: printf(" %d:%d", n->line, n->pos);
1.1 kristaps 164: }
165:
1.11 schwarze 166: putchar('\n');
1.1 kristaps 167:
168: if (n->child)
169: print_mdoc(n->child, indent + 1);
170: if (n->next)
171: print_mdoc(n->next, indent);
172: }
173:
174:
175: static void
176: print_man(const struct man_node *n, int indent)
177: {
178: const char *p, *t;
179: int i;
180:
181: switch (n->type) {
182: case (MAN_ROOT):
183: t = "root";
184: break;
185: case (MAN_ELEM):
186: t = "elem";
187: break;
188: case (MAN_TEXT):
189: t = "text";
190: break;
1.3 schwarze 191: case (MAN_BLOCK):
192: t = "block";
193: break;
194: case (MAN_HEAD):
195: t = "block-head";
196: break;
197: case (MAN_BODY):
198: t = "block-body";
199: break;
1.11 schwarze 200: case (MAN_TBL):
201: t = "tbl";
202: break;
1.14 ! schwarze 203: case (MAN_EQN):
! 204: t = "eqn";
! 205: break;
1.1 kristaps 206: default:
207: abort();
208: /* NOTREACHED */
209: }
210:
1.11 schwarze 211: p = NULL;
212:
1.1 kristaps 213: switch (n->type) {
214: case (MAN_TEXT):
215: p = n->string;
216: break;
217: case (MAN_ELEM):
1.3 schwarze 218: /* FALLTHROUGH */
219: case (MAN_BLOCK):
220: /* FALLTHROUGH */
221: case (MAN_HEAD):
222: /* FALLTHROUGH */
223: case (MAN_BODY):
1.1 kristaps 224: p = man_macronames[n->tok];
225: break;
226: case (MAN_ROOT):
227: p = "root";
228: break;
1.11 schwarze 229: case (MAN_TBL):
1.14 ! schwarze 230: break;
! 231: case (MAN_EQN):
! 232: p = n->eqn->data;
1.11 schwarze 233: break;
1.1 kristaps 234: default:
235: abort();
236: /* NOTREACHED */
237: }
238:
1.11 schwarze 239: if (n->span) {
240: assert(NULL == p);
241: print_span(n->span, indent);
242: } else {
243: for (i = 0; i < indent; i++)
244: putchar('\t');
245: printf("%s (%s) %d:%d", p, t, n->line, n->pos);
246: }
247:
248: putchar('\n');
1.1 kristaps 249:
250: if (n->child)
251: print_man(n->child, indent + 1);
252: if (n->next)
253: print_man(n->next, indent);
1.11 schwarze 254: }
255:
256: static void
257: print_span(const struct tbl_span *sp, int indent)
258: {
259: const struct tbl_dat *dp;
260: int i;
261:
262: for (i = 0; i < indent; i++)
263: putchar('\t');
264:
265: switch (sp->pos) {
266: case (TBL_SPAN_HORIZ):
267: putchar('-');
268: return;
269: case (TBL_SPAN_DHORIZ):
270: putchar('=');
271: return;
272: default:
273: break;
274: }
275:
276: for (dp = sp->first; dp; dp = dp->next) {
277: switch (dp->pos) {
278: case (TBL_DATA_HORIZ):
279: /* FALLTHROUGH */
280: case (TBL_DATA_NHORIZ):
281: putchar('-');
282: continue;
283: case (TBL_DATA_DHORIZ):
284: /* FALLTHROUGH */
285: case (TBL_DATA_NDHORIZ):
286: putchar('=');
287: continue;
288: default:
289: break;
290: }
1.12 schwarze 291: printf("[\"%s\"", dp->string ? dp->string : "");
292: if (dp->spans)
293: printf("(%d)", dp->spans);
294: if (NULL == dp->layout)
295: putchar('*');
296: putchar(']');
1.13 schwarze 297: putchar(' ');
1.11 schwarze 298: }
1.13 schwarze 299:
300: printf("(tbl) %d:1", sp->line);
1.1 kristaps 301: }