![[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.13 ! schwarze 1: /* $Id: tree.c,v 1.12 2011/01/16 01:11:50 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.1 kristaps 91: default:
92: abort();
93: /* NOTREACHED */
94: }
95:
1.11 schwarze 96: p = NULL;
97:
1.1 kristaps 98: switch (n->type) {
99: case (MDOC_TEXT):
100: p = n->string;
101: break;
102: case (MDOC_BODY):
103: p = mdoc_macronames[n->tok];
104: break;
105: case (MDOC_HEAD):
106: p = mdoc_macronames[n->tok];
107: break;
108: case (MDOC_TAIL):
109: p = mdoc_macronames[n->tok];
110: break;
111: case (MDOC_ELEM):
112: p = mdoc_macronames[n->tok];
113: if (n->args) {
114: argv = n->args->argv;
115: argc = n->args->argc;
116: }
117: break;
118: case (MDOC_BLOCK):
119: p = mdoc_macronames[n->tok];
120: if (n->args) {
121: argv = n->args->argv;
122: argc = n->args->argc;
123: }
124: break;
1.11 schwarze 125: case (MDOC_TBL):
126: break;
1.1 kristaps 127: case (MDOC_ROOT):
128: p = "root";
129: break;
130: default:
131: abort();
132: /* NOTREACHED */
133: }
134:
1.11 schwarze 135: if (n->span) {
136: assert(NULL == p);
137: print_span(n->span, indent);
138: } else {
139: for (i = 0; i < indent; i++)
140: putchar('\t');
141:
142: printf("%s (%s)", p, t);
143:
144: for (i = 0; i < (int)argc; i++) {
145: printf(" -%s", mdoc_argnames[argv[i].arg]);
146: if (argv[i].sz > 0)
147: printf(" [");
148: for (j = 0; j < (int)argv[i].sz; j++)
149: printf(" [%s]", argv[i].value[j]);
150: if (argv[i].sz > 0)
151: printf(" ]");
152: }
153:
154: for (i = 0; i < (int)sz; i++)
155: printf(" [%s]", params[i]);
1.1 kristaps 156:
1.11 schwarze 157: printf(" %d:%d", n->line, n->pos);
1.1 kristaps 158: }
159:
1.11 schwarze 160: putchar('\n');
1.1 kristaps 161:
162: if (n->child)
163: print_mdoc(n->child, indent + 1);
164: if (n->next)
165: print_mdoc(n->next, indent);
166: }
167:
168:
169: static void
170: print_man(const struct man_node *n, int indent)
171: {
172: const char *p, *t;
173: int i;
174:
175: switch (n->type) {
176: case (MAN_ROOT):
177: t = "root";
178: break;
179: case (MAN_ELEM):
180: t = "elem";
181: break;
182: case (MAN_TEXT):
183: t = "text";
184: break;
1.3 schwarze 185: case (MAN_BLOCK):
186: t = "block";
187: break;
188: case (MAN_HEAD):
189: t = "block-head";
190: break;
191: case (MAN_BODY):
192: t = "block-body";
193: break;
1.11 schwarze 194: case (MAN_TBL):
195: t = "tbl";
196: break;
1.1 kristaps 197: default:
198: abort();
199: /* NOTREACHED */
200: }
201:
1.11 schwarze 202: p = NULL;
203:
1.1 kristaps 204: switch (n->type) {
205: case (MAN_TEXT):
206: p = n->string;
207: break;
208: case (MAN_ELEM):
1.3 schwarze 209: /* FALLTHROUGH */
210: case (MAN_BLOCK):
211: /* FALLTHROUGH */
212: case (MAN_HEAD):
213: /* FALLTHROUGH */
214: case (MAN_BODY):
1.1 kristaps 215: p = man_macronames[n->tok];
216: break;
217: case (MAN_ROOT):
218: p = "root";
219: break;
1.11 schwarze 220: case (MAN_TBL):
221: break;
1.1 kristaps 222: default:
223: abort();
224: /* NOTREACHED */
225: }
226:
1.11 schwarze 227: if (n->span) {
228: assert(NULL == p);
229: print_span(n->span, indent);
230: } else {
231: for (i = 0; i < indent; i++)
232: putchar('\t');
233: printf("%s (%s) %d:%d", p, t, n->line, n->pos);
234: }
235:
236: putchar('\n');
1.1 kristaps 237:
238: if (n->child)
239: print_man(n->child, indent + 1);
240: if (n->next)
241: print_man(n->next, indent);
1.11 schwarze 242: }
243:
244: static void
245: print_span(const struct tbl_span *sp, int indent)
246: {
247: const struct tbl_dat *dp;
248: int i;
249:
250: for (i = 0; i < indent; i++)
251: putchar('\t');
252:
253: switch (sp->pos) {
254: case (TBL_SPAN_HORIZ):
255: putchar('-');
256: return;
257: case (TBL_SPAN_DHORIZ):
258: putchar('=');
259: return;
260: default:
261: break;
262: }
263:
264: for (dp = sp->first; dp; dp = dp->next) {
265: switch (dp->pos) {
266: case (TBL_DATA_HORIZ):
267: /* FALLTHROUGH */
268: case (TBL_DATA_NHORIZ):
269: putchar('-');
270: continue;
271: case (TBL_DATA_DHORIZ):
272: /* FALLTHROUGH */
273: case (TBL_DATA_NDHORIZ):
274: putchar('=');
275: continue;
276: default:
277: break;
278: }
1.12 schwarze 279: printf("[\"%s\"", dp->string ? dp->string : "");
280: if (dp->spans)
281: printf("(%d)", dp->spans);
282: if (NULL == dp->layout)
283: putchar('*');
284: putchar(']');
1.13 ! schwarze 285: putchar(' ');
1.11 schwarze 286: }
1.13 ! schwarze 287:
! 288: printf("(tbl) %d:1", sp->line);
1.1 kristaps 289: }