dud.sdlang.visitor source code

1 module dud.sdlang.visitor;
2 
3 import dud.sdlang.ast;
4 import dud.sdlang.tokenmodule;
5 
6 class Visitor : ConstVisitor {
7 @safe pure:
8 
9 	alias accept = ConstVisitor.accept;
10 
11 	alias enter = ConstVisitor.enter;
12 
13 	alias exit = ConstVisitor.exit;
14 
15 
16 	void enter(Root obj) {}
17 	void exit(Root obj) {}
18 
19 	void accept(Root obj) {
20 		enter(obj);
21 		final switch(obj.ruleSelection) {
22 			case RootEnum.T:
23 				obj.tags.visit(this);
24 				break;
25 			case RootEnum.TT:
26 				obj.tags.visit(this);
27 				break;
28 			case RootEnum.E:
29 				break;
30 		}
31 		exit(obj);
32 	}
33 
34 	void enter(Tags obj) {}
35 	void exit(Tags obj) {}
36 
37 	void accept(Tags obj) {
38 		enter(obj);
39 		final switch(obj.ruleSelection) {
40 			case TagsEnum.Tag:
41 				obj.cur.visit(this);
42 				break;
43 			case TagsEnum.TagFollow:
44 				obj.cur.visit(this);
45 				obj.follow.visit(this);
46 				break;
47 		}
48 		exit(obj);
49 	}
50 
51 	void enter(Tag obj) {}
52 	void exit(Tag obj) {}
53 
54 	void accept(Tag obj) {
55 		enter(obj);
56 		final switch(obj.ruleSelection) {
57 			case TagEnum.IVAO:
58 				obj.id.visit(this);
59 				obj.vals.visit(this);
60 				obj.attrs.visit(this);
61 				obj.oc.visit(this);
62 				break;
63 			case TagEnum.IAO:
64 				obj.id.visit(this);
65 				obj.attrs.visit(this);
66 				obj.oc.visit(this);
67 				break;
68 			case TagEnum.IVO:
69 				obj.id.visit(this);
70 				obj.vals.visit(this);
71 				obj.oc.visit(this);
72 				break;
73 			case TagEnum.IVA:
74 				obj.id.visit(this);
75 				obj.vals.visit(this);
76 				obj.attrs.visit(this);
77 				break;
78 			case TagEnum.IO:
79 				obj.id.visit(this);
80 				obj.oc.visit(this);
81 				break;
82 			case TagEnum.IA:
83 				obj.id.visit(this);
84 				obj.attrs.visit(this);
85 				break;
86 			case TagEnum.IV:
87 				obj.id.visit(this);
88 				obj.vals.visit(this);
89 				break;
90 			case TagEnum.IE:
91 				obj.id.visit(this);
92 				break;
93 			case TagEnum.IVAOT:
94 				obj.id.visit(this);
95 				obj.vals.visit(this);
96 				obj.attrs.visit(this);
97 				obj.oc.visit(this);
98 				break;
99 			case TagEnum.IAOT:
100 				obj.id.visit(this);
101 				obj.attrs.visit(this);
102 				obj.oc.visit(this);
103 				break;
104 			case TagEnum.IVOT:
105 				obj.id.visit(this);
106 				obj.vals.visit(this);
107 				obj.oc.visit(this);
108 				break;
109 			case TagEnum.IVAT:
110 				obj.id.visit(this);
111 				obj.vals.visit(this);
112 				obj.attrs.visit(this);
113 				break;
114 			case TagEnum.IOT:
115 				obj.id.visit(this);
116 				obj.oc.visit(this);
117 				break;
118 			case TagEnum.IAT:
119 				obj.id.visit(this);
120 				obj.attrs.visit(this);
121 				break;
122 			case TagEnum.IVT:
123 				obj.id.visit(this);
124 				obj.vals.visit(this);
125 				break;
126 			case TagEnum.IET:
127 				obj.id.visit(this);
128 				break;
129 			case TagEnum.VAO:
130 				obj.vals.visit(this);
131 				obj.attrs.visit(this);
132 				obj.oc.visit(this);
133 				break;
134 			case TagEnum.VO:
135 				obj.vals.visit(this);
136 				obj.oc.visit(this);
137 				break;
138 			case TagEnum.VA:
139 				obj.vals.visit(this);
140 				obj.attrs.visit(this);
141 				break;
142 			case TagEnum.O:
143 				obj.oc.visit(this);
144 				break;
145 			case TagEnum.V:
146 				obj.vals.visit(this);
147 				break;
148 			case TagEnum.VAOT:
149 				obj.vals.visit(this);
150 				obj.attrs.visit(this);
151 				obj.oc.visit(this);
152 				break;
153 			case TagEnum.VOT:
154 				obj.vals.visit(this);
155 				obj.oc.visit(this);
156 				break;
157 			case TagEnum.VAT:
158 				obj.vals.visit(this);
159 				obj.attrs.visit(this);
160 				break;
161 			case TagEnum.OT:
162 				obj.oc.visit(this);
163 				break;
164 			case TagEnum.VT:
165 				obj.vals.visit(this);
166 				break;
167 		}
168 		exit(obj);
169 	}
170 
171 	void enter(IDFull obj) {}
172 	void exit(IDFull obj) {}
173 
174 	void accept(IDFull obj) {
175 		enter(obj);
176 		final switch(obj.ruleSelection) {
177 			case IDFullEnum.S:
178 				obj.cur.visit(this);
179 				break;
180 			case IDFullEnum.L:
181 				obj.cur.visit(this);
182 				obj.follow.visit(this);
183 				break;
184 		}
185 		exit(obj);
186 	}
187 
188 	void enter(Values obj) {}
189 	void exit(Values obj) {}
190 
191 	void accept(Values obj) {
192 		enter(obj);
193 		final switch(obj.ruleSelection) {
194 			case ValuesEnum.Value:
195 				obj.cur.visit(this);
196 				break;
197 			case ValuesEnum.ValueFollow:
198 				obj.cur.visit(this);
199 				obj.follow.visit(this);
200 				break;
201 		}
202 		exit(obj);
203 	}
204 
205 	void enter(Attributes obj) {}
206 	void exit(Attributes obj) {}
207 
208 	void accept(Attributes obj) {
209 		enter(obj);
210 		final switch(obj.ruleSelection) {
211 			case AttributesEnum.Attribute:
212 				obj.cur.visit(this);
213 				break;
214 			case AttributesEnum.AttributeFollow:
215 				obj.cur.visit(this);
216 				obj.follow.visit(this);
217 				break;
218 		}
219 		exit(obj);
220 	}
221 
222 	void enter(Attribute obj) {}
223 	void exit(Attribute obj) {}
224 
225 	void accept(Attribute obj) {
226 		enter(obj);
227 		final switch(obj.ruleSelection) {
228 			case AttributeEnum.A:
229 				obj.id.visit(this);
230 				obj.value.visit(this);
231 				break;
232 		}
233 		exit(obj);
234 	}
235 
236 	void enter(OptChild obj) {}
237 	void exit(OptChild obj) {}
238 
239 	void accept(OptChild obj) {
240 		enter(obj);
241 		final switch(obj.ruleSelection) {
242 			case OptChildEnum.T:
243 				obj.tags.visit(this);
244 				break;
245 			case OptChildEnum.E:
246 				break;
247 			case OptChildEnum.E2:
248 				break;
249 		}
250 		exit(obj);
251 	}
252 
253 	void enter(TagTerminator obj) {}
254 	void exit(TagTerminator obj) {}
255 
256 	void accept(TagTerminator obj) {
257 		enter(obj);
258 		final switch(obj.ruleSelection) {
259 			case TagTerminatorEnum.E:
260 				break;
261 			case TagTerminatorEnum.S:
262 				break;
263 			case TagTerminatorEnum.EF:
264 				break;
265 			case TagTerminatorEnum.SF:
266 				break;
267 		}
268 		exit(obj);
269 	}
270 }
271 
272 class ConstVisitor {
273 @safe pure:
274 
275 
276 	void enter(const(Root) obj) {}
277 	void exit(const(Root) obj) {}
278 
279 	void accept(const(Root) obj) {
280 		enter(obj);
281 		final switch(obj.ruleSelection) {
282 			case RootEnum.T:
283 				obj.tags.visit(this);
284 				break;
285 			case RootEnum.TT:
286 				obj.tags.visit(this);
287 				break;
288 			case RootEnum.E:
289 				break;
290 		}
291 		exit(obj);
292 	}
293 
294 	void enter(const(Tags) obj) {}
295 	void exit(const(Tags) obj) {}
296 
297 	void accept(const(Tags) obj) {
298 		enter(obj);
299 		final switch(obj.ruleSelection) {
300 			case TagsEnum.Tag:
301 				obj.cur.visit(this);
302 				break;
303 			case TagsEnum.TagFollow:
304 				obj.cur.visit(this);
305 				obj.follow.visit(this);
306 				break;
307 		}
308 		exit(obj);
309 	}
310 
311 	void enter(const(Tag) obj) {}
312 	void exit(const(Tag) obj) {}
313 
314 	void accept(const(Tag) obj) {
315 		enter(obj);
316 		final switch(obj.ruleSelection) {
317 			case TagEnum.IVAO:
318 				obj.id.visit(this);
319 				obj.vals.visit(this);
320 				obj.attrs.visit(this);
321 				obj.oc.visit(this);
322 				break;
323 			case TagEnum.IAO:
324 				obj.id.visit(this);
325 				obj.attrs.visit(this);
326 				obj.oc.visit(this);
327 				break;
328 			case TagEnum.IVO:
329 				obj.id.visit(this);
330 				obj.vals.visit(this);
331 				obj.oc.visit(this);
332 				break;
333 			case TagEnum.IVA:
334 				obj.id.visit(this);
335 				obj.vals.visit(this);
336 				obj.attrs.visit(this);
337 				break;
338 			case TagEnum.IO:
339 				obj.id.visit(this);
340 				obj.oc.visit(this);
341 				break;
342 			case TagEnum.IA:
343 				obj.id.visit(this);
344 				obj.attrs.visit(this);
345 				break;
346 			case TagEnum.IV:
347 				obj.id.visit(this);
348 				obj.vals.visit(this);
349 				break;
350 			case TagEnum.IE:
351 				obj.id.visit(this);
352 				break;
353 			case TagEnum.IVAOT:
354 				obj.id.visit(this);
355 				obj.vals.visit(this);
356 				obj.attrs.visit(this);
357 				obj.oc.visit(this);
358 				break;
359 			case TagEnum.IAOT:
360 				obj.id.visit(this);
361 				obj.attrs.visit(this);
362 				obj.oc.visit(this);
363 				break;
364 			case TagEnum.IVOT:
365 				obj.id.visit(this);
366 				obj.vals.visit(this);
367 				obj.oc.visit(this);
368 				break;
369 			case TagEnum.IVAT:
370 				obj.id.visit(this);
371 				obj.vals.visit(this);
372 				obj.attrs.visit(this);
373 				break;
374 			case TagEnum.IOT:
375 				obj.id.visit(this);
376 				obj.oc.visit(this);
377 				break;
378 			case TagEnum.IAT:
379 				obj.id.visit(this);
380 				obj.attrs.visit(this);
381 				break;
382 			case TagEnum.IVT:
383 				obj.id.visit(this);
384 				obj.vals.visit(this);
385 				break;
386 			case TagEnum.IET:
387 				obj.id.visit(this);
388 				break;
389 			case TagEnum.VAO:
390 				obj.vals.visit(this);
391 				obj.attrs.visit(this);
392 				obj.oc.visit(this);
393 				break;
394 			case TagEnum.VO:
395 				obj.vals.visit(this);
396 				obj.oc.visit(this);
397 				break;
398 			case TagEnum.VA:
399 				obj.vals.visit(this);
400 				obj.attrs.visit(this);
401 				break;
402 			case TagEnum.O:
403 				obj.oc.visit(this);
404 				break;
405 			case TagEnum.V:
406 				obj.vals.visit(this);
407 				break;
408 			case TagEnum.VAOT:
409 				obj.vals.visit(this);
410 				obj.attrs.visit(this);
411 				obj.oc.visit(this);
412 				break;
413 			case TagEnum.VOT:
414 				obj.vals.visit(this);
415 				obj.oc.visit(this);
416 				break;
417 			case TagEnum.VAT:
418 				obj.vals.visit(this);
419 				obj.attrs.visit(this);
420 				break;
421 			case TagEnum.OT:
422 				obj.oc.visit(this);
423 				break;
424 			case TagEnum.VT:
425 				obj.vals.visit(this);
426 				break;
427 		}
428 		exit(obj);
429 	}
430 
431 	void enter(const(IDFull) obj) {}
432 	void exit(const(IDFull) obj) {}
433 
434 	void accept(const(IDFull) obj) {
435 		enter(obj);
436 		final switch(obj.ruleSelection) {
437 			case IDFullEnum.S:
438 				obj.cur.visit(this);
439 				break;
440 			case IDFullEnum.L:
441 				obj.cur.visit(this);
442 				obj.follow.visit(this);
443 				break;
444 		}
445 		exit(obj);
446 	}
447 
448 	void enter(const(Values) obj) {}
449 	void exit(const(Values) obj) {}
450 
451 	void accept(const(Values) obj) {
452 		enter(obj);
453 		final switch(obj.ruleSelection) {
454 			case ValuesEnum.Value:
455 				obj.cur.visit(this);
456 				break;
457 			case ValuesEnum.ValueFollow:
458 				obj.cur.visit(this);
459 				obj.follow.visit(this);
460 				break;
461 		}
462 		exit(obj);
463 	}
464 
465 	void enter(const(Attributes) obj) {}
466 	void exit(const(Attributes) obj) {}
467 
468 	void accept(const(Attributes) obj) {
469 		enter(obj);
470 		final switch(obj.ruleSelection) {
471 			case AttributesEnum.Attribute:
472 				obj.cur.visit(this);
473 				break;
474 			case AttributesEnum.AttributeFollow:
475 				obj.cur.visit(this);
476 				obj.follow.visit(this);
477 				break;
478 		}
479 		exit(obj);
480 	}
481 
482 	void enter(const(Attribute) obj) {}
483 	void exit(const(Attribute) obj) {}
484 
485 	void accept(const(Attribute) obj) {
486 		enter(obj);
487 		final switch(obj.ruleSelection) {
488 			case AttributeEnum.A:
489 				obj.id.visit(this);
490 				obj.value.visit(this);
491 				break;
492 		}
493 		exit(obj);
494 	}
495 
496 	void enter(const(OptChild) obj) {}
497 	void exit(const(OptChild) obj) {}
498 
499 	void accept(const(OptChild) obj) {
500 		enter(obj);
501 		final switch(obj.ruleSelection) {
502 			case OptChildEnum.T:
503 				obj.tags.visit(this);
504 				break;
505 			case OptChildEnum.E:
506 				break;
507 			case OptChildEnum.E2:
508 				break;
509 		}
510 		exit(obj);
511 	}
512 
513 	void enter(const(TagTerminator) obj) {}
514 	void exit(const(TagTerminator) obj) {}
515 
516 	void accept(const(TagTerminator) obj) {
517 		enter(obj);
518 		final switch(obj.ruleSelection) {
519 			case TagTerminatorEnum.E:
520 				break;
521 			case TagTerminatorEnum.S:
522 				break;
523 			case TagTerminatorEnum.EF:
524 				break;
525 			case TagTerminatorEnum.SF:
526 				break;
527 		}
528 		exit(obj);
529 	}
530 }
531