~zorba-coders/zorba/bug-950621

« back to all changes in this revision

Viewing changes to src/compiler/parsetree/parsenode_print_dot_visitor.cpp

  • Committer: brantmat at ETHZ
  • Date: 2007-10-09 12:58:38 UTC
  • Revision ID: svn-v4:8046edc3-af21-0410-8661-ec7318497eea:trunk/zorba:904
commit of the new directory structure

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
#include "parsenode_print_dot_visitor.h"
 
2
 
 
3
#include <ostream>
 
4
 
 
5
#include "../parser/parsenodes.h"
 
6
 
 
7
namespace xqp {
 
8
 
 
9
 
 
10
ParseNodePrintDOTVisitor::ParseNodePrintDOTVisitor(std::ostream &aStream)
 
11
  : theIndent(0),
 
12
    os(aStream)
 
13
{
 
14
}
 
15
 
 
16
void
 
17
ParseNodePrintDOTVisitor::print(parsenode* n)
 
18
{
 
19
    os << "digraph query {" << std::endl;
 
20
    n->accept(*this);
 
21
    os << "}" << std::endl;
 
22
}
 
23
 
 
24
bool
 
25
ParseNodePrintDOTVisitor::begin_visit(const parsenode &n)
 
26
{    
 
27
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
28
          << "label=\"ParseNode\\n[" 
 
29
          << n.get_location() << "]" << "\"]" << std::endl;
 
30
 
 
31
    NL;
 
32
 
 
33
    return true;
 
34
}
 
35
 
 
36
 
 
37
bool
 
38
ParseNodePrintDOTVisitor::begin_visit(const AbbrevForwardStep &n)
 
39
{
 
40
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
41
          << "label=\"AbbrevForwardStep\\n[" 
 
42
          << n.get_location() << "]" << "\"]" << std::endl;
 
43
 
 
44
    NL;
 
45
    return true;
 
46
}
 
47
 
 
48
 
 
49
bool
 
50
ParseNodePrintDOTVisitor::begin_visit(const AnyKindTest &n)
 
51
{
 
52
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
53
          << "label=\"AnyKindTest\\n[" 
 
54
          << n.get_location() << "]" << "\"]" << std::endl;
 
55
 
 
56
    NL;
 
57
    return true;
 
58
}
 
59
 
 
60
 
 
61
bool
 
62
ParseNodePrintDOTVisitor::begin_visit(const AposAttrContentList &n)
 
63
{
 
64
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
65
          << "label=\"AposAttrContentList\\n[" 
 
66
          << n.get_location() << "]" << "\"]" << std::endl;
 
67
 
 
68
    NL;
 
69
    return true;
 
70
}
 
71
 
 
72
 
 
73
bool
 
74
ParseNodePrintDOTVisitor::begin_visit(const AposAttrValueContent &n)
 
75
{
 
76
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
77
          << "label=\"AposAttrValueContent\\n[" 
 
78
          << n.get_location() << "]" << "\"]" << std::endl;
 
79
 
 
80
    NL;
 
81
    return true;
 
82
}
 
83
 
 
84
 
 
85
bool
 
86
ParseNodePrintDOTVisitor::begin_visit(const ArgList &n)
 
87
{
 
88
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
89
          << "label=\"ArgList\\n[" 
 
90
          << n.get_location() << "]" << "\"]" << std::endl;
 
91
 
 
92
    NL;
 
93
    return true;
 
94
}
 
95
 
 
96
 
 
97
bool
 
98
ParseNodePrintDOTVisitor::begin_visit(const AtomicType &n)
 
99
{
 
100
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
101
          << "label=\"AtomicType\\n[" 
 
102
          << n.get_location() << "]" << "\"]" << std::endl;
 
103
 
 
104
    NL;
 
105
    return true;
 
106
}
 
107
 
 
108
 
 
109
bool
 
110
ParseNodePrintDOTVisitor::begin_visit(const AttributeTest &n)
 
111
{
 
112
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
113
          << "label=\"AttributeTest\\n[" 
 
114
          << n.get_location() << "]" << "\"]" << std::endl;
 
115
 
 
116
    NL;
 
117
    return true;
 
118
}
 
119
 
 
120
 
 
121
bool
 
122
ParseNodePrintDOTVisitor::begin_visit(const BaseURIDecl &n)
 
123
{
 
124
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
125
          << "label=\"BaseURIDecl\\n[" 
 
126
          << n.get_location() << "]" << "\"]" << std::endl;
 
127
 
 
128
    NL;
 
129
    return true;
 
130
}
 
131
 
 
132
 
 
133
bool
 
134
ParseNodePrintDOTVisitor::begin_visit(const BoundarySpaceDecl &n)
 
135
{
 
136
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
137
          << "label=\"BoundarySpaceDecl\\n[" 
 
138
          << n.get_location() << "]" << "\"]" << std::endl;
 
139
 
 
140
    NL;
 
141
    return true;
 
142
}
 
143
 
 
144
 
 
145
bool
 
146
ParseNodePrintDOTVisitor::begin_visit(const CaseClause &n)
 
147
{
 
148
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
149
          << "label=\"CaseClause\\n[" 
 
150
          << n.get_location() << "]" << "\"]" << std::endl;
 
151
 
 
152
    NL;
 
153
    return true;
 
154
}
 
155
 
 
156
 
 
157
bool
 
158
ParseNodePrintDOTVisitor::begin_visit(const CaseClauseList &n)
 
159
{
 
160
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
161
          << "label=\"CaseClauseList\\n[" 
 
162
          << n.get_location() << "]" << "\"]" << std::endl;
 
163
 
 
164
    NL;
 
165
    return true;
 
166
}
 
167
 
 
168
 
 
169
bool
 
170
ParseNodePrintDOTVisitor::begin_visit(const CommentTest &n)
 
171
{
 
172
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
173
          << "label=\"CommentTest\\n[" 
 
174
          << n.get_location() << "]" << "\"]" << std::endl;
 
175
 
 
176
    NL;
 
177
    return true;
 
178
}
 
179
 
 
180
 
 
181
bool
 
182
ParseNodePrintDOTVisitor::begin_visit(const ConstructionDecl &n)
 
183
{
 
184
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
185
          << "label=\"ConstructionDecl\\n[" 
 
186
          << n.get_location() << "]" << "\"]" << std::endl;
 
187
 
 
188
    NL;
 
189
    return true;
 
190
}
 
191
 
 
192
 
 
193
bool
 
194
ParseNodePrintDOTVisitor::begin_visit(const CopyNamespacesDecl &n)
 
195
{
 
196
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
197
          << "label=\"CopyNamespacesDecl\\n[" 
 
198
          << n.get_location() << "]" << "\"]" << std::endl;
 
199
 
 
200
    NL;
 
201
    return true;
 
202
}
 
203
 
 
204
 
 
205
bool
 
206
ParseNodePrintDOTVisitor::begin_visit(const DefaultCollationDecl &n)
 
207
{
 
208
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
209
          << "label=\"DefaultCollationDecl\\n[" 
 
210
          << n.get_location() << "]" << "\"]" << std::endl;
 
211
 
 
212
    NL;
 
213
    return true;
 
214
}
 
215
 
 
216
 
 
217
bool
 
218
ParseNodePrintDOTVisitor::begin_visit(const DefaultNamespaceDecl &n)
 
219
{
 
220
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
221
          << "label=\"DefaultNamespaceDecl\\n[" 
 
222
          << n.get_location() << "]" << "\"]" << std::endl;
 
223
 
 
224
    NL;
 
225
    return true;
 
226
}
 
227
 
 
228
 
 
229
bool
 
230
ParseNodePrintDOTVisitor::begin_visit(const DirAttr &n)
 
231
{
 
232
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
233
          << "label=\"DirAttr\\n[" 
 
234
          << n.get_location() << "]" << "\"]" << std::endl;
 
235
 
 
236
    NL;
 
237
    return true;
 
238
}
 
239
 
 
240
 
 
241
bool
 
242
ParseNodePrintDOTVisitor::begin_visit(const DirAttributeList &n)
 
243
{
 
244
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
245
          << "label=\"DirAttributeList\\n[" 
 
246
          << n.get_location() << "]" << "\"]" << std::endl;
 
247
 
 
248
    NL;
 
249
    return true;
 
250
}
 
251
 
 
252
 
 
253
bool
 
254
ParseNodePrintDOTVisitor::begin_visit(const DirAttributeValue &n)
 
255
{
 
256
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
257
          << "label=\"DirAttributeValue\\n[" 
 
258
          << n.get_location() << "]" << "\"]" << std::endl;
 
259
 
 
260
    NL;
 
261
    return true;
 
262
}
 
263
 
 
264
 
 
265
bool
 
266
ParseNodePrintDOTVisitor::begin_visit(const DirElemContentList &n)
 
267
{
 
268
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
269
          << "label=\"DirElemContentList\\n[" 
 
270
          << n.get_location() << "]" << "\"]" << std::endl;
 
271
 
 
272
    NL;
 
273
    return true;
 
274
}
 
275
 
 
276
 
 
277
bool
 
278
ParseNodePrintDOTVisitor::begin_visit(const DocumentTest &n)
 
279
{
 
280
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
281
          << "label=\"DocumentTest\\n[" 
 
282
          << n.get_location() << "]" << "\"]" << std::endl;
 
283
 
 
284
    NL;
 
285
    return true;
 
286
}
 
287
 
 
288
 
 
289
bool
 
290
ParseNodePrintDOTVisitor::begin_visit(const ElementTest &n)
 
291
{
 
292
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
293
          << "label=\"ElementTest\\n[" 
 
294
          << n.get_location() << "]" << "\"]" << std::endl;
 
295
 
 
296
    NL;
 
297
    return true;
 
298
}
 
299
 
 
300
 
 
301
bool
 
302
ParseNodePrintDOTVisitor::begin_visit(const EmptyOrderDecl &n)
 
303
{
 
304
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
305
          << "label=\"EmptyOrderDecl\\n[" 
 
306
          << n.get_location() << "]" << "\"]" << std::endl;
 
307
 
 
308
    NL;
 
309
    return true;
 
310
}
 
311
 
 
312
 
 
313
bool
 
314
ParseNodePrintDOTVisitor::begin_visit(const ForClause &n)
 
315
{
 
316
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
317
          << "label=\"ForClause\\n[" 
 
318
          << n.get_location() << "]" << "\"]" << std::endl;
 
319
 
 
320
    NL;
 
321
    return true;
 
322
}
 
323
 
 
324
 
 
325
// bool
 
326
// ParseNodePrintDOTVisitor::begin_visit(const ForLetClause &n)
 
327
// {
 
328
//     INDENT;
 
329
//     
 
330
//     os << "<MainModule position='" << n.get_location() << "'";
 
331
// 
 
332
//     os << ">";
 
333
//     
 
334
//     INDENT_INC;
 
335
//     NL;
 
336
//     return true;
 
337
// }
 
338
 
 
339
 
 
340
bool
 
341
ParseNodePrintDOTVisitor::begin_visit(const ForLetClauseList &n)
 
342
{
 
343
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
344
          << "label=\"ForLetClauseList\\n[" 
 
345
          << n.get_location() << "]" << "\"]" << std::endl;
 
346
 
 
347
    NL;
 
348
    return true;
 
349
}
 
350
 
 
351
 
 
352
bool
 
353
ParseNodePrintDOTVisitor::begin_visit(const ForwardAxis &n)
 
354
{
 
355
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
356
          << "label=\"ForwardAxis\\n[" 
 
357
          << n.get_location() << "]" << "\"]" << std::endl;
 
358
 
 
359
    NL;
 
360
    return true;
 
361
}
 
362
 
 
363
 
 
364
bool
 
365
ParseNodePrintDOTVisitor::begin_visit(const ForwardStep &n)
 
366
{
 
367
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
368
          << "label=\"ForwardStep\\n[" 
 
369
          << n.get_location() << "]" << "\"]" << std::endl;
 
370
 
 
371
    NL;
 
372
    return true;
 
373
}
 
374
 
 
375
 
 
376
bool
 
377
ParseNodePrintDOTVisitor::begin_visit(const FunctionDecl &n)
 
378
{
 
379
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
380
          << "label=\"FunctionDecl\\n[" 
 
381
          << n.get_location() << "]" << "\"]" << std::endl;
 
382
 
 
383
    NL;
 
384
    return true;
 
385
}
 
386
 
 
387
 
 
388
bool
 
389
ParseNodePrintDOTVisitor::begin_visit(const GeneralComp &n)
 
390
{
 
391
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
392
          << "label=\"GeneralComp\\n[" 
 
393
          << n.get_location() << "]" << "\"]" << std::endl;
 
394
 
 
395
    NL;
 
396
    return true;
 
397
}
 
398
 
 
399
 
 
400
bool
 
401
ParseNodePrintDOTVisitor::begin_visit(const ItemType &n)
 
402
{
 
403
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
404
          << "label=\"ItemType\\n[" 
 
405
          << n.get_location() << "]" << "\"]" << std::endl;
 
406
 
 
407
    NL;
 
408
    return true;
 
409
}
 
410
 
 
411
 
 
412
bool
 
413
ParseNodePrintDOTVisitor::begin_visit(const LetClause &n)
 
414
{
 
415
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
416
          << "label=\"LetClause\\n[" 
 
417
          << n.get_location() << "]" << "\"]" << std::endl;
 
418
 
 
419
    NL;
 
420
    return true;
 
421
}
 
422
 
 
423
 
 
424
bool
 
425
ParseNodePrintDOTVisitor::begin_visit(const LibraryModule &n)
 
426
{
 
427
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
428
          << "label=\"LibraryModule\\n[" 
 
429
          << n.get_location() << "]" << "\"]" << std::endl;
 
430
 
 
431
    NL;
 
432
    return true;
 
433
}
 
434
 
 
435
 
 
436
bool
 
437
ParseNodePrintDOTVisitor::begin_visit(const MainModule  &n)
 
438
{
 
439
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
440
          << "label=\"MainModule\\n[" 
 
441
          << n.get_location() << "]" << "\"]" << std::endl;
 
442
 
 
443
    NL;
 
444
 
 
445
    return true;
 
446
}
 
447
 
 
448
 
 
449
bool
 
450
ParseNodePrintDOTVisitor::begin_visit(const Module &n)
 
451
{
 
452
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
453
          << "label=\"Module\\n[" 
 
454
          << n.get_location() << "]" << "\"]" << std::endl;
 
455
 
 
456
    NL;
 
457
    return true;
 
458
}
 
459
 
 
460
 
 
461
bool
 
462
ParseNodePrintDOTVisitor::begin_visit(const ModuleDecl &n)
 
463
{
 
464
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
465
          << "label=\"ModuleDecl position='" << n.get_location() << "'";
 
466
    os << " prefix='" << n.get_prefix() << "' " 
 
467
       << "target_namespace='" << n.get_target_namespace() << "'";
 
468
    os << ">";
 
469
    
 
470
    INDENT_INC;
 
471
    NL;
 
472
    return true;
 
473
}
 
474
 
 
475
 
 
476
bool
 
477
ParseNodePrintDOTVisitor::begin_visit(const ModuleImport &n)
 
478
{
 
479
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
480
          << "label=\"ModuleImport\\n[" 
 
481
          << n.get_location() << "]" << "\"]" << std::endl;
 
482
 
 
483
    NL;
 
484
    return true;
 
485
}
 
486
 
 
487
 
 
488
bool
 
489
ParseNodePrintDOTVisitor::begin_visit(const NameTest &n)
 
490
{
 
491
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
492
          << "label=\"NameTest\\n[" 
 
493
          << n.get_location() << "]" << "\"]" << std::endl;
 
494
 
 
495
    NL;
 
496
    return true;
 
497
}
 
498
 
 
499
 
 
500
bool
 
501
ParseNodePrintDOTVisitor::begin_visit(const NamespaceDecl &n)
 
502
{
 
503
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
504
          << "label=\"NamespaceDecl\\n[" 
 
505
          << n.get_location() << "]" << "\"]" << std::endl;
 
506
 
 
507
    NL;
 
508
    return true;
 
509
}
 
510
 
 
511
 
 
512
bool
 
513
ParseNodePrintDOTVisitor::begin_visit(const NodeComp &n)
 
514
{
 
515
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
516
          << "label=\"NodeComp\\n[" 
 
517
          << n.get_location() << "]" << "\"]" << std::endl;
 
518
 
 
519
    NL;
 
520
    return true;
 
521
}
 
522
 
 
523
 
 
524
bool
 
525
ParseNodePrintDOTVisitor::begin_visit(const OccurrenceIndicator &n)
 
526
{
 
527
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
528
          << "label=\"OccurrenceIndicator\\n[" 
 
529
          << n.get_location() << "]" << "\"]" << std::endl;
 
530
 
 
531
    NL;
 
532
    return true;
 
533
}
 
534
 
 
535
 
 
536
bool
 
537
ParseNodePrintDOTVisitor::begin_visit(const OptionDecl &n)
 
538
{
 
539
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
540
          << "label=\"OptionDecl\\n[" 
 
541
          << n.get_location() << "]" << "\"]" << std::endl;
 
542
 
 
543
    NL;
 
544
    return true;
 
545
}
 
546
 
 
547
 
 
548
bool
 
549
ParseNodePrintDOTVisitor::begin_visit(const OrderByClause &n)
 
550
{
 
551
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
552
          << "label=\"OrderByClause\\n[" 
 
553
          << n.get_location() << "]" << "\"]" << std::endl;
 
554
 
 
555
    NL;
 
556
    return true;
 
557
}
 
558
 
 
559
 
 
560
bool
 
561
ParseNodePrintDOTVisitor::begin_visit(const OrderCollationSpec &n)
 
562
{
 
563
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
564
          << "label=\"OrderCollationSpec\\n[" 
 
565
          << n.get_location() << "]" << "\"]" << std::endl;
 
566
 
 
567
    NL;
 
568
    return true;
 
569
}
 
570
 
 
571
 
 
572
bool
 
573
ParseNodePrintDOTVisitor::begin_visit(const OrderDirSpec &n)
 
574
{
 
575
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
576
          << "label=\"OrderDirSpec\\n[" 
 
577
          << n.get_location() << "]" << "\"]" << std::endl;
 
578
 
 
579
    NL;
 
580
    return true;
 
581
}
 
582
 
 
583
 
 
584
bool
 
585
ParseNodePrintDOTVisitor::begin_visit(const OrderEmptySpec &n)
 
586
{
 
587
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
588
          << "label=\"OrderEmptySpec\\n[" 
 
589
          << n.get_location() << "]" << "\"]" << std::endl;
 
590
 
 
591
    NL;
 
592
    return true;
 
593
}
 
594
 
 
595
 
 
596
bool
 
597
ParseNodePrintDOTVisitor::begin_visit(const OrderModifier &n)
 
598
{
 
599
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
600
          << "label=\"OrderModifier\\n[" 
 
601
          << n.get_location() << "]" << "\"]" << std::endl;
 
602
 
 
603
    NL;
 
604
    return true;
 
605
}
 
606
 
 
607
 
 
608
bool
 
609
ParseNodePrintDOTVisitor::begin_visit(const OrderSpec &n)
 
610
{
 
611
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
612
          << "label=\"OrderSpec\\n[" 
 
613
          << n.get_location() << "]" << "\"]" << std::endl;
 
614
 
 
615
    NL;
 
616
    return true;
 
617
}
 
618
 
 
619
 
 
620
bool
 
621
ParseNodePrintDOTVisitor::begin_visit(const OrderSpecList &n)
 
622
{
 
623
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
624
          << "label=\"OrderSpecList\\n[" 
 
625
          << n.get_location() << "]" << "\"]" << std::endl;
 
626
 
 
627
    NL;
 
628
    return true;
 
629
}
 
630
 
 
631
 
 
632
bool
 
633
ParseNodePrintDOTVisitor::begin_visit(const OrderingModeDecl &n)
 
634
{
 
635
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
636
          << "label=\"OrderingModeDecl\\n[" 
 
637
          << n.get_location() << "]" << "\"]" << std::endl;
 
638
 
 
639
    NL;
 
640
    return true;
 
641
}
 
642
 
 
643
 
 
644
bool
 
645
ParseNodePrintDOTVisitor::begin_visit(const PITest &n)
 
646
{
 
647
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
648
          << "label=\"PITest\\n[" 
 
649
          << n.get_location() << "]" << "\"]" << std::endl;
 
650
 
 
651
    NL;
 
652
    return true;
 
653
}
 
654
 
 
655
 
 
656
bool
 
657
ParseNodePrintDOTVisitor::begin_visit(const Param &n)
 
658
{
 
659
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
660
          << "label=\"Param\\n[" 
 
661
          << n.get_location() << "]" << "\"]" << std::endl;
 
662
 
 
663
    NL;
 
664
    return true;
 
665
}
 
666
 
 
667
 
 
668
bool
 
669
ParseNodePrintDOTVisitor::begin_visit(const ParamList &n)
 
670
{
 
671
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
672
          << "label=\"ParamList\\n[" 
 
673
          << n.get_location() << "]" << "\"]" << std::endl;
 
674
 
 
675
    NL;
 
676
    return true;
 
677
}
 
678
 
 
679
 
 
680
bool
 
681
ParseNodePrintDOTVisitor::begin_visit(const PositionalVar &n)
 
682
{
 
683
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
684
          << "label=\"PositionalVar\\n[" 
 
685
          << n.get_location() << "]" << "\"]" << std::endl;
 
686
 
 
687
    NL;
 
688
    return true;
 
689
}
 
690
 
 
691
 
 
692
bool
 
693
ParseNodePrintDOTVisitor::begin_visit(const Pragma &n)
 
694
{
 
695
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
696
          << "label=\"Pragma\\n[" 
 
697
          << n.get_location() << "]" << "\"]" << std::endl;
 
698
 
 
699
    NL;
 
700
    return true;
 
701
}
 
702
 
 
703
 
 
704
bool
 
705
ParseNodePrintDOTVisitor::begin_visit(const PragmaList &n)
 
706
{
 
707
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
708
          << "label=\"PragmaList\\n[" 
 
709
          << n.get_location() << "]" << "\"]" << std::endl;
 
710
 
 
711
    NL;
 
712
    return true;
 
713
}
 
714
 
 
715
 
 
716
bool
 
717
ParseNodePrintDOTVisitor::begin_visit(const PredicateList &n)
 
718
{
 
719
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
720
          << "label=\"PredicateList\\n[" 
 
721
          << n.get_location() << "]" << "\"]" << std::endl;
 
722
 
 
723
    NL;
 
724
    return true;
 
725
}
 
726
 
 
727
 
 
728
bool
 
729
ParseNodePrintDOTVisitor::begin_visit(const Prolog &n)
 
730
{
 
731
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
732
          << "label=\"Prolog\\n[" 
 
733
          << n.get_location() << "]" << "\"]" << std::endl;
 
734
 
 
735
    NL;
 
736
    return true;
 
737
}
 
738
 
 
739
 
 
740
bool
 
741
ParseNodePrintDOTVisitor::begin_visit(const QVarInDecl &n)
 
742
{
 
743
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
744
          << "label=\"QVarInDecl\\n[" 
 
745
          << n.get_location() << "]" << "\"]" << std::endl;
 
746
 
 
747
    NL;
 
748
    return true;
 
749
}
 
750
 
 
751
 
 
752
bool
 
753
ParseNodePrintDOTVisitor::begin_visit(const QVarInDeclList &n)
 
754
{
 
755
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
756
          << "label=\"QVarInDeclList\\n[" 
 
757
          << n.get_location() << "]" << "\"]" << std::endl;
 
758
 
 
759
    NL;
 
760
    return true;
 
761
}
 
762
 
 
763
 
 
764
bool
 
765
ParseNodePrintDOTVisitor::begin_visit(const QuoteAttrValueContent &n)
 
766
{
 
767
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
768
          << "label=\"QuoteAttrValueContent\\n[" 
 
769
          << n.get_location() << "]" << "\"]" << std::endl;
 
770
 
 
771
    NL;
 
772
    return true;
 
773
}
 
774
 
 
775
 
 
776
bool
 
777
ParseNodePrintDOTVisitor::begin_visit(const QuoteAttrContentList &n)
 
778
{
 
779
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
780
          << "label=\"QuoteAttrContentList\\n[" 
 
781
          << n.get_location() << "]" << "\"]" << std::endl;
 
782
 
 
783
    NL;
 
784
    return true;
 
785
}
 
786
 
 
787
 
 
788
bool
 
789
ParseNodePrintDOTVisitor::begin_visit(const ReverseAxis &n)
 
790
{
 
791
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
792
          << "label=\"ReverseAxis\\n[" 
 
793
          << n.get_location() << "]" << "\"]" << std::endl;
 
794
 
 
795
    NL;
 
796
    return true;
 
797
}
 
798
 
 
799
 
 
800
bool
 
801
ParseNodePrintDOTVisitor::begin_visit(const ReverseStep &n)
 
802
{
 
803
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
804
          << "label=\"ReverseStep\\n[" 
 
805
          << n.get_location() << "]" << "\"]" << std::endl;
 
806
 
 
807
    NL;
 
808
    return true;
 
809
}
 
810
 
 
811
 
 
812
bool
 
813
ParseNodePrintDOTVisitor::begin_visit(const SIND_DeclList &n)
 
814
{
 
815
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
816
          << "label=\"SIND_DeclList\\n[" 
 
817
          << n.get_location() << "]" << "\"]" << std::endl;
 
818
 
 
819
    NL;
 
820
    return true;
 
821
}
 
822
 
 
823
 
 
824
bool
 
825
ParseNodePrintDOTVisitor::begin_visit(const SchemaAttributeTest &n)
 
826
{
 
827
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
828
          << "label=\"SchemaAttributeTest\\n[" 
 
829
          << n.get_location() << "]" << "\"]" << std::endl;
 
830
 
 
831
    NL;
 
832
    return true;
 
833
}
 
834
 
 
835
 
 
836
bool
 
837
ParseNodePrintDOTVisitor::begin_visit(const SchemaElementTest &n)
 
838
{
 
839
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
840
          << "label=\"SchemaElementTest\\n[" 
 
841
          << n.get_location() << "]" << "\"]" << std::endl;
 
842
 
 
843
    NL;
 
844
    return true;
 
845
}
 
846
 
 
847
 
 
848
bool
 
849
ParseNodePrintDOTVisitor::begin_visit(const SchemaImport &n)
 
850
{
 
851
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
852
          << "label=\"SchemaImport\\n[" 
 
853
          << n.get_location() << "]" << "\"]" << std::endl;
 
854
 
 
855
    NL;
 
856
    return true;
 
857
}
 
858
 
 
859
 
 
860
bool
 
861
ParseNodePrintDOTVisitor::begin_visit(const SchemaPrefix &n)
 
862
{
 
863
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
864
          << "label=\"SchemaPrefix\\n[" 
 
865
          << n.get_location() << "]" << "\"]" << std::endl;
 
866
 
 
867
    NL;
 
868
    return true;
 
869
}
 
870
 
 
871
 
 
872
bool
 
873
ParseNodePrintDOTVisitor::begin_visit(const SequenceType &n)
 
874
{
 
875
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
876
          << "label=\"SequenceType\\n[" 
 
877
          << n.get_location() << "]" << "\"]" << std::endl;
 
878
 
 
879
    NL;
 
880
    return true;
 
881
}
 
882
 
 
883
 
 
884
bool
 
885
ParseNodePrintDOTVisitor::begin_visit(const SignList &n)
 
886
{
 
887
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
888
          << "label=\"SignList\\n[" 
 
889
          << n.get_location() << "]" << "\"]" << std::endl;
 
890
 
 
891
    NL;
 
892
    return true;
 
893
}
 
894
 
 
895
 
 
896
bool
 
897
ParseNodePrintDOTVisitor::begin_visit(const SingleType &n)
 
898
{
 
899
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
900
          << "label=\"SingleType\\n[" 
 
901
          << n.get_location() << "]" << "\"]" << std::endl;
 
902
 
 
903
    NL;
 
904
    return true;
 
905
}
 
906
 
 
907
 
 
908
bool
 
909
ParseNodePrintDOTVisitor::begin_visit(const TextTest &n)
 
910
{
 
911
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
912
          << "label=\"TextTest\\n[" 
 
913
          << n.get_location() << "]" << "\"]" << std::endl;
 
914
 
 
915
    NL;
 
916
    return true;
 
917
}
 
918
 
 
919
 
 
920
bool
 
921
ParseNodePrintDOTVisitor::begin_visit(const TypeDeclaration &n)
 
922
{
 
923
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
924
          << "label=\"TypeDeclaration\\n[" 
 
925
          << n.get_location() << "]" << "\"]" << std::endl;
 
926
 
 
927
    NL;
 
928
    return true;
 
929
}
 
930
 
 
931
 
 
932
bool
 
933
ParseNodePrintDOTVisitor::begin_visit(const TypeName &n)
 
934
{
 
935
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
936
          << "label=\"TypeName\\n[" 
 
937
          << n.get_location() << "]" << "\"]" << std::endl;
 
938
 
 
939
    NL;
 
940
    return true;
 
941
}
 
942
 
 
943
 
 
944
bool
 
945
ParseNodePrintDOTVisitor::begin_visit(const URILiteralList &n)
 
946
{
 
947
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
948
          << "label=\"URILiteralList\\n[" 
 
949
          << n.get_location() << "]" << "\"]" << std::endl;
 
950
 
 
951
    NL;
 
952
    return true;
 
953
}
 
954
 
 
955
 
 
956
bool
 
957
ParseNodePrintDOTVisitor::begin_visit(const ValueComp &n)
 
958
{
 
959
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
960
          << "label=\"ValueComp\\n[" 
 
961
          << n.get_location() << "]" << "\"]" << std::endl;
 
962
 
 
963
    NL;
 
964
    return true;
 
965
}
 
966
 
 
967
 
 
968
bool
 
969
ParseNodePrintDOTVisitor::begin_visit(const VarDecl &n)
 
970
{
 
971
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
972
          << "label=\"VarDecl\\n[" 
 
973
          << n.get_location() << "]" << "\"]" << std::endl;
 
974
 
 
975
    NL;
 
976
    return true;
 
977
}
 
978
 
 
979
 
 
980
bool
 
981
ParseNodePrintDOTVisitor::begin_visit(const VarGetsDecl &n)
 
982
{
 
983
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
984
          << "label=\"VarGetsDecl\\n[" 
 
985
          << n.get_location() << "]" << "\"]" << std::endl;
 
986
 
 
987
    NL;
 
988
    return true;
 
989
}
 
990
 
 
991
 
 
992
bool
 
993
ParseNodePrintDOTVisitor::begin_visit(const VarGetsDeclList &n)
 
994
{
 
995
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
996
          << "label=\"VarGetsDeclList\\n[" 
 
997
          << n.get_location() << "]" << "\"]" << std::endl;
 
998
 
 
999
    NL;
 
1000
    return true;
 
1001
}
 
1002
 
 
1003
 
 
1004
bool
 
1005
ParseNodePrintDOTVisitor::begin_visit(const VarInDecl &n)
 
1006
{
 
1007
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1008
          << "label=\"VarInDecl\\n[" 
 
1009
          << n.get_location() << "]" << "\"]" << std::endl;
 
1010
 
 
1011
    NL;
 
1012
    return true;
 
1013
}
 
1014
 
 
1015
 
 
1016
bool
 
1017
ParseNodePrintDOTVisitor::begin_visit(const VarInDeclList &n)
 
1018
{
 
1019
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1020
          << "label=\"VarInDeclList\\n[" 
 
1021
          << n.get_location() << "]" << "\"]" << std::endl;
 
1022
 
 
1023
    NL;
 
1024
    return true;
 
1025
}
 
1026
 
 
1027
 
 
1028
bool
 
1029
ParseNodePrintDOTVisitor::begin_visit(const VersionDecl &n)
 
1030
{
 
1031
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1032
          << "label=\"VersionDecl position='" << n.get_location() << "'";
 
1033
    os << "version='" << n.get_version() << "' " 
 
1034
       << "encoding='" << n.get_encoding() << "' ";
 
1035
 
 
1036
    os << ">";
 
1037
    
 
1038
    INDENT_INC;
 
1039
    NL;
 
1040
    return true;
 
1041
}
 
1042
 
 
1043
 
 
1044
bool
 
1045
ParseNodePrintDOTVisitor::begin_visit(const VFO_DeclList &n)
 
1046
{
 
1047
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1048
          << "label=\"VFO_DeclList\\n[" 
 
1049
          << n.get_location() << "]" << "\"]" << std::endl;
 
1050
 
 
1051
    NL;
 
1052
    return true;
 
1053
}
 
1054
 
 
1055
 
 
1056
bool
 
1057
ParseNodePrintDOTVisitor::begin_visit(const WhereClause &n)
 
1058
{
 
1059
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1060
          << "label=\"WhereClause\\n[" 
 
1061
          << n.get_location() << "]" << "\"]" << std::endl;
 
1062
 
 
1063
    NL;
 
1064
    return true;
 
1065
}
 
1066
 
 
1067
 
 
1068
bool
 
1069
ParseNodePrintDOTVisitor::begin_visit(const Wildcard &n)
 
1070
{
 
1071
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1072
          << "label=\"Wildcard\\n[" 
 
1073
          << n.get_location() << "]" << "\"]" << std::endl;
 
1074
 
 
1075
    NL;
 
1076
    return true;
 
1077
}
 
1078
 
 
1079
 
 
1080
 
 
1081
bool
 
1082
ParseNodePrintDOTVisitor::begin_visit(const exprnode &n)
 
1083
{
 
1084
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1085
          << "label=\"exprnode\\n[" 
 
1086
          << n.get_location() << "]" << "\"]" << std::endl;
 
1087
 
 
1088
    NL;
 
1089
    return true;
 
1090
}
 
1091
 
 
1092
 
 
1093
bool
 
1094
ParseNodePrintDOTVisitor::begin_visit(const AdditiveExpr &n)
 
1095
{
 
1096
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1097
          << "label=\"AdditiveExpr\\n[" 
 
1098
          << n.get_location() << "]" << "\"]" << std::endl;
 
1099
 
 
1100
    NL;
 
1101
    return true;
 
1102
}
 
1103
 
 
1104
 
 
1105
bool
 
1106
ParseNodePrintDOTVisitor::begin_visit(const AndExpr &n)
 
1107
{
 
1108
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1109
          << "label=\"AndExpr\\n[" 
 
1110
          << n.get_location() << "]" << "\"]" << std::endl;
 
1111
 
 
1112
    NL;
 
1113
    return true;
 
1114
}
 
1115
 
 
1116
 
 
1117
bool
 
1118
ParseNodePrintDOTVisitor::begin_visit(const AxisStep &n)
 
1119
{
 
1120
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1121
          << "label=\"AxisStep\\n[" 
 
1122
          << n.get_location() << "]" << "\"]" << std::endl;
 
1123
 
 
1124
    NL;
 
1125
    return true;
 
1126
}
 
1127
 
 
1128
 
 
1129
bool
 
1130
ParseNodePrintDOTVisitor::begin_visit(const CDataSection &n)
 
1131
{
 
1132
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1133
          << "label=\"CDataSection\\n[" 
 
1134
          << n.get_location() << "]" << "\"]" << std::endl;
 
1135
 
 
1136
    NL;
 
1137
    return true;
 
1138
}
 
1139
 
 
1140
 
 
1141
bool
 
1142
ParseNodePrintDOTVisitor::begin_visit(const CastExpr &n)
 
1143
{
 
1144
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1145
          << "label=\"CastExpr\\n[" 
 
1146
          << n.get_location() << "]" << "\"]" << std::endl;
 
1147
 
 
1148
    NL;
 
1149
    return true;
 
1150
}
 
1151
 
 
1152
 
 
1153
bool
 
1154
ParseNodePrintDOTVisitor::begin_visit(const CastableExpr &n)
 
1155
{
 
1156
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1157
          << "label=\"CastableExpr\\n[" 
 
1158
          << n.get_location() << "]" << "\"]" << std::endl;
 
1159
 
 
1160
    NL;
 
1161
    return true;
 
1162
}
 
1163
 
 
1164
 
 
1165
bool
 
1166
ParseNodePrintDOTVisitor::begin_visit(const CommonContent &n)
 
1167
{
 
1168
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1169
          << "label=\"CommonContent\\n[" 
 
1170
          << n.get_location() << "]" << "\"]" << std::endl;
 
1171
 
 
1172
    NL;
 
1173
    return true;
 
1174
}
 
1175
 
 
1176
 
 
1177
bool
 
1178
ParseNodePrintDOTVisitor::begin_visit(const ComparisonExpr &n)
 
1179
{
 
1180
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1181
          << "label=\"ComparisonExpr\\n[" 
 
1182
          << n.get_location() << "]" << "\"]" << std::endl;
 
1183
 
 
1184
    NL;
 
1185
    return true;
 
1186
}
 
1187
 
 
1188
 
 
1189
bool
 
1190
ParseNodePrintDOTVisitor::begin_visit(const CompAttrConstructor &n)
 
1191
{
 
1192
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1193
          << "label=\"CompAttrConstructor\\n[" 
 
1194
          << n.get_location() << "]" << "\"]" << std::endl;
 
1195
 
 
1196
    NL;
 
1197
    return true;
 
1198
}
 
1199
 
 
1200
 
 
1201
bool
 
1202
ParseNodePrintDOTVisitor::begin_visit(const CompCommentConstructor &n)
 
1203
{
 
1204
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1205
          << "label=\"CompCommentConstructor\\n[" 
 
1206
          << n.get_location() << "]" << "\"]" << std::endl;
 
1207
 
 
1208
    NL;
 
1209
    return true;
 
1210
}
 
1211
 
 
1212
 
 
1213
bool
 
1214
ParseNodePrintDOTVisitor::begin_visit(const CompDocConstructor &n)
 
1215
{
 
1216
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1217
          << "label=\"CompDocConstructor\\n[" 
 
1218
          << n.get_location() << "]" << "\"]" << std::endl;
 
1219
 
 
1220
    NL;
 
1221
    return true;
 
1222
}
 
1223
 
 
1224
 
 
1225
bool
 
1226
ParseNodePrintDOTVisitor::begin_visit(const CompElemConstructor &n)
 
1227
{
 
1228
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1229
          << "label=\"CompElemConstructor\\n[" 
 
1230
          << n.get_location() << "]" << "\"]" << std::endl;
 
1231
 
 
1232
    NL;
 
1233
    return true;
 
1234
}
 
1235
 
 
1236
 
 
1237
bool
 
1238
ParseNodePrintDOTVisitor::begin_visit(const CompPIConstructor &n)
 
1239
{
 
1240
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1241
          << "label=\"CompPIConstructor\\n[" 
 
1242
          << n.get_location() << "]" << "\"]" << std::endl;
 
1243
 
 
1244
    NL;
 
1245
    return true;
 
1246
}
 
1247
 
 
1248
 
 
1249
bool
 
1250
ParseNodePrintDOTVisitor::begin_visit(const CompTextConstructor &n)
 
1251
{
 
1252
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1253
          << "label=\"CompTextConstructor\\n[" 
 
1254
          << n.get_location() << "]" << "\"]" << std::endl;
 
1255
 
 
1256
    NL;
 
1257
    return true;
 
1258
}
 
1259
 
 
1260
 
 
1261
bool
 
1262
ParseNodePrintDOTVisitor::begin_visit(const ContextItemExpr &n)
 
1263
{
 
1264
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1265
          << "label=\"ContextItemExpr\\n[" 
 
1266
          << n.get_location() << "]" << "\"]" << std::endl;
 
1267
 
 
1268
    NL;
 
1269
    return true;
 
1270
}
 
1271
 
 
1272
 
 
1273
bool
 
1274
ParseNodePrintDOTVisitor::begin_visit(const DirCommentConstructor &n)
 
1275
{
 
1276
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1277
          << "label=\"DirCommentConstructor\\n[" 
 
1278
          << n.get_location() << "]" << "\"]" << std::endl;
 
1279
 
 
1280
    NL;
 
1281
    return true;
 
1282
}
 
1283
 
 
1284
 
 
1285
bool
 
1286
ParseNodePrintDOTVisitor::begin_visit(const DirElemConstructor &n)
 
1287
{
 
1288
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1289
          << "label=\"DirElemConstructor\\n[" 
 
1290
          << n.get_location() << "]" << "\"]" << std::endl;
 
1291
 
 
1292
    NL;
 
1293
    return true;
 
1294
}
 
1295
 
 
1296
 
 
1297
bool
 
1298
ParseNodePrintDOTVisitor::begin_visit(const DirElemContent &n)
 
1299
{
 
1300
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1301
          << "label=\"DirElemContent\\n[" 
 
1302
          << n.get_location() << "]" << "\"]" << std::endl;
 
1303
 
 
1304
    NL;
 
1305
    return true;
 
1306
}
 
1307
 
 
1308
 
 
1309
bool
 
1310
ParseNodePrintDOTVisitor::begin_visit(const DirPIConstructor &n)
 
1311
{
 
1312
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1313
          << "label=\"DirPIConstructor\\n[" 
 
1314
          << n.get_location() << "]" << "\"]" << std::endl;
 
1315
 
 
1316
    NL;
 
1317
    return true;
 
1318
}
 
1319
 
 
1320
 
 
1321
bool
 
1322
ParseNodePrintDOTVisitor::begin_visit(const EnclosedExpr &n)
 
1323
{
 
1324
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1325
          << "label=\"EnclosedExpr\\n[" 
 
1326
          << n.get_location() << "]" << "\"]" << std::endl;
 
1327
 
 
1328
    NL;
 
1329
    return true;
 
1330
}
 
1331
 
 
1332
 
 
1333
bool
 
1334
ParseNodePrintDOTVisitor::begin_visit(const Expr &n)
 
1335
{
 
1336
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1337
          << "label=\"Expr\\n[" 
 
1338
          << n.get_location() << "]" << "\"]" << std::endl;
 
1339
 
 
1340
    NL;
 
1341
    return true;
 
1342
}
 
1343
 
 
1344
 
 
1345
// bool
 
1346
// ParseNodePrintDOTVisitor::begin_visit(const ExprSingle &n)
 
1347
// {
 
1348
//     INDENT;
 
1349
//     
 
1350
//     os << "<MainModule position='" << n.get_location() << "'";
 
1351
// 
 
1352
//     os << ">";
 
1353
//     
 
1354
//     INDENT_INC;
 
1355
//     NL;
 
1356
//     return true;
 
1357
// }
 
1358
 
 
1359
 
 
1360
bool
 
1361
ParseNodePrintDOTVisitor::begin_visit(const ExtensionExpr &n)
 
1362
{
 
1363
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1364
          << "label=\"ExtensionExpr\\n[" 
 
1365
          << n.get_location() << "]" << "\"]" << std::endl;
 
1366
 
 
1367
    NL;
 
1368
    return true;
 
1369
}
 
1370
 
 
1371
 
 
1372
bool
 
1373
ParseNodePrintDOTVisitor::begin_visit(const FLWORExpr &n)
 
1374
{
 
1375
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1376
          << "label=\"FLWORExpr\\n[" 
 
1377
          << n.get_location() << "]" << "\"]" << std::endl;
 
1378
 
 
1379
    NL;
 
1380
    return true;
 
1381
}
 
1382
 
 
1383
 
 
1384
bool
 
1385
ParseNodePrintDOTVisitor::begin_visit(const FilterExpr &n)
 
1386
{
 
1387
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1388
          << "label=\"FilterExpr\\n[" 
 
1389
          << n.get_location() << "]" << "\"]" << std::endl;
 
1390
 
 
1391
    NL;
 
1392
    return true;
 
1393
}
 
1394
 
 
1395
 
 
1396
bool
 
1397
ParseNodePrintDOTVisitor::begin_visit(const FunctionCall &n)
 
1398
{
 
1399
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1400
          << "label=\"FunctionCall\\n[" 
 
1401
          << n.get_location() << "]" << "\"]" << std::endl;
 
1402
 
 
1403
    NL;
 
1404
    return true;
 
1405
}
 
1406
 
 
1407
 
 
1408
bool
 
1409
ParseNodePrintDOTVisitor::begin_visit(const IfExpr &n)
 
1410
{
 
1411
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1412
          << "label=\"IfExpr\\n[" 
 
1413
          << n.get_location() << "]" << "\"]" << std::endl;
 
1414
 
 
1415
    NL;
 
1416
    return true;
 
1417
}
 
1418
 
 
1419
 
 
1420
bool
 
1421
ParseNodePrintDOTVisitor::begin_visit(const InstanceofExpr &n)
 
1422
{
 
1423
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1424
          << "label=\"InstanceofExpr\\n[" 
 
1425
          << n.get_location() << "]" << "\"]" << std::endl;
 
1426
 
 
1427
    NL;
 
1428
    return true;
 
1429
}
 
1430
 
 
1431
 
 
1432
bool
 
1433
ParseNodePrintDOTVisitor::begin_visit(const IntersectExceptExpr &n)
 
1434
{
 
1435
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1436
          << "label=\"IntersectExceptExpr\\n[" 
 
1437
          << n.get_location() << "]" << "\"]" << std::endl;
 
1438
 
 
1439
    NL;
 
1440
    return true;
 
1441
}
 
1442
 
 
1443
 
 
1444
bool
 
1445
ParseNodePrintDOTVisitor::begin_visit(const MultiplicativeExpr &n)
 
1446
{
 
1447
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1448
          << "label=\"MultiplicativeExpr\\n[" 
 
1449
          << n.get_location() << "]" << "\"]" << std::endl;
 
1450
 
 
1451
    NL;
 
1452
    return true;
 
1453
}
 
1454
 
 
1455
 
 
1456
bool
 
1457
ParseNodePrintDOTVisitor::begin_visit(const NumericLiteral &n)
 
1458
{
 
1459
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1460
          << "label=\"NumericLiteral\\n[" 
 
1461
          << n.get_location() << "]" << "\"]" << std::endl;
 
1462
 
 
1463
    NL;
 
1464
    return true;
 
1465
}
 
1466
 
 
1467
 
 
1468
bool
 
1469
ParseNodePrintDOTVisitor::begin_visit(const OrExpr &n)
 
1470
{
 
1471
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1472
          << "label=\"OrExpr\\n[" 
 
1473
          << n.get_location() << "]" << "\"]" << std::endl;
 
1474
 
 
1475
    NL;
 
1476
    return true;
 
1477
}
 
1478
 
 
1479
 
 
1480
bool
 
1481
ParseNodePrintDOTVisitor::begin_visit(const OrderedExpr &n)
 
1482
{
 
1483
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1484
          << "label=\"OrderedExpr\\n[" 
 
1485
          << n.get_location() << "]" << "\"]" << std::endl;
 
1486
 
 
1487
    NL;
 
1488
    return true;
 
1489
}
 
1490
 
 
1491
 
 
1492
bool
 
1493
ParseNodePrintDOTVisitor::begin_visit(const ParenthesizedExpr &n)
 
1494
{
 
1495
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1496
          << "label=\"ParenthesizedExpr\\n[" 
 
1497
          << n.get_location() << "]" << "\"]" << std::endl;
 
1498
 
 
1499
    NL;
 
1500
    return true;
 
1501
}
 
1502
 
 
1503
 
 
1504
bool
 
1505
ParseNodePrintDOTVisitor::begin_visit(const PathExpr &n)
 
1506
{
 
1507
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1508
          << "label=\"PathExpr\\n[" 
 
1509
          << n.get_location() << "]" << "\"]" << std::endl;
 
1510
 
 
1511
    NL;
 
1512
    return true;
 
1513
}
 
1514
 
 
1515
 
 
1516
bool
 
1517
ParseNodePrintDOTVisitor::begin_visit(const QuantifiedExpr &n)
 
1518
{
 
1519
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1520
          << "label=\"QuantifiedExpr\\n[" 
 
1521
          << n.get_location() << "]" << "\"]" << std::endl;
 
1522
 
 
1523
    NL;
 
1524
    return true;
 
1525
}
 
1526
 
 
1527
 
 
1528
bool
 
1529
ParseNodePrintDOTVisitor::begin_visit(const QueryBody &n)
 
1530
{
 
1531
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1532
          << "label=\"QueryBody\\n[" 
 
1533
          << n.get_location() << "]" << "\"]" << std::endl;
 
1534
 
 
1535
    NL;
 
1536
    return true;
 
1537
}
 
1538
 
 
1539
 
 
1540
bool
 
1541
ParseNodePrintDOTVisitor::begin_visit(const RangeExpr &n)
 
1542
{
 
1543
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1544
          << "label=\"RangeExpr\\n[" 
 
1545
          << n.get_location() << "]" << "\"]" << std::endl;
 
1546
 
 
1547
    NL;
 
1548
    return true;
 
1549
}
 
1550
 
 
1551
 
 
1552
bool
 
1553
ParseNodePrintDOTVisitor::begin_visit(const RelativePathExpr &n)
 
1554
{
 
1555
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1556
          << "label=\"RelativePathExpr\\n[" 
 
1557
          << n.get_location() << "]" << "\"]" << std::endl;
 
1558
 
 
1559
    NL;
 
1560
    return true;
 
1561
}
 
1562
 
 
1563
 
 
1564
bool
 
1565
ParseNodePrintDOTVisitor::begin_visit(const StringLiteral &n)
 
1566
{
 
1567
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1568
          << "label=\"StringLiteral\\n[" 
 
1569
          << n.get_location() << "]" << "\"]" << std::endl;
 
1570
 
 
1571
    NL;
 
1572
    return true;
 
1573
}
 
1574
 
 
1575
 
 
1576
bool
 
1577
ParseNodePrintDOTVisitor::begin_visit(const TreatExpr &n)
 
1578
{
 
1579
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1580
          << "label=\"TreatExpr\\n[" 
 
1581
          << n.get_location() << "]" << "\"]" << std::endl;
 
1582
 
 
1583
    NL;
 
1584
    return true;
 
1585
}
 
1586
 
 
1587
 
 
1588
bool
 
1589
ParseNodePrintDOTVisitor::begin_visit(const TypeswitchExpr &n)
 
1590
{
 
1591
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1592
          << "label=\"TypeswitchExpr\\n[" 
 
1593
          << n.get_location() << "]" << "\"]" << std::endl;
 
1594
 
 
1595
    NL;
 
1596
    return true;
 
1597
}
 
1598
 
 
1599
 
 
1600
bool
 
1601
ParseNodePrintDOTVisitor::begin_visit(const UnaryExpr &n)
 
1602
{
 
1603
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1604
          << "label=\"UnaryExpr\\n[" 
 
1605
          << n.get_location() << "]" << "\"]" << std::endl;
 
1606
 
 
1607
    NL;
 
1608
    return true;
 
1609
}
 
1610
 
 
1611
 
 
1612
bool
 
1613
ParseNodePrintDOTVisitor::begin_visit(const UnionExpr &n)
 
1614
{
 
1615
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1616
          << "label=\"UnionExpr\\n[" 
 
1617
          << n.get_location() << "]" << "\"]" << std::endl;
 
1618
 
 
1619
    NL;
 
1620
    return true;
 
1621
}
 
1622
 
 
1623
 
 
1624
bool
 
1625
ParseNodePrintDOTVisitor::begin_visit(const UnorderedExpr &n)
 
1626
{
 
1627
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1628
          << "label=\"UnorderedExpr\\n[" 
 
1629
          << n.get_location() << "]" << "\"]" << std::endl;
 
1630
 
 
1631
    NL;
 
1632
    return true;
 
1633
}
 
1634
 
 
1635
 
 
1636
bool
 
1637
ParseNodePrintDOTVisitor::begin_visit(const ValidateExpr &n)
 
1638
{
 
1639
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1640
          << "label=\"ValidateExpr\\n[" 
 
1641
          << n.get_location() << "]" << "\"]" << std::endl;
 
1642
 
 
1643
    NL;
 
1644
    return true;
 
1645
}
 
1646
 
 
1647
 
 
1648
bool
 
1649
ParseNodePrintDOTVisitor::begin_visit(const VarRef &n)
 
1650
{
 
1651
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1652
          << "label=\"VarRef\\n[" 
 
1653
          << n.get_location() << "]" << "\"]" << std::endl;
 
1654
 
 
1655
    NL;
 
1656
    return true;
 
1657
}
 
1658
 
 
1659
 
 
1660
 
 
1661
bool
 
1662
ParseNodePrintDOTVisitor::begin_visit(const DeleteExpr &n)
 
1663
{
 
1664
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1665
          << "label=\"DeleteExpr\\n[" 
 
1666
          << n.get_location() << "]" << "\"]" << std::endl;
 
1667
 
 
1668
    NL;
 
1669
    return true;
 
1670
}
 
1671
 
 
1672
 
 
1673
bool
 
1674
ParseNodePrintDOTVisitor::begin_visit(const InsertExpr &n)
 
1675
{
 
1676
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1677
          << "label=\"InsertExpr\\n[" 
 
1678
          << n.get_location() << "]" << "\"]" << std::endl;
 
1679
 
 
1680
    NL;
 
1681
    return true;
 
1682
}
 
1683
 
 
1684
 
 
1685
bool
 
1686
ParseNodePrintDOTVisitor::begin_visit(const RenameExpr &n)
 
1687
{
 
1688
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1689
          << "label=\"RenameExpr\\n[" 
 
1690
          << n.get_location() << "]" << "\"]" << std::endl;
 
1691
 
 
1692
    NL;
 
1693
    return true;
 
1694
}
 
1695
 
 
1696
 
 
1697
bool
 
1698
ParseNodePrintDOTVisitor::begin_visit(const ReplaceExpr &n)
 
1699
{
 
1700
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1701
          << "label=\"ReplaceExpr\\n[" 
 
1702
          << n.get_location() << "]" << "\"]" << std::endl;
 
1703
 
 
1704
    NL;
 
1705
    return true;
 
1706
}
 
1707
 
 
1708
 
 
1709
bool
 
1710
ParseNodePrintDOTVisitor::begin_visit(const RevalidationDecl &n)
 
1711
{
 
1712
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1713
          << "label=\"RevalidationDecl\\n[" 
 
1714
          << n.get_location() << "]" << "\"]" << std::endl;
 
1715
 
 
1716
    NL;
 
1717
    return true;
 
1718
}
 
1719
 
 
1720
 
 
1721
bool
 
1722
ParseNodePrintDOTVisitor::begin_visit(const TransformExpr &n)
 
1723
{
 
1724
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1725
          << "label=\"TransformExpr\\n[" 
 
1726
          << n.get_location() << "]" << "\"]" << std::endl;
 
1727
 
 
1728
    NL;
 
1729
    return true;
 
1730
}
 
1731
 
 
1732
 
 
1733
bool
 
1734
ParseNodePrintDOTVisitor::begin_visit(const VarNameList &n)
 
1735
{
 
1736
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1737
          << "label=\"VarNameList\\n[" 
 
1738
          << n.get_location() << "]" << "\"]" << std::endl;
 
1739
 
 
1740
    NL;
 
1741
    return true;
 
1742
}
 
1743
 
 
1744
 
 
1745
 
 
1746
bool
 
1747
ParseNodePrintDOTVisitor::begin_visit(const FTAnd &n)
 
1748
{
 
1749
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1750
          << "label=\"FTAnd\\n[" 
 
1751
          << n.get_location() << "]" << "\"]" << std::endl;
 
1752
 
 
1753
    NL;
 
1754
    return true;
 
1755
}
 
1756
 
 
1757
 
 
1758
bool
 
1759
ParseNodePrintDOTVisitor::begin_visit(const FTAnyallOption &n)
 
1760
{
 
1761
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1762
          << "label=\"FTAnyallOption\\n[" 
 
1763
          << n.get_location() << "]" << "\"]" << std::endl;
 
1764
 
 
1765
    NL;
 
1766
    return true;
 
1767
}
 
1768
 
 
1769
 
 
1770
bool
 
1771
ParseNodePrintDOTVisitor::begin_visit(const FTBigUnit &n)
 
1772
{
 
1773
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1774
          << "label=\"FTBigUnit\\n[" 
 
1775
          << n.get_location() << "]" << "\"]" << std::endl;
 
1776
 
 
1777
    NL;
 
1778
    return true;
 
1779
}
 
1780
 
 
1781
 
 
1782
bool
 
1783
ParseNodePrintDOTVisitor::begin_visit(const FTCaseOption &n)
 
1784
{
 
1785
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1786
          << "label=\"FTCaseOption\\n[" 
 
1787
          << n.get_location() << "]" << "\"]" << std::endl;
 
1788
 
 
1789
    NL;
 
1790
    return true;
 
1791
}
 
1792
 
 
1793
 
 
1794
bool
 
1795
ParseNodePrintDOTVisitor::begin_visit(const FTContainsExpr &n)
 
1796
{
 
1797
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1798
          << "label=\"FTContainsExpr\\n[" 
 
1799
          << n.get_location() << "]" << "\"]" << std::endl;
 
1800
 
 
1801
    NL;
 
1802
    return true;
 
1803
}
 
1804
 
 
1805
 
 
1806
bool
 
1807
ParseNodePrintDOTVisitor::begin_visit(const FTContent &n)
 
1808
{
 
1809
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1810
          << "label=\"FTContent\\n[" 
 
1811
          << n.get_location() << "]" << "\"]" << std::endl;
 
1812
 
 
1813
    NL;
 
1814
    return true;
 
1815
}
 
1816
 
 
1817
 
 
1818
bool
 
1819
ParseNodePrintDOTVisitor::begin_visit(const FTDiacriticsOption &n)
 
1820
{
 
1821
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1822
          << "label=\"FTDiacriticsOption\\n[" 
 
1823
          << n.get_location() << "]" << "\"]" << std::endl;
 
1824
 
 
1825
    NL;
 
1826
    return true;
 
1827
}
 
1828
 
 
1829
 
 
1830
bool
 
1831
ParseNodePrintDOTVisitor::begin_visit(const FTDistance &n)
 
1832
{
 
1833
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1834
          << "label=\"FTDistance\\n[" 
 
1835
          << n.get_location() << "]" << "\"]" << std::endl;
 
1836
 
 
1837
    NL;
 
1838
    return true;
 
1839
}
 
1840
 
 
1841
 
 
1842
bool
 
1843
ParseNodePrintDOTVisitor::begin_visit(const FTIgnoreOption &n)
 
1844
{
 
1845
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1846
          << "label=\"FTIgnoreOption\\n[" 
 
1847
          << n.get_location() << "]" << "\"]" << std::endl;
 
1848
 
 
1849
    NL;
 
1850
    return true;
 
1851
}
 
1852
 
 
1853
 
 
1854
bool
 
1855
ParseNodePrintDOTVisitor::begin_visit(const FTInclExclStringLiteral &n)
 
1856
{
 
1857
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1858
          << "label=\"FTInclExclStringLiteral\\n[" 
 
1859
          << n.get_location() << "]" << "\"]" << std::endl;
 
1860
 
 
1861
    NL;
 
1862
    return true;
 
1863
}
 
1864
 
 
1865
 
 
1866
bool
 
1867
ParseNodePrintDOTVisitor::begin_visit(const FTInclExclStringLiteralList &n)
 
1868
{
 
1869
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1870
          << "label=\"FTInclExclStringLiteralList\\n[" 
 
1871
          << n.get_location() << "]" << "\"]" << std::endl;
 
1872
 
 
1873
    NL;
 
1874
    return true;
 
1875
}
 
1876
 
 
1877
 
 
1878
bool
 
1879
ParseNodePrintDOTVisitor::begin_visit(const FTLanguageOption &n)
 
1880
{
 
1881
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1882
          << "label=\"FTLanguageOption\\n[" 
 
1883
          << n.get_location() << "]" << "\"]" << std::endl;
 
1884
 
 
1885
    NL;
 
1886
    return true;
 
1887
}
 
1888
 
 
1889
 
 
1890
bool
 
1891
ParseNodePrintDOTVisitor::begin_visit(const FTMatchOption &n)
 
1892
{
 
1893
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1894
          << "label=\"FTMatchOption\\n[" 
 
1895
          << n.get_location() << "]" << "\"]" << std::endl;
 
1896
 
 
1897
    NL;
 
1898
    return true;
 
1899
}
 
1900
 
 
1901
 
 
1902
bool
 
1903
ParseNodePrintDOTVisitor::begin_visit(const FTMatchOptionProximityList &n)
 
1904
{
 
1905
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1906
          << "label=\"FTMatchOptionProximityList\\n[" 
 
1907
          << n.get_location() << "]" << "\"]" << std::endl;
 
1908
 
 
1909
    NL;
 
1910
    return true;
 
1911
}
 
1912
 
 
1913
 
 
1914
bool
 
1915
ParseNodePrintDOTVisitor::begin_visit(const FTMildnot &n)
 
1916
{
 
1917
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1918
          << "label=\"FTMildnot\\n[" 
 
1919
          << n.get_location() << "]" << "\"]" << std::endl;
 
1920
 
 
1921
    NL;
 
1922
    return true;
 
1923
}
 
1924
 
 
1925
 
 
1926
bool
 
1927
ParseNodePrintDOTVisitor::begin_visit(const FTOptionDecl &n)
 
1928
{
 
1929
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1930
          << "label=\"FTOptionDecl\\n[" 
 
1931
          << n.get_location() << "]" << "\"]" << std::endl;
 
1932
 
 
1933
    NL;
 
1934
    return true;
 
1935
}
 
1936
 
 
1937
 
 
1938
bool
 
1939
ParseNodePrintDOTVisitor::begin_visit(const FTOr &n)
 
1940
{
 
1941
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1942
          << "label=\"FTOr\\n[" 
 
1943
          << n.get_location() << "]" << "\"]" << std::endl;
 
1944
 
 
1945
    NL;
 
1946
    return true;
 
1947
}
 
1948
 
 
1949
 
 
1950
bool
 
1951
ParseNodePrintDOTVisitor::begin_visit(const FTOrderedIndicator &n)
 
1952
{
 
1953
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1954
          << "label=\"FTOrderedIndicator\\n[" 
 
1955
          << n.get_location() << "]" << "\"]" << std::endl;
 
1956
 
 
1957
    NL;
 
1958
    return true;
 
1959
}
 
1960
 
 
1961
 
 
1962
bool
 
1963
ParseNodePrintDOTVisitor::begin_visit(const FTProximity &n)
 
1964
{
 
1965
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1966
          << "label=\"FTProximity\\n[" 
 
1967
          << n.get_location() << "]" << "\"]" << std::endl;
 
1968
 
 
1969
    NL;
 
1970
    return true;
 
1971
}
 
1972
 
 
1973
 
 
1974
bool
 
1975
ParseNodePrintDOTVisitor::begin_visit(const FTRange &n)
 
1976
{
 
1977
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1978
          << "label=\"FTRange\\n[" 
 
1979
          << n.get_location() << "]" << "\"]" << std::endl;
 
1980
 
 
1981
    NL;
 
1982
    return true;
 
1983
}
 
1984
 
 
1985
 
 
1986
bool
 
1987
ParseNodePrintDOTVisitor::begin_visit(const FTRefOrList &n)
 
1988
{
 
1989
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
1990
          << "label=\"FTRefOrList\\n[" 
 
1991
          << n.get_location() << "]" << "\"]" << std::endl;
 
1992
 
 
1993
    NL;
 
1994
    return true;
 
1995
}
 
1996
 
 
1997
 
 
1998
bool
 
1999
ParseNodePrintDOTVisitor::begin_visit(const FTScope &n)
 
2000
{
 
2001
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
2002
          << "label=\"FTScope\\n[" 
 
2003
          << n.get_location() << "]" << "\"]" << std::endl;
 
2004
 
 
2005
    NL;
 
2006
    return true;
 
2007
}
 
2008
 
 
2009
 
 
2010
bool
 
2011
ParseNodePrintDOTVisitor::begin_visit(const FTScoreVar &n)
 
2012
{
 
2013
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
2014
          << "label=\"FTScoreVar\\n[" 
 
2015
          << n.get_location() << "]" << "\"]" << std::endl;
 
2016
 
 
2017
    NL;
 
2018
    return true;
 
2019
}
 
2020
 
 
2021
 
 
2022
bool
 
2023
ParseNodePrintDOTVisitor::begin_visit(const FTSelection &n)
 
2024
{
 
2025
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
2026
          << "label=\"FTSelection\\n[" 
 
2027
          << n.get_location() << "]" << "\"]" << std::endl;
 
2028
 
 
2029
    NL;
 
2030
    return true;
 
2031
}
 
2032
 
 
2033
 
 
2034
bool
 
2035
ParseNodePrintDOTVisitor::begin_visit(const FTStemOption &n)
 
2036
{
 
2037
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
2038
          << "label=\"FTStemOption\\n[" 
 
2039
          << n.get_location() << "]" << "\"]" << std::endl;
 
2040
 
 
2041
    NL;
 
2042
    return true;
 
2043
}
 
2044
 
 
2045
 
 
2046
bool
 
2047
ParseNodePrintDOTVisitor::begin_visit(const FTStopwordOption &n)
 
2048
{
 
2049
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
2050
          << "label=\"FTStopwordOption\\n[" 
 
2051
          << n.get_location() << "]" << "\"]" << std::endl;
 
2052
 
 
2053
    NL;
 
2054
    return true;
 
2055
}
 
2056
 
 
2057
 
 
2058
bool
 
2059
ParseNodePrintDOTVisitor::begin_visit(const FTStringLiteralList &n)
 
2060
{
 
2061
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
2062
          << "label=\"FTStringLiteralList\\n[" 
 
2063
          << n.get_location() << "]" << "\"]" << std::endl;
 
2064
 
 
2065
    NL;
 
2066
    return true;
 
2067
}
 
2068
 
 
2069
 
 
2070
bool
 
2071
ParseNodePrintDOTVisitor::begin_visit(const FTThesaurusID &n)
 
2072
{
 
2073
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
2074
          << "label=\"FTThesaurusID\\n[" 
 
2075
          << n.get_location() << "]" << "\"]" << std::endl;
 
2076
 
 
2077
    NL;
 
2078
    return true;
 
2079
}
 
2080
 
 
2081
 
 
2082
bool
 
2083
ParseNodePrintDOTVisitor::begin_visit(const FTThesaurusList &n)
 
2084
{
 
2085
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
2086
          << "label=\"FTThesaurusList\\n[" 
 
2087
          << n.get_location() << "]" << "\"]" << std::endl;
 
2088
 
 
2089
    NL;
 
2090
    return true;
 
2091
}
 
2092
 
 
2093
 
 
2094
bool
 
2095
ParseNodePrintDOTVisitor::begin_visit(const FTThesaurusOption &n)
 
2096
{
 
2097
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
2098
          << "label=\"FTThesaurusOption\\n[" 
 
2099
          << n.get_location() << "]" << "\"]" << std::endl;
 
2100
 
 
2101
    NL;
 
2102
    return true;
 
2103
}
 
2104
 
 
2105
 
 
2106
bool
 
2107
ParseNodePrintDOTVisitor::begin_visit(const FTTimes &n)
 
2108
{
 
2109
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
2110
          << "label=\"FTTimes\\n[" 
 
2111
          << n.get_location() << "]" << "\"]" << std::endl;
 
2112
 
 
2113
    NL;
 
2114
    return true;
 
2115
}
 
2116
 
 
2117
 
 
2118
bool
 
2119
ParseNodePrintDOTVisitor::begin_visit(const FTUnaryNot &n)
 
2120
{
 
2121
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
2122
          << "label=\"FTUnaryNot\\n[" 
 
2123
          << n.get_location() << "]" << "\"]" << std::endl;
 
2124
 
 
2125
    NL;
 
2126
    return true;
 
2127
}
 
2128
 
 
2129
 
 
2130
bool
 
2131
ParseNodePrintDOTVisitor::begin_visit(const FTUnit &n)
 
2132
{
 
2133
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
2134
          << "label=\"FTUnit\\n[" 
 
2135
          << n.get_location() << "]" << "\"]" << std::endl;
 
2136
 
 
2137
    NL;
 
2138
    return true;
 
2139
}
 
2140
 
 
2141
 
 
2142
bool
 
2143
ParseNodePrintDOTVisitor::begin_visit(const FTWildcardOption &n)
 
2144
{
 
2145
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
2146
          << "label=\"FTWildcardOption\\n[" 
 
2147
          << n.get_location() << "]" << "\"]" << std::endl;
 
2148
 
 
2149
    NL;
 
2150
    return true;
 
2151
}
 
2152
 
 
2153
 
 
2154
bool
 
2155
ParseNodePrintDOTVisitor::begin_visit(const FTWindow &n)
 
2156
{
 
2157
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
2158
          << "label=\"FTWindow\\n[" 
 
2159
          << n.get_location() << "]" << "\"]" << std::endl;
 
2160
 
 
2161
    NL;
 
2162
    return true;
 
2163
}
 
2164
 
 
2165
 
 
2166
bool
 
2167
ParseNodePrintDOTVisitor::begin_visit(const FTWords &n)
 
2168
{
 
2169
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
2170
          << "label=\"FTWords\\n[" 
 
2171
          << n.get_location() << "]" << "\"]" << std::endl;
 
2172
 
 
2173
    NL;
 
2174
    return true;
 
2175
}
 
2176
 
 
2177
 
 
2178
bool
 
2179
ParseNodePrintDOTVisitor::begin_visit(const FTWordsSelection &n)
 
2180
{
 
2181
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
2182
          << "label=\"FTWordsSelection\\n[" 
 
2183
          << n.get_location() << "]" << "\"]" << std::endl;
 
2184
 
 
2185
    NL;
 
2186
    return true;
 
2187
}
 
2188
 
 
2189
 
 
2190
bool
 
2191
ParseNodePrintDOTVisitor::begin_visit(const FTWordsValue &n)
 
2192
{
 
2193
    os << reinterpret_cast<intptr_t>(&n) << "[" << std::endl
 
2194
          << "label=\"FTWordsValue\\n[" 
 
2195
          << n.get_location() << "]" << "\"]" << std::endl;
 
2196
 
 
2197
    NL;
 
2198
    return true;
 
2199
}
 
2200
 
 
2201
 
 
2202
void
 
2203
ParseNodePrintDOTVisitor::end_visit(const parsenode &n)
 
2204
{
 
2205
}
 
2206
 
 
2207
 
 
2208
void
 
2209
ParseNodePrintDOTVisitor::end_visit(const AbbrevForwardStep &n)
 
2210
{
 
2211
    if (n.get_node_test() != NULL)
 
2212
      os << reinterpret_cast<intptr_t>(&n) << " -> " 
 
2213
         << reinterpret_cast<intptr_t>(&*n.get_node_test()) << std::endl;    
 
2214
}
 
2215
 
 
2216
void
 
2217
ParseNodePrintDOTVisitor::end_visit(const AnyKindTest &n)
 
2218
{
 
2219
}
 
2220
 
 
2221
void
 
2222
ParseNodePrintDOTVisitor::end_visit(const AposAttrContentList &n)
 
2223
{
 
2224
}
 
2225
 
 
2226
 
 
2227
void
 
2228
ParseNodePrintDOTVisitor::end_visit(const AposAttrValueContent &n)
 
2229
{
 
2230
}
 
2231
 
 
2232
 
 
2233
void
 
2234
ParseNodePrintDOTVisitor::end_visit(const ArgList &n)
 
2235
{
 
2236
}
 
2237
 
 
2238
 
 
2239
void
 
2240
ParseNodePrintDOTVisitor::end_visit(const AtomicType &n)
 
2241
{
 
2242
}
 
2243
 
 
2244
 
 
2245
void
 
2246
ParseNodePrintDOTVisitor::end_visit(const AttributeTest &n)
 
2247
{
 
2248
}
 
2249
 
 
2250
 
 
2251
void
 
2252
ParseNodePrintDOTVisitor::end_visit(const BaseURIDecl &n)
 
2253
{
 
2254
}
 
2255
 
 
2256
 
 
2257
void
 
2258
ParseNodePrintDOTVisitor::end_visit(const BoundarySpaceDecl &n)
 
2259
{
 
2260
}
 
2261
 
 
2262
 
 
2263
void
 
2264
ParseNodePrintDOTVisitor::end_visit(const CaseClause &n)
 
2265
{
 
2266
}
 
2267
 
 
2268
 
 
2269
void
 
2270
ParseNodePrintDOTVisitor::end_visit(const CaseClauseList &n)
 
2271
{
 
2272
}
 
2273
 
 
2274
 
 
2275
void
 
2276
ParseNodePrintDOTVisitor::end_visit(const CommentTest &n)
 
2277
{
 
2278
}
 
2279
 
 
2280
 
 
2281
void
 
2282
ParseNodePrintDOTVisitor::end_visit(const ConstructionDecl &n)
 
2283
{
 
2284
}
 
2285
 
 
2286
 
 
2287
void
 
2288
ParseNodePrintDOTVisitor::end_visit(const CopyNamespacesDecl &n)
 
2289
{
 
2290
}
 
2291
 
 
2292
 
 
2293
void
 
2294
ParseNodePrintDOTVisitor::end_visit(const DefaultCollationDecl &n)
 
2295
{
 
2296
}
 
2297
 
 
2298
 
 
2299
void
 
2300
ParseNodePrintDOTVisitor::end_visit(const DefaultNamespaceDecl &n)
 
2301
{
 
2302
}
 
2303
 
 
2304
 
 
2305
void
 
2306
ParseNodePrintDOTVisitor::end_visit(const DirAttr &n)
 
2307
{
 
2308
}
 
2309
 
 
2310
 
 
2311
void
 
2312
ParseNodePrintDOTVisitor::end_visit(const DirAttributeList &n)
 
2313
{
 
2314
}
 
2315
 
 
2316
 
 
2317
void
 
2318
ParseNodePrintDOTVisitor::end_visit(const DirAttributeValue &n)
 
2319
{
 
2320
}
 
2321
 
 
2322
 
 
2323
void
 
2324
ParseNodePrintDOTVisitor::end_visit(const DirElemContentList &n)
 
2325
{
 
2326
}
 
2327
 
 
2328
 
 
2329
void
 
2330
ParseNodePrintDOTVisitor::end_visit(const DocumentTest &n)
 
2331
{
 
2332
}
 
2333
 
 
2334
 
 
2335
void
 
2336
ParseNodePrintDOTVisitor::end_visit(const ElementTest &n)
 
2337
{
 
2338
}
 
2339
 
 
2340
 
 
2341
void
 
2342
ParseNodePrintDOTVisitor::end_visit(const EmptyOrderDecl &n)
 
2343
{
 
2344
}
 
2345
 
 
2346
 
 
2347
void
 
2348
ParseNodePrintDOTVisitor::end_visit(const ForClause &n)
 
2349
{
 
2350
}
 
2351
 
 
2352
 
 
2353
// void
 
2354
// ParseNodePrintDOTVisitor::end_visit(const ForLetClause &n)
 
2355
// {
 
2356
//     INDENT_DEC;
 
2357
//     
 
2358
//     INDENT;
 
2359
//     os << "</MainModule>";
 
2360
//     NL;
 
2361
// }
 
2362
 
 
2363
 
 
2364
void
 
2365
ParseNodePrintDOTVisitor::end_visit(const ForLetClauseList &n)
 
2366
{
 
2367
}
 
2368
 
 
2369
 
 
2370
void
 
2371
ParseNodePrintDOTVisitor::end_visit(const ForwardAxis &n)
 
2372
{
 
2373
 
 
2374
}
 
2375
 
 
2376
 
 
2377
void
 
2378
ParseNodePrintDOTVisitor::end_visit(const ForwardStep &n)
 
2379
{
 
2380
    if (n.get_forward_axis() != NULL)
 
2381
      os << reinterpret_cast<intptr_t>(&n) << " -> " 
 
2382
         << reinterpret_cast<intptr_t>(&*n.get_forward_axis()) << std::endl;
 
2383
 
 
2384
    if (n.get_node_test() != NULL)
 
2385
      os << reinterpret_cast<intptr_t>(&n) << " -> " 
 
2386
         << reinterpret_cast<intptr_t>(&*n.get_node_test()) << std::endl;               
 
2387
 
 
2388
    if (n.get_abbrev_step() != NULL)
 
2389
      os << reinterpret_cast<intptr_t>(&n) << " -> " 
 
2390
         << reinterpret_cast<intptr_t>(&*n.get_abbrev_step()) << std::endl;    
 
2391
 
 
2392
}
 
2393
 
 
2394
 
 
2395
void
 
2396
ParseNodePrintDOTVisitor::end_visit(const FunctionDecl &n)
 
2397
{
 
2398
}
 
2399
 
 
2400
 
 
2401
void
 
2402
ParseNodePrintDOTVisitor::end_visit(const GeneralComp &n)
 
2403
{
 
2404
}
 
2405
 
 
2406
 
 
2407
void
 
2408
ParseNodePrintDOTVisitor::end_visit(const ItemType &n)
 
2409
{
 
2410
}
 
2411
 
 
2412
 
 
2413
void
 
2414
ParseNodePrintDOTVisitor::end_visit(const LetClause &n)
 
2415
{
 
2416
}
 
2417
 
 
2418
 
 
2419
void
 
2420
ParseNodePrintDOTVisitor::end_visit(const LibraryModule &n)
 
2421
{
 
2422
    os << reinterpret_cast<intptr_t>(&n) << " -> " 
 
2423
          << reinterpret_cast<intptr_t>(&*n.get_decl());
 
2424
 
 
2425
       os << reinterpret_cast<intptr_t>(&n) << " -> " 
 
2426
          << reinterpret_cast<intptr_t>(&*n.get_prolog());
 
2427
    NL;
 
2428
}
 
2429
 
 
2430
 
 
2431
void
 
2432
ParseNodePrintDOTVisitor::end_visit(const MainModule  &n)
 
2433
{
 
2434
    if (n.get_prolog() != NULL)
 
2435
        os << reinterpret_cast<intptr_t>(&n) << " -> " 
 
2436
           << reinterpret_cast<intptr_t>(&*n.get_prolog()) << std::endl;
 
2437
  
 
2438
    if (n.get_query_body() != NULL)
 
2439
        os << reinterpret_cast<intptr_t>(&n) << " -> " 
 
2440
           << reinterpret_cast<intptr_t>(&*n.get_query_body()) << std::endl;
 
2441
}
 
2442
 
 
2443
 
 
2444
void
 
2445
ParseNodePrintDOTVisitor::end_visit(const Module &n)
 
2446
{
 
2447
}
 
2448
 
 
2449
 
 
2450
void
 
2451
ParseNodePrintDOTVisitor::end_visit(const ModuleDecl &n)
 
2452
{
 
2453
    
 
2454
    os << reinterpret_cast<intptr_t>(&n) << " -> " 
 
2455
         << reinterpret_cast<intptr_t>(&n);
 
2456
 
 
2457
    NL;
 
2458
}
 
2459
 
 
2460
 
 
2461
void
 
2462
ParseNodePrintDOTVisitor::end_visit(const ModuleImport &n)
 
2463
{
 
2464
}
 
2465
 
 
2466
 
 
2467
void
 
2468
ParseNodePrintDOTVisitor::end_visit(const NameTest &n)
 
2469
{
 
2470
}
 
2471
 
 
2472
 
 
2473
void
 
2474
ParseNodePrintDOTVisitor::end_visit(const NamespaceDecl &n)
 
2475
{
 
2476
}
 
2477
 
 
2478
 
 
2479
void
 
2480
ParseNodePrintDOTVisitor::end_visit(const NodeComp &n)
 
2481
{
 
2482
}
 
2483
 
 
2484
 
 
2485
void
 
2486
ParseNodePrintDOTVisitor::end_visit(const OccurrenceIndicator &n)
 
2487
{
 
2488
}
 
2489
 
 
2490
 
 
2491
void
 
2492
ParseNodePrintDOTVisitor::end_visit(const OptionDecl &n)
 
2493
{
 
2494
}
 
2495
 
 
2496
 
 
2497
void
 
2498
ParseNodePrintDOTVisitor::end_visit(const OrderByClause &n)
 
2499
{
 
2500
}
 
2501
 
 
2502
 
 
2503
void
 
2504
ParseNodePrintDOTVisitor::end_visit(const OrderCollationSpec &n)
 
2505
{
 
2506
}
 
2507
 
 
2508
 
 
2509
void
 
2510
ParseNodePrintDOTVisitor::end_visit(const OrderDirSpec &n)
 
2511
{
 
2512
}
 
2513
 
 
2514
 
 
2515
void
 
2516
ParseNodePrintDOTVisitor::end_visit(const OrderEmptySpec &n)
 
2517
{
 
2518
}
 
2519
 
 
2520
 
 
2521
void
 
2522
ParseNodePrintDOTVisitor::end_visit(const OrderModifier &n)
 
2523
{
 
2524
}
 
2525
 
 
2526
 
 
2527
void
 
2528
ParseNodePrintDOTVisitor::end_visit(const OrderSpec &n)
 
2529
{
 
2530
}
 
2531
 
 
2532
 
 
2533
void
 
2534
ParseNodePrintDOTVisitor::end_visit(const OrderSpecList &n)
 
2535
{
 
2536
}
 
2537
 
 
2538
 
 
2539
void
 
2540
ParseNodePrintDOTVisitor::end_visit(const OrderingModeDecl &n)
 
2541
{
 
2542
}
 
2543
 
 
2544
 
 
2545
void
 
2546
ParseNodePrintDOTVisitor::end_visit(const PITest &n)
 
2547
{
 
2548
}
 
2549
 
 
2550
 
 
2551
void
 
2552
ParseNodePrintDOTVisitor::end_visit(const Param &n)
 
2553
{
 
2554
}
 
2555
 
 
2556
 
 
2557
void
 
2558
ParseNodePrintDOTVisitor::end_visit(const ParamList &n)
 
2559
{
 
2560
}
 
2561
 
 
2562
 
 
2563
void
 
2564
ParseNodePrintDOTVisitor::end_visit(const PositionalVar &n)
 
2565
{
 
2566
}
 
2567
 
 
2568
 
 
2569
void
 
2570
ParseNodePrintDOTVisitor::end_visit(const Pragma &n)
 
2571
{
 
2572
}
 
2573
 
 
2574
 
 
2575
void
 
2576
ParseNodePrintDOTVisitor::end_visit(const PragmaList &n)
 
2577
{
 
2578
}
 
2579
 
 
2580
 
 
2581
void
 
2582
ParseNodePrintDOTVisitor::end_visit(const PredicateList &n)
 
2583
{
 
2584
}
 
2585
 
 
2586
 
 
2587
void
 
2588
ParseNodePrintDOTVisitor::end_visit(const Prolog &n)
 
2589
{
 
2590
}
 
2591
 
 
2592
 
 
2593
void
 
2594
ParseNodePrintDOTVisitor::end_visit(const QVarInDecl &n)
 
2595
{
 
2596
}
 
2597
 
 
2598
 
 
2599
void
 
2600
ParseNodePrintDOTVisitor::end_visit(const QVarInDeclList &n)
 
2601
{
 
2602
}
 
2603
 
 
2604
 
 
2605
void
 
2606
ParseNodePrintDOTVisitor::end_visit(const QuoteAttrValueContent &n)
 
2607
{
 
2608
}
 
2609
 
 
2610
 
 
2611
void
 
2612
ParseNodePrintDOTVisitor::end_visit(const QuoteAttrContentList &n)
 
2613
{
 
2614
}
 
2615
 
 
2616
 
 
2617
void
 
2618
ParseNodePrintDOTVisitor::end_visit(const ReverseAxis &n)
 
2619
{
 
2620
}
 
2621
 
 
2622
 
 
2623
void
 
2624
ParseNodePrintDOTVisitor::end_visit(const ReverseStep &n)
 
2625
{
 
2626
}
 
2627
 
 
2628
 
 
2629
void
 
2630
ParseNodePrintDOTVisitor::end_visit(const SIND_DeclList &n)
 
2631
{
 
2632
}
 
2633
 
 
2634
 
 
2635
void
 
2636
ParseNodePrintDOTVisitor::end_visit(const SchemaAttributeTest &n)
 
2637
{
 
2638
}
 
2639
 
 
2640
 
 
2641
void
 
2642
ParseNodePrintDOTVisitor::end_visit(const SchemaElementTest &n)
 
2643
{
 
2644
}
 
2645
 
 
2646
 
 
2647
void
 
2648
ParseNodePrintDOTVisitor::end_visit(const SchemaImport &n)
 
2649
{
 
2650
}
 
2651
 
 
2652
 
 
2653
void
 
2654
ParseNodePrintDOTVisitor::end_visit(const SchemaPrefix &n)
 
2655
{
 
2656
}
 
2657
 
 
2658
 
 
2659
void
 
2660
ParseNodePrintDOTVisitor::end_visit(const SequenceType &n)
 
2661
{
 
2662
}
 
2663
 
 
2664
 
 
2665
void
 
2666
ParseNodePrintDOTVisitor::end_visit(const SignList &n)
 
2667
{
 
2668
}
 
2669
 
 
2670
 
 
2671
void
 
2672
ParseNodePrintDOTVisitor::end_visit(const SingleType &n)
 
2673
{
 
2674
}
 
2675
 
 
2676
 
 
2677
void
 
2678
ParseNodePrintDOTVisitor::end_visit(const TextTest &n)
 
2679
{
 
2680
}
 
2681
 
 
2682
 
 
2683
void
 
2684
ParseNodePrintDOTVisitor::end_visit(const TypeDeclaration &n)
 
2685
{
 
2686
}
 
2687
 
 
2688
 
 
2689
void
 
2690
ParseNodePrintDOTVisitor::end_visit(const TypeName &n)
 
2691
{
 
2692
}
 
2693
 
 
2694
 
 
2695
void
 
2696
ParseNodePrintDOTVisitor::end_visit(const URILiteralList &n)
 
2697
{
 
2698
}
 
2699
 
 
2700
 
 
2701
void
 
2702
ParseNodePrintDOTVisitor::end_visit(const ValueComp &n)
 
2703
{
 
2704
}
 
2705
 
 
2706
 
 
2707
void
 
2708
ParseNodePrintDOTVisitor::end_visit(const VarDecl &n)
 
2709
{
 
2710
}
 
2711
 
 
2712
 
 
2713
void
 
2714
ParseNodePrintDOTVisitor::end_visit(const VarGetsDecl &n)
 
2715
{
 
2716
}
 
2717
 
 
2718
 
 
2719
void
 
2720
ParseNodePrintDOTVisitor::end_visit(const VarGetsDeclList &n)
 
2721
{
 
2722
}
 
2723
 
 
2724
 
 
2725
void
 
2726
ParseNodePrintDOTVisitor::end_visit(const VarInDecl &n)
 
2727
{
 
2728
}
 
2729
 
 
2730
 
 
2731
void
 
2732
ParseNodePrintDOTVisitor::end_visit(const VarInDeclList &n)
 
2733
{
 
2734
}
 
2735
 
 
2736
 
 
2737
void
 
2738
ParseNodePrintDOTVisitor::end_visit(const VersionDecl &n)
 
2739
{
 
2740
}
 
2741
 
 
2742
 
 
2743
void
 
2744
ParseNodePrintDOTVisitor::end_visit(const VFO_DeclList &n)
 
2745
{
 
2746
}
 
2747
 
 
2748
 
 
2749
void
 
2750
ParseNodePrintDOTVisitor::end_visit(const WhereClause &n)
 
2751
{
 
2752
}
 
2753
 
 
2754
 
 
2755
void
 
2756
ParseNodePrintDOTVisitor::end_visit(const Wildcard &n)
 
2757
{
 
2758
}
 
2759
 
 
2760
 
 
2761
 
 
2762
void
 
2763
ParseNodePrintDOTVisitor::end_visit(const exprnode &n)
 
2764
{
 
2765
}
 
2766
 
 
2767
 
 
2768
void
 
2769
ParseNodePrintDOTVisitor::end_visit(const AdditiveExpr &n)
 
2770
{
 
2771
}
 
2772
 
 
2773
 
 
2774
void
 
2775
ParseNodePrintDOTVisitor::end_visit(const AndExpr &n)
 
2776
{
 
2777
}
 
2778
 
 
2779
 
 
2780
void
 
2781
ParseNodePrintDOTVisitor::end_visit(const AxisStep &n)
 
2782
{
 
2783
    if (n.get_forward_step() != NULL)
 
2784
        os << reinterpret_cast<intptr_t>(&n) << " -> " 
 
2785
           << reinterpret_cast<intptr_t>(&*n.get_forward_step()) << std::endl;
 
2786
 
 
2787
   if (n.get_reverse_step() != NULL)
 
2788
       os << reinterpret_cast<intptr_t>(&n) << " -> " 
 
2789
          << reinterpret_cast<intptr_t>(&*n.get_reverse_step()) << std::endl;
 
2790
 
 
2791
  if (n.get_predicate_list() != NULL)
 
2792
      os << reinterpret_cast<intptr_t>(&n) << " -> " 
 
2793
         << reinterpret_cast<intptr_t>(&*n.get_predicate_list()) << std::endl;
 
2794
}
 
2795
 
 
2796
 
 
2797
void
 
2798
ParseNodePrintDOTVisitor::end_visit(const CDataSection &n)
 
2799
{
 
2800
}
 
2801
 
 
2802
 
 
2803
void
 
2804
ParseNodePrintDOTVisitor::end_visit(const CastExpr &n)
 
2805
{
 
2806
}
 
2807
 
 
2808
 
 
2809
void
 
2810
ParseNodePrintDOTVisitor::end_visit(const CastableExpr &n)
 
2811
{
 
2812
}
 
2813
 
 
2814
 
 
2815
void
 
2816
ParseNodePrintDOTVisitor::end_visit(const CommonContent &n)
 
2817
{
 
2818
}
 
2819
 
 
2820
 
 
2821
void
 
2822
ParseNodePrintDOTVisitor::end_visit(const ComparisonExpr &n)
 
2823
{
 
2824
}
 
2825
 
 
2826
 
 
2827
void
 
2828
ParseNodePrintDOTVisitor::end_visit(const CompAttrConstructor &n)
 
2829
{
 
2830
}
 
2831
 
 
2832
 
 
2833
void
 
2834
ParseNodePrintDOTVisitor::end_visit(const CompCommentConstructor &n)
 
2835
{
 
2836
}
 
2837
 
 
2838
 
 
2839
void
 
2840
ParseNodePrintDOTVisitor::end_visit(const CompDocConstructor &n)
 
2841
{
 
2842
}
 
2843
 
 
2844
 
 
2845
void
 
2846
ParseNodePrintDOTVisitor::end_visit(const CompElemConstructor &n)
 
2847
{
 
2848
}
 
2849
 
 
2850
 
 
2851
void
 
2852
ParseNodePrintDOTVisitor::end_visit(const CompPIConstructor &n)
 
2853
{
 
2854
}
 
2855
 
 
2856
 
 
2857
void
 
2858
ParseNodePrintDOTVisitor::end_visit(const CompTextConstructor &n)
 
2859
{
 
2860
}
 
2861
 
 
2862
 
 
2863
void
 
2864
ParseNodePrintDOTVisitor::end_visit(const ContextItemExpr &n)
 
2865
{
 
2866
}
 
2867
 
 
2868
 
 
2869
void
 
2870
ParseNodePrintDOTVisitor::end_visit(const DirCommentConstructor &n)
 
2871
{
 
2872
}
 
2873
 
 
2874
 
 
2875
void
 
2876
ParseNodePrintDOTVisitor::end_visit(const DirElemConstructor &n)
 
2877
{
 
2878
}
 
2879
 
 
2880
 
 
2881
void
 
2882
ParseNodePrintDOTVisitor::end_visit(const DirElemContent &n)
 
2883
{
 
2884
}
 
2885
 
 
2886
 
 
2887
void
 
2888
ParseNodePrintDOTVisitor::end_visit(const DirPIConstructor &n)
 
2889
{
 
2890
}
 
2891
 
 
2892
 
 
2893
void
 
2894
ParseNodePrintDOTVisitor::end_visit(const EnclosedExpr &n)
 
2895
{
 
2896
}
 
2897
 
 
2898
 
 
2899
void
 
2900
ParseNodePrintDOTVisitor::end_visit(const Expr &n)
 
2901
{
 
2902
   for (int i = 0; i < n.numberOfChildren(); ++i)
 
2903
   {
 
2904
        os << reinterpret_cast<intptr_t>(&n) << " -> " 
 
2905
           << reinterpret_cast<intptr_t>(&*(n[i])) << std::endl;
 
2906
   }
 
2907
}
 
2908
 
 
2909
 
 
2910
// void
 
2911
// ParseNodePrintDOTVisitor::end_visit(const ExprSingle &n)
 
2912
// {
 
2913
//     INDENT_DEC;
 
2914
//     
 
2915
//     INDENT;
 
2916
//     os << "</MainModule>";
 
2917
//     NL;
 
2918
// }
 
2919
 
 
2920
 
 
2921
void
 
2922
ParseNodePrintDOTVisitor::end_visit(const ExtensionExpr &n)
 
2923
{
 
2924
}
 
2925
 
 
2926
 
 
2927
void
 
2928
ParseNodePrintDOTVisitor::end_visit(const FLWORExpr &n)
 
2929
{
 
2930
}
 
2931
 
 
2932
 
 
2933
void
 
2934
ParseNodePrintDOTVisitor::end_visit(const FilterExpr &n)
 
2935
{
 
2936
}
 
2937
 
 
2938
 
 
2939
void
 
2940
ParseNodePrintDOTVisitor::end_visit(const FunctionCall &n)
 
2941
{
 
2942
}
 
2943
 
 
2944
 
 
2945
void
 
2946
ParseNodePrintDOTVisitor::end_visit(const IfExpr &n)
 
2947
{
 
2948
}
 
2949
 
 
2950
 
 
2951
void
 
2952
ParseNodePrintDOTVisitor::end_visit(const InstanceofExpr &n)
 
2953
{
 
2954
}
 
2955
 
 
2956
 
 
2957
void
 
2958
ParseNodePrintDOTVisitor::end_visit(const IntersectExceptExpr &n)
 
2959
{
 
2960
}
 
2961
 
 
2962
 
 
2963
void
 
2964
ParseNodePrintDOTVisitor::end_visit(const MultiplicativeExpr &n)
 
2965
{
 
2966
}
 
2967
 
 
2968
 
 
2969
void
 
2970
ParseNodePrintDOTVisitor::end_visit(const NumericLiteral &n)
 
2971
{
 
2972
}
 
2973
 
 
2974
 
 
2975
void
 
2976
ParseNodePrintDOTVisitor::end_visit(const OrExpr &n)
 
2977
{
 
2978
}
 
2979
 
 
2980
 
 
2981
void
 
2982
ParseNodePrintDOTVisitor::end_visit(const OrderedExpr &n)
 
2983
{
 
2984
}
 
2985
 
 
2986
 
 
2987
void
 
2988
ParseNodePrintDOTVisitor::end_visit(const ParenthesizedExpr &n)
 
2989
{
 
2990
}
 
2991
 
 
2992
 
 
2993
void
 
2994
ParseNodePrintDOTVisitor::end_visit(const PathExpr &n)
 
2995
{
 
2996
    if (n.get_relpath_expr() != NULL)
 
2997
        os << reinterpret_cast<intptr_t>(&n) << " -> " 
 
2998
           << reinterpret_cast<intptr_t>(&*n.get_relpath_expr()) << std::endl;    
 
2999
}
 
3000
 
 
3001
 
 
3002
void
 
3003
ParseNodePrintDOTVisitor::end_visit(const QuantifiedExpr &n)
 
3004
{
 
3005
}
 
3006
 
 
3007
 
 
3008
void
 
3009
ParseNodePrintDOTVisitor::end_visit(const QueryBody &n)
 
3010
{
 
3011
    if (n.get_expr() != NULL)
 
3012
        os << reinterpret_cast<intptr_t>(&n) << " -> " 
 
3013
           << reinterpret_cast<intptr_t>(&*n.get_expr()) << std::endl;    
 
3014
}
 
3015
 
 
3016
 
 
3017
void
 
3018
ParseNodePrintDOTVisitor::end_visit(const RangeExpr &n)
 
3019
{
 
3020
}
 
3021
 
 
3022
 
 
3023
void
 
3024
ParseNodePrintDOTVisitor::end_visit(const RelativePathExpr &n)
 
3025
{
 
3026
}
 
3027
 
 
3028
 
 
3029
void
 
3030
ParseNodePrintDOTVisitor::end_visit(const StringLiteral &n)
 
3031
{
 
3032
}
 
3033
 
 
3034
 
 
3035
void
 
3036
ParseNodePrintDOTVisitor::end_visit(const TreatExpr &n)
 
3037
{
 
3038
}
 
3039
 
 
3040
 
 
3041
void
 
3042
ParseNodePrintDOTVisitor::end_visit(const TypeswitchExpr &n)
 
3043
{
 
3044
}
 
3045
 
 
3046
 
 
3047
void
 
3048
ParseNodePrintDOTVisitor::end_visit(const UnaryExpr &n)
 
3049
{
 
3050
}
 
3051
 
 
3052
 
 
3053
void
 
3054
ParseNodePrintDOTVisitor::end_visit(const UnionExpr &n)
 
3055
{
 
3056
}
 
3057
 
 
3058
 
 
3059
void
 
3060
ParseNodePrintDOTVisitor::end_visit(const UnorderedExpr &n)
 
3061
{
 
3062
}
 
3063
 
 
3064
 
 
3065
void
 
3066
ParseNodePrintDOTVisitor::end_visit(const ValidateExpr &n)
 
3067
{
 
3068
}
 
3069
 
 
3070
 
 
3071
void
 
3072
ParseNodePrintDOTVisitor::end_visit(const VarRef &n)
 
3073
{
 
3074
}
 
3075
 
 
3076
void
 
3077
ParseNodePrintDOTVisitor::end_visit(const DeleteExpr &n)
 
3078
{
 
3079
}
 
3080
 
 
3081
 
 
3082
void
 
3083
ParseNodePrintDOTVisitor::end_visit(const InsertExpr &n)
 
3084
{
 
3085
}
 
3086
 
 
3087
 
 
3088
void
 
3089
ParseNodePrintDOTVisitor::end_visit(const RenameExpr &n)
 
3090
{
 
3091
}
 
3092
 
 
3093
 
 
3094
void
 
3095
ParseNodePrintDOTVisitor::end_visit(const ReplaceExpr &n)
 
3096
{
 
3097
}
 
3098
 
 
3099
 
 
3100
void
 
3101
ParseNodePrintDOTVisitor::end_visit(const RevalidationDecl &n)
 
3102
{
 
3103
}
 
3104
 
 
3105
 
 
3106
void
 
3107
ParseNodePrintDOTVisitor::end_visit(const TransformExpr &n)
 
3108
{
 
3109
}
 
3110
 
 
3111
 
 
3112
void
 
3113
ParseNodePrintDOTVisitor::end_visit(const VarNameList &n)
 
3114
{
 
3115
}
 
3116
 
 
3117
 
 
3118
void
 
3119
ParseNodePrintDOTVisitor::end_visit(const FTAnd &n)
 
3120
{
 
3121
}
 
3122
 
 
3123
 
 
3124
void
 
3125
ParseNodePrintDOTVisitor::end_visit(const FTAnyallOption &n)
 
3126
{
 
3127
}
 
3128
 
 
3129
 
 
3130
void
 
3131
ParseNodePrintDOTVisitor::end_visit(const FTBigUnit &n)
 
3132
{
 
3133
}
 
3134
 
 
3135
 
 
3136
void
 
3137
ParseNodePrintDOTVisitor::end_visit(const FTCaseOption &n)
 
3138
{
 
3139
}
 
3140
 
 
3141
 
 
3142
void
 
3143
ParseNodePrintDOTVisitor::end_visit(const FTContainsExpr &n)
 
3144
{
 
3145
}
 
3146
 
 
3147
 
 
3148
void
 
3149
ParseNodePrintDOTVisitor::end_visit(const FTContent &n)
 
3150
{
 
3151
}
 
3152
 
 
3153
 
 
3154
void
 
3155
ParseNodePrintDOTVisitor::end_visit(const FTDiacriticsOption &n)
 
3156
{
 
3157
}
 
3158
 
 
3159
 
 
3160
void
 
3161
ParseNodePrintDOTVisitor::end_visit(const FTDistance &n)
 
3162
{
 
3163
}
 
3164
 
 
3165
 
 
3166
void
 
3167
ParseNodePrintDOTVisitor::end_visit(const FTIgnoreOption &n)
 
3168
{
 
3169
}
 
3170
 
 
3171
 
 
3172
void
 
3173
ParseNodePrintDOTVisitor::end_visit(const FTInclExclStringLiteral &n)
 
3174
{
 
3175
}
 
3176
 
 
3177
 
 
3178
void
 
3179
ParseNodePrintDOTVisitor::end_visit(const FTInclExclStringLiteralList &n)
 
3180
{
 
3181
}
 
3182
 
 
3183
 
 
3184
void
 
3185
ParseNodePrintDOTVisitor::end_visit(const FTLanguageOption &n)
 
3186
{
 
3187
}
 
3188
 
 
3189
 
 
3190
void
 
3191
ParseNodePrintDOTVisitor::end_visit(const FTMatchOption &n)
 
3192
{
 
3193
}
 
3194
 
 
3195
 
 
3196
void
 
3197
ParseNodePrintDOTVisitor::end_visit(const FTMatchOptionProximityList &n)
 
3198
{
 
3199
}
 
3200
 
 
3201
 
 
3202
void
 
3203
ParseNodePrintDOTVisitor::end_visit(const FTMildnot &n)
 
3204
{
 
3205
}
 
3206
 
 
3207
 
 
3208
void
 
3209
ParseNodePrintDOTVisitor::end_visit(const FTOptionDecl &n)
 
3210
{
 
3211
}
 
3212
 
 
3213
 
 
3214
void
 
3215
ParseNodePrintDOTVisitor::end_visit(const FTOr &n)
 
3216
{
 
3217
}
 
3218
 
 
3219
 
 
3220
void
 
3221
ParseNodePrintDOTVisitor::end_visit(const FTOrderedIndicator &n)
 
3222
{
 
3223
}
 
3224
 
 
3225
 
 
3226
void
 
3227
ParseNodePrintDOTVisitor::end_visit(const FTProximity &n)
 
3228
{
 
3229
}
 
3230
 
 
3231
 
 
3232
void
 
3233
ParseNodePrintDOTVisitor::end_visit(const FTRange &n)
 
3234
{
 
3235
}
 
3236
 
 
3237
 
 
3238
void
 
3239
ParseNodePrintDOTVisitor::end_visit(const FTRefOrList &n)
 
3240
{
 
3241
}
 
3242
 
 
3243
 
 
3244
void
 
3245
ParseNodePrintDOTVisitor::end_visit(const FTScope &n)
 
3246
{
 
3247
}
 
3248
 
 
3249
 
 
3250
void
 
3251
ParseNodePrintDOTVisitor::end_visit(const FTScoreVar &n)
 
3252
{
 
3253
}
 
3254
 
 
3255
 
 
3256
void
 
3257
ParseNodePrintDOTVisitor::end_visit(const FTSelection &n)
 
3258
{
 
3259
}
 
3260
 
 
3261
 
 
3262
void
 
3263
ParseNodePrintDOTVisitor::end_visit(const FTStemOption &n)
 
3264
{
 
3265
}
 
3266
 
 
3267
 
 
3268
void
 
3269
ParseNodePrintDOTVisitor::end_visit(const FTStopwordOption &n)
 
3270
{
 
3271
}
 
3272
 
 
3273
 
 
3274
void
 
3275
ParseNodePrintDOTVisitor::end_visit(const FTStringLiteralList &n)
 
3276
{
 
3277
}
 
3278
 
 
3279
 
 
3280
void
 
3281
ParseNodePrintDOTVisitor::end_visit(const FTThesaurusID &n)
 
3282
{
 
3283
}
 
3284
 
 
3285
 
 
3286
void
 
3287
ParseNodePrintDOTVisitor::end_visit(const FTThesaurusList &n)
 
3288
{
 
3289
}
 
3290
 
 
3291
 
 
3292
void
 
3293
ParseNodePrintDOTVisitor::end_visit(const FTThesaurusOption &n)
 
3294
{
 
3295
}
 
3296
 
 
3297
 
 
3298
void
 
3299
ParseNodePrintDOTVisitor::end_visit(const FTTimes &n)
 
3300
{
 
3301
}
 
3302
 
 
3303
 
 
3304
void
 
3305
ParseNodePrintDOTVisitor::end_visit(const FTUnaryNot &n)
 
3306
{
 
3307
}
 
3308
 
 
3309
 
 
3310
void
 
3311
ParseNodePrintDOTVisitor::end_visit(const FTUnit &n)
 
3312
{
 
3313
}
 
3314
 
 
3315
 
 
3316
void
 
3317
ParseNodePrintDOTVisitor::end_visit(const FTWildcardOption &n)
 
3318
{
 
3319
}
 
3320
 
 
3321
 
 
3322
void
 
3323
ParseNodePrintDOTVisitor::end_visit(const FTWindow &n)
 
3324
{
 
3325
}
 
3326
 
 
3327
 
 
3328
void
 
3329
ParseNodePrintDOTVisitor::end_visit(const FTWords &n)
 
3330
{
 
3331
}
 
3332
 
 
3333
 
 
3334
void
 
3335
ParseNodePrintDOTVisitor::end_visit(const FTWordsSelection &n)
 
3336
{
 
3337
}
 
3338
 
 
3339
 
 
3340
void
 
3341
ParseNodePrintDOTVisitor::end_visit(const FTWordsValue &n)
 
3342
{
 
3343
}
 
3344
 
 
3345
 
 
3346
 
 
3347
 
 
3348
} // end namespace
 
3349