tree.c (279527) | tree.c (294113) |
---|---|
1/* $Id: tree.c,v 1.62 2015/02/05 00:14:13 schwarze Exp $ */ | 1/* $Id: tree.c,v 1.69 2015/10/12 00:08:16 schwarze Exp $ */ |
2/* 3 * Copyright (c) 2008, 2009, 2011, 2014 Kristaps Dzonsons <kristaps@bsd.lv> 4 * Copyright (c) 2013, 2014, 2015 Ingo Schwarze <schwarze@openbsd.org> 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 * | 2/* 3 * Copyright (c) 2008, 2009, 2011, 2014 Kristaps Dzonsons <kristaps@bsd.lv> 4 * Copyright (c) 2013, 2014, 2015 Ingo Schwarze <schwarze@openbsd.org> 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 AUTHOR DISCLAIMS ALL WARRANTIES | 10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHORS DISCLAIM ALL WARRANTIES |
11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF | 11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF |
12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR | 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 "config.h" 19 20#include <sys/types.h> 21 22#include <assert.h> 23#include <limits.h> 24#include <stdio.h> 25#include <stdlib.h> 26#include <time.h> 27 28#include "mandoc.h" | 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 "config.h" 19 20#include <sys/types.h> 21 22#include <assert.h> 23#include <limits.h> 24#include <stdio.h> 25#include <stdlib.h> 26#include <time.h> 27 28#include "mandoc.h" |
29#include "roff.h" |
|
29#include "mdoc.h" 30#include "man.h" 31#include "main.h" 32 33static void print_box(const struct eqn_box *, int); | 30#include "mdoc.h" 31#include "man.h" 32#include "main.h" 33 34static void print_box(const struct eqn_box *, int); |
34static void print_man(const struct man_node *, int); 35static void print_mdoc(const struct mdoc_node *, int); | 35static void print_man(const struct roff_node *, int); 36static void print_mdoc(const struct roff_node *, int); |
36static void print_span(const struct tbl_span *, int); 37 38 39void | 37static void print_span(const struct tbl_span *, int); 38 39 40void |
40tree_mdoc(void *arg, const struct mdoc *mdoc) | 41tree_mdoc(void *arg, const struct roff_man *mdoc) |
41{ 42 | 42{ 43 |
43 print_mdoc(mdoc_node(mdoc)->child, 0); | 44 print_mdoc(mdoc->first->child, 0); |
44} 45 46void | 45} 46 47void |
47tree_man(void *arg, const struct man *man) | 48tree_man(void *arg, const struct roff_man *man) |
48{ 49 | 49{ 50 |
50 print_man(man_node(man)->child, 0); | 51 print_man(man->first->child, 0); |
51} 52 53static void | 52} 53 54static void |
54print_mdoc(const struct mdoc_node *n, int indent) | 55print_mdoc(const struct roff_node *n, int indent) |
55{ 56 const char *p, *t; 57 int i, j; 58 size_t argc; 59 struct mdoc_argv *argv; 60 61 if (n == NULL) 62 return; 63 64 argv = NULL; 65 argc = 0; 66 t = p = NULL; 67 68 switch (n->type) { | 56{ 57 const char *p, *t; 58 int i, j; 59 size_t argc; 60 struct mdoc_argv *argv; 61 62 if (n == NULL) 63 return; 64 65 argv = NULL; 66 argc = 0; 67 t = p = NULL; 68 69 switch (n->type) { |
69 case MDOC_ROOT: | 70 case ROFFT_ROOT: |
70 t = "root"; 71 break; | 71 t = "root"; 72 break; |
72 case MDOC_BLOCK: | 73 case ROFFT_BLOCK: |
73 t = "block"; 74 break; | 74 t = "block"; 75 break; |
75 case MDOC_HEAD: 76 t = "block-head"; | 76 case ROFFT_HEAD: 77 t = "head"; |
77 break; | 78 break; |
78 case MDOC_BODY: | 79 case ROFFT_BODY: |
79 if (n->end) 80 t = "body-end"; 81 else | 80 if (n->end) 81 t = "body-end"; 82 else |
82 t = "block-body"; | 83 t = "body"; |
83 break; | 84 break; |
84 case MDOC_TAIL: 85 t = "block-tail"; | 85 case ROFFT_TAIL: 86 t = "tail"; |
86 break; | 87 break; |
87 case MDOC_ELEM: | 88 case ROFFT_ELEM: |
88 t = "elem"; 89 break; | 89 t = "elem"; 90 break; |
90 case MDOC_TEXT: | 91 case ROFFT_TEXT: |
91 t = "text"; 92 break; | 92 t = "text"; 93 break; |
93 case MDOC_TBL: | 94 case ROFFT_TBL: |
94 break; | 95 break; |
95 case MDOC_EQN: | 96 case ROFFT_EQN: |
96 t = "eqn"; 97 break; 98 default: 99 abort(); | 97 t = "eqn"; 98 break; 99 default: 100 abort(); |
100 /* NOTREACHED */ | |
101 } 102 103 switch (n->type) { | 101 } 102 103 switch (n->type) { |
104 case MDOC_TEXT: | 104 case ROFFT_TEXT: |
105 p = n->string; 106 break; | 105 p = n->string; 106 break; |
107 case MDOC_BODY: | 107 case ROFFT_BODY: |
108 p = mdoc_macronames[n->tok]; 109 break; | 108 p = mdoc_macronames[n->tok]; 109 break; |
110 case MDOC_HEAD: | 110 case ROFFT_HEAD: |
111 p = mdoc_macronames[n->tok]; 112 break; | 111 p = mdoc_macronames[n->tok]; 112 break; |
113 case MDOC_TAIL: | 113 case ROFFT_TAIL: |
114 p = mdoc_macronames[n->tok]; 115 break; | 114 p = mdoc_macronames[n->tok]; 115 break; |
116 case MDOC_ELEM: | 116 case ROFFT_ELEM: |
117 p = mdoc_macronames[n->tok]; 118 if (n->args) { 119 argv = n->args->argv; 120 argc = n->args->argc; 121 } 122 break; | 117 p = mdoc_macronames[n->tok]; 118 if (n->args) { 119 argv = n->args->argv; 120 argc = n->args->argc; 121 } 122 break; |
123 case MDOC_BLOCK: | 123 case ROFFT_BLOCK: |
124 p = mdoc_macronames[n->tok]; 125 if (n->args) { 126 argv = n->args->argv; 127 argc = n->args->argc; 128 } 129 break; | 124 p = mdoc_macronames[n->tok]; 125 if (n->args) { 126 argv = n->args->argv; 127 argc = n->args->argc; 128 } 129 break; |
130 case MDOC_TBL: | 130 case ROFFT_TBL: |
131 break; | 131 break; |
132 case MDOC_EQN: | 132 case ROFFT_EQN: |
133 p = "EQ"; 134 break; | 133 p = "EQ"; 134 break; |
135 case MDOC_ROOT: | 135 case ROFFT_ROOT: |
136 p = "root"; 137 break; 138 default: 139 abort(); | 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 { 147 for (i = 0; i < indent; i++) 148 putchar(' '); --- 6 unchanged lines hidden (view full) --- 155 printf(" ["); 156 for (j = 0; j < (int)argv[i].sz; j++) 157 printf(" [%s]", argv[i].value[j]); 158 if (argv[i].sz > 0) 159 printf(" ]"); 160 } 161 162 putchar(' '); | 140 } 141 142 if (n->span) { 143 assert(NULL == p && NULL == t); 144 print_span(n->span, indent); 145 } else { 146 for (i = 0; i < indent; i++) 147 putchar(' '); --- 6 unchanged lines hidden (view full) --- 154 printf(" ["); 155 for (j = 0; j < (int)argv[i].sz; j++) 156 printf(" [%s]", argv[i].value[j]); 157 if (argv[i].sz > 0) 158 printf(" ]"); 159 } 160 161 putchar(' '); |
162 if (MDOC_DELIMO & n->flags) 163 putchar('('); |
|
163 if (MDOC_LINE & n->flags) 164 putchar('*'); | 164 if (MDOC_LINE & n->flags) 165 putchar('*'); |
165 printf("%d:%d\n", n->line, n->pos + 1); | 166 printf("%d:%d", n->line, n->pos + 1); 167 if (MDOC_DELIMC & n->flags) 168 putchar(')'); 169 if (MDOC_EOS & n->flags) 170 putchar('.'); 171 putchar('\n'); |
166 } 167 168 if (n->eqn) 169 print_box(n->eqn->root->first, indent + 4); 170 if (n->child) 171 print_mdoc(n->child, indent + | 172 } 173 174 if (n->eqn) 175 print_box(n->eqn->root->first, indent + 4); 176 if (n->child) 177 print_mdoc(n->child, indent + |
172 (n->type == MDOC_BLOCK ? 2 : 4)); | 178 (n->type == ROFFT_BLOCK ? 2 : 4)); |
173 if (n->next) 174 print_mdoc(n->next, indent); 175} 176 177static void | 179 if (n->next) 180 print_mdoc(n->next, indent); 181} 182 183static void |
178print_man(const struct man_node *n, int indent) | 184print_man(const struct roff_node *n, int indent) |
179{ 180 const char *p, *t; 181 int i; 182 183 if (n == NULL) 184 return; 185 186 t = p = NULL; 187 188 switch (n->type) { | 185{ 186 const char *p, *t; 187 int i; 188 189 if (n == NULL) 190 return; 191 192 t = p = NULL; 193 194 switch (n->type) { |
189 case MAN_ROOT: | 195 case ROFFT_ROOT: |
190 t = "root"; 191 break; | 196 t = "root"; 197 break; |
192 case MAN_ELEM: | 198 case ROFFT_ELEM: |
193 t = "elem"; 194 break; | 199 t = "elem"; 200 break; |
195 case MAN_TEXT: | 201 case ROFFT_TEXT: |
196 t = "text"; 197 break; | 202 t = "text"; 203 break; |
198 case MAN_BLOCK: | 204 case ROFFT_BLOCK: |
199 t = "block"; 200 break; | 205 t = "block"; 206 break; |
201 case MAN_HEAD: 202 t = "block-head"; | 207 case ROFFT_HEAD: 208 t = "head"; |
203 break; | 209 break; |
204 case MAN_BODY: 205 t = "block-body"; | 210 case ROFFT_BODY: 211 t = "body"; |
206 break; | 212 break; |
207 case MAN_TBL: | 213 case ROFFT_TBL: |
208 break; | 214 break; |
209 case MAN_EQN: | 215 case ROFFT_EQN: |
210 t = "eqn"; 211 break; 212 default: 213 abort(); | 216 t = "eqn"; 217 break; 218 default: 219 abort(); |
214 /* NOTREACHED */ | |
215 } 216 217 switch (n->type) { | 220 } 221 222 switch (n->type) { |
218 case MAN_TEXT: | 223 case ROFFT_TEXT: |
219 p = n->string; 220 break; | 224 p = n->string; 225 break; |
221 case MAN_ELEM: 222 /* FALLTHROUGH */ 223 case MAN_BLOCK: 224 /* FALLTHROUGH */ 225 case MAN_HEAD: 226 /* FALLTHROUGH */ 227 case MAN_BODY: | 226 case ROFFT_ELEM: 227 case ROFFT_BLOCK: 228 case ROFFT_HEAD: 229 case ROFFT_BODY: |
228 p = man_macronames[n->tok]; 229 break; | 230 p = man_macronames[n->tok]; 231 break; |
230 case MAN_ROOT: | 232 case ROFFT_ROOT: |
231 p = "root"; 232 break; | 233 p = "root"; 234 break; |
233 case MAN_TBL: | 235 case ROFFT_TBL: |
234 break; | 236 break; |
235 case MAN_EQN: | 237 case ROFFT_EQN: |
236 p = "EQ"; 237 break; 238 default: 239 abort(); | 238 p = "EQ"; 239 break; 240 default: 241 abort(); |
240 /* NOTREACHED */ | |
241 } 242 243 if (n->span) { 244 assert(NULL == p && NULL == t); 245 print_span(n->span, indent); 246 } else { 247 for (i = 0; i < indent; i++) 248 putchar(' '); 249 printf("%s (%s) ", p, t); 250 if (MAN_LINE & n->flags) 251 putchar('*'); | 242 } 243 244 if (n->span) { 245 assert(NULL == p && NULL == t); 246 print_span(n->span, indent); 247 } else { 248 for (i = 0; i < indent; i++) 249 putchar(' '); 250 printf("%s (%s) ", p, t); 251 if (MAN_LINE & n->flags) 252 putchar('*'); |
252 printf("%d:%d\n", n->line, n->pos + 1); | 253 printf("%d:%d", n->line, n->pos + 1); 254 if (MAN_EOS & n->flags) 255 putchar('.'); 256 putchar('\n'); |
253 } 254 255 if (n->eqn) 256 print_box(n->eqn->root->first, indent + 4); 257 if (n->child) 258 print_man(n->child, indent + | 257 } 258 259 if (n->eqn) 260 print_box(n->eqn->root->first, indent + 4); 261 if (n->child) 262 print_man(n->child, indent + |
259 (n->type == MAN_BLOCK ? 2 : 4)); | 263 (n->type == ROFFT_BLOCK ? 2 : 4)); |
260 if (n->next) 261 print_man(n->next, indent); 262} 263 264static void 265print_box(const struct eqn_box *ep, int indent) 266{ 267 int i; --- 77 unchanged lines hidden (view full) --- 345 return; 346 default: 347 break; 348 } 349 350 for (dp = sp->first; dp; dp = dp->next) { 351 switch (dp->pos) { 352 case TBL_DATA_HORIZ: | 264 if (n->next) 265 print_man(n->next, indent); 266} 267 268static void 269print_box(const struct eqn_box *ep, int indent) 270{ 271 int i; --- 77 unchanged lines hidden (view full) --- 349 return; 350 default: 351 break; 352 } 353 354 for (dp = sp->first; dp; dp = dp->next) { 355 switch (dp->pos) { 356 case TBL_DATA_HORIZ: |
353 /* FALLTHROUGH */ | |
354 case TBL_DATA_NHORIZ: 355 putchar('-'); 356 continue; 357 case TBL_DATA_DHORIZ: | 357 case TBL_DATA_NHORIZ: 358 putchar('-'); 359 continue; 360 case TBL_DATA_DHORIZ: |
358 /* FALLTHROUGH */ | |
359 case TBL_DATA_NDHORIZ: 360 putchar('='); 361 continue; 362 default: 363 break; 364 } 365 printf("[\"%s\"", dp->string ? dp->string : ""); 366 if (dp->spans) 367 printf("(%d)", dp->spans); 368 if (NULL == dp->layout) 369 putchar('*'); 370 putchar(']'); 371 putchar(' '); 372 } 373 374 printf("(tbl) %d:1\n", sp->line); 375} | 361 case TBL_DATA_NDHORIZ: 362 putchar('='); 363 continue; 364 default: 365 break; 366 } 367 printf("[\"%s\"", dp->string ? dp->string : ""); 368 if (dp->spans) 369 printf("(%d)", dp->spans); 370 if (NULL == dp->layout) 371 putchar('*'); 372 putchar(']'); 373 putchar(' '); 374 } 375 376 printf("(tbl) %d:1\n", sp->line); 377} |