]>
Commit | Line | Data |
---|---|---|
1 | /* Copyright (C) 1995, 1996 Tom Lord | |
2 | * | |
3 | * This program is free software; you can redistribute it and/or modify | |
4 | * it under the terms of the GNU Library General Public License as published by | |
5 | * the Free Software Foundation; either version 2, or (at your option) | |
6 | * any later version. | |
7 | * | |
8 | * This program is distributed in the hope that it will be useful, | |
9 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
10 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
11 | * GNU Library General Public License for more details. | |
12 | * | |
13 | * You should have received a copy of the GNU Library General Public License | |
14 | * along with this software; see the file COPYING. If not, write to | |
15 | * the Free Software Foundation, 59 Temple Place - Suite 330, | |
16 | * Boston, MA 02111-1307, USA. | |
17 | */ | |
18 | ||
19 | ||
20 | \f | |
21 | #include <stdio.h> | |
22 | #include "rxall.h" | |
23 | #include "rxgnucomp.h" | |
24 | #include "rxnfa.h" | |
25 | \f | |
26 | ||
27 | #ifdef HAVE_POSITIONAL_ARRAY_INITS | |
28 | #define AT(X) [X] = | |
29 | #else | |
30 | #define AT(X) | |
31 | #endif | |
32 | ||
33 | ||
34 | char *node_type_names[] = | |
35 | { | |
36 | AT(r_cset) "r_cset", | |
37 | AT(r_concat) "r_concat", | |
38 | AT(r_alternate) "r_alternate", | |
39 | AT(r_opt) "r_opt", | |
40 | AT(r_star) "r_star", | |
41 | AT(r_plus) "r_plus", | |
42 | AT(r_string) "r_string", | |
43 | AT(r_cut) "r_cut", | |
44 | ||
45 | AT(r_interval) "r_interval", | |
46 | AT(r_parens) "r_parens", | |
47 | AT(r_context) "r_context" | |
48 | }; | |
49 | ||
50 | void | |
51 | print_cset (cset_size, cs) | |
52 | int cset_size; | |
53 | rx_Bitset cs; | |
54 | { | |
55 | int x; | |
56 | if (!cs) | |
57 | printf ("nil"); | |
58 | else | |
59 | { | |
60 | putchar ('['); | |
61 | for (x = 0; x < cset_size; ++x) | |
62 | if (RX_bitset_member (cs, x)) | |
63 | { | |
64 | if (isprint(x)) | |
65 | putchar (x); | |
66 | else | |
67 | printf ("\\0%o ", x); | |
68 | } | |
69 | putchar (']'); | |
70 | } | |
71 | } | |
72 | ||
73 | void | |
74 | print_string(struct rx_string *s, char bracket) | |
75 | { | |
76 | int x; | |
77 | if (!s && bracket) | |
78 | printf ("nil"); | |
79 | else | |
80 | { | |
81 | if (bracket) | |
82 | putchar ('\"'); | |
83 | for (x = 0; x < s->len; ++x) | |
84 | if (isprint(s->contents[x])) | |
85 | putchar (s->contents[x]); | |
86 | else | |
87 | printf ("\\0%o ", x); | |
88 | if (bracket) | |
89 | putchar ('\"'); | |
90 | } | |
91 | } | |
92 | ||
93 | void | |
94 | spaces (n) | |
95 | int n; | |
96 | { | |
97 | while (n--) | |
98 | putchar (' '); | |
99 | } | |
100 | ||
101 | void | |
102 | print_rexp (cset_size, indent, rexp) | |
103 | int cset_size; | |
104 | int indent; | |
105 | struct rexp_node * rexp; | |
106 | { | |
107 | spaces (indent); | |
108 | if (!rexp) | |
109 | printf ("nil\n"); | |
110 | else | |
111 | { | |
112 | printf ("Node %d type %d (%s), iv=%d(%c), iv2=%d, len=%d obs=%d cs=", | |
113 | rexp->id, rexp->type, node_type_names[rexp->type], | |
114 | rexp->params.intval, | |
115 | (isprint (rexp->params.intval) | |
116 | ? rexp->params.intval | |
117 | : ' '), | |
118 | rexp->params.intval2, | |
119 | rexp->len, | |
120 | rexp->observed); | |
121 | print_cset (cset_size, rexp->params.cset); | |
122 | printf (" s="); | |
123 | print_string (&(rexp->params.cstr), 1); | |
124 | putchar ('\n'); | |
125 | if (rexp->params.pair.left || rexp->params.pair.right) | |
126 | { | |
127 | print_rexp (cset_size, indent + 2, rexp->params.pair.left); | |
128 | print_rexp (cset_size, indent + 2, rexp->params.pair.right); | |
129 | } | |
130 | } | |
131 | } | |
132 | ||
133 | ||
134 | ||
135 | ||
136 | void | |
137 | unparse_print_rexp (cset_size, rexp) | |
138 | int cset_size; | |
139 | struct rexp_node * rexp; | |
140 | { | |
141 | if (!rexp) | |
142 | return; | |
143 | else | |
144 | switch (rexp->type) | |
145 | { | |
146 | case r_cset: | |
147 | if (1 != rx_bitset_population (cset_size, rexp->params.cset)) | |
148 | print_cset (cset_size, rexp->params.cset); | |
149 | else | |
150 | { | |
151 | int x; | |
152 | rx_Bitset cs; | |
153 | ||
154 | cs = rexp->params.cset; | |
155 | for (x = 0; x < cset_size; ++x) | |
156 | if (RX_bitset_member (cs, x)) | |
157 | { | |
158 | if (isprint(x)) | |
159 | putchar (x); | |
160 | else | |
161 | printf ("\\0%o ", x); | |
162 | } | |
163 | } | |
164 | break; | |
165 | ||
166 | case r_string: | |
167 | print_string (&(rexp->params.cstr), 0); | |
168 | break; | |
169 | ||
170 | case r_parens: | |
171 | putchar ('('); | |
172 | unparse_print_rexp (cset_size, rexp->params.pair.left); | |
173 | putchar (')'); | |
174 | break; | |
175 | ||
176 | case r_context: | |
177 | putchar ('\\'); | |
178 | putchar (rexp->params.intval); | |
179 | break; | |
180 | ||
181 | case r_cut: | |
182 | printf ("[[:cut %d:]]", rexp->params.intval); | |
183 | break; | |
184 | ||
185 | case r_concat: | |
186 | unparse_print_rexp (cset_size, rexp->params.pair.left); | |
187 | unparse_print_rexp (cset_size, rexp->params.pair.right); | |
188 | break; | |
189 | ||
190 | case r_alternate: | |
191 | unparse_print_rexp (cset_size, rexp->params.pair.left); | |
192 | putchar ('|'); | |
193 | unparse_print_rexp (cset_size, rexp->params.pair.right); | |
194 | break; | |
195 | ||
196 | case r_opt: | |
197 | unparse_print_rexp (cset_size, rexp->params.pair.left); | |
198 | putchar ('?'); | |
199 | break; | |
200 | ||
201 | case r_star: | |
202 | unparse_print_rexp (cset_size, rexp->params.pair.left); | |
203 | putchar ('*'); | |
204 | break; | |
205 | ||
206 | case r_plus: | |
207 | unparse_print_rexp (cset_size, rexp->params.pair.left); | |
208 | putchar ('+'); | |
209 | break; | |
210 | ||
211 | case r_interval: | |
212 | unparse_print_rexp (cset_size, rexp->params.pair.left); | |
213 | printf ("{%d,%d}", rexp->params.intval, rexp->params.intval2); | |
214 | break; | |
215 | } | |
216 | } | |
217 | ||
218 | ||
219 | void | |
220 | print_nfa_state (rx, state) | |
221 | struct rx * rx; | |
222 | struct rx_nfa_state * state; | |
223 | { | |
224 | struct rx_nfa_edge * e; | |
225 | printf ("state %d, is_final %d, is_start %d\n", | |
226 | state->id, state->is_final, state->is_start); | |
227 | for (e = state->edges; e; e = e->next) | |
228 | { | |
229 | printf ("\tEdge %s to %d ", | |
230 | (e->type == ne_cset | |
231 | ? "cset" | |
232 | : (e->type == ne_epsilon | |
233 | ? "epsilon" | |
234 | : "side effect")), | |
235 | e->dest->id); | |
236 | if (e->type == ne_cset) | |
237 | print_cset (rx->local_cset_size, e->params.cset); | |
238 | else | |
239 | printf ("%d", (int)e->params.side_effect); | |
240 | putchar ('\n'); | |
241 | } | |
242 | } | |
243 | ||
244 | void | |
245 | print_nfa (rx) | |
246 | struct rx * rx; | |
247 | { | |
248 | struct rx_nfa_state * state; | |
249 | for (state = rx->nfa_states; state; state = state->next) | |
250 | print_nfa_state (rx, state); | |
251 | } |