1 /* $Id: tree.c,v 1.47 2011/09/18 14:14:15 schwarze Exp $ */
2 /*
3 * Copyright (c) 2008, 2009, 2011 Kristaps Dzonsons <kristaps@bsd.lv>
4 *
5 * Permission to use, copy, modify, and distribute this software for any
6 * purpose with or without fee is hereby granted, provided that the above
7 * copyright notice and this permission notice appear in all copies.
8 *
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.
16 */
17 #ifdef HAVE_CONFIG_H
18 #include "config.h"
19 #endif
20
21 #include <assert.h>
22 #include <limits.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <time.h>
26
27 #include "mandoc.h"
28 #include "mdoc.h"
29 #include "man.h"
30 #include "main.h"
31
32 static void print_box(const struct eqn_box *, int);
33 static void print_man(const struct man_node *, int);
34 static void print_mdoc(const struct mdoc_node *, int);
35 static void print_span(const struct tbl_span *, int);
36
37
38 /* ARGSUSED */
39 void
40 tree_mdoc(void *arg, const struct mdoc *mdoc)
41 {
42
43 print_mdoc(mdoc_node(mdoc), 0);
44 }
45
46
47 /* ARGSUSED */
48 void
49 tree_man(void *arg, const struct man *man)
50 {
51
52 print_man(man_node(man), 0);
53 }
54
55
56 static void
57 print_mdoc(const struct mdoc_node *n, int indent)
58 {
59 const char *p, *t;
60 int i, j;
61 size_t argc, sz;
62 char **params;
63 struct mdoc_argv *argv;
64
65 argv = NULL;
66 argc = sz = 0;
67 params = NULL;
68 t = p = NULL;
69
70 switch (n->type) {
71 case (MDOC_ROOT):
72 t = "root";
73 break;
74 case (MDOC_BLOCK):
75 t = "block";
76 break;
77 case (MDOC_HEAD):
78 t = "block-head";
79 break;
80 case (MDOC_BODY):
81 if (n->end)
82 t = "body-end";
83 else
84 t = "block-body";
85 break;
86 case (MDOC_TAIL):
87 t = "block-tail";
88 break;
89 case (MDOC_ELEM):
90 t = "elem";
91 break;
92 case (MDOC_TEXT):
93 t = "text";
94 break;
95 case (MDOC_TBL):
96 /* FALLTHROUGH */
97 case (MDOC_EQN):
98 break;
99 default:
100 abort();
101 /* NOTREACHED */
102 }
103
104 switch (n->type) {
105 case (MDOC_TEXT):
106 p = n->string;
107 break;
108 case (MDOC_BODY):
109 p = mdoc_macronames[n->tok];
110 break;
111 case (MDOC_HEAD):
112 p = mdoc_macronames[n->tok];
113 break;
114 case (MDOC_TAIL):
115 p = mdoc_macronames[n->tok];
116 break;
117 case (MDOC_ELEM):
118 p = mdoc_macronames[n->tok];
119 if (n->args) {
120 argv = n->args->argv;
121 argc = n->args->argc;
122 }
123 break;
124 case (MDOC_BLOCK):
125 p = mdoc_macronames[n->tok];
126 if (n->args) {
127 argv = n->args->argv;
128 argc = n->args->argc;
129 }
130 break;
131 case (MDOC_TBL):
132 /* FALLTHROUGH */
133 case (MDOC_EQN):
134 break;
135 case (MDOC_ROOT):
136 p = "root";
137 break;
138 default:
139 abort();
140 /* NOTREACHED */
141 }
142
143 if (n->span) {
144 assert(NULL == p && NULL == t);
145 print_span(n->span, indent);
146 } else if (n->eqn) {
147 assert(NULL == p && NULL == t);
148 print_box(n->eqn->root, indent);
149 } else {
150 for (i = 0; i < indent; i++)
151 putchar('\t');
152
153 printf("%s (%s)", p, t);
154
155 for (i = 0; i < (int)argc; i++) {
156 printf(" -%s", mdoc_argnames[argv[i].arg]);
157 if (argv[i].sz > 0)
158 printf(" [");
159 for (j = 0; j < (int)argv[i].sz; j++)
160 printf(" [%s]", argv[i].value[j]);
161 if (argv[i].sz > 0)
162 printf(" ]");
163 }
164
165 for (i = 0; i < (int)sz; i++)
166 printf(" [%s]", params[i]);
167
168 printf(" %d:%d\n", n->line, n->pos);
169 }
170
171 if (n->child)
172 print_mdoc(n->child, indent + 1);
173 if (n->next)
174 print_mdoc(n->next, indent);
175 }
176
177
178 static void
179 print_man(const struct man_node *n, int indent)
180 {
181 const char *p, *t;
182 int i;
183
184 t = p = NULL;
185
186 switch (n->type) {
187 case (MAN_ROOT):
188 t = "root";
189 break;
190 case (MAN_ELEM):
191 t = "elem";
192 break;
193 case (MAN_TEXT):
194 t = "text";
195 break;
196 case (MAN_BLOCK):
197 t = "block";
198 break;
199 case (MAN_HEAD):
200 t = "block-head";
201 break;
202 case (MAN_BODY):
203 t = "block-body";
204 break;
205 case (MAN_TAIL):
206 t = "block-tail";
207 break;
208 case (MAN_TBL):
209 /* FALLTHROUGH */
210 case (MAN_EQN):
211 break;
212 default:
213 abort();
214 /* NOTREACHED */
215 }
216
217 switch (n->type) {
218 case (MAN_TEXT):
219 p = n->string;
220 break;
221 case (MAN_ELEM):
222 /* FALLTHROUGH */
223 case (MAN_BLOCK):
224 /* FALLTHROUGH */
225 case (MAN_HEAD):
226 /* FALLTHROUGH */
227 case (MAN_TAIL):
228 /* FALLTHROUGH */
229 case (MAN_BODY):
230 p = man_macronames[n->tok];
231 break;
232 case (MAN_ROOT):
233 p = "root";
234 break;
235 case (MAN_TBL):
236 /* FALLTHROUGH */
237 case (MAN_EQN):
238 break;
239 default:
240 abort();
241 /* NOTREACHED */
242 }
243
244 if (n->span) {
245 assert(NULL == p && NULL == t);
246 print_span(n->span, indent);
247 } else if (n->eqn) {
248 assert(NULL == p && NULL == t);
249 print_box(n->eqn->root, indent);
250 } else {
251 for (i = 0; i < indent; i++)
252 putchar('\t');
253 printf("%s (%s) %d:%d\n", p, t, n->line, n->pos);
254 }
255
256 if (n->child)
257 print_man(n->child, indent + 1);
258 if (n->next)
259 print_man(n->next, indent);
260 }
261
262 static void
263 print_box(const struct eqn_box *ep, int indent)
264 {
265 int i;
266 const char *t;
267
268 if (NULL == ep)
269 return;
270 for (i = 0; i < indent; i++)
271 putchar('\t');
272
273 t = NULL;
274 switch (ep->type) {
275 case (EQN_ROOT):
276 t = "eqn-root";
277 break;
278 case (EQN_LIST):
279 t = "eqn-list";
280 break;
281 case (EQN_SUBEXPR):
282 t = "eqn-expr";
283 break;
284 case (EQN_TEXT):
285 t = "eqn-text";
286 break;
287 case (EQN_MATRIX):
288 t = "eqn-matrix";
289 break;
290 }
291
292 assert(t);
293 printf("%s(%d, %d, %d, %d, %d, \"%s\", \"%s\") %s\n",
294 t, EQN_DEFSIZE == ep->size ? 0 : ep->size,
295 ep->pos, ep->font, ep->mark, ep->pile,
296 ep->left ? ep->left : "",
297 ep->right ? ep->right : "",
298 ep->text ? ep->text : "");
299
300 print_box(ep->first, indent + 1);
301 print_box(ep->next, indent);
302 }
303
304 static void
305 print_span(const struct tbl_span *sp, int indent)
306 {
307 const struct tbl_dat *dp;
308 int i;
309
310 for (i = 0; i < indent; i++)
311 putchar('\t');
312
313 switch (sp->pos) {
314 case (TBL_SPAN_HORIZ):
315 putchar('-');
316 return;
317 case (TBL_SPAN_DHORIZ):
318 putchar('=');
319 return;
320 default:
321 break;
322 }
323
324 for (dp = sp->first; dp; dp = dp->next) {
325 switch (dp->pos) {
326 case (TBL_DATA_HORIZ):
327 /* FALLTHROUGH */
328 case (TBL_DATA_NHORIZ):
329 putchar('-');
330 continue;
331 case (TBL_DATA_DHORIZ):
332 /* FALLTHROUGH */
333 case (TBL_DATA_NDHORIZ):
334 putchar('=');
335 continue;
336 default:
337 break;
338 }
339 printf("[\"%s\"", dp->string ? dp->string : "");
340 if (dp->spans)
341 printf("(%d)", dp->spans);
342 if (NULL == dp->layout)
343 putchar('*');
344 putchar(']');
345 putchar(' ');
346 }
347
348 printf("(tbl) %d:1\n", sp->line);
349 }