Unofficial Dub Package Documentation 
1 module visitor;
2 
3 import ast;
4 import tokenmodule;
5 
6 class Visitor {
7 
8 	void enter(Document obj) {}
9 	void exit(Document obj) {}
10 
11 	void accept(Document obj) {
12 		enter(obj);
13 		final switch(obj.ruleSelection) {
14 			case DocumentEnum.Defi:
15 				obj.defs.visit(this);
16 				break;
17 		}
18 		exit(obj);
19 	}
20 
21 	void enter(const(Document) obj) {}
22 	void exit(const(Document) obj) {}
23 
24 	void accept(const(Document) obj) {
25 		enter(obj);
26 		final switch(obj.ruleSelection) {
27 			case DocumentEnum.Defi:
28 				obj.defs.visit(this);
29 				break;
30 		}
31 		exit(obj);
32 	}
33 
34 	void enter(Definitions obj) {}
35 	void exit(Definitions obj) {}
36 
37 	void accept(Definitions obj) {
38 		enter(obj);
39 		final switch(obj.ruleSelection) {
40 			case DefinitionsEnum.Def:
41 				obj.def.visit(this);
42 				break;
43 			case DefinitionsEnum.Defs:
44 				obj.def.visit(this);
45 				obj.follow.visit(this);
46 				break;
47 		}
48 		exit(obj);
49 	}
50 
51 	void enter(const(Definitions) obj) {}
52 	void exit(const(Definitions) obj) {}
53 
54 	void accept(const(Definitions) obj) {
55 		enter(obj);
56 		final switch(obj.ruleSelection) {
57 			case DefinitionsEnum.Def:
58 				obj.def.visit(this);
59 				break;
60 			case DefinitionsEnum.Defs:
61 				obj.def.visit(this);
62 				obj.follow.visit(this);
63 				break;
64 		}
65 		exit(obj);
66 	}
67 
68 	void enter(Definition obj) {}
69 	void exit(Definition obj) {}
70 
71 	void accept(Definition obj) {
72 		enter(obj);
73 		final switch(obj.ruleSelection) {
74 			case DefinitionEnum.O:
75 				obj.op.visit(this);
76 				break;
77 			case DefinitionEnum.F:
78 				obj.frag.visit(this);
79 				break;
80 			case DefinitionEnum.T:
81 				obj.type.visit(this);
82 				break;
83 		}
84 		exit(obj);
85 	}
86 
87 	void enter(const(Definition) obj) {}
88 	void exit(const(Definition) obj) {}
89 
90 	void accept(const(Definition) obj) {
91 		enter(obj);
92 		final switch(obj.ruleSelection) {
93 			case DefinitionEnum.O:
94 				obj.op.visit(this);
95 				break;
96 			case DefinitionEnum.F:
97 				obj.frag.visit(this);
98 				break;
99 			case DefinitionEnum.T:
100 				obj.type.visit(this);
101 				break;
102 		}
103 		exit(obj);
104 	}
105 
106 	void enter(OperationDefinition obj) {}
107 	void exit(OperationDefinition obj) {}
108 
109 	void accept(OperationDefinition obj) {
110 		enter(obj);
111 		final switch(obj.ruleSelection) {
112 			case OperationDefinitionEnum.SelSet:
113 				obj.ss.visit(this);
114 				break;
115 			case OperationDefinitionEnum.OT_N_VD:
116 				obj.ot.visit(this);
117 				obj.name.visit(this);
118 				obj.vd.visit(this);
119 				obj.d.visit(this);
120 				obj.ss.visit(this);
121 				break;
122 			case OperationDefinitionEnum.OT_N_V:
123 				obj.ot.visit(this);
124 				obj.name.visit(this);
125 				obj.vd.visit(this);
126 				obj.ss.visit(this);
127 				break;
128 			case OperationDefinitionEnum.OT_N_D:
129 				obj.ot.visit(this);
130 				obj.name.visit(this);
131 				obj.d.visit(this);
132 				obj.ss.visit(this);
133 				break;
134 			case OperationDefinitionEnum.OT_N:
135 				obj.ot.visit(this);
136 				obj.name.visit(this);
137 				obj.ss.visit(this);
138 				break;
139 			case OperationDefinitionEnum.OT_VD:
140 				obj.ot.visit(this);
141 				obj.vd.visit(this);
142 				obj.d.visit(this);
143 				obj.ss.visit(this);
144 				break;
145 			case OperationDefinitionEnum.OT_V:
146 				obj.ot.visit(this);
147 				obj.vd.visit(this);
148 				obj.ss.visit(this);
149 				break;
150 			case OperationDefinitionEnum.OT_D:
151 				obj.ot.visit(this);
152 				obj.d.visit(this);
153 				obj.ss.visit(this);
154 				break;
155 			case OperationDefinitionEnum.OT:
156 				obj.ot.visit(this);
157 				obj.ss.visit(this);
158 				break;
159 		}
160 		exit(obj);
161 	}
162 
163 	void enter(const(OperationDefinition) obj) {}
164 	void exit(const(OperationDefinition) obj) {}
165 
166 	void accept(const(OperationDefinition) obj) {
167 		enter(obj);
168 		final switch(obj.ruleSelection) {
169 			case OperationDefinitionEnum.SelSet:
170 				obj.ss.visit(this);
171 				break;
172 			case OperationDefinitionEnum.OT_N_VD:
173 				obj.ot.visit(this);
174 				obj.name.visit(this);
175 				obj.vd.visit(this);
176 				obj.d.visit(this);
177 				obj.ss.visit(this);
178 				break;
179 			case OperationDefinitionEnum.OT_N_V:
180 				obj.ot.visit(this);
181 				obj.name.visit(this);
182 				obj.vd.visit(this);
183 				obj.ss.visit(this);
184 				break;
185 			case OperationDefinitionEnum.OT_N_D:
186 				obj.ot.visit(this);
187 				obj.name.visit(this);
188 				obj.d.visit(this);
189 				obj.ss.visit(this);
190 				break;
191 			case OperationDefinitionEnum.OT_N:
192 				obj.ot.visit(this);
193 				obj.name.visit(this);
194 				obj.ss.visit(this);
195 				break;
196 			case OperationDefinitionEnum.OT_VD:
197 				obj.ot.visit(this);
198 				obj.vd.visit(this);
199 				obj.d.visit(this);
200 				obj.ss.visit(this);
201 				break;
202 			case OperationDefinitionEnum.OT_V:
203 				obj.ot.visit(this);
204 				obj.vd.visit(this);
205 				obj.ss.visit(this);
206 				break;
207 			case OperationDefinitionEnum.OT_D:
208 				obj.ot.visit(this);
209 				obj.d.visit(this);
210 				obj.ss.visit(this);
211 				break;
212 			case OperationDefinitionEnum.OT:
213 				obj.ot.visit(this);
214 				obj.ss.visit(this);
215 				break;
216 		}
217 		exit(obj);
218 	}
219 
220 	void enter(SelectionSet obj) {}
221 	void exit(SelectionSet obj) {}
222 
223 	void accept(SelectionSet obj) {
224 		enter(obj);
225 		final switch(obj.ruleSelection) {
226 			case SelectionSetEnum.SS:
227 				obj.sel.visit(this);
228 				break;
229 		}
230 		exit(obj);
231 	}
232 
233 	void enter(const(SelectionSet) obj) {}
234 	void exit(const(SelectionSet) obj) {}
235 
236 	void accept(const(SelectionSet) obj) {
237 		enter(obj);
238 		final switch(obj.ruleSelection) {
239 			case SelectionSetEnum.SS:
240 				obj.sel.visit(this);
241 				break;
242 		}
243 		exit(obj);
244 	}
245 
246 	void enter(OperationType obj) {}
247 	void exit(OperationType obj) {}
248 
249 	void accept(OperationType obj) {
250 		enter(obj);
251 		final switch(obj.ruleSelection) {
252 			case OperationTypeEnum.Query:
253 				obj.tok.visit(this);
254 				break;
255 			case OperationTypeEnum.Mutation:
256 				obj.tok.visit(this);
257 				break;
258 			case OperationTypeEnum.Sub:
259 				obj.tok.visit(this);
260 				break;
261 		}
262 		exit(obj);
263 	}
264 
265 	void enter(const(OperationType) obj) {}
266 	void exit(const(OperationType) obj) {}
267 
268 	void accept(const(OperationType) obj) {
269 		enter(obj);
270 		final switch(obj.ruleSelection) {
271 			case OperationTypeEnum.Query:
272 				obj.tok.visit(this);
273 				break;
274 			case OperationTypeEnum.Mutation:
275 				obj.tok.visit(this);
276 				break;
277 			case OperationTypeEnum.Sub:
278 				obj.tok.visit(this);
279 				break;
280 		}
281 		exit(obj);
282 	}
283 
284 	void enter(Selections obj) {}
285 	void exit(Selections obj) {}
286 
287 	void accept(Selections obj) {
288 		enter(obj);
289 		final switch(obj.ruleSelection) {
290 			case SelectionsEnum.Sel:
291 				obj.sel.visit(this);
292 				break;
293 			case SelectionsEnum.Sels:
294 				obj.sel.visit(this);
295 				obj.follow.visit(this);
296 				break;
297 			case SelectionsEnum.Selsc:
298 				obj.sel.visit(this);
299 				obj.follow.visit(this);
300 				break;
301 		}
302 		exit(obj);
303 	}
304 
305 	void enter(const(Selections) obj) {}
306 	void exit(const(Selections) obj) {}
307 
308 	void accept(const(Selections) obj) {
309 		enter(obj);
310 		final switch(obj.ruleSelection) {
311 			case SelectionsEnum.Sel:
312 				obj.sel.visit(this);
313 				break;
314 			case SelectionsEnum.Sels:
315 				obj.sel.visit(this);
316 				obj.follow.visit(this);
317 				break;
318 			case SelectionsEnum.Selsc:
319 				obj.sel.visit(this);
320 				obj.follow.visit(this);
321 				break;
322 		}
323 		exit(obj);
324 	}
325 
326 	void enter(Selection obj) {}
327 	void exit(Selection obj) {}
328 
329 	void accept(Selection obj) {
330 		enter(obj);
331 		final switch(obj.ruleSelection) {
332 			case SelectionEnum.Field:
333 				obj.field.visit(this);
334 				break;
335 			case SelectionEnum.Spread:
336 				obj.frag.visit(this);
337 				break;
338 			case SelectionEnum.IFrag:
339 				obj.ifrag.visit(this);
340 				break;
341 		}
342 		exit(obj);
343 	}
344 
345 	void enter(const(Selection) obj) {}
346 	void exit(const(Selection) obj) {}
347 
348 	void accept(const(Selection) obj) {
349 		enter(obj);
350 		final switch(obj.ruleSelection) {
351 			case SelectionEnum.Field:
352 				obj.field.visit(this);
353 				break;
354 			case SelectionEnum.Spread:
355 				obj.frag.visit(this);
356 				break;
357 			case SelectionEnum.IFrag:
358 				obj.ifrag.visit(this);
359 				break;
360 		}
361 		exit(obj);
362 	}
363 
364 	void enter(FragmentSpread obj) {}
365 	void exit(FragmentSpread obj) {}
366 
367 	void accept(FragmentSpread obj) {
368 		enter(obj);
369 		final switch(obj.ruleSelection) {
370 			case FragmentSpreadEnum.FD:
371 				obj.name.visit(this);
372 				obj.dirs.visit(this);
373 				break;
374 			case FragmentSpreadEnum.F:
375 				obj.name.visit(this);
376 				break;
377 		}
378 		exit(obj);
379 	}
380 
381 	void enter(const(FragmentSpread) obj) {}
382 	void exit(const(FragmentSpread) obj) {}
383 
384 	void accept(const(FragmentSpread) obj) {
385 		enter(obj);
386 		final switch(obj.ruleSelection) {
387 			case FragmentSpreadEnum.FD:
388 				obj.name.visit(this);
389 				obj.dirs.visit(this);
390 				break;
391 			case FragmentSpreadEnum.F:
392 				obj.name.visit(this);
393 				break;
394 		}
395 		exit(obj);
396 	}
397 
398 	void enter(InlineFragment obj) {}
399 	void exit(InlineFragment obj) {}
400 
401 	void accept(InlineFragment obj) {
402 		enter(obj);
403 		final switch(obj.ruleSelection) {
404 			case InlineFragmentEnum.TDS:
405 				obj.tc.visit(this);
406 				obj.dirs.visit(this);
407 				obj.ss.visit(this);
408 				break;
409 			case InlineFragmentEnum.TS:
410 				obj.tc.visit(this);
411 				obj.ss.visit(this);
412 				break;
413 			case InlineFragmentEnum.DS:
414 				obj.dirs.visit(this);
415 				obj.ss.visit(this);
416 				break;
417 			case InlineFragmentEnum.S:
418 				obj.ss.visit(this);
419 				break;
420 		}
421 		exit(obj);
422 	}
423 
424 	void enter(const(InlineFragment) obj) {}
425 	void exit(const(InlineFragment) obj) {}
426 
427 	void accept(const(InlineFragment) obj) {
428 		enter(obj);
429 		final switch(obj.ruleSelection) {
430 			case InlineFragmentEnum.TDS:
431 				obj.tc.visit(this);
432 				obj.dirs.visit(this);
433 				obj.ss.visit(this);
434 				break;
435 			case InlineFragmentEnum.TS:
436 				obj.tc.visit(this);
437 				obj.ss.visit(this);
438 				break;
439 			case InlineFragmentEnum.DS:
440 				obj.dirs.visit(this);
441 				obj.ss.visit(this);
442 				break;
443 			case InlineFragmentEnum.S:
444 				obj.ss.visit(this);
445 				break;
446 		}
447 		exit(obj);
448 	}
449 
450 	void enter(Field obj) {}
451 	void exit(Field obj) {}
452 
453 	void accept(Field obj) {
454 		enter(obj);
455 		final switch(obj.ruleSelection) {
456 			case FieldEnum.FADS:
457 				obj.name.visit(this);
458 				obj.args.visit(this);
459 				obj.dirs.visit(this);
460 				obj.ss.visit(this);
461 				break;
462 			case FieldEnum.FAS:
463 				obj.name.visit(this);
464 				obj.args.visit(this);
465 				obj.ss.visit(this);
466 				break;
467 			case FieldEnum.FAD:
468 				obj.name.visit(this);
469 				obj.args.visit(this);
470 				obj.dirs.visit(this);
471 				break;
472 			case FieldEnum.FDS:
473 				obj.name.visit(this);
474 				obj.dirs.visit(this);
475 				obj.ss.visit(this);
476 				break;
477 			case FieldEnum.FS:
478 				obj.name.visit(this);
479 				obj.ss.visit(this);
480 				break;
481 			case FieldEnum.FD:
482 				obj.name.visit(this);
483 				obj.dirs.visit(this);
484 				break;
485 			case FieldEnum.FA:
486 				obj.name.visit(this);
487 				obj.args.visit(this);
488 				break;
489 			case FieldEnum.F:
490 				obj.name.visit(this);
491 				break;
492 		}
493 		exit(obj);
494 	}
495 
496 	void enter(const(Field) obj) {}
497 	void exit(const(Field) obj) {}
498 
499 	void accept(const(Field) obj) {
500 		enter(obj);
501 		final switch(obj.ruleSelection) {
502 			case FieldEnum.FADS:
503 				obj.name.visit(this);
504 				obj.args.visit(this);
505 				obj.dirs.visit(this);
506 				obj.ss.visit(this);
507 				break;
508 			case FieldEnum.FAS:
509 				obj.name.visit(this);
510 				obj.args.visit(this);
511 				obj.ss.visit(this);
512 				break;
513 			case FieldEnum.FAD:
514 				obj.name.visit(this);
515 				obj.args.visit(this);
516 				obj.dirs.visit(this);
517 				break;
518 			case FieldEnum.FDS:
519 				obj.name.visit(this);
520 				obj.dirs.visit(this);
521 				obj.ss.visit(this);
522 				break;
523 			case FieldEnum.FS:
524 				obj.name.visit(this);
525 				obj.ss.visit(this);
526 				break;
527 			case FieldEnum.FD:
528 				obj.name.visit(this);
529 				obj.dirs.visit(this);
530 				break;
531 			case FieldEnum.FA:
532 				obj.name.visit(this);
533 				obj.args.visit(this);
534 				break;
535 			case FieldEnum.F:
536 				obj.name.visit(this);
537 				break;
538 		}
539 		exit(obj);
540 	}
541 
542 	void enter(FieldName obj) {}
543 	void exit(FieldName obj) {}
544 
545 	void accept(FieldName obj) {
546 		enter(obj);
547 		final switch(obj.ruleSelection) {
548 			case FieldNameEnum.A:
549 				obj.name.visit(this);
550 				obj.aka.visit(this);
551 				break;
552 			case FieldNameEnum.N:
553 				obj.name.visit(this);
554 				break;
555 			case FieldNameEnum.T:
556 				obj.type.visit(this);
557 				break;
558 			case FieldNameEnum.S:
559 				obj.schema.visit(this);
560 				break;
561 		}
562 		exit(obj);
563 	}
564 
565 	void enter(const(FieldName) obj) {}
566 	void exit(const(FieldName) obj) {}
567 
568 	void accept(const(FieldName) obj) {
569 		enter(obj);
570 		final switch(obj.ruleSelection) {
571 			case FieldNameEnum.A:
572 				obj.name.visit(this);
573 				obj.aka.visit(this);
574 				break;
575 			case FieldNameEnum.N:
576 				obj.name.visit(this);
577 				break;
578 			case FieldNameEnum.T:
579 				obj.type.visit(this);
580 				break;
581 			case FieldNameEnum.S:
582 				obj.schema.visit(this);
583 				break;
584 		}
585 		exit(obj);
586 	}
587 
588 	void enter(Arguments obj) {}
589 	void exit(Arguments obj) {}
590 
591 	void accept(Arguments obj) {
592 		enter(obj);
593 		final switch(obj.ruleSelection) {
594 			case ArgumentsEnum.List:
595 				obj.arg.visit(this);
596 				break;
597 			case ArgumentsEnum.Empty:
598 				break;
599 		}
600 		exit(obj);
601 	}
602 
603 	void enter(const(Arguments) obj) {}
604 	void exit(const(Arguments) obj) {}
605 
606 	void accept(const(Arguments) obj) {
607 		enter(obj);
608 		final switch(obj.ruleSelection) {
609 			case ArgumentsEnum.List:
610 				obj.arg.visit(this);
611 				break;
612 			case ArgumentsEnum.Empty:
613 				break;
614 		}
615 		exit(obj);
616 	}
617 
618 	void enter(ArgumentList obj) {}
619 	void exit(ArgumentList obj) {}
620 
621 	void accept(ArgumentList obj) {
622 		enter(obj);
623 		final switch(obj.ruleSelection) {
624 			case ArgumentListEnum.A:
625 				obj.arg.visit(this);
626 				break;
627 			case ArgumentListEnum.ACS:
628 				obj.arg.visit(this);
629 				obj.follow.visit(this);
630 				break;
631 			case ArgumentListEnum.AS:
632 				obj.arg.visit(this);
633 				obj.follow.visit(this);
634 				break;
635 		}
636 		exit(obj);
637 	}
638 
639 	void enter(const(ArgumentList) obj) {}
640 	void exit(const(ArgumentList) obj) {}
641 
642 	void accept(const(ArgumentList) obj) {
643 		enter(obj);
644 		final switch(obj.ruleSelection) {
645 			case ArgumentListEnum.A:
646 				obj.arg.visit(this);
647 				break;
648 			case ArgumentListEnum.ACS:
649 				obj.arg.visit(this);
650 				obj.follow.visit(this);
651 				break;
652 			case ArgumentListEnum.AS:
653 				obj.arg.visit(this);
654 				obj.follow.visit(this);
655 				break;
656 		}
657 		exit(obj);
658 	}
659 
660 	void enter(Argument obj) {}
661 	void exit(Argument obj) {}
662 
663 	void accept(Argument obj) {
664 		enter(obj);
665 		final switch(obj.ruleSelection) {
666 			case ArgumentEnum.Name:
667 				obj.name.visit(this);
668 				obj.vv.visit(this);
669 				break;
670 		}
671 		exit(obj);
672 	}
673 
674 	void enter(const(Argument) obj) {}
675 	void exit(const(Argument) obj) {}
676 
677 	void accept(const(Argument) obj) {
678 		enter(obj);
679 		final switch(obj.ruleSelection) {
680 			case ArgumentEnum.Name:
681 				obj.name.visit(this);
682 				obj.vv.visit(this);
683 				break;
684 		}
685 		exit(obj);
686 	}
687 
688 	void enter(FragmentDefinition obj) {}
689 	void exit(FragmentDefinition obj) {}
690 
691 	void accept(FragmentDefinition obj) {
692 		enter(obj);
693 		final switch(obj.ruleSelection) {
694 			case FragmentDefinitionEnum.FTDS:
695 				obj.name.visit(this);
696 				obj.tc.visit(this);
697 				obj.dirs.visit(this);
698 				obj.ss.visit(this);
699 				break;
700 			case FragmentDefinitionEnum.FTS:
701 				obj.name.visit(this);
702 				obj.tc.visit(this);
703 				obj.ss.visit(this);
704 				break;
705 		}
706 		exit(obj);
707 	}
708 
709 	void enter(const(FragmentDefinition) obj) {}
710 	void exit(const(FragmentDefinition) obj) {}
711 
712 	void accept(const(FragmentDefinition) obj) {
713 		enter(obj);
714 		final switch(obj.ruleSelection) {
715 			case FragmentDefinitionEnum.FTDS:
716 				obj.name.visit(this);
717 				obj.tc.visit(this);
718 				obj.dirs.visit(this);
719 				obj.ss.visit(this);
720 				break;
721 			case FragmentDefinitionEnum.FTS:
722 				obj.name.visit(this);
723 				obj.tc.visit(this);
724 				obj.ss.visit(this);
725 				break;
726 		}
727 		exit(obj);
728 	}
729 
730 	void enter(Directives obj) {}
731 	void exit(Directives obj) {}
732 
733 	void accept(Directives obj) {
734 		enter(obj);
735 		final switch(obj.ruleSelection) {
736 			case DirectivesEnum.Dir:
737 				obj.dir.visit(this);
738 				break;
739 			case DirectivesEnum.Dirs:
740 				obj.dir.visit(this);
741 				obj.follow.visit(this);
742 				break;
743 		}
744 		exit(obj);
745 	}
746 
747 	void enter(const(Directives) obj) {}
748 	void exit(const(Directives) obj) {}
749 
750 	void accept(const(Directives) obj) {
751 		enter(obj);
752 		final switch(obj.ruleSelection) {
753 			case DirectivesEnum.Dir:
754 				obj.dir.visit(this);
755 				break;
756 			case DirectivesEnum.Dirs:
757 				obj.dir.visit(this);
758 				obj.follow.visit(this);
759 				break;
760 		}
761 		exit(obj);
762 	}
763 
764 	void enter(Directive obj) {}
765 	void exit(Directive obj) {}
766 
767 	void accept(Directive obj) {
768 		enter(obj);
769 		final switch(obj.ruleSelection) {
770 			case DirectiveEnum.NArg:
771 				obj.name.visit(this);
772 				obj.arg.visit(this);
773 				break;
774 			case DirectiveEnum.N:
775 				obj.name.visit(this);
776 				break;
777 		}
778 		exit(obj);
779 	}
780 
781 	void enter(const(Directive) obj) {}
782 	void exit(const(Directive) obj) {}
783 
784 	void accept(const(Directive) obj) {
785 		enter(obj);
786 		final switch(obj.ruleSelection) {
787 			case DirectiveEnum.NArg:
788 				obj.name.visit(this);
789 				obj.arg.visit(this);
790 				break;
791 			case DirectiveEnum.N:
792 				obj.name.visit(this);
793 				break;
794 		}
795 		exit(obj);
796 	}
797 
798 	void enter(VariableDefinitions obj) {}
799 	void exit(VariableDefinitions obj) {}
800 
801 	void accept(VariableDefinitions obj) {
802 		enter(obj);
803 		final switch(obj.ruleSelection) {
804 			case VariableDefinitionsEnum.Empty:
805 				break;
806 			case VariableDefinitionsEnum.Vars:
807 				obj.vars.visit(this);
808 				break;
809 		}
810 		exit(obj);
811 	}
812 
813 	void enter(const(VariableDefinitions) obj) {}
814 	void exit(const(VariableDefinitions) obj) {}
815 
816 	void accept(const(VariableDefinitions) obj) {
817 		enter(obj);
818 		final switch(obj.ruleSelection) {
819 			case VariableDefinitionsEnum.Empty:
820 				break;
821 			case VariableDefinitionsEnum.Vars:
822 				obj.vars.visit(this);
823 				break;
824 		}
825 		exit(obj);
826 	}
827 
828 	void enter(VariableDefinitionList obj) {}
829 	void exit(VariableDefinitionList obj) {}
830 
831 	void accept(VariableDefinitionList obj) {
832 		enter(obj);
833 		final switch(obj.ruleSelection) {
834 			case VariableDefinitionListEnum.V:
835 				obj.var.visit(this);
836 				break;
837 			case VariableDefinitionListEnum.VCF:
838 				obj.var.visit(this);
839 				obj.follow.visit(this);
840 				break;
841 			case VariableDefinitionListEnum.VF:
842 				obj.var.visit(this);
843 				obj.follow.visit(this);
844 				break;
845 		}
846 		exit(obj);
847 	}
848 
849 	void enter(const(VariableDefinitionList) obj) {}
850 	void exit(const(VariableDefinitionList) obj) {}
851 
852 	void accept(const(VariableDefinitionList) obj) {
853 		enter(obj);
854 		final switch(obj.ruleSelection) {
855 			case VariableDefinitionListEnum.V:
856 				obj.var.visit(this);
857 				break;
858 			case VariableDefinitionListEnum.VCF:
859 				obj.var.visit(this);
860 				obj.follow.visit(this);
861 				break;
862 			case VariableDefinitionListEnum.VF:
863 				obj.var.visit(this);
864 				obj.follow.visit(this);
865 				break;
866 		}
867 		exit(obj);
868 	}
869 
870 	void enter(VariableDefinition obj) {}
871 	void exit(VariableDefinition obj) {}
872 
873 	void accept(VariableDefinition obj) {
874 		enter(obj);
875 		final switch(obj.ruleSelection) {
876 			case VariableDefinitionEnum.VarD:
877 				obj.type.visit(this);
878 				obj.dvalue.visit(this);
879 				break;
880 			case VariableDefinitionEnum.Var:
881 				obj.type.visit(this);
882 				break;
883 		}
884 		exit(obj);
885 	}
886 
887 	void enter(const(VariableDefinition) obj) {}
888 	void exit(const(VariableDefinition) obj) {}
889 
890 	void accept(const(VariableDefinition) obj) {
891 		enter(obj);
892 		final switch(obj.ruleSelection) {
893 			case VariableDefinitionEnum.VarD:
894 				obj.type.visit(this);
895 				obj.dvalue.visit(this);
896 				break;
897 			case VariableDefinitionEnum.Var:
898 				obj.type.visit(this);
899 				break;
900 		}
901 		exit(obj);
902 	}
903 
904 	void enter(Variable obj) {}
905 	void exit(Variable obj) {}
906 
907 	void accept(Variable obj) {
908 		enter(obj);
909 		final switch(obj.ruleSelection) {
910 			case VariableEnum.Var:
911 				obj.name.visit(this);
912 				break;
913 		}
914 		exit(obj);
915 	}
916 
917 	void enter(const(Variable) obj) {}
918 	void exit(const(Variable) obj) {}
919 
920 	void accept(const(Variable) obj) {
921 		enter(obj);
922 		final switch(obj.ruleSelection) {
923 			case VariableEnum.Var:
924 				obj.name.visit(this);
925 				break;
926 		}
927 		exit(obj);
928 	}
929 
930 	void enter(DefaultValue obj) {}
931 	void exit(DefaultValue obj) {}
932 
933 	void accept(DefaultValue obj) {
934 		enter(obj);
935 		final switch(obj.ruleSelection) {
936 			case DefaultValueEnum.DV:
937 				obj.value.visit(this);
938 				break;
939 		}
940 		exit(obj);
941 	}
942 
943 	void enter(const(DefaultValue) obj) {}
944 	void exit(const(DefaultValue) obj) {}
945 
946 	void accept(const(DefaultValue) obj) {
947 		enter(obj);
948 		final switch(obj.ruleSelection) {
949 			case DefaultValueEnum.DV:
950 				obj.value.visit(this);
951 				break;
952 		}
953 		exit(obj);
954 	}
955 
956 	void enter(ValueOrVariable obj) {}
957 	void exit(ValueOrVariable obj) {}
958 
959 	void accept(ValueOrVariable obj) {
960 		enter(obj);
961 		final switch(obj.ruleSelection) {
962 			case ValueOrVariableEnum.Val:
963 				obj.val.visit(this);
964 				break;
965 			case ValueOrVariableEnum.Var:
966 				obj.var.visit(this);
967 				break;
968 		}
969 		exit(obj);
970 	}
971 
972 	void enter(const(ValueOrVariable) obj) {}
973 	void exit(const(ValueOrVariable) obj) {}
974 
975 	void accept(const(ValueOrVariable) obj) {
976 		enter(obj);
977 		final switch(obj.ruleSelection) {
978 			case ValueOrVariableEnum.Val:
979 				obj.val.visit(this);
980 				break;
981 			case ValueOrVariableEnum.Var:
982 				obj.var.visit(this);
983 				break;
984 		}
985 		exit(obj);
986 	}
987 
988 	void enter(Value obj) {}
989 	void exit(Value obj) {}
990 
991 	void accept(Value obj) {
992 		enter(obj);
993 		final switch(obj.ruleSelection) {
994 			case ValueEnum.STR:
995 				obj.tok.visit(this);
996 				break;
997 			case ValueEnum.INT:
998 				obj.tok.visit(this);
999 				break;
1000 			case ValueEnum.FLOAT:
1001 				obj.tok.visit(this);
1002 				break;
1003 			case ValueEnum.T:
1004 				obj.tok.visit(this);
1005 				break;
1006 			case ValueEnum.F:
1007 				obj.tok.visit(this);
1008 				break;
1009 			case ValueEnum.ARR:
1010 				obj.arr.visit(this);
1011 				break;
1012 			case ValueEnum.O:
1013 				obj.obj.visit(this);
1014 				break;
1015 		}
1016 		exit(obj);
1017 	}
1018 
1019 	void enter(const(Value) obj) {}
1020 	void exit(const(Value) obj) {}
1021 
1022 	void accept(const(Value) obj) {
1023 		enter(obj);
1024 		final switch(obj.ruleSelection) {
1025 			case ValueEnum.STR:
1026 				obj.tok.visit(this);
1027 				break;
1028 			case ValueEnum.INT:
1029 				obj.tok.visit(this);
1030 				break;
1031 			case ValueEnum.FLOAT:
1032 				obj.tok.visit(this);
1033 				break;
1034 			case ValueEnum.T:
1035 				obj.tok.visit(this);
1036 				break;
1037 			case ValueEnum.F:
1038 				obj.tok.visit(this);
1039 				break;
1040 			case ValueEnum.ARR:
1041 				obj.arr.visit(this);
1042 				break;
1043 			case ValueEnum.O:
1044 				obj.obj.visit(this);
1045 				break;
1046 		}
1047 		exit(obj);
1048 	}
1049 
1050 	void enter(Type obj) {}
1051 	void exit(Type obj) {}
1052 
1053 	void accept(Type obj) {
1054 		enter(obj);
1055 		final switch(obj.ruleSelection) {
1056 			case TypeEnum.TN:
1057 				obj.tname.visit(this);
1058 				break;
1059 			case TypeEnum.LN:
1060 				obj.list.visit(this);
1061 				break;
1062 			case TypeEnum.T:
1063 				obj.tname.visit(this);
1064 				break;
1065 			case TypeEnum.L:
1066 				obj.list.visit(this);
1067 				break;
1068 		}
1069 		exit(obj);
1070 	}
1071 
1072 	void enter(const(Type) obj) {}
1073 	void exit(const(Type) obj) {}
1074 
1075 	void accept(const(Type) obj) {
1076 		enter(obj);
1077 		final switch(obj.ruleSelection) {
1078 			case TypeEnum.TN:
1079 				obj.tname.visit(this);
1080 				break;
1081 			case TypeEnum.LN:
1082 				obj.list.visit(this);
1083 				break;
1084 			case TypeEnum.T:
1085 				obj.tname.visit(this);
1086 				break;
1087 			case TypeEnum.L:
1088 				obj.list.visit(this);
1089 				break;
1090 		}
1091 		exit(obj);
1092 	}
1093 
1094 	void enter(ListType obj) {}
1095 	void exit(ListType obj) {}
1096 
1097 	void accept(ListType obj) {
1098 		enter(obj);
1099 		final switch(obj.ruleSelection) {
1100 			case ListTypeEnum.T:
1101 				obj.type.visit(this);
1102 				break;
1103 		}
1104 		exit(obj);
1105 	}
1106 
1107 	void enter(const(ListType) obj) {}
1108 	void exit(const(ListType) obj) {}
1109 
1110 	void accept(const(ListType) obj) {
1111 		enter(obj);
1112 		final switch(obj.ruleSelection) {
1113 			case ListTypeEnum.T:
1114 				obj.type.visit(this);
1115 				break;
1116 		}
1117 		exit(obj);
1118 	}
1119 
1120 	void enter(Values obj) {}
1121 	void exit(Values obj) {}
1122 
1123 	void accept(Values obj) {
1124 		enter(obj);
1125 		final switch(obj.ruleSelection) {
1126 			case ValuesEnum.Val:
1127 				obj.val.visit(this);
1128 				break;
1129 			case ValuesEnum.Vals:
1130 				obj.val.visit(this);
1131 				obj.follow.visit(this);
1132 				break;
1133 		}
1134 		exit(obj);
1135 	}
1136 
1137 	void enter(const(Values) obj) {}
1138 	void exit(const(Values) obj) {}
1139 
1140 	void accept(const(Values) obj) {
1141 		enter(obj);
1142 		final switch(obj.ruleSelection) {
1143 			case ValuesEnum.Val:
1144 				obj.val.visit(this);
1145 				break;
1146 			case ValuesEnum.Vals:
1147 				obj.val.visit(this);
1148 				obj.follow.visit(this);
1149 				break;
1150 		}
1151 		exit(obj);
1152 	}
1153 
1154 	void enter(Array obj) {}
1155 	void exit(Array obj) {}
1156 
1157 	void accept(Array obj) {
1158 		enter(obj);
1159 		final switch(obj.ruleSelection) {
1160 			case ArrayEnum.Empty:
1161 				break;
1162 			case ArrayEnum.Value:
1163 				obj.vals.visit(this);
1164 				break;
1165 		}
1166 		exit(obj);
1167 	}
1168 
1169 	void enter(const(Array) obj) {}
1170 	void exit(const(Array) obj) {}
1171 
1172 	void accept(const(Array) obj) {
1173 		enter(obj);
1174 		final switch(obj.ruleSelection) {
1175 			case ArrayEnum.Empty:
1176 				break;
1177 			case ArrayEnum.Value:
1178 				obj.vals.visit(this);
1179 				break;
1180 		}
1181 		exit(obj);
1182 	}
1183 
1184 	void enter(ObjectValues obj) {}
1185 	void exit(ObjectValues obj) {}
1186 
1187 	void accept(ObjectValues obj) {
1188 		enter(obj);
1189 		final switch(obj.ruleSelection) {
1190 			case ObjectValuesEnum.V:
1191 				obj.name.visit(this);
1192 				obj.val.visit(this);
1193 				break;
1194 			case ObjectValuesEnum.Vsc:
1195 				obj.name.visit(this);
1196 				obj.val.visit(this);
1197 				obj.follow.visit(this);
1198 				break;
1199 			case ObjectValuesEnum.Vs:
1200 				obj.name.visit(this);
1201 				obj.val.visit(this);
1202 				obj.follow.visit(this);
1203 				break;
1204 		}
1205 		exit(obj);
1206 	}
1207 
1208 	void enter(const(ObjectValues) obj) {}
1209 	void exit(const(ObjectValues) obj) {}
1210 
1211 	void accept(const(ObjectValues) obj) {
1212 		enter(obj);
1213 		final switch(obj.ruleSelection) {
1214 			case ObjectValuesEnum.V:
1215 				obj.name.visit(this);
1216 				obj.val.visit(this);
1217 				break;
1218 			case ObjectValuesEnum.Vsc:
1219 				obj.name.visit(this);
1220 				obj.val.visit(this);
1221 				obj.follow.visit(this);
1222 				break;
1223 			case ObjectValuesEnum.Vs:
1224 				obj.name.visit(this);
1225 				obj.val.visit(this);
1226 				obj.follow.visit(this);
1227 				break;
1228 		}
1229 		exit(obj);
1230 	}
1231 
1232 	void enter(ObjectValue obj) {}
1233 	void exit(ObjectValue obj) {}
1234 
1235 	void accept(ObjectValue obj) {
1236 		enter(obj);
1237 		final switch(obj.ruleSelection) {
1238 			case ObjectValueEnum.V:
1239 				obj.name.visit(this);
1240 				obj.val.visit(this);
1241 				break;
1242 		}
1243 		exit(obj);
1244 	}
1245 
1246 	void enter(const(ObjectValue) obj) {}
1247 	void exit(const(ObjectValue) obj) {}
1248 
1249 	void accept(const(ObjectValue) obj) {
1250 		enter(obj);
1251 		final switch(obj.ruleSelection) {
1252 			case ObjectValueEnum.V:
1253 				obj.name.visit(this);
1254 				obj.val.visit(this);
1255 				break;
1256 		}
1257 		exit(obj);
1258 	}
1259 
1260 	void enter(ObjectType obj) {}
1261 	void exit(ObjectType obj) {}
1262 
1263 	void accept(ObjectType obj) {
1264 		enter(obj);
1265 		final switch(obj.ruleSelection) {
1266 			case ObjectTypeEnum.Var:
1267 				obj.vals.visit(this);
1268 				break;
1269 		}
1270 		exit(obj);
1271 	}
1272 
1273 	void enter(const(ObjectType) obj) {}
1274 	void exit(const(ObjectType) obj) {}
1275 
1276 	void accept(const(ObjectType) obj) {
1277 		enter(obj);
1278 		final switch(obj.ruleSelection) {
1279 			case ObjectTypeEnum.Var:
1280 				obj.vals.visit(this);
1281 				break;
1282 		}
1283 		exit(obj);
1284 	}
1285 
1286 	void enter(TypeSystemDefinition obj) {}
1287 	void exit(TypeSystemDefinition obj) {}
1288 
1289 	void accept(TypeSystemDefinition obj) {
1290 		enter(obj);
1291 		final switch(obj.ruleSelection) {
1292 			case TypeSystemDefinitionEnum.S:
1293 				obj.sch.visit(this);
1294 				break;
1295 			case TypeSystemDefinitionEnum.T:
1296 				obj.td.visit(this);
1297 				break;
1298 			case TypeSystemDefinitionEnum.TE:
1299 				obj.ted.visit(this);
1300 				break;
1301 			case TypeSystemDefinitionEnum.D:
1302 				obj.dd.visit(this);
1303 				break;
1304 		}
1305 		exit(obj);
1306 	}
1307 
1308 	void enter(const(TypeSystemDefinition) obj) {}
1309 	void exit(const(TypeSystemDefinition) obj) {}
1310 
1311 	void accept(const(TypeSystemDefinition) obj) {
1312 		enter(obj);
1313 		final switch(obj.ruleSelection) {
1314 			case TypeSystemDefinitionEnum.S:
1315 				obj.sch.visit(this);
1316 				break;
1317 			case TypeSystemDefinitionEnum.T:
1318 				obj.td.visit(this);
1319 				break;
1320 			case TypeSystemDefinitionEnum.TE:
1321 				obj.ted.visit(this);
1322 				break;
1323 			case TypeSystemDefinitionEnum.D:
1324 				obj.dd.visit(this);
1325 				break;
1326 		}
1327 		exit(obj);
1328 	}
1329 
1330 	void enter(TypeDefinition obj) {}
1331 	void exit(TypeDefinition obj) {}
1332 
1333 	void accept(TypeDefinition obj) {
1334 		enter(obj);
1335 		final switch(obj.ruleSelection) {
1336 			case TypeDefinitionEnum.S:
1337 				obj.std.visit(this);
1338 				break;
1339 			case TypeDefinitionEnum.O:
1340 				obj.otd.visit(this);
1341 				break;
1342 			case TypeDefinitionEnum.I:
1343 				obj.itd.visit(this);
1344 				break;
1345 			case TypeDefinitionEnum.U:
1346 				obj.utd.visit(this);
1347 				break;
1348 			case TypeDefinitionEnum.E:
1349 				obj.etd.visit(this);
1350 				break;
1351 			case TypeDefinitionEnum.IO:
1352 				obj.iod.visit(this);
1353 				break;
1354 		}
1355 		exit(obj);
1356 	}
1357 
1358 	void enter(const(TypeDefinition) obj) {}
1359 	void exit(const(TypeDefinition) obj) {}
1360 
1361 	void accept(const(TypeDefinition) obj) {
1362 		enter(obj);
1363 		final switch(obj.ruleSelection) {
1364 			case TypeDefinitionEnum.S:
1365 				obj.std.visit(this);
1366 				break;
1367 			case TypeDefinitionEnum.O:
1368 				obj.otd.visit(this);
1369 				break;
1370 			case TypeDefinitionEnum.I:
1371 				obj.itd.visit(this);
1372 				break;
1373 			case TypeDefinitionEnum.U:
1374 				obj.utd.visit(this);
1375 				break;
1376 			case TypeDefinitionEnum.E:
1377 				obj.etd.visit(this);
1378 				break;
1379 			case TypeDefinitionEnum.IO:
1380 				obj.iod.visit(this);
1381 				break;
1382 		}
1383 		exit(obj);
1384 	}
1385 
1386 	void enter(SchemaDefinition obj) {}
1387 	void exit(SchemaDefinition obj) {}
1388 
1389 	void accept(SchemaDefinition obj) {
1390 		enter(obj);
1391 		final switch(obj.ruleSelection) {
1392 			case SchemaDefinitionEnum.DO:
1393 				obj.dir.visit(this);
1394 				obj.otds.visit(this);
1395 				break;
1396 			case SchemaDefinitionEnum.O:
1397 				obj.otds.visit(this);
1398 				break;
1399 		}
1400 		exit(obj);
1401 	}
1402 
1403 	void enter(const(SchemaDefinition) obj) {}
1404 	void exit(const(SchemaDefinition) obj) {}
1405 
1406 	void accept(const(SchemaDefinition) obj) {
1407 		enter(obj);
1408 		final switch(obj.ruleSelection) {
1409 			case SchemaDefinitionEnum.DO:
1410 				obj.dir.visit(this);
1411 				obj.otds.visit(this);
1412 				break;
1413 			case SchemaDefinitionEnum.O:
1414 				obj.otds.visit(this);
1415 				break;
1416 		}
1417 		exit(obj);
1418 	}
1419 
1420 	void enter(OperationTypeDefinitions obj) {}
1421 	void exit(OperationTypeDefinitions obj) {}
1422 
1423 	void accept(OperationTypeDefinitions obj) {
1424 		enter(obj);
1425 		final switch(obj.ruleSelection) {
1426 			case OperationTypeDefinitionsEnum.O:
1427 				obj.otd.visit(this);
1428 				break;
1429 			case OperationTypeDefinitionsEnum.OCS:
1430 				obj.otd.visit(this);
1431 				obj.follow.visit(this);
1432 				break;
1433 			case OperationTypeDefinitionsEnum.OS:
1434 				obj.otd.visit(this);
1435 				obj.follow.visit(this);
1436 				break;
1437 		}
1438 		exit(obj);
1439 	}
1440 
1441 	void enter(const(OperationTypeDefinitions) obj) {}
1442 	void exit(const(OperationTypeDefinitions) obj) {}
1443 
1444 	void accept(const(OperationTypeDefinitions) obj) {
1445 		enter(obj);
1446 		final switch(obj.ruleSelection) {
1447 			case OperationTypeDefinitionsEnum.O:
1448 				obj.otd.visit(this);
1449 				break;
1450 			case OperationTypeDefinitionsEnum.OCS:
1451 				obj.otd.visit(this);
1452 				obj.follow.visit(this);
1453 				break;
1454 			case OperationTypeDefinitionsEnum.OS:
1455 				obj.otd.visit(this);
1456 				obj.follow.visit(this);
1457 				break;
1458 		}
1459 		exit(obj);
1460 	}
1461 
1462 	void enter(OperationTypeDefinition obj) {}
1463 	void exit(OperationTypeDefinition obj) {}
1464 
1465 	void accept(OperationTypeDefinition obj) {
1466 		enter(obj);
1467 		final switch(obj.ruleSelection) {
1468 			case OperationTypeDefinitionEnum.O:
1469 				obj.ot.visit(this);
1470 				obj.nt.visit(this);
1471 				break;
1472 		}
1473 		exit(obj);
1474 	}
1475 
1476 	void enter(const(OperationTypeDefinition) obj) {}
1477 	void exit(const(OperationTypeDefinition) obj) {}
1478 
1479 	void accept(const(OperationTypeDefinition) obj) {
1480 		enter(obj);
1481 		final switch(obj.ruleSelection) {
1482 			case OperationTypeDefinitionEnum.O:
1483 				obj.ot.visit(this);
1484 				obj.nt.visit(this);
1485 				break;
1486 		}
1487 		exit(obj);
1488 	}
1489 
1490 	void enter(ScalarTypeDefinition obj) {}
1491 	void exit(ScalarTypeDefinition obj) {}
1492 
1493 	void accept(ScalarTypeDefinition obj) {
1494 		enter(obj);
1495 		final switch(obj.ruleSelection) {
1496 			case ScalarTypeDefinitionEnum.D:
1497 				obj.name.visit(this);
1498 				obj.dir.visit(this);
1499 				break;
1500 			case ScalarTypeDefinitionEnum.S:
1501 				obj.name.visit(this);
1502 				break;
1503 		}
1504 		exit(obj);
1505 	}
1506 
1507 	void enter(const(ScalarTypeDefinition) obj) {}
1508 	void exit(const(ScalarTypeDefinition) obj) {}
1509 
1510 	void accept(const(ScalarTypeDefinition) obj) {
1511 		enter(obj);
1512 		final switch(obj.ruleSelection) {
1513 			case ScalarTypeDefinitionEnum.D:
1514 				obj.name.visit(this);
1515 				obj.dir.visit(this);
1516 				break;
1517 			case ScalarTypeDefinitionEnum.S:
1518 				obj.name.visit(this);
1519 				break;
1520 		}
1521 		exit(obj);
1522 	}
1523 
1524 	void enter(ObjectTypeDefinition obj) {}
1525 	void exit(ObjectTypeDefinition obj) {}
1526 
1527 	void accept(ObjectTypeDefinition obj) {
1528 		enter(obj);
1529 		final switch(obj.ruleSelection) {
1530 			case ObjectTypeDefinitionEnum.ID:
1531 				obj.name.visit(this);
1532 				obj.ii.visit(this);
1533 				obj.dir.visit(this);
1534 				obj.fds.visit(this);
1535 				break;
1536 			case ObjectTypeDefinitionEnum.I:
1537 				obj.name.visit(this);
1538 				obj.ii.visit(this);
1539 				obj.fds.visit(this);
1540 				break;
1541 			case ObjectTypeDefinitionEnum.D:
1542 				obj.name.visit(this);
1543 				obj.dir.visit(this);
1544 				obj.fds.visit(this);
1545 				break;
1546 			case ObjectTypeDefinitionEnum.F:
1547 				obj.name.visit(this);
1548 				obj.fds.visit(this);
1549 				break;
1550 		}
1551 		exit(obj);
1552 	}
1553 
1554 	void enter(const(ObjectTypeDefinition) obj) {}
1555 	void exit(const(ObjectTypeDefinition) obj) {}
1556 
1557 	void accept(const(ObjectTypeDefinition) obj) {
1558 		enter(obj);
1559 		final switch(obj.ruleSelection) {
1560 			case ObjectTypeDefinitionEnum.ID:
1561 				obj.name.visit(this);
1562 				obj.ii.visit(this);
1563 				obj.dir.visit(this);
1564 				obj.fds.visit(this);
1565 				break;
1566 			case ObjectTypeDefinitionEnum.I:
1567 				obj.name.visit(this);
1568 				obj.ii.visit(this);
1569 				obj.fds.visit(this);
1570 				break;
1571 			case ObjectTypeDefinitionEnum.D:
1572 				obj.name.visit(this);
1573 				obj.dir.visit(this);
1574 				obj.fds.visit(this);
1575 				break;
1576 			case ObjectTypeDefinitionEnum.F:
1577 				obj.name.visit(this);
1578 				obj.fds.visit(this);
1579 				break;
1580 		}
1581 		exit(obj);
1582 	}
1583 
1584 	void enter(FieldDefinitions obj) {}
1585 	void exit(FieldDefinitions obj) {}
1586 
1587 	void accept(FieldDefinitions obj) {
1588 		enter(obj);
1589 		final switch(obj.ruleSelection) {
1590 			case FieldDefinitionsEnum.F:
1591 				obj.fd.visit(this);
1592 				break;
1593 			case FieldDefinitionsEnum.FC:
1594 				obj.fd.visit(this);
1595 				obj.follow.visit(this);
1596 				break;
1597 			case FieldDefinitionsEnum.FNC:
1598 				obj.fd.visit(this);
1599 				obj.follow.visit(this);
1600 				break;
1601 		}
1602 		exit(obj);
1603 	}
1604 
1605 	void enter(const(FieldDefinitions) obj) {}
1606 	void exit(const(FieldDefinitions) obj) {}
1607 
1608 	void accept(const(FieldDefinitions) obj) {
1609 		enter(obj);
1610 		final switch(obj.ruleSelection) {
1611 			case FieldDefinitionsEnum.F:
1612 				obj.fd.visit(this);
1613 				break;
1614 			case FieldDefinitionsEnum.FC:
1615 				obj.fd.visit(this);
1616 				obj.follow.visit(this);
1617 				break;
1618 			case FieldDefinitionsEnum.FNC:
1619 				obj.fd.visit(this);
1620 				obj.follow.visit(this);
1621 				break;
1622 		}
1623 		exit(obj);
1624 	}
1625 
1626 	void enter(FieldDefinition obj) {}
1627 	void exit(FieldDefinition obj) {}
1628 
1629 	void accept(FieldDefinition obj) {
1630 		enter(obj);
1631 		final switch(obj.ruleSelection) {
1632 			case FieldDefinitionEnum.AD:
1633 				obj.name.visit(this);
1634 				obj.arg.visit(this);
1635 				obj.typ.visit(this);
1636 				obj.dir.visit(this);
1637 				break;
1638 			case FieldDefinitionEnum.A:
1639 				obj.name.visit(this);
1640 				obj.arg.visit(this);
1641 				obj.typ.visit(this);
1642 				break;
1643 			case FieldDefinitionEnum.D:
1644 				obj.name.visit(this);
1645 				obj.typ.visit(this);
1646 				obj.dir.visit(this);
1647 				break;
1648 			case FieldDefinitionEnum.T:
1649 				obj.name.visit(this);
1650 				obj.typ.visit(this);
1651 				break;
1652 		}
1653 		exit(obj);
1654 	}
1655 
1656 	void enter(const(FieldDefinition) obj) {}
1657 	void exit(const(FieldDefinition) obj) {}
1658 
1659 	void accept(const(FieldDefinition) obj) {
1660 		enter(obj);
1661 		final switch(obj.ruleSelection) {
1662 			case FieldDefinitionEnum.AD:
1663 				obj.name.visit(this);
1664 				obj.arg.visit(this);
1665 				obj.typ.visit(this);
1666 				obj.dir.visit(this);
1667 				break;
1668 			case FieldDefinitionEnum.A:
1669 				obj.name.visit(this);
1670 				obj.arg.visit(this);
1671 				obj.typ.visit(this);
1672 				break;
1673 			case FieldDefinitionEnum.D:
1674 				obj.name.visit(this);
1675 				obj.typ.visit(this);
1676 				obj.dir.visit(this);
1677 				break;
1678 			case FieldDefinitionEnum.T:
1679 				obj.name.visit(this);
1680 				obj.typ.visit(this);
1681 				break;
1682 		}
1683 		exit(obj);
1684 	}
1685 
1686 	void enter(ImplementsInterfaces obj) {}
1687 	void exit(ImplementsInterfaces obj) {}
1688 
1689 	void accept(ImplementsInterfaces obj) {
1690 		enter(obj);
1691 		final switch(obj.ruleSelection) {
1692 			case ImplementsInterfacesEnum.N:
1693 				obj.nts.visit(this);
1694 				break;
1695 		}
1696 		exit(obj);
1697 	}
1698 
1699 	void enter(const(ImplementsInterfaces) obj) {}
1700 	void exit(const(ImplementsInterfaces) obj) {}
1701 
1702 	void accept(const(ImplementsInterfaces) obj) {
1703 		enter(obj);
1704 		final switch(obj.ruleSelection) {
1705 			case ImplementsInterfacesEnum.N:
1706 				obj.nts.visit(this);
1707 				break;
1708 		}
1709 		exit(obj);
1710 	}
1711 
1712 	void enter(NamedTypes obj) {}
1713 	void exit(NamedTypes obj) {}
1714 
1715 	void accept(NamedTypes obj) {
1716 		enter(obj);
1717 		final switch(obj.ruleSelection) {
1718 			case NamedTypesEnum.N:
1719 				obj.name.visit(this);
1720 				break;
1721 			case NamedTypesEnum.NCS:
1722 				obj.name.visit(this);
1723 				obj.follow.visit(this);
1724 				break;
1725 			case NamedTypesEnum.NS:
1726 				obj.name.visit(this);
1727 				obj.follow.visit(this);
1728 				break;
1729 		}
1730 		exit(obj);
1731 	}
1732 
1733 	void enter(const(NamedTypes) obj) {}
1734 	void exit(const(NamedTypes) obj) {}
1735 
1736 	void accept(const(NamedTypes) obj) {
1737 		enter(obj);
1738 		final switch(obj.ruleSelection) {
1739 			case NamedTypesEnum.N:
1740 				obj.name.visit(this);
1741 				break;
1742 			case NamedTypesEnum.NCS:
1743 				obj.name.visit(this);
1744 				obj.follow.visit(this);
1745 				break;
1746 			case NamedTypesEnum.NS:
1747 				obj.name.visit(this);
1748 				obj.follow.visit(this);
1749 				break;
1750 		}
1751 		exit(obj);
1752 	}
1753 
1754 	void enter(ArgumentsDefinition obj) {}
1755 	void exit(ArgumentsDefinition obj) {}
1756 
1757 	void accept(ArgumentsDefinition obj) {
1758 		enter(obj);
1759 		final switch(obj.ruleSelection) {
1760 			case ArgumentsDefinitionEnum.A:
1761 				break;
1762 		}
1763 		exit(obj);
1764 	}
1765 
1766 	void enter(const(ArgumentsDefinition) obj) {}
1767 	void exit(const(ArgumentsDefinition) obj) {}
1768 
1769 	void accept(const(ArgumentsDefinition) obj) {
1770 		enter(obj);
1771 		final switch(obj.ruleSelection) {
1772 			case ArgumentsDefinitionEnum.A:
1773 				break;
1774 		}
1775 		exit(obj);
1776 	}
1777 
1778 	void enter(InputValueDefinitions obj) {}
1779 	void exit(InputValueDefinitions obj) {}
1780 
1781 	void accept(InputValueDefinitions obj) {
1782 		enter(obj);
1783 		final switch(obj.ruleSelection) {
1784 			case InputValueDefinitionsEnum.I:
1785 				obj.iv.visit(this);
1786 				break;
1787 			case InputValueDefinitionsEnum.ICF:
1788 				obj.iv.visit(this);
1789 				obj.follow.visit(this);
1790 				break;
1791 			case InputValueDefinitionsEnum.IF:
1792 				obj.iv.visit(this);
1793 				obj.follow.visit(this);
1794 				break;
1795 		}
1796 		exit(obj);
1797 	}
1798 
1799 	void enter(const(InputValueDefinitions) obj) {}
1800 	void exit(const(InputValueDefinitions) obj) {}
1801 
1802 	void accept(const(InputValueDefinitions) obj) {
1803 		enter(obj);
1804 		final switch(obj.ruleSelection) {
1805 			case InputValueDefinitionsEnum.I:
1806 				obj.iv.visit(this);
1807 				break;
1808 			case InputValueDefinitionsEnum.ICF:
1809 				obj.iv.visit(this);
1810 				obj.follow.visit(this);
1811 				break;
1812 			case InputValueDefinitionsEnum.IF:
1813 				obj.iv.visit(this);
1814 				obj.follow.visit(this);
1815 				break;
1816 		}
1817 		exit(obj);
1818 	}
1819 
1820 	void enter(InputValueDefinition obj) {}
1821 	void exit(InputValueDefinition obj) {}
1822 
1823 	void accept(InputValueDefinition obj) {
1824 		enter(obj);
1825 		final switch(obj.ruleSelection) {
1826 			case InputValueDefinitionEnum.TVD:
1827 				obj.name.visit(this);
1828 				obj.type.visit(this);
1829 				obj.df.visit(this);
1830 				obj.dirs.visit(this);
1831 				break;
1832 			case InputValueDefinitionEnum.TD:
1833 				obj.name.visit(this);
1834 				obj.type.visit(this);
1835 				obj.dirs.visit(this);
1836 				break;
1837 			case InputValueDefinitionEnum.TV:
1838 				obj.name.visit(this);
1839 				obj.type.visit(this);
1840 				obj.df.visit(this);
1841 				break;
1842 			case InputValueDefinitionEnum.T:
1843 				obj.name.visit(this);
1844 				obj.type.visit(this);
1845 				break;
1846 		}
1847 		exit(obj);
1848 	}
1849 
1850 	void enter(const(InputValueDefinition) obj) {}
1851 	void exit(const(InputValueDefinition) obj) {}
1852 
1853 	void accept(const(InputValueDefinition) obj) {
1854 		enter(obj);
1855 		final switch(obj.ruleSelection) {
1856 			case InputValueDefinitionEnum.TVD:
1857 				obj.name.visit(this);
1858 				obj.type.visit(this);
1859 				obj.df.visit(this);
1860 				obj.dirs.visit(this);
1861 				break;
1862 			case InputValueDefinitionEnum.TD:
1863 				obj.name.visit(this);
1864 				obj.type.visit(this);
1865 				obj.dirs.visit(this);
1866 				break;
1867 			case InputValueDefinitionEnum.TV:
1868 				obj.name.visit(this);
1869 				obj.type.visit(this);
1870 				obj.df.visit(this);
1871 				break;
1872 			case InputValueDefinitionEnum.T:
1873 				obj.name.visit(this);
1874 				obj.type.visit(this);
1875 				break;
1876 		}
1877 		exit(obj);
1878 	}
1879 
1880 	void enter(InterfaceTypeDefinition obj) {}
1881 	void exit(InterfaceTypeDefinition obj) {}
1882 
1883 	void accept(InterfaceTypeDefinition obj) {
1884 		enter(obj);
1885 		final switch(obj.ruleSelection) {
1886 			case InterfaceTypeDefinitionEnum.NDF:
1887 				obj.name.visit(this);
1888 				obj.dirs.visit(this);
1889 				obj.fds.visit(this);
1890 				break;
1891 			case InterfaceTypeDefinitionEnum.NF:
1892 				obj.name.visit(this);
1893 				obj.fds.visit(this);
1894 				break;
1895 		}
1896 		exit(obj);
1897 	}
1898 
1899 	void enter(const(InterfaceTypeDefinition) obj) {}
1900 	void exit(const(InterfaceTypeDefinition) obj) {}
1901 
1902 	void accept(const(InterfaceTypeDefinition) obj) {
1903 		enter(obj);
1904 		final switch(obj.ruleSelection) {
1905 			case InterfaceTypeDefinitionEnum.NDF:
1906 				obj.name.visit(this);
1907 				obj.dirs.visit(this);
1908 				obj.fds.visit(this);
1909 				break;
1910 			case InterfaceTypeDefinitionEnum.NF:
1911 				obj.name.visit(this);
1912 				obj.fds.visit(this);
1913 				break;
1914 		}
1915 		exit(obj);
1916 	}
1917 
1918 	void enter(UnionTypeDefinition obj) {}
1919 	void exit(UnionTypeDefinition obj) {}
1920 
1921 	void accept(UnionTypeDefinition obj) {
1922 		enter(obj);
1923 		final switch(obj.ruleSelection) {
1924 			case UnionTypeDefinitionEnum.NDU:
1925 				obj.name.visit(this);
1926 				obj.dirs.visit(this);
1927 				obj.um.visit(this);
1928 				break;
1929 			case UnionTypeDefinitionEnum.NU:
1930 				obj.name.visit(this);
1931 				obj.um.visit(this);
1932 				break;
1933 		}
1934 		exit(obj);
1935 	}
1936 
1937 	void enter(const(UnionTypeDefinition) obj) {}
1938 	void exit(const(UnionTypeDefinition) obj) {}
1939 
1940 	void accept(const(UnionTypeDefinition) obj) {
1941 		enter(obj);
1942 		final switch(obj.ruleSelection) {
1943 			case UnionTypeDefinitionEnum.NDU:
1944 				obj.name.visit(this);
1945 				obj.dirs.visit(this);
1946 				obj.um.visit(this);
1947 				break;
1948 			case UnionTypeDefinitionEnum.NU:
1949 				obj.name.visit(this);
1950 				obj.um.visit(this);
1951 				break;
1952 		}
1953 		exit(obj);
1954 	}
1955 
1956 	void enter(UnionMembers obj) {}
1957 	void exit(UnionMembers obj) {}
1958 
1959 	void accept(UnionMembers obj) {
1960 		enter(obj);
1961 		final switch(obj.ruleSelection) {
1962 			case UnionMembersEnum.S:
1963 				obj.name.visit(this);
1964 				break;
1965 			case UnionMembersEnum.SPF:
1966 				obj.name.visit(this);
1967 				obj.follow.visit(this);
1968 				break;
1969 			case UnionMembersEnum.SF:
1970 				obj.name.visit(this);
1971 				obj.follow.visit(this);
1972 				break;
1973 		}
1974 		exit(obj);
1975 	}
1976 
1977 	void enter(const(UnionMembers) obj) {}
1978 	void exit(const(UnionMembers) obj) {}
1979 
1980 	void accept(const(UnionMembers) obj) {
1981 		enter(obj);
1982 		final switch(obj.ruleSelection) {
1983 			case UnionMembersEnum.S:
1984 				obj.name.visit(this);
1985 				break;
1986 			case UnionMembersEnum.SPF:
1987 				obj.name.visit(this);
1988 				obj.follow.visit(this);
1989 				break;
1990 			case UnionMembersEnum.SF:
1991 				obj.name.visit(this);
1992 				obj.follow.visit(this);
1993 				break;
1994 		}
1995 		exit(obj);
1996 	}
1997 
1998 	void enter(EnumTypeDefinition obj) {}
1999 	void exit(EnumTypeDefinition obj) {}
2000 
2001 	void accept(EnumTypeDefinition obj) {
2002 		enter(obj);
2003 		final switch(obj.ruleSelection) {
2004 			case EnumTypeDefinitionEnum.NDE:
2005 				obj.name.visit(this);
2006 				obj.dir.visit(this);
2007 				obj.evds.visit(this);
2008 				break;
2009 			case EnumTypeDefinitionEnum.NE:
2010 				obj.name.visit(this);
2011 				obj.evds.visit(this);
2012 				break;
2013 		}
2014 		exit(obj);
2015 	}
2016 
2017 	void enter(const(EnumTypeDefinition) obj) {}
2018 	void exit(const(EnumTypeDefinition) obj) {}
2019 
2020 	void accept(const(EnumTypeDefinition) obj) {
2021 		enter(obj);
2022 		final switch(obj.ruleSelection) {
2023 			case EnumTypeDefinitionEnum.NDE:
2024 				obj.name.visit(this);
2025 				obj.dir.visit(this);
2026 				obj.evds.visit(this);
2027 				break;
2028 			case EnumTypeDefinitionEnum.NE:
2029 				obj.name.visit(this);
2030 				obj.evds.visit(this);
2031 				break;
2032 		}
2033 		exit(obj);
2034 	}
2035 
2036 	void enter(EnumValueDefinitions obj) {}
2037 	void exit(EnumValueDefinitions obj) {}
2038 
2039 	void accept(EnumValueDefinitions obj) {
2040 		enter(obj);
2041 		final switch(obj.ruleSelection) {
2042 			case EnumValueDefinitionsEnum.D:
2043 				obj.evd.visit(this);
2044 				break;
2045 			case EnumValueDefinitionsEnum.DCE:
2046 				obj.evd.visit(this);
2047 				obj.follow.visit(this);
2048 				break;
2049 			case EnumValueDefinitionsEnum.DE:
2050 				obj.evd.visit(this);
2051 				obj.follow.visit(this);
2052 				break;
2053 		}
2054 		exit(obj);
2055 	}
2056 
2057 	void enter(const(EnumValueDefinitions) obj) {}
2058 	void exit(const(EnumValueDefinitions) obj) {}
2059 
2060 	void accept(const(EnumValueDefinitions) obj) {
2061 		enter(obj);
2062 		final switch(obj.ruleSelection) {
2063 			case EnumValueDefinitionsEnum.D:
2064 				obj.evd.visit(this);
2065 				break;
2066 			case EnumValueDefinitionsEnum.DCE:
2067 				obj.evd.visit(this);
2068 				obj.follow.visit(this);
2069 				break;
2070 			case EnumValueDefinitionsEnum.DE:
2071 				obj.evd.visit(this);
2072 				obj.follow.visit(this);
2073 				break;
2074 		}
2075 		exit(obj);
2076 	}
2077 
2078 	void enter(EnumValueDefinition obj) {}
2079 	void exit(EnumValueDefinition obj) {}
2080 
2081 	void accept(EnumValueDefinition obj) {
2082 		enter(obj);
2083 		final switch(obj.ruleSelection) {
2084 			case EnumValueDefinitionEnum.ED:
2085 				obj.name.visit(this);
2086 				obj.dirs.visit(this);
2087 				break;
2088 			case EnumValueDefinitionEnum.E:
2089 				obj.name.visit(this);
2090 				break;
2091 		}
2092 		exit(obj);
2093 	}
2094 
2095 	void enter(const(EnumValueDefinition) obj) {}
2096 	void exit(const(EnumValueDefinition) obj) {}
2097 
2098 	void accept(const(EnumValueDefinition) obj) {
2099 		enter(obj);
2100 		final switch(obj.ruleSelection) {
2101 			case EnumValueDefinitionEnum.ED:
2102 				obj.name.visit(this);
2103 				obj.dirs.visit(this);
2104 				break;
2105 			case EnumValueDefinitionEnum.E:
2106 				obj.name.visit(this);
2107 				break;
2108 		}
2109 		exit(obj);
2110 	}
2111 
2112 	void enter(InputTypeDefinition obj) {}
2113 	void exit(InputTypeDefinition obj) {}
2114 
2115 	void accept(InputTypeDefinition obj) {
2116 		enter(obj);
2117 		final switch(obj.ruleSelection) {
2118 			case InputTypeDefinitionEnum.NDE:
2119 				obj.name.visit(this);
2120 				obj.dir.visit(this);
2121 				obj.ivds.visit(this);
2122 				break;
2123 			case InputTypeDefinitionEnum.NE:
2124 				obj.name.visit(this);
2125 				obj.ivds.visit(this);
2126 				break;
2127 		}
2128 		exit(obj);
2129 	}
2130 
2131 	void enter(const(InputTypeDefinition) obj) {}
2132 	void exit(const(InputTypeDefinition) obj) {}
2133 
2134 	void accept(const(InputTypeDefinition) obj) {
2135 		enter(obj);
2136 		final switch(obj.ruleSelection) {
2137 			case InputTypeDefinitionEnum.NDE:
2138 				obj.name.visit(this);
2139 				obj.dir.visit(this);
2140 				obj.ivds.visit(this);
2141 				break;
2142 			case InputTypeDefinitionEnum.NE:
2143 				obj.name.visit(this);
2144 				obj.ivds.visit(this);
2145 				break;
2146 		}
2147 		exit(obj);
2148 	}
2149 
2150 	void enter(TypeExtensionDefinition obj) {}
2151 	void exit(TypeExtensionDefinition obj) {}
2152 
2153 	void accept(TypeExtensionDefinition obj) {
2154 		enter(obj);
2155 		final switch(obj.ruleSelection) {
2156 			case TypeExtensionDefinitionEnum.O:
2157 				obj.otd.visit(this);
2158 				break;
2159 		}
2160 		exit(obj);
2161 	}
2162 
2163 	void enter(const(TypeExtensionDefinition) obj) {}
2164 	void exit(const(TypeExtensionDefinition) obj) {}
2165 
2166 	void accept(const(TypeExtensionDefinition) obj) {
2167 		enter(obj);
2168 		final switch(obj.ruleSelection) {
2169 			case TypeExtensionDefinitionEnum.O:
2170 				obj.otd.visit(this);
2171 				break;
2172 		}
2173 		exit(obj);
2174 	}
2175 
2176 	void enter(DirectiveDefinition obj) {}
2177 	void exit(DirectiveDefinition obj) {}
2178 
2179 	void accept(DirectiveDefinition obj) {
2180 		enter(obj);
2181 		final switch(obj.ruleSelection) {
2182 			case DirectiveDefinitionEnum.AD:
2183 				obj.name.visit(this);
2184 				obj.ad.visit(this);
2185 				obj.dl.visit(this);
2186 				break;
2187 			case DirectiveDefinitionEnum.D:
2188 				obj.name.visit(this);
2189 				obj.dl.visit(this);
2190 				break;
2191 		}
2192 		exit(obj);
2193 	}
2194 
2195 	void enter(const(DirectiveDefinition) obj) {}
2196 	void exit(const(DirectiveDefinition) obj) {}
2197 
2198 	void accept(const(DirectiveDefinition) obj) {
2199 		enter(obj);
2200 		final switch(obj.ruleSelection) {
2201 			case DirectiveDefinitionEnum.AD:
2202 				obj.name.visit(this);
2203 				obj.ad.visit(this);
2204 				obj.dl.visit(this);
2205 				break;
2206 			case DirectiveDefinitionEnum.D:
2207 				obj.name.visit(this);
2208 				obj.dl.visit(this);
2209 				break;
2210 		}
2211 		exit(obj);
2212 	}
2213 
2214 	void enter(DirectiveLocations obj) {}
2215 	void exit(DirectiveLocations obj) {}
2216 
2217 	void accept(DirectiveLocations obj) {
2218 		enter(obj);
2219 		final switch(obj.ruleSelection) {
2220 			case DirectiveLocationsEnum.N:
2221 				obj.name.visit(this);
2222 				break;
2223 			case DirectiveLocationsEnum.NPF:
2224 				obj.name.visit(this);
2225 				obj.follow.visit(this);
2226 				break;
2227 			case DirectiveLocationsEnum.NF:
2228 				obj.name.visit(this);
2229 				obj.follow.visit(this);
2230 				break;
2231 		}
2232 		exit(obj);
2233 	}
2234 
2235 	void enter(const(DirectiveLocations) obj) {}
2236 	void exit(const(DirectiveLocations) obj) {}
2237 
2238 	void accept(const(DirectiveLocations) obj) {
2239 		enter(obj);
2240 		final switch(obj.ruleSelection) {
2241 			case DirectiveLocationsEnum.N:
2242 				obj.name.visit(this);
2243 				break;
2244 			case DirectiveLocationsEnum.NPF:
2245 				obj.name.visit(this);
2246 				obj.follow.visit(this);
2247 				break;
2248 			case DirectiveLocationsEnum.NF:
2249 				obj.name.visit(this);
2250 				obj.follow.visit(this);
2251 				break;
2252 		}
2253 		exit(obj);
2254 	}
2255 
2256 	void enter(InputObjectTypeDefinition obj) {}
2257 	void exit(InputObjectTypeDefinition obj) {}
2258 
2259 	void accept(InputObjectTypeDefinition obj) {
2260 		enter(obj);
2261 		final switch(obj.ruleSelection) {
2262 			case InputObjectTypeDefinitionEnum.NDI:
2263 				obj.name.visit(this);
2264 				obj.dirs.visit(this);
2265 				break;
2266 			case InputObjectTypeDefinitionEnum.NI:
2267 				obj.name.visit(this);
2268 				break;
2269 		}
2270 		exit(obj);
2271 	}
2272 
2273 	void enter(const(InputObjectTypeDefinition) obj) {}
2274 	void exit(const(InputObjectTypeDefinition) obj) {}
2275 
2276 	void accept(const(InputObjectTypeDefinition) obj) {
2277 		enter(obj);
2278 		final switch(obj.ruleSelection) {
2279 			case InputObjectTypeDefinitionEnum.NDI:
2280 				obj.name.visit(this);
2281 				obj.dirs.visit(this);
2282 				break;
2283 			case InputObjectTypeDefinitionEnum.NI:
2284 				obj.name.visit(this);
2285 				break;
2286 		}
2287 		exit(obj);
2288 	}
2289 }

Page generated by adrdox