1 #ifndef TEST1AST_H_HPP_GUARD_
2 #define TEST1AST_H_HPP_GUARD_
3 #include <string>
4 #include <list>
5 #include "test1visitor.h"
6
7 class node
8 {
9 public:
~node()10 virtual ~node() {}
11 virtual void accept( Visitor * ) const = 0;
12 };
13
14 class stmt: public node
15 {
16 public:
stmt()17 stmt()
18 {}
~stmt()19 virtual ~stmt() {}
20
21 };
22
23 class stmt_selectStmt_optSemicolon : public stmt
24 {
25 public:
stmt_selectStmt_optSemicolon(selectStmt * pNewselectStmt1,optSemicolon * pNewoptSemicolon2)26 stmt_selectStmt_optSemicolon(
27 selectStmt* pNewselectStmt1,
28 optSemicolon* pNewoptSemicolon2
29 )
30 : stmt()
31 , m_pselectStmt1(pNewselectStmt1)
32 , m_poptSemicolon2(pNewoptSemicolon2)
33 {}
34
35 virtual ~stmt_selectStmt_optSemicolon();
36
accept(Visitor * v)37 void accept( Visitor* v ) const
38 {
39 v->visit_stmt_selectStmt_optSemicolon( this );
40 }
41
42 selectStmt* m_pselectStmt1;
43 optSemicolon* m_poptSemicolon2;
44 };
45
46 class stmt_updateStmt_optSemicolon : public stmt
47 {
48 public:
stmt_updateStmt_optSemicolon(updateStmt * pNewupdateStmt1,optSemicolon * pNewoptSemicolon2)49 stmt_updateStmt_optSemicolon(
50 updateStmt* pNewupdateStmt1,
51 optSemicolon* pNewoptSemicolon2
52 )
53 : stmt()
54 , m_pupdateStmt1(pNewupdateStmt1)
55 , m_poptSemicolon2(pNewoptSemicolon2)
56 {}
57
58 virtual ~stmt_updateStmt_optSemicolon();
59
accept(Visitor * v)60 void accept( Visitor* v ) const
61 {
62 v->visit_stmt_updateStmt_optSemicolon( this );
63 }
64
65 updateStmt* m_pupdateStmt1;
66 optSemicolon* m_poptSemicolon2;
67 };
68
69 class stmt_insertStmt_optSemicolon : public stmt
70 {
71 public:
stmt_insertStmt_optSemicolon(insertStmt * pNewinsertStmt1,optSemicolon * pNewoptSemicolon2)72 stmt_insertStmt_optSemicolon(
73 insertStmt* pNewinsertStmt1,
74 optSemicolon* pNewoptSemicolon2
75 )
76 : stmt()
77 , m_pinsertStmt1(pNewinsertStmt1)
78 , m_poptSemicolon2(pNewoptSemicolon2)
79 {}
80
81 virtual ~stmt_insertStmt_optSemicolon();
82
accept(Visitor * v)83 void accept( Visitor* v ) const
84 {
85 v->visit_stmt_insertStmt_optSemicolon( this );
86 }
87
88 insertStmt* m_pinsertStmt1;
89 optSemicolon* m_poptSemicolon2;
90 };
91
92 class stmt_deleteStmt_optSemicolon : public stmt
93 {
94 public:
stmt_deleteStmt_optSemicolon(deleteStmt * pNewdeleteStmt1,optSemicolon * pNewoptSemicolon2)95 stmt_deleteStmt_optSemicolon(
96 deleteStmt* pNewdeleteStmt1,
97 optSemicolon* pNewoptSemicolon2
98 )
99 : stmt()
100 , m_pdeleteStmt1(pNewdeleteStmt1)
101 , m_poptSemicolon2(pNewoptSemicolon2)
102 {}
103
104 virtual ~stmt_deleteStmt_optSemicolon();
105
accept(Visitor * v)106 void accept( Visitor* v ) const
107 {
108 v->visit_stmt_deleteStmt_optSemicolon( this );
109 }
110
111 deleteStmt* m_pdeleteStmt1;
112 optSemicolon* m_poptSemicolon2;
113 };
114
115 class optSemicolon: public node
116 {
117 public:
optSemicolon()118 optSemicolon()
119 {}
~optSemicolon()120 virtual ~optSemicolon() {}
121
122 };
123
124 class optSemicolon_empty : public optSemicolon
125 {
126 public:
optSemicolon_empty()127 optSemicolon_empty(
128 )
129 : optSemicolon()
130 {}
131
132 virtual ~optSemicolon_empty();
133
accept(Visitor * v)134 void accept( Visitor* v ) const
135 {
136 v->visit_optSemicolon_empty( this );
137 }
138
139 };
140
141 class optSemicolon_SEMICOLON : public optSemicolon
142 {
143 public:
optSemicolon_SEMICOLON(std::string * pNewSEMICOLON1)144 optSemicolon_SEMICOLON(
145 std::string* pNewSEMICOLON1
146 )
147 : optSemicolon()
148 , m_pSEMICOLON1(pNewSEMICOLON1)
149 {}
150
151 virtual ~optSemicolon_SEMICOLON();
152
accept(Visitor * v)153 void accept( Visitor* v ) const
154 {
155 v->visit_optSemicolon_SEMICOLON( this );
156 }
157
158 std::string* m_pSEMICOLON1;
159 };
160
161 class insertStmt : public node
162 {
163 public:
insertStmt(std::string * pNewINSERT1,std::string * pNewINTO2,std::string * pNewstrRelationName3,insertRest * pNewinsertRest4)164 insertStmt(
165 std::string* pNewINSERT1,
166 std::string* pNewINTO2,
167 std::string* pNewstrRelationName3,
168 insertRest* pNewinsertRest4
169 )
170 : m_pINSERT1(pNewINSERT1)
171 , m_pINTO2(pNewINTO2)
172 , m_pstrRelationName3(pNewstrRelationName3)
173 , m_pinsertRest4(pNewinsertRest4)
174 {}
175
176 virtual ~insertStmt();
177
accept(Visitor * v)178 void accept( Visitor* v ) const
179 {
180 v->visit_insertStmt( this );
181 }
182
183 std::string* m_pINSERT1;
184 std::string* m_pINTO2;
185 std::string* m_pstrRelationName3;
186 insertRest* m_pinsertRest4;
187 };
188
189 class insertRest: public node
190 {
191 public:
insertRest()192 insertRest()
193 {}
~insertRest()194 virtual ~insertRest() {}
195
196 };
197
198 class insertRest_VALUES_LEFTPAREN_targetList_RIGHTPAREN : public insertRest
199 {
200 public:
insertRest_VALUES_LEFTPAREN_targetList_RIGHTPAREN(std::string * pNewVALUES1,std::string * pNewLEFTPAREN2,std::list<targetEl * > * pNewtargetList3,std::string * pNewRIGHTPAREN4)201 insertRest_VALUES_LEFTPAREN_targetList_RIGHTPAREN(
202 std::string* pNewVALUES1,
203 std::string* pNewLEFTPAREN2,
204 std::list< targetEl* >* pNewtargetList3,
205 std::string* pNewRIGHTPAREN4
206 )
207 : insertRest()
208 , m_pVALUES1(pNewVALUES1)
209 , m_pLEFTPAREN2(pNewLEFTPAREN2)
210 , m_ptargetList3(pNewtargetList3)
211 , m_pRIGHTPAREN4(pNewRIGHTPAREN4)
212 {}
213
214 virtual ~insertRest_VALUES_LEFTPAREN_targetList_RIGHTPAREN();
215
accept(Visitor * v)216 void accept( Visitor* v ) const
217 {
218 v->visit_insertRest_VALUES_LEFTPAREN_targetList_RIGHTPAREN( this );
219 }
220
221 std::string* m_pVALUES1;
222 std::string* m_pLEFTPAREN2;
223 std::list< targetEl* >* m_ptargetList3;
224 std::string* m_pRIGHTPAREN4;
225 };
226
227 class insertRest_DEFAULT_VALUES : public insertRest
228 {
229 public:
insertRest_DEFAULT_VALUES(std::string * pNewDEFAULT1,std::string * pNewVALUES2)230 insertRest_DEFAULT_VALUES(
231 std::string* pNewDEFAULT1,
232 std::string* pNewVALUES2
233 )
234 : insertRest()
235 , m_pDEFAULT1(pNewDEFAULT1)
236 , m_pVALUES2(pNewVALUES2)
237 {}
238
239 virtual ~insertRest_DEFAULT_VALUES();
240
accept(Visitor * v)241 void accept( Visitor* v ) const
242 {
243 v->visit_insertRest_DEFAULT_VALUES( this );
244 }
245
246 std::string* m_pDEFAULT1;
247 std::string* m_pVALUES2;
248 };
249
250 class insertRest_LEFTPAREN_columnList_RIGHTPAREN_VALUES_LEFTPAREN_targetList_RIGHTPAREN : public insertRest
251 {
252 public:
insertRest_LEFTPAREN_columnList_RIGHTPAREN_VALUES_LEFTPAREN_targetList_RIGHTPAREN(std::string * pNewLEFTPAREN1,std::list<std::string * > * pNewcolumnList2,std::string * pNewRIGHTPAREN3,std::string * pNewVALUES4,std::string * pNewLEFTPAREN5,std::list<targetEl * > * pNewtargetList6,std::string * pNewRIGHTPAREN7)253 insertRest_LEFTPAREN_columnList_RIGHTPAREN_VALUES_LEFTPAREN_targetList_RIGHTPAREN(
254 std::string* pNewLEFTPAREN1,
255 std::list< std::string* >* pNewcolumnList2,
256 std::string* pNewRIGHTPAREN3,
257 std::string* pNewVALUES4,
258 std::string* pNewLEFTPAREN5,
259 std::list< targetEl* >* pNewtargetList6,
260 std::string* pNewRIGHTPAREN7
261 )
262 : insertRest()
263 , m_pLEFTPAREN1(pNewLEFTPAREN1)
264 , m_pcolumnList2(pNewcolumnList2)
265 , m_pRIGHTPAREN3(pNewRIGHTPAREN3)
266 , m_pVALUES4(pNewVALUES4)
267 , m_pLEFTPAREN5(pNewLEFTPAREN5)
268 , m_ptargetList6(pNewtargetList6)
269 , m_pRIGHTPAREN7(pNewRIGHTPAREN7)
270 {}
271
272 virtual ~insertRest_LEFTPAREN_columnList_RIGHTPAREN_VALUES_LEFTPAREN_targetList_RIGHTPAREN();
273
accept(Visitor * v)274 void accept( Visitor* v ) const
275 {
276 v->visit_insertRest_LEFTPAREN_columnList_RIGHTPAREN_VALUES_LEFTPAREN_targetList_RIGHTPAREN( this );
277 }
278
279 std::string* m_pLEFTPAREN1;
280 std::list< std::string* >* m_pcolumnList2;
281 std::string* m_pRIGHTPAREN3;
282 std::string* m_pVALUES4;
283 std::string* m_pLEFTPAREN5;
284 std::list< targetEl* >* m_ptargetList6;
285 std::string* m_pRIGHTPAREN7;
286 };
287
288 class deleteStmt : public node
289 {
290 public:
deleteStmt(std::string * pNewDELETE1,std::string * pNewFROM2,std::string * pNewstrRelationName3,optWhereClause * pNewoptWhereClause4)291 deleteStmt(
292 std::string* pNewDELETE1,
293 std::string* pNewFROM2,
294 std::string* pNewstrRelationName3,
295 optWhereClause* pNewoptWhereClause4
296 )
297 : m_pDELETE1(pNewDELETE1)
298 , m_pFROM2(pNewFROM2)
299 , m_pstrRelationName3(pNewstrRelationName3)
300 , m_poptWhereClause4(pNewoptWhereClause4)
301 {}
302
303 virtual ~deleteStmt();
304
accept(Visitor * v)305 void accept( Visitor* v ) const
306 {
307 v->visit_deleteStmt( this );
308 }
309
310 std::string* m_pDELETE1;
311 std::string* m_pFROM2;
312 std::string* m_pstrRelationName3;
313 optWhereClause* m_poptWhereClause4;
314 };
315
316 class updateStmt : public node
317 {
318 public:
updateStmt(std::string * pNewUPDATE1,std::string * pNewstrRelationName2,std::string * pNewSET3,std::list<updateTargetEl * > * pNewupdateTargetList4,optWhereClause * pNewoptWhereClause5)319 updateStmt(
320 std::string* pNewUPDATE1,
321 std::string* pNewstrRelationName2,
322 std::string* pNewSET3,
323 std::list< updateTargetEl* >* pNewupdateTargetList4,
324 optWhereClause* pNewoptWhereClause5
325 )
326 : m_pUPDATE1(pNewUPDATE1)
327 , m_pstrRelationName2(pNewstrRelationName2)
328 , m_pSET3(pNewSET3)
329 , m_pupdateTargetList4(pNewupdateTargetList4)
330 , m_poptWhereClause5(pNewoptWhereClause5)
331 {}
332
333 virtual ~updateStmt();
334
accept(Visitor * v)335 void accept( Visitor* v ) const
336 {
337 v->visit_updateStmt( this );
338 }
339
340 std::string* m_pUPDATE1;
341 std::string* m_pstrRelationName2;
342 std::string* m_pSET3;
343 std::list< updateTargetEl* >* m_pupdateTargetList4;
344 optWhereClause* m_poptWhereClause5;
345 };
346
347 class selectStmt : public node
348 {
349 public:
selectStmt(std::string * pNewSELECT1,optDistinct * pNewoptDistinct2,std::list<targetEl * > * pNewtargetList3,optFromClause * pNewoptFromClause4,optWhereClause * pNewoptWhereClause5,optGroupClause * pNewoptGroupClause6,optHavingClause * pNewoptHavingClause7,optSortClause * pNewoptSortClause8)350 selectStmt(
351 std::string* pNewSELECT1,
352 optDistinct* pNewoptDistinct2,
353 std::list< targetEl* >* pNewtargetList3,
354 optFromClause* pNewoptFromClause4,
355 optWhereClause* pNewoptWhereClause5,
356 optGroupClause* pNewoptGroupClause6,
357 optHavingClause* pNewoptHavingClause7,
358 optSortClause* pNewoptSortClause8
359 )
360 : m_pSELECT1(pNewSELECT1)
361 , m_poptDistinct2(pNewoptDistinct2)
362 , m_ptargetList3(pNewtargetList3)
363 , m_poptFromClause4(pNewoptFromClause4)
364 , m_poptWhereClause5(pNewoptWhereClause5)
365 , m_poptGroupClause6(pNewoptGroupClause6)
366 , m_poptHavingClause7(pNewoptHavingClause7)
367 , m_poptSortClause8(pNewoptSortClause8)
368 {}
369
370 virtual ~selectStmt();
371
accept(Visitor * v)372 void accept( Visitor* v ) const
373 {
374 v->visit_selectStmt( this );
375 }
376
377 std::string* m_pSELECT1;
378 optDistinct* m_poptDistinct2;
379 std::list< targetEl* >* m_ptargetList3;
380 optFromClause* m_poptFromClause4;
381 optWhereClause* m_poptWhereClause5;
382 optGroupClause* m_poptGroupClause6;
383 optHavingClause* m_poptHavingClause7;
384 optSortClause* m_poptSortClause8;
385 };
386
387 class exprSeq: public node
388 {
389 public:
exprSeq()390 exprSeq()
391 {}
~exprSeq()392 virtual ~exprSeq() {}
393
394 };
395
396 class exprSeq_aExpr : public exprSeq
397 {
398 public:
exprSeq_aExpr(aExpr * pNewaExpr1)399 exprSeq_aExpr(
400 aExpr* pNewaExpr1
401 )
402 : exprSeq()
403 , m_paExpr1(pNewaExpr1)
404 {}
405
406 virtual ~exprSeq_aExpr();
407
accept(Visitor * v)408 void accept( Visitor* v ) const
409 {
410 v->visit_exprSeq_aExpr( this );
411 }
412
413 aExpr* m_paExpr1;
414 };
415
416 class exprSeq_exprSeq_COMMA_aExpr : public exprSeq
417 {
418 public:
exprSeq_exprSeq_COMMA_aExpr(exprSeq * pNewexprSeq1,std::string * pNewCOMMA2,aExpr * pNewaExpr3)419 exprSeq_exprSeq_COMMA_aExpr(
420 exprSeq* pNewexprSeq1,
421 std::string* pNewCOMMA2,
422 aExpr* pNewaExpr3
423 )
424 : exprSeq()
425 , m_pexprSeq1(pNewexprSeq1)
426 , m_pCOMMA2(pNewCOMMA2)
427 , m_paExpr3(pNewaExpr3)
428 {}
429
430 virtual ~exprSeq_exprSeq_COMMA_aExpr();
431
accept(Visitor * v)432 void accept( Visitor* v ) const
433 {
434 v->visit_exprSeq_exprSeq_COMMA_aExpr( this );
435 }
436
437 exprSeq* m_pexprSeq1;
438 std::string* m_pCOMMA2;
439 aExpr* m_paExpr3;
440 };
441
442 class exprSeq_exprSeq_USING_aExpr : public exprSeq
443 {
444 public:
exprSeq_exprSeq_USING_aExpr(exprSeq * pNewexprSeq1,std::string * pNewUSING2,aExpr * pNewaExpr3)445 exprSeq_exprSeq_USING_aExpr(
446 exprSeq* pNewexprSeq1,
447 std::string* pNewUSING2,
448 aExpr* pNewaExpr3
449 )
450 : exprSeq()
451 , m_pexprSeq1(pNewexprSeq1)
452 , m_pUSING2(pNewUSING2)
453 , m_paExpr3(pNewaExpr3)
454 {}
455
456 virtual ~exprSeq_exprSeq_USING_aExpr();
457
accept(Visitor * v)458 void accept( Visitor* v ) const
459 {
460 v->visit_exprSeq_exprSeq_USING_aExpr( this );
461 }
462
463 exprSeq* m_pexprSeq1;
464 std::string* m_pUSING2;
465 aExpr* m_paExpr3;
466 };
467
468 class optDistinct: public node
469 {
470 public:
optDistinct()471 optDistinct()
472 {}
~optDistinct()473 virtual ~optDistinct() {}
474
475 };
476
477 class optDistinct_empty : public optDistinct
478 {
479 public:
optDistinct_empty()480 optDistinct_empty(
481 )
482 : optDistinct()
483 {}
484
485 virtual ~optDistinct_empty();
486
accept(Visitor * v)487 void accept( Visitor* v ) const
488 {
489 v->visit_optDistinct_empty( this );
490 }
491
492 };
493
494 class optDistinct_DISTINCT : public optDistinct
495 {
496 public:
optDistinct_DISTINCT(std::string * pNewDISTINCT1)497 optDistinct_DISTINCT(
498 std::string* pNewDISTINCT1
499 )
500 : optDistinct()
501 , m_pDISTINCT1(pNewDISTINCT1)
502 {}
503
504 virtual ~optDistinct_DISTINCT();
505
accept(Visitor * v)506 void accept( Visitor* v ) const
507 {
508 v->visit_optDistinct_DISTINCT( this );
509 }
510
511 std::string* m_pDISTINCT1;
512 };
513
514 class optDistinct_DISTINCT_ON_LEFTPAREN_exprSeq_RIGHTPAREN : public optDistinct
515 {
516 public:
optDistinct_DISTINCT_ON_LEFTPAREN_exprSeq_RIGHTPAREN(std::string * pNewDISTINCT1,std::string * pNewON2,std::string * pNewLEFTPAREN3,exprSeq * pNewexprSeq4,std::string * pNewRIGHTPAREN5)517 optDistinct_DISTINCT_ON_LEFTPAREN_exprSeq_RIGHTPAREN(
518 std::string* pNewDISTINCT1,
519 std::string* pNewON2,
520 std::string* pNewLEFTPAREN3,
521 exprSeq* pNewexprSeq4,
522 std::string* pNewRIGHTPAREN5
523 )
524 : optDistinct()
525 , m_pDISTINCT1(pNewDISTINCT1)
526 , m_pON2(pNewON2)
527 , m_pLEFTPAREN3(pNewLEFTPAREN3)
528 , m_pexprSeq4(pNewexprSeq4)
529 , m_pRIGHTPAREN5(pNewRIGHTPAREN5)
530 {}
531
532 virtual ~optDistinct_DISTINCT_ON_LEFTPAREN_exprSeq_RIGHTPAREN();
533
accept(Visitor * v)534 void accept( Visitor* v ) const
535 {
536 v->visit_optDistinct_DISTINCT_ON_LEFTPAREN_exprSeq_RIGHTPAREN( this );
537 }
538
539 std::string* m_pDISTINCT1;
540 std::string* m_pON2;
541 std::string* m_pLEFTPAREN3;
542 exprSeq* m_pexprSeq4;
543 std::string* m_pRIGHTPAREN5;
544 };
545
546 class optDistinct_ALL : public optDistinct
547 {
548 public:
optDistinct_ALL(std::string * pNewALL1)549 optDistinct_ALL(
550 std::string* pNewALL1
551 )
552 : optDistinct()
553 , m_pALL1(pNewALL1)
554 {}
555
556 virtual ~optDistinct_ALL();
557
accept(Visitor * v)558 void accept( Visitor* v ) const
559 {
560 v->visit_optDistinct_ALL( this );
561 }
562
563 std::string* m_pALL1;
564 };
565
566 class sortClause : public node
567 {
568 public:
sortClause(std::string * pNewORDER1,std::string * pNewBY2,std::list<sortby * > * pNewsortbyList3)569 sortClause(
570 std::string* pNewORDER1,
571 std::string* pNewBY2,
572 std::list< sortby* >* pNewsortbyList3
573 )
574 : m_pORDER1(pNewORDER1)
575 , m_pBY2(pNewBY2)
576 , m_psortbyList3(pNewsortbyList3)
577 {}
578
579 virtual ~sortClause();
580
accept(Visitor * v)581 void accept( Visitor* v ) const
582 {
583 v->visit_sortClause( this );
584 }
585
586 std::string* m_pORDER1;
587 std::string* m_pBY2;
588 std::list< sortby* >* m_psortbyList3;
589 };
590
591 class optSortClause: public node
592 {
593 public:
optSortClause()594 optSortClause()
595 {}
~optSortClause()596 virtual ~optSortClause() {}
597
598 };
599
600 class optSortClause_empty : public optSortClause
601 {
602 public:
optSortClause_empty()603 optSortClause_empty(
604 )
605 : optSortClause()
606 {}
607
608 virtual ~optSortClause_empty();
609
accept(Visitor * v)610 void accept( Visitor* v ) const
611 {
612 v->visit_optSortClause_empty( this );
613 }
614
615 };
616
617 class optSortClause_sortClause : public optSortClause
618 {
619 public:
optSortClause_sortClause(sortClause * pNewsortClause1)620 optSortClause_sortClause(
621 sortClause* pNewsortClause1
622 )
623 : optSortClause()
624 , m_psortClause1(pNewsortClause1)
625 {}
626
627 virtual ~optSortClause_sortClause();
628
accept(Visitor * v)629 void accept( Visitor* v ) const
630 {
631 v->visit_optSortClause_sortClause( this );
632 }
633
634 sortClause* m_psortClause1;
635 };
636
637 class sortby : public node
638 {
639 public:
sortby(aExpr * pNewaExpr1,std::string * pNewstrOptOrderSpecification2)640 sortby(
641 aExpr* pNewaExpr1,
642 std::string* pNewstrOptOrderSpecification2
643 )
644 : m_paExpr1(pNewaExpr1)
645 , m_pstrOptOrderSpecification2(pNewstrOptOrderSpecification2)
646 {}
647
648 virtual ~sortby();
649
accept(Visitor * v)650 void accept( Visitor* v ) const
651 {
652 v->visit_sortby( this );
653 }
654
655 aExpr* m_paExpr1;
656 std::string* m_pstrOptOrderSpecification2;
657 };
658
659 class optGroupClause: public node
660 {
661 public:
optGroupClause()662 optGroupClause()
663 {}
~optGroupClause()664 virtual ~optGroupClause() {}
665
666 };
667
668 class optGroupClause_empty : public optGroupClause
669 {
670 public:
optGroupClause_empty()671 optGroupClause_empty(
672 )
673 : optGroupClause()
674 {}
675
676 virtual ~optGroupClause_empty();
677
accept(Visitor * v)678 void accept( Visitor* v ) const
679 {
680 v->visit_optGroupClause_empty( this );
681 }
682
683 };
684
685 class optGroupClause_GROUP_BY_exprSeq : public optGroupClause
686 {
687 public:
optGroupClause_GROUP_BY_exprSeq(std::string * pNewGROUP1,std::string * pNewBY2,exprSeq * pNewexprSeq3)688 optGroupClause_GROUP_BY_exprSeq(
689 std::string* pNewGROUP1,
690 std::string* pNewBY2,
691 exprSeq* pNewexprSeq3
692 )
693 : optGroupClause()
694 , m_pGROUP1(pNewGROUP1)
695 , m_pBY2(pNewBY2)
696 , m_pexprSeq3(pNewexprSeq3)
697 {}
698
699 virtual ~optGroupClause_GROUP_BY_exprSeq();
700
accept(Visitor * v)701 void accept( Visitor* v ) const
702 {
703 v->visit_optGroupClause_GROUP_BY_exprSeq( this );
704 }
705
706 std::string* m_pGROUP1;
707 std::string* m_pBY2;
708 exprSeq* m_pexprSeq3;
709 };
710
711 class optHavingClause: public node
712 {
713 public:
optHavingClause()714 optHavingClause()
715 {}
~optHavingClause()716 virtual ~optHavingClause() {}
717
718 };
719
720 class optHavingClause_empty : public optHavingClause
721 {
722 public:
optHavingClause_empty()723 optHavingClause_empty(
724 )
725 : optHavingClause()
726 {}
727
728 virtual ~optHavingClause_empty();
729
accept(Visitor * v)730 void accept( Visitor* v ) const
731 {
732 v->visit_optHavingClause_empty( this );
733 }
734
735 };
736
737 class optHavingClause_HAVING_aExpr : public optHavingClause
738 {
739 public:
optHavingClause_HAVING_aExpr(std::string * pNewHAVING1,aExpr * pNewaExpr2)740 optHavingClause_HAVING_aExpr(
741 std::string* pNewHAVING1,
742 aExpr* pNewaExpr2
743 )
744 : optHavingClause()
745 , m_pHAVING1(pNewHAVING1)
746 , m_paExpr2(pNewaExpr2)
747 {}
748
749 virtual ~optHavingClause_HAVING_aExpr();
750
accept(Visitor * v)751 void accept( Visitor* v ) const
752 {
753 v->visit_optHavingClause_HAVING_aExpr( this );
754 }
755
756 std::string* m_pHAVING1;
757 aExpr* m_paExpr2;
758 };
759
760 class optFromClause: public node
761 {
762 public:
optFromClause()763 optFromClause()
764 {}
~optFromClause()765 virtual ~optFromClause() {}
766
767 };
768
769 class optFromClause_empty : public optFromClause
770 {
771 public:
optFromClause_empty()772 optFromClause_empty(
773 )
774 : optFromClause()
775 {}
776
777 virtual ~optFromClause_empty();
778
accept(Visitor * v)779 void accept( Visitor* v ) const
780 {
781 v->visit_optFromClause_empty( this );
782 }
783
784 };
785
786 class optFromClause_FROM_fromList : public optFromClause
787 {
788 public:
optFromClause_FROM_fromList(std::string * pNewFROM1,std::list<tableRef * > * pNewfromList2)789 optFromClause_FROM_fromList(
790 std::string* pNewFROM1,
791 std::list< tableRef* >* pNewfromList2
792 )
793 : optFromClause()
794 , m_pFROM1(pNewFROM1)
795 , m_pfromList2(pNewfromList2)
796 {}
797
798 virtual ~optFromClause_FROM_fromList();
799
accept(Visitor * v)800 void accept( Visitor* v ) const
801 {
802 v->visit_optFromClause_FROM_fromList( this );
803 }
804
805 std::string* m_pFROM1;
806 std::list< tableRef* >* m_pfromList2;
807 };
808
809 class tableRef: public node
810 {
811 public:
tableRef()812 tableRef()
813 {}
~tableRef()814 virtual ~tableRef() {}
815
816 };
817
818 class tableRef_relationExpr : public tableRef
819 {
820 public:
tableRef_relationExpr(relationExpr * pNewrelationExpr1)821 tableRef_relationExpr(
822 relationExpr* pNewrelationExpr1
823 )
824 : tableRef()
825 , m_prelationExpr1(pNewrelationExpr1)
826 {}
827
828 virtual ~tableRef_relationExpr();
829
accept(Visitor * v)830 void accept( Visitor* v ) const
831 {
832 v->visit_tableRef_relationExpr( this );
833 }
834
835 relationExpr* m_prelationExpr1;
836 };
837
838 class tableRef_relationExpr_aliasClause : public tableRef
839 {
840 public:
tableRef_relationExpr_aliasClause(relationExpr * pNewrelationExpr1,aliasClause * pNewaliasClause2)841 tableRef_relationExpr_aliasClause(
842 relationExpr* pNewrelationExpr1,
843 aliasClause* pNewaliasClause2
844 )
845 : tableRef()
846 , m_prelationExpr1(pNewrelationExpr1)
847 , m_paliasClause2(pNewaliasClause2)
848 {}
849
850 virtual ~tableRef_relationExpr_aliasClause();
851
accept(Visitor * v)852 void accept( Visitor* v ) const
853 {
854 v->visit_tableRef_relationExpr_aliasClause( this );
855 }
856
857 relationExpr* m_prelationExpr1;
858 aliasClause* m_paliasClause2;
859 };
860
861 class tableRef_joinedTable : public tableRef
862 {
863 public:
tableRef_joinedTable(joinedTable * pNewjoinedTable1)864 tableRef_joinedTable(
865 joinedTable* pNewjoinedTable1
866 )
867 : tableRef()
868 , m_pjoinedTable1(pNewjoinedTable1)
869 {}
870
871 virtual ~tableRef_joinedTable();
872
accept(Visitor * v)873 void accept( Visitor* v ) const
874 {
875 v->visit_tableRef_joinedTable( this );
876 }
877
878 joinedTable* m_pjoinedTable1;
879 };
880
881 class tableRef_LEFTPAREN_joinedTable_RIGHTPAREN_aliasClause : public tableRef
882 {
883 public:
tableRef_LEFTPAREN_joinedTable_RIGHTPAREN_aliasClause(std::string * pNewLEFTPAREN1,joinedTable * pNewjoinedTable2,std::string * pNewRIGHTPAREN3,aliasClause * pNewaliasClause4)884 tableRef_LEFTPAREN_joinedTable_RIGHTPAREN_aliasClause(
885 std::string* pNewLEFTPAREN1,
886 joinedTable* pNewjoinedTable2,
887 std::string* pNewRIGHTPAREN3,
888 aliasClause* pNewaliasClause4
889 )
890 : tableRef()
891 , m_pLEFTPAREN1(pNewLEFTPAREN1)
892 , m_pjoinedTable2(pNewjoinedTable2)
893 , m_pRIGHTPAREN3(pNewRIGHTPAREN3)
894 , m_paliasClause4(pNewaliasClause4)
895 {}
896
897 virtual ~tableRef_LEFTPAREN_joinedTable_RIGHTPAREN_aliasClause();
898
accept(Visitor * v)899 void accept( Visitor* v ) const
900 {
901 v->visit_tableRef_LEFTPAREN_joinedTable_RIGHTPAREN_aliasClause( this );
902 }
903
904 std::string* m_pLEFTPAREN1;
905 joinedTable* m_pjoinedTable2;
906 std::string* m_pRIGHTPAREN3;
907 aliasClause* m_paliasClause4;
908 };
909
910 class joinedTable: public node
911 {
912 public:
joinedTable()913 joinedTable()
914 {}
~joinedTable()915 virtual ~joinedTable() {}
916
917 };
918
919 class joinedTable_LEFTPAREN_joinedTable_RIGHTPAREN : public joinedTable
920 {
921 public:
joinedTable_LEFTPAREN_joinedTable_RIGHTPAREN(std::string * pNewLEFTPAREN1,joinedTable * pNewjoinedTable2,std::string * pNewRIGHTPAREN3)922 joinedTable_LEFTPAREN_joinedTable_RIGHTPAREN(
923 std::string* pNewLEFTPAREN1,
924 joinedTable* pNewjoinedTable2,
925 std::string* pNewRIGHTPAREN3
926 )
927 : joinedTable()
928 , m_pLEFTPAREN1(pNewLEFTPAREN1)
929 , m_pjoinedTable2(pNewjoinedTable2)
930 , m_pRIGHTPAREN3(pNewRIGHTPAREN3)
931 {}
932
933 virtual ~joinedTable_LEFTPAREN_joinedTable_RIGHTPAREN();
934
accept(Visitor * v)935 void accept( Visitor* v ) const
936 {
937 v->visit_joinedTable_LEFTPAREN_joinedTable_RIGHTPAREN( this );
938 }
939
940 std::string* m_pLEFTPAREN1;
941 joinedTable* m_pjoinedTable2;
942 std::string* m_pRIGHTPAREN3;
943 };
944
945 class joinedTable_tableRef_CROSS_JOIN_tableRef : public joinedTable
946 {
947 public:
joinedTable_tableRef_CROSS_JOIN_tableRef(tableRef * pNewtableRef1,std::string * pNewCROSS2,std::string * pNewJOIN3,tableRef * pNewtableRef4)948 joinedTable_tableRef_CROSS_JOIN_tableRef(
949 tableRef* pNewtableRef1,
950 std::string* pNewCROSS2,
951 std::string* pNewJOIN3,
952 tableRef* pNewtableRef4
953 )
954 : joinedTable()
955 , m_ptableRef1(pNewtableRef1)
956 , m_pCROSS2(pNewCROSS2)
957 , m_pJOIN3(pNewJOIN3)
958 , m_ptableRef4(pNewtableRef4)
959 {}
960
961 virtual ~joinedTable_tableRef_CROSS_JOIN_tableRef();
962
accept(Visitor * v)963 void accept( Visitor* v ) const
964 {
965 v->visit_joinedTable_tableRef_CROSS_JOIN_tableRef( this );
966 }
967
968 tableRef* m_ptableRef1;
969 std::string* m_pCROSS2;
970 std::string* m_pJOIN3;
971 tableRef* m_ptableRef4;
972 };
973
974 class joinedTable_tableRef_UNIONJOIN_tableRef : public joinedTable
975 {
976 public:
joinedTable_tableRef_UNIONJOIN_tableRef(tableRef * pNewtableRef1,std::string * pNewUNIONJOIN2,tableRef * pNewtableRef3)977 joinedTable_tableRef_UNIONJOIN_tableRef(
978 tableRef* pNewtableRef1,
979 std::string* pNewUNIONJOIN2,
980 tableRef* pNewtableRef3
981 )
982 : joinedTable()
983 , m_ptableRef1(pNewtableRef1)
984 , m_pUNIONJOIN2(pNewUNIONJOIN2)
985 , m_ptableRef3(pNewtableRef3)
986 {}
987
988 virtual ~joinedTable_tableRef_UNIONJOIN_tableRef();
989
accept(Visitor * v)990 void accept( Visitor* v ) const
991 {
992 v->visit_joinedTable_tableRef_UNIONJOIN_tableRef( this );
993 }
994
995 tableRef* m_ptableRef1;
996 std::string* m_pUNIONJOIN2;
997 tableRef* m_ptableRef3;
998 };
999
1000 class joinedTable_tableRef_joinType_JOIN_tableRef_joinQual : public joinedTable
1001 {
1002 public:
joinedTable_tableRef_joinType_JOIN_tableRef_joinQual(tableRef * pNewtableRef1,joinType * pNewjoinType2,std::string * pNewJOIN3,tableRef * pNewtableRef4,joinQual * pNewjoinQual5)1003 joinedTable_tableRef_joinType_JOIN_tableRef_joinQual(
1004 tableRef* pNewtableRef1,
1005 joinType* pNewjoinType2,
1006 std::string* pNewJOIN3,
1007 tableRef* pNewtableRef4,
1008 joinQual* pNewjoinQual5
1009 )
1010 : joinedTable()
1011 , m_ptableRef1(pNewtableRef1)
1012 , m_pjoinType2(pNewjoinType2)
1013 , m_pJOIN3(pNewJOIN3)
1014 , m_ptableRef4(pNewtableRef4)
1015 , m_pjoinQual5(pNewjoinQual5)
1016 {}
1017
1018 virtual ~joinedTable_tableRef_joinType_JOIN_tableRef_joinQual();
1019
accept(Visitor * v)1020 void accept( Visitor* v ) const
1021 {
1022 v->visit_joinedTable_tableRef_joinType_JOIN_tableRef_joinQual( this );
1023 }
1024
1025 tableRef* m_ptableRef1;
1026 joinType* m_pjoinType2;
1027 std::string* m_pJOIN3;
1028 tableRef* m_ptableRef4;
1029 joinQual* m_pjoinQual5;
1030 };
1031
1032 class joinedTable_tableRef_JOIN_tableRef_joinQual : public joinedTable
1033 {
1034 public:
joinedTable_tableRef_JOIN_tableRef_joinQual(tableRef * pNewtableRef1,std::string * pNewJOIN2,tableRef * pNewtableRef3,joinQual * pNewjoinQual4)1035 joinedTable_tableRef_JOIN_tableRef_joinQual(
1036 tableRef* pNewtableRef1,
1037 std::string* pNewJOIN2,
1038 tableRef* pNewtableRef3,
1039 joinQual* pNewjoinQual4
1040 )
1041 : joinedTable()
1042 , m_ptableRef1(pNewtableRef1)
1043 , m_pJOIN2(pNewJOIN2)
1044 , m_ptableRef3(pNewtableRef3)
1045 , m_pjoinQual4(pNewjoinQual4)
1046 {}
1047
1048 virtual ~joinedTable_tableRef_JOIN_tableRef_joinQual();
1049
accept(Visitor * v)1050 void accept( Visitor* v ) const
1051 {
1052 v->visit_joinedTable_tableRef_JOIN_tableRef_joinQual( this );
1053 }
1054
1055 tableRef* m_ptableRef1;
1056 std::string* m_pJOIN2;
1057 tableRef* m_ptableRef3;
1058 joinQual* m_pjoinQual4;
1059 };
1060
1061 class joinedTable_tableRef_NATURAL_joinType_JOIN_tableRef : public joinedTable
1062 {
1063 public:
joinedTable_tableRef_NATURAL_joinType_JOIN_tableRef(tableRef * pNewtableRef1,std::string * pNewNATURAL2,joinType * pNewjoinType3,std::string * pNewJOIN4,tableRef * pNewtableRef5)1064 joinedTable_tableRef_NATURAL_joinType_JOIN_tableRef(
1065 tableRef* pNewtableRef1,
1066 std::string* pNewNATURAL2,
1067 joinType* pNewjoinType3,
1068 std::string* pNewJOIN4,
1069 tableRef* pNewtableRef5
1070 )
1071 : joinedTable()
1072 , m_ptableRef1(pNewtableRef1)
1073 , m_pNATURAL2(pNewNATURAL2)
1074 , m_pjoinType3(pNewjoinType3)
1075 , m_pJOIN4(pNewJOIN4)
1076 , m_ptableRef5(pNewtableRef5)
1077 {}
1078
1079 virtual ~joinedTable_tableRef_NATURAL_joinType_JOIN_tableRef();
1080
accept(Visitor * v)1081 void accept( Visitor* v ) const
1082 {
1083 v->visit_joinedTable_tableRef_NATURAL_joinType_JOIN_tableRef( this );
1084 }
1085
1086 tableRef* m_ptableRef1;
1087 std::string* m_pNATURAL2;
1088 joinType* m_pjoinType3;
1089 std::string* m_pJOIN4;
1090 tableRef* m_ptableRef5;
1091 };
1092
1093 class joinedTable_tableRef_NATURAL_JOIN_tableRef : public joinedTable
1094 {
1095 public:
joinedTable_tableRef_NATURAL_JOIN_tableRef(tableRef * pNewtableRef1,std::string * pNewNATURAL2,std::string * pNewJOIN3,tableRef * pNewtableRef4)1096 joinedTable_tableRef_NATURAL_JOIN_tableRef(
1097 tableRef* pNewtableRef1,
1098 std::string* pNewNATURAL2,
1099 std::string* pNewJOIN3,
1100 tableRef* pNewtableRef4
1101 )
1102 : joinedTable()
1103 , m_ptableRef1(pNewtableRef1)
1104 , m_pNATURAL2(pNewNATURAL2)
1105 , m_pJOIN3(pNewJOIN3)
1106 , m_ptableRef4(pNewtableRef4)
1107 {}
1108
1109 virtual ~joinedTable_tableRef_NATURAL_JOIN_tableRef();
1110
accept(Visitor * v)1111 void accept( Visitor* v ) const
1112 {
1113 v->visit_joinedTable_tableRef_NATURAL_JOIN_tableRef( this );
1114 }
1115
1116 tableRef* m_ptableRef1;
1117 std::string* m_pNATURAL2;
1118 std::string* m_pJOIN3;
1119 tableRef* m_ptableRef4;
1120 };
1121
1122 class aliasClause: public node
1123 {
1124 public:
aliasClause()1125 aliasClause()
1126 {}
~aliasClause()1127 virtual ~aliasClause() {}
1128
1129 };
1130
1131 class aliasClause_AS_strColId_LEFTPAREN_nameList_RIGHTPAREN : public aliasClause
1132 {
1133 public:
aliasClause_AS_strColId_LEFTPAREN_nameList_RIGHTPAREN(std::string * pNewAS1,std::string * pNewstrColId2,std::string * pNewLEFTPAREN3,std::list<std::string * > * pNewnameList4,std::string * pNewRIGHTPAREN5)1134 aliasClause_AS_strColId_LEFTPAREN_nameList_RIGHTPAREN(
1135 std::string* pNewAS1,
1136 std::string* pNewstrColId2,
1137 std::string* pNewLEFTPAREN3,
1138 std::list< std::string* >* pNewnameList4,
1139 std::string* pNewRIGHTPAREN5
1140 )
1141 : aliasClause()
1142 , m_pAS1(pNewAS1)
1143 , m_pstrColId2(pNewstrColId2)
1144 , m_pLEFTPAREN3(pNewLEFTPAREN3)
1145 , m_pnameList4(pNewnameList4)
1146 , m_pRIGHTPAREN5(pNewRIGHTPAREN5)
1147 {}
1148
1149 virtual ~aliasClause_AS_strColId_LEFTPAREN_nameList_RIGHTPAREN();
1150
accept(Visitor * v)1151 void accept( Visitor* v ) const
1152 {
1153 v->visit_aliasClause_AS_strColId_LEFTPAREN_nameList_RIGHTPAREN( this );
1154 }
1155
1156 std::string* m_pAS1;
1157 std::string* m_pstrColId2;
1158 std::string* m_pLEFTPAREN3;
1159 std::list< std::string* >* m_pnameList4;
1160 std::string* m_pRIGHTPAREN5;
1161 };
1162
1163 class aliasClause_AS_strColId : public aliasClause
1164 {
1165 public:
aliasClause_AS_strColId(std::string * pNewAS1,std::string * pNewstrColId2)1166 aliasClause_AS_strColId(
1167 std::string* pNewAS1,
1168 std::string* pNewstrColId2
1169 )
1170 : aliasClause()
1171 , m_pAS1(pNewAS1)
1172 , m_pstrColId2(pNewstrColId2)
1173 {}
1174
1175 virtual ~aliasClause_AS_strColId();
1176
accept(Visitor * v)1177 void accept( Visitor* v ) const
1178 {
1179 v->visit_aliasClause_AS_strColId( this );
1180 }
1181
1182 std::string* m_pAS1;
1183 std::string* m_pstrColId2;
1184 };
1185
1186 class aliasClause_strColId_LEFTPAREN_nameList_RIGHTPAREN : public aliasClause
1187 {
1188 public:
aliasClause_strColId_LEFTPAREN_nameList_RIGHTPAREN(std::string * pNewstrColId1,std::string * pNewLEFTPAREN2,std::list<std::string * > * pNewnameList3,std::string * pNewRIGHTPAREN4)1189 aliasClause_strColId_LEFTPAREN_nameList_RIGHTPAREN(
1190 std::string* pNewstrColId1,
1191 std::string* pNewLEFTPAREN2,
1192 std::list< std::string* >* pNewnameList3,
1193 std::string* pNewRIGHTPAREN4
1194 )
1195 : aliasClause()
1196 , m_pstrColId1(pNewstrColId1)
1197 , m_pLEFTPAREN2(pNewLEFTPAREN2)
1198 , m_pnameList3(pNewnameList3)
1199 , m_pRIGHTPAREN4(pNewRIGHTPAREN4)
1200 {}
1201
1202 virtual ~aliasClause_strColId_LEFTPAREN_nameList_RIGHTPAREN();
1203
accept(Visitor * v)1204 void accept( Visitor* v ) const
1205 {
1206 v->visit_aliasClause_strColId_LEFTPAREN_nameList_RIGHTPAREN( this );
1207 }
1208
1209 std::string* m_pstrColId1;
1210 std::string* m_pLEFTPAREN2;
1211 std::list< std::string* >* m_pnameList3;
1212 std::string* m_pRIGHTPAREN4;
1213 };
1214
1215 class aliasClause_strColId : public aliasClause
1216 {
1217 public:
aliasClause_strColId(std::string * pNewstrColId1)1218 aliasClause_strColId(
1219 std::string* pNewstrColId1
1220 )
1221 : aliasClause()
1222 , m_pstrColId1(pNewstrColId1)
1223 {}
1224
1225 virtual ~aliasClause_strColId();
1226
accept(Visitor * v)1227 void accept( Visitor* v ) const
1228 {
1229 v->visit_aliasClause_strColId( this );
1230 }
1231
1232 std::string* m_pstrColId1;
1233 };
1234
1235 class joinType: public node
1236 {
1237 public:
joinType()1238 joinType()
1239 {}
~joinType()1240 virtual ~joinType() {}
1241
1242 };
1243
1244 class joinType_FULL_strOptJoinOuter : public joinType
1245 {
1246 public:
joinType_FULL_strOptJoinOuter(std::string * pNewFULL1,std::string * pNewstrOptJoinOuter2)1247 joinType_FULL_strOptJoinOuter(
1248 std::string* pNewFULL1,
1249 std::string* pNewstrOptJoinOuter2
1250 )
1251 : joinType()
1252 , m_pFULL1(pNewFULL1)
1253 , m_pstrOptJoinOuter2(pNewstrOptJoinOuter2)
1254 {}
1255
1256 virtual ~joinType_FULL_strOptJoinOuter();
1257
accept(Visitor * v)1258 void accept( Visitor* v ) const
1259 {
1260 v->visit_joinType_FULL_strOptJoinOuter( this );
1261 }
1262
1263 std::string* m_pFULL1;
1264 std::string* m_pstrOptJoinOuter2;
1265 };
1266
1267 class joinType_LEFT_strOptJoinOuter : public joinType
1268 {
1269 public:
joinType_LEFT_strOptJoinOuter(std::string * pNewLEFT1,std::string * pNewstrOptJoinOuter2)1270 joinType_LEFT_strOptJoinOuter(
1271 std::string* pNewLEFT1,
1272 std::string* pNewstrOptJoinOuter2
1273 )
1274 : joinType()
1275 , m_pLEFT1(pNewLEFT1)
1276 , m_pstrOptJoinOuter2(pNewstrOptJoinOuter2)
1277 {}
1278
1279 virtual ~joinType_LEFT_strOptJoinOuter();
1280
accept(Visitor * v)1281 void accept( Visitor* v ) const
1282 {
1283 v->visit_joinType_LEFT_strOptJoinOuter( this );
1284 }
1285
1286 std::string* m_pLEFT1;
1287 std::string* m_pstrOptJoinOuter2;
1288 };
1289
1290 class joinType_RIGHT_strOptJoinOuter : public joinType
1291 {
1292 public:
joinType_RIGHT_strOptJoinOuter(std::string * pNewRIGHT1,std::string * pNewstrOptJoinOuter2)1293 joinType_RIGHT_strOptJoinOuter(
1294 std::string* pNewRIGHT1,
1295 std::string* pNewstrOptJoinOuter2
1296 )
1297 : joinType()
1298 , m_pRIGHT1(pNewRIGHT1)
1299 , m_pstrOptJoinOuter2(pNewstrOptJoinOuter2)
1300 {}
1301
1302 virtual ~joinType_RIGHT_strOptJoinOuter();
1303
accept(Visitor * v)1304 void accept( Visitor* v ) const
1305 {
1306 v->visit_joinType_RIGHT_strOptJoinOuter( this );
1307 }
1308
1309 std::string* m_pRIGHT1;
1310 std::string* m_pstrOptJoinOuter2;
1311 };
1312
1313 class joinType_INNERP : public joinType
1314 {
1315 public:
joinType_INNERP(std::string * pNewINNERP1)1316 joinType_INNERP(
1317 std::string* pNewINNERP1
1318 )
1319 : joinType()
1320 , m_pINNERP1(pNewINNERP1)
1321 {}
1322
1323 virtual ~joinType_INNERP();
1324
accept(Visitor * v)1325 void accept( Visitor* v ) const
1326 {
1327 v->visit_joinType_INNERP( this );
1328 }
1329
1330 std::string* m_pINNERP1;
1331 };
1332
1333 class joinQual: public node
1334 {
1335 public:
joinQual()1336 joinQual()
1337 {}
~joinQual()1338 virtual ~joinQual() {}
1339
1340 };
1341
1342 class joinQual_USING_LEFTPAREN_nameList_RIGHTPAREN : public joinQual
1343 {
1344 public:
joinQual_USING_LEFTPAREN_nameList_RIGHTPAREN(std::string * pNewUSING1,std::string * pNewLEFTPAREN2,std::list<std::string * > * pNewnameList3,std::string * pNewRIGHTPAREN4)1345 joinQual_USING_LEFTPAREN_nameList_RIGHTPAREN(
1346 std::string* pNewUSING1,
1347 std::string* pNewLEFTPAREN2,
1348 std::list< std::string* >* pNewnameList3,
1349 std::string* pNewRIGHTPAREN4
1350 )
1351 : joinQual()
1352 , m_pUSING1(pNewUSING1)
1353 , m_pLEFTPAREN2(pNewLEFTPAREN2)
1354 , m_pnameList3(pNewnameList3)
1355 , m_pRIGHTPAREN4(pNewRIGHTPAREN4)
1356 {}
1357
1358 virtual ~joinQual_USING_LEFTPAREN_nameList_RIGHTPAREN();
1359
accept(Visitor * v)1360 void accept( Visitor* v ) const
1361 {
1362 v->visit_joinQual_USING_LEFTPAREN_nameList_RIGHTPAREN( this );
1363 }
1364
1365 std::string* m_pUSING1;
1366 std::string* m_pLEFTPAREN2;
1367 std::list< std::string* >* m_pnameList3;
1368 std::string* m_pRIGHTPAREN4;
1369 };
1370
1371 class joinQual_ON_aExpr : public joinQual
1372 {
1373 public:
joinQual_ON_aExpr(std::string * pNewON1,aExpr * pNewaExpr2)1374 joinQual_ON_aExpr(
1375 std::string* pNewON1,
1376 aExpr* pNewaExpr2
1377 )
1378 : joinQual()
1379 , m_pON1(pNewON1)
1380 , m_paExpr2(pNewaExpr2)
1381 {}
1382
1383 virtual ~joinQual_ON_aExpr();
1384
accept(Visitor * v)1385 void accept( Visitor* v ) const
1386 {
1387 v->visit_joinQual_ON_aExpr( this );
1388 }
1389
1390 std::string* m_pON1;
1391 aExpr* m_paExpr2;
1392 };
1393
1394 class relationExpr: public node
1395 {
1396 public:
relationExpr()1397 relationExpr()
1398 {}
~relationExpr()1399 virtual ~relationExpr() {}
1400
1401 };
1402
1403 class relationExpr_strRelationName : public relationExpr
1404 {
1405 public:
relationExpr_strRelationName(std::string * pNewstrRelationName1)1406 relationExpr_strRelationName(
1407 std::string* pNewstrRelationName1
1408 )
1409 : relationExpr()
1410 , m_pstrRelationName1(pNewstrRelationName1)
1411 {}
1412
1413 virtual ~relationExpr_strRelationName();
1414
accept(Visitor * v)1415 void accept( Visitor* v ) const
1416 {
1417 v->visit_relationExpr_strRelationName( this );
1418 }
1419
1420 std::string* m_pstrRelationName1;
1421 };
1422
1423 class relationExpr_strRelationName_ASTERISK : public relationExpr
1424 {
1425 public:
relationExpr_strRelationName_ASTERISK(std::string * pNewstrRelationName1,std::string * pNewASTERISK2)1426 relationExpr_strRelationName_ASTERISK(
1427 std::string* pNewstrRelationName1,
1428 std::string* pNewASTERISK2
1429 )
1430 : relationExpr()
1431 , m_pstrRelationName1(pNewstrRelationName1)
1432 , m_pASTERISK2(pNewASTERISK2)
1433 {}
1434
1435 virtual ~relationExpr_strRelationName_ASTERISK();
1436
accept(Visitor * v)1437 void accept( Visitor* v ) const
1438 {
1439 v->visit_relationExpr_strRelationName_ASTERISK( this );
1440 }
1441
1442 std::string* m_pstrRelationName1;
1443 std::string* m_pASTERISK2;
1444 };
1445
1446 class relationExpr_ONLY_strRelationName : public relationExpr
1447 {
1448 public:
relationExpr_ONLY_strRelationName(std::string * pNewONLY1,std::string * pNewstrRelationName2)1449 relationExpr_ONLY_strRelationName(
1450 std::string* pNewONLY1,
1451 std::string* pNewstrRelationName2
1452 )
1453 : relationExpr()
1454 , m_pONLY1(pNewONLY1)
1455 , m_pstrRelationName2(pNewstrRelationName2)
1456 {}
1457
1458 virtual ~relationExpr_ONLY_strRelationName();
1459
accept(Visitor * v)1460 void accept( Visitor* v ) const
1461 {
1462 v->visit_relationExpr_ONLY_strRelationName( this );
1463 }
1464
1465 std::string* m_pONLY1;
1466 std::string* m_pstrRelationName2;
1467 };
1468
1469 class optWhereClause: public node
1470 {
1471 public:
optWhereClause()1472 optWhereClause()
1473 {}
~optWhereClause()1474 virtual ~optWhereClause() {}
1475
1476 };
1477
1478 class optWhereClause_empty : public optWhereClause
1479 {
1480 public:
optWhereClause_empty()1481 optWhereClause_empty(
1482 )
1483 : optWhereClause()
1484 {}
1485
1486 virtual ~optWhereClause_empty();
1487
accept(Visitor * v)1488 void accept( Visitor* v ) const
1489 {
1490 v->visit_optWhereClause_empty( this );
1491 }
1492
1493 };
1494
1495 class optWhereClause_WHERE_aExpr : public optWhereClause
1496 {
1497 public:
optWhereClause_WHERE_aExpr(std::string * pNewWHERE1,aExpr * pNewaExpr2)1498 optWhereClause_WHERE_aExpr(
1499 std::string* pNewWHERE1,
1500 aExpr* pNewaExpr2
1501 )
1502 : optWhereClause()
1503 , m_pWHERE1(pNewWHERE1)
1504 , m_paExpr2(pNewaExpr2)
1505 {}
1506
1507 virtual ~optWhereClause_WHERE_aExpr();
1508
accept(Visitor * v)1509 void accept( Visitor* v ) const
1510 {
1511 v->visit_optWhereClause_WHERE_aExpr( this );
1512 }
1513
1514 std::string* m_pWHERE1;
1515 aExpr* m_paExpr2;
1516 };
1517
1518 class rowExpr : public node
1519 {
1520 public:
rowExpr(std::string * pNewLEFTPAREN1,rowDescriptor * pNewrowDescriptor2,std::string * pNewRIGHTPAREN3,std::string * pNewstrAllOp4,std::string * pNewLEFTPAREN5,rowDescriptor * pNewrowDescriptor6,std::string * pNewRIGHTPAREN7)1521 rowExpr(
1522 std::string* pNewLEFTPAREN1,
1523 rowDescriptor* pNewrowDescriptor2,
1524 std::string* pNewRIGHTPAREN3,
1525 std::string* pNewstrAllOp4,
1526 std::string* pNewLEFTPAREN5,
1527 rowDescriptor* pNewrowDescriptor6,
1528 std::string* pNewRIGHTPAREN7
1529 )
1530 : m_pLEFTPAREN1(pNewLEFTPAREN1)
1531 , m_prowDescriptor2(pNewrowDescriptor2)
1532 , m_pRIGHTPAREN3(pNewRIGHTPAREN3)
1533 , m_pstrAllOp4(pNewstrAllOp4)
1534 , m_pLEFTPAREN5(pNewLEFTPAREN5)
1535 , m_prowDescriptor6(pNewrowDescriptor6)
1536 , m_pRIGHTPAREN7(pNewRIGHTPAREN7)
1537 {}
1538
1539 virtual ~rowExpr();
1540
accept(Visitor * v)1541 void accept( Visitor* v ) const
1542 {
1543 v->visit_rowExpr( this );
1544 }
1545
1546 std::string* m_pLEFTPAREN1;
1547 rowDescriptor* m_prowDescriptor2;
1548 std::string* m_pRIGHTPAREN3;
1549 std::string* m_pstrAllOp4;
1550 std::string* m_pLEFTPAREN5;
1551 rowDescriptor* m_prowDescriptor6;
1552 std::string* m_pRIGHTPAREN7;
1553 };
1554
1555 class rowDescriptor : public node
1556 {
1557 public:
rowDescriptor(std::list<aExpr * > * pNewrowList1,std::string * pNewCOMMA2,aExpr * pNewaExpr3)1558 rowDescriptor(
1559 std::list< aExpr* >* pNewrowList1,
1560 std::string* pNewCOMMA2,
1561 aExpr* pNewaExpr3
1562 )
1563 : m_prowList1(pNewrowList1)
1564 , m_pCOMMA2(pNewCOMMA2)
1565 , m_paExpr3(pNewaExpr3)
1566 {}
1567
1568 virtual ~rowDescriptor();
1569
accept(Visitor * v)1570 void accept( Visitor* v ) const
1571 {
1572 v->visit_rowDescriptor( this );
1573 }
1574
1575 std::list< aExpr* >* m_prowList1;
1576 std::string* m_pCOMMA2;
1577 aExpr* m_paExpr3;
1578 };
1579
1580 class aExpr: public node
1581 {
1582 public:
aExpr()1583 aExpr()
1584 {}
~aExpr()1585 virtual ~aExpr() {}
1586
1587 };
1588
1589 class aExpr_cExpr : public aExpr
1590 {
1591 public:
aExpr_cExpr(cExpr * pNewcExpr1)1592 aExpr_cExpr(
1593 cExpr* pNewcExpr1
1594 )
1595 : aExpr()
1596 , m_pcExpr1(pNewcExpr1)
1597 {}
1598
1599 virtual ~aExpr_cExpr();
1600
accept(Visitor * v)1601 void accept( Visitor* v ) const
1602 {
1603 v->visit_aExpr_cExpr( this );
1604 }
1605
1606 cExpr* m_pcExpr1;
1607 };
1608
1609 class aExpr_aExpr_AT_TIME_ZONE_cExpr : public aExpr
1610 {
1611 public:
aExpr_aExpr_AT_TIME_ZONE_cExpr(aExpr * pNewaExpr1,std::string * pNewAT2,std::string * pNewTIME3,std::string * pNewZONE4,cExpr * pNewcExpr5)1612 aExpr_aExpr_AT_TIME_ZONE_cExpr(
1613 aExpr* pNewaExpr1,
1614 std::string* pNewAT2,
1615 std::string* pNewTIME3,
1616 std::string* pNewZONE4,
1617 cExpr* pNewcExpr5
1618 )
1619 : aExpr()
1620 , m_paExpr1(pNewaExpr1)
1621 , m_pAT2(pNewAT2)
1622 , m_pTIME3(pNewTIME3)
1623 , m_pZONE4(pNewZONE4)
1624 , m_pcExpr5(pNewcExpr5)
1625 {}
1626
1627 virtual ~aExpr_aExpr_AT_TIME_ZONE_cExpr();
1628
accept(Visitor * v)1629 void accept( Visitor* v ) const
1630 {
1631 v->visit_aExpr_aExpr_AT_TIME_ZONE_cExpr( this );
1632 }
1633
1634 aExpr* m_paExpr1;
1635 std::string* m_pAT2;
1636 std::string* m_pTIME3;
1637 std::string* m_pZONE4;
1638 cExpr* m_pcExpr5;
1639 };
1640
1641 class aExpr_PLUS_aExpr : public aExpr
1642 {
1643 public:
aExpr_PLUS_aExpr(std::string * pNewPLUS1,aExpr * pNewaExpr2)1644 aExpr_PLUS_aExpr(
1645 std::string* pNewPLUS1,
1646 aExpr* pNewaExpr2
1647 )
1648 : aExpr()
1649 , m_pPLUS1(pNewPLUS1)
1650 , m_paExpr2(pNewaExpr2)
1651 {}
1652
1653 virtual ~aExpr_PLUS_aExpr();
1654
accept(Visitor * v)1655 void accept( Visitor* v ) const
1656 {
1657 v->visit_aExpr_PLUS_aExpr( this );
1658 }
1659
1660 std::string* m_pPLUS1;
1661 aExpr* m_paExpr2;
1662 };
1663
1664 class aExpr_MINUS_aExpr : public aExpr
1665 {
1666 public:
aExpr_MINUS_aExpr(std::string * pNewMINUS1,aExpr * pNewaExpr2)1667 aExpr_MINUS_aExpr(
1668 std::string* pNewMINUS1,
1669 aExpr* pNewaExpr2
1670 )
1671 : aExpr()
1672 , m_pMINUS1(pNewMINUS1)
1673 , m_paExpr2(pNewaExpr2)
1674 {}
1675
1676 virtual ~aExpr_MINUS_aExpr();
1677
accept(Visitor * v)1678 void accept( Visitor* v ) const
1679 {
1680 v->visit_aExpr_MINUS_aExpr( this );
1681 }
1682
1683 std::string* m_pMINUS1;
1684 aExpr* m_paExpr2;
1685 };
1686
1687 class aExpr_BITINVERT_aExpr : public aExpr
1688 {
1689 public:
aExpr_BITINVERT_aExpr(std::string * pNewBITINVERT1,aExpr * pNewaExpr2)1690 aExpr_BITINVERT_aExpr(
1691 std::string* pNewBITINVERT1,
1692 aExpr* pNewaExpr2
1693 )
1694 : aExpr()
1695 , m_pBITINVERT1(pNewBITINVERT1)
1696 , m_paExpr2(pNewaExpr2)
1697 {}
1698
1699 virtual ~aExpr_BITINVERT_aExpr();
1700
accept(Visitor * v)1701 void accept( Visitor* v ) const
1702 {
1703 v->visit_aExpr_BITINVERT_aExpr( this );
1704 }
1705
1706 std::string* m_pBITINVERT1;
1707 aExpr* m_paExpr2;
1708 };
1709
1710 class aExpr_aExpr_PLUS_aExpr : public aExpr
1711 {
1712 public:
aExpr_aExpr_PLUS_aExpr(aExpr * pNewaExpr1,std::string * pNewPLUS2,aExpr * pNewaExpr3)1713 aExpr_aExpr_PLUS_aExpr(
1714 aExpr* pNewaExpr1,
1715 std::string* pNewPLUS2,
1716 aExpr* pNewaExpr3
1717 )
1718 : aExpr()
1719 , m_paExpr1(pNewaExpr1)
1720 , m_pPLUS2(pNewPLUS2)
1721 , m_paExpr3(pNewaExpr3)
1722 {}
1723
1724 virtual ~aExpr_aExpr_PLUS_aExpr();
1725
accept(Visitor * v)1726 void accept( Visitor* v ) const
1727 {
1728 v->visit_aExpr_aExpr_PLUS_aExpr( this );
1729 }
1730
1731 aExpr* m_paExpr1;
1732 std::string* m_pPLUS2;
1733 aExpr* m_paExpr3;
1734 };
1735
1736 class aExpr_aExpr_MINUS_aExpr : public aExpr
1737 {
1738 public:
aExpr_aExpr_MINUS_aExpr(aExpr * pNewaExpr1,std::string * pNewMINUS2,aExpr * pNewaExpr3)1739 aExpr_aExpr_MINUS_aExpr(
1740 aExpr* pNewaExpr1,
1741 std::string* pNewMINUS2,
1742 aExpr* pNewaExpr3
1743 )
1744 : aExpr()
1745 , m_paExpr1(pNewaExpr1)
1746 , m_pMINUS2(pNewMINUS2)
1747 , m_paExpr3(pNewaExpr3)
1748 {}
1749
1750 virtual ~aExpr_aExpr_MINUS_aExpr();
1751
accept(Visitor * v)1752 void accept( Visitor* v ) const
1753 {
1754 v->visit_aExpr_aExpr_MINUS_aExpr( this );
1755 }
1756
1757 aExpr* m_paExpr1;
1758 std::string* m_pMINUS2;
1759 aExpr* m_paExpr3;
1760 };
1761
1762 class aExpr_aExpr_ASTERISK_aExpr : public aExpr
1763 {
1764 public:
aExpr_aExpr_ASTERISK_aExpr(aExpr * pNewaExpr1,std::string * pNewASTERISK2,aExpr * pNewaExpr3)1765 aExpr_aExpr_ASTERISK_aExpr(
1766 aExpr* pNewaExpr1,
1767 std::string* pNewASTERISK2,
1768 aExpr* pNewaExpr3
1769 )
1770 : aExpr()
1771 , m_paExpr1(pNewaExpr1)
1772 , m_pASTERISK2(pNewASTERISK2)
1773 , m_paExpr3(pNewaExpr3)
1774 {}
1775
1776 virtual ~aExpr_aExpr_ASTERISK_aExpr();
1777
accept(Visitor * v)1778 void accept( Visitor* v ) const
1779 {
1780 v->visit_aExpr_aExpr_ASTERISK_aExpr( this );
1781 }
1782
1783 aExpr* m_paExpr1;
1784 std::string* m_pASTERISK2;
1785 aExpr* m_paExpr3;
1786 };
1787
1788 class aExpr_aExpr_SOLIDUS_aExpr : public aExpr
1789 {
1790 public:
aExpr_aExpr_SOLIDUS_aExpr(aExpr * pNewaExpr1,std::string * pNewSOLIDUS2,aExpr * pNewaExpr3)1791 aExpr_aExpr_SOLIDUS_aExpr(
1792 aExpr* pNewaExpr1,
1793 std::string* pNewSOLIDUS2,
1794 aExpr* pNewaExpr3
1795 )
1796 : aExpr()
1797 , m_paExpr1(pNewaExpr1)
1798 , m_pSOLIDUS2(pNewSOLIDUS2)
1799 , m_paExpr3(pNewaExpr3)
1800 {}
1801
1802 virtual ~aExpr_aExpr_SOLIDUS_aExpr();
1803
accept(Visitor * v)1804 void accept( Visitor* v ) const
1805 {
1806 v->visit_aExpr_aExpr_SOLIDUS_aExpr( this );
1807 }
1808
1809 aExpr* m_paExpr1;
1810 std::string* m_pSOLIDUS2;
1811 aExpr* m_paExpr3;
1812 };
1813
1814 class aExpr_aExpr_PERCENT_aExpr : public aExpr
1815 {
1816 public:
aExpr_aExpr_PERCENT_aExpr(aExpr * pNewaExpr1,std::string * pNewPERCENT2,aExpr * pNewaExpr3)1817 aExpr_aExpr_PERCENT_aExpr(
1818 aExpr* pNewaExpr1,
1819 std::string* pNewPERCENT2,
1820 aExpr* pNewaExpr3
1821 )
1822 : aExpr()
1823 , m_paExpr1(pNewaExpr1)
1824 , m_pPERCENT2(pNewPERCENT2)
1825 , m_paExpr3(pNewaExpr3)
1826 {}
1827
1828 virtual ~aExpr_aExpr_PERCENT_aExpr();
1829
accept(Visitor * v)1830 void accept( Visitor* v ) const
1831 {
1832 v->visit_aExpr_aExpr_PERCENT_aExpr( this );
1833 }
1834
1835 aExpr* m_paExpr1;
1836 std::string* m_pPERCENT2;
1837 aExpr* m_paExpr3;
1838 };
1839
1840 class aExpr_aExpr_BITAND_aExpr : public aExpr
1841 {
1842 public:
aExpr_aExpr_BITAND_aExpr(aExpr * pNewaExpr1,std::string * pNewBITAND2,aExpr * pNewaExpr3)1843 aExpr_aExpr_BITAND_aExpr(
1844 aExpr* pNewaExpr1,
1845 std::string* pNewBITAND2,
1846 aExpr* pNewaExpr3
1847 )
1848 : aExpr()
1849 , m_paExpr1(pNewaExpr1)
1850 , m_pBITAND2(pNewBITAND2)
1851 , m_paExpr3(pNewaExpr3)
1852 {}
1853
1854 virtual ~aExpr_aExpr_BITAND_aExpr();
1855
accept(Visitor * v)1856 void accept( Visitor* v ) const
1857 {
1858 v->visit_aExpr_aExpr_BITAND_aExpr( this );
1859 }
1860
1861 aExpr* m_paExpr1;
1862 std::string* m_pBITAND2;
1863 aExpr* m_paExpr3;
1864 };
1865
1866 class aExpr_aExpr_BITOR_aExpr : public aExpr
1867 {
1868 public:
aExpr_aExpr_BITOR_aExpr(aExpr * pNewaExpr1,std::string * pNewBITOR2,aExpr * pNewaExpr3)1869 aExpr_aExpr_BITOR_aExpr(
1870 aExpr* pNewaExpr1,
1871 std::string* pNewBITOR2,
1872 aExpr* pNewaExpr3
1873 )
1874 : aExpr()
1875 , m_paExpr1(pNewaExpr1)
1876 , m_pBITOR2(pNewBITOR2)
1877 , m_paExpr3(pNewaExpr3)
1878 {}
1879
1880 virtual ~aExpr_aExpr_BITOR_aExpr();
1881
accept(Visitor * v)1882 void accept( Visitor* v ) const
1883 {
1884 v->visit_aExpr_aExpr_BITOR_aExpr( this );
1885 }
1886
1887 aExpr* m_paExpr1;
1888 std::string* m_pBITOR2;
1889 aExpr* m_paExpr3;
1890 };
1891
1892 class aExpr_aExpr_BITSHIFTLEFT_aExpr : public aExpr
1893 {
1894 public:
aExpr_aExpr_BITSHIFTLEFT_aExpr(aExpr * pNewaExpr1,std::string * pNewBITSHIFTLEFT2,aExpr * pNewaExpr3)1895 aExpr_aExpr_BITSHIFTLEFT_aExpr(
1896 aExpr* pNewaExpr1,
1897 std::string* pNewBITSHIFTLEFT2,
1898 aExpr* pNewaExpr3
1899 )
1900 : aExpr()
1901 , m_paExpr1(pNewaExpr1)
1902 , m_pBITSHIFTLEFT2(pNewBITSHIFTLEFT2)
1903 , m_paExpr3(pNewaExpr3)
1904 {}
1905
1906 virtual ~aExpr_aExpr_BITSHIFTLEFT_aExpr();
1907
accept(Visitor * v)1908 void accept( Visitor* v ) const
1909 {
1910 v->visit_aExpr_aExpr_BITSHIFTLEFT_aExpr( this );
1911 }
1912
1913 aExpr* m_paExpr1;
1914 std::string* m_pBITSHIFTLEFT2;
1915 aExpr* m_paExpr3;
1916 };
1917
1918 class aExpr_aExpr_BITSHIFTRIGHT_aExpr : public aExpr
1919 {
1920 public:
aExpr_aExpr_BITSHIFTRIGHT_aExpr(aExpr * pNewaExpr1,std::string * pNewBITSHIFTRIGHT2,aExpr * pNewaExpr3)1921 aExpr_aExpr_BITSHIFTRIGHT_aExpr(
1922 aExpr* pNewaExpr1,
1923 std::string* pNewBITSHIFTRIGHT2,
1924 aExpr* pNewaExpr3
1925 )
1926 : aExpr()
1927 , m_paExpr1(pNewaExpr1)
1928 , m_pBITSHIFTRIGHT2(pNewBITSHIFTRIGHT2)
1929 , m_paExpr3(pNewaExpr3)
1930 {}
1931
1932 virtual ~aExpr_aExpr_BITSHIFTRIGHT_aExpr();
1933
accept(Visitor * v)1934 void accept( Visitor* v ) const
1935 {
1936 v->visit_aExpr_aExpr_BITSHIFTRIGHT_aExpr( this );
1937 }
1938
1939 aExpr* m_paExpr1;
1940 std::string* m_pBITSHIFTRIGHT2;
1941 aExpr* m_paExpr3;
1942 };
1943
1944 class aExpr_aExpr_LESSTHAN_aExpr : public aExpr
1945 {
1946 public:
aExpr_aExpr_LESSTHAN_aExpr(aExpr * pNewaExpr1,std::string * pNewLESSTHAN2,aExpr * pNewaExpr3)1947 aExpr_aExpr_LESSTHAN_aExpr(
1948 aExpr* pNewaExpr1,
1949 std::string* pNewLESSTHAN2,
1950 aExpr* pNewaExpr3
1951 )
1952 : aExpr()
1953 , m_paExpr1(pNewaExpr1)
1954 , m_pLESSTHAN2(pNewLESSTHAN2)
1955 , m_paExpr3(pNewaExpr3)
1956 {}
1957
1958 virtual ~aExpr_aExpr_LESSTHAN_aExpr();
1959
accept(Visitor * v)1960 void accept( Visitor* v ) const
1961 {
1962 v->visit_aExpr_aExpr_LESSTHAN_aExpr( this );
1963 }
1964
1965 aExpr* m_paExpr1;
1966 std::string* m_pLESSTHAN2;
1967 aExpr* m_paExpr3;
1968 };
1969
1970 class aExpr_aExpr_LESSTHANOREQUALS_aExpr : public aExpr
1971 {
1972 public:
aExpr_aExpr_LESSTHANOREQUALS_aExpr(aExpr * pNewaExpr1,std::string * pNewLESSTHANOREQUALS2,aExpr * pNewaExpr3)1973 aExpr_aExpr_LESSTHANOREQUALS_aExpr(
1974 aExpr* pNewaExpr1,
1975 std::string* pNewLESSTHANOREQUALS2,
1976 aExpr* pNewaExpr3
1977 )
1978 : aExpr()
1979 , m_paExpr1(pNewaExpr1)
1980 , m_pLESSTHANOREQUALS2(pNewLESSTHANOREQUALS2)
1981 , m_paExpr3(pNewaExpr3)
1982 {}
1983
1984 virtual ~aExpr_aExpr_LESSTHANOREQUALS_aExpr();
1985
accept(Visitor * v)1986 void accept( Visitor* v ) const
1987 {
1988 v->visit_aExpr_aExpr_LESSTHANOREQUALS_aExpr( this );
1989 }
1990
1991 aExpr* m_paExpr1;
1992 std::string* m_pLESSTHANOREQUALS2;
1993 aExpr* m_paExpr3;
1994 };
1995
1996 class aExpr_aExpr_GREATERTHAN_aExpr : public aExpr
1997 {
1998 public:
aExpr_aExpr_GREATERTHAN_aExpr(aExpr * pNewaExpr1,std::string * pNewGREATERTHAN2,aExpr * pNewaExpr3)1999 aExpr_aExpr_GREATERTHAN_aExpr(
2000 aExpr* pNewaExpr1,
2001 std::string* pNewGREATERTHAN2,
2002 aExpr* pNewaExpr3
2003 )
2004 : aExpr()
2005 , m_paExpr1(pNewaExpr1)
2006 , m_pGREATERTHAN2(pNewGREATERTHAN2)
2007 , m_paExpr3(pNewaExpr3)
2008 {}
2009
2010 virtual ~aExpr_aExpr_GREATERTHAN_aExpr();
2011
accept(Visitor * v)2012 void accept( Visitor* v ) const
2013 {
2014 v->visit_aExpr_aExpr_GREATERTHAN_aExpr( this );
2015 }
2016
2017 aExpr* m_paExpr1;
2018 std::string* m_pGREATERTHAN2;
2019 aExpr* m_paExpr3;
2020 };
2021
2022 class aExpr_aExpr_GREATERTHANOREQUALS_aExpr : public aExpr
2023 {
2024 public:
aExpr_aExpr_GREATERTHANOREQUALS_aExpr(aExpr * pNewaExpr1,std::string * pNewGREATERTHANOREQUALS2,aExpr * pNewaExpr3)2025 aExpr_aExpr_GREATERTHANOREQUALS_aExpr(
2026 aExpr* pNewaExpr1,
2027 std::string* pNewGREATERTHANOREQUALS2,
2028 aExpr* pNewaExpr3
2029 )
2030 : aExpr()
2031 , m_paExpr1(pNewaExpr1)
2032 , m_pGREATERTHANOREQUALS2(pNewGREATERTHANOREQUALS2)
2033 , m_paExpr3(pNewaExpr3)
2034 {}
2035
2036 virtual ~aExpr_aExpr_GREATERTHANOREQUALS_aExpr();
2037
accept(Visitor * v)2038 void accept( Visitor* v ) const
2039 {
2040 v->visit_aExpr_aExpr_GREATERTHANOREQUALS_aExpr( this );
2041 }
2042
2043 aExpr* m_paExpr1;
2044 std::string* m_pGREATERTHANOREQUALS2;
2045 aExpr* m_paExpr3;
2046 };
2047
2048 class aExpr_aExpr_EQUALS_aExpr : public aExpr
2049 {
2050 public:
aExpr_aExpr_EQUALS_aExpr(aExpr * pNewaExpr1,std::string * pNewEQUALS2,aExpr * pNewaExpr3)2051 aExpr_aExpr_EQUALS_aExpr(
2052 aExpr* pNewaExpr1,
2053 std::string* pNewEQUALS2,
2054 aExpr* pNewaExpr3
2055 )
2056 : aExpr()
2057 , m_paExpr1(pNewaExpr1)
2058 , m_pEQUALS2(pNewEQUALS2)
2059 , m_paExpr3(pNewaExpr3)
2060 {}
2061
2062 virtual ~aExpr_aExpr_EQUALS_aExpr();
2063
accept(Visitor * v)2064 void accept( Visitor* v ) const
2065 {
2066 v->visit_aExpr_aExpr_EQUALS_aExpr( this );
2067 }
2068
2069 aExpr* m_paExpr1;
2070 std::string* m_pEQUALS2;
2071 aExpr* m_paExpr3;
2072 };
2073
2074 class aExpr_aExpr_NOTEQUALS_aExpr : public aExpr
2075 {
2076 public:
aExpr_aExpr_NOTEQUALS_aExpr(aExpr * pNewaExpr1,std::string * pNewNOTEQUALS2,aExpr * pNewaExpr3)2077 aExpr_aExpr_NOTEQUALS_aExpr(
2078 aExpr* pNewaExpr1,
2079 std::string* pNewNOTEQUALS2,
2080 aExpr* pNewaExpr3
2081 )
2082 : aExpr()
2083 , m_paExpr1(pNewaExpr1)
2084 , m_pNOTEQUALS2(pNewNOTEQUALS2)
2085 , m_paExpr3(pNewaExpr3)
2086 {}
2087
2088 virtual ~aExpr_aExpr_NOTEQUALS_aExpr();
2089
accept(Visitor * v)2090 void accept( Visitor* v ) const
2091 {
2092 v->visit_aExpr_aExpr_NOTEQUALS_aExpr( this );
2093 }
2094
2095 aExpr* m_paExpr1;
2096 std::string* m_pNOTEQUALS2;
2097 aExpr* m_paExpr3;
2098 };
2099
2100 class aExpr_aExpr_AND_aExpr : public aExpr
2101 {
2102 public:
aExpr_aExpr_AND_aExpr(aExpr * pNewaExpr1,std::string * pNewAND2,aExpr * pNewaExpr3)2103 aExpr_aExpr_AND_aExpr(
2104 aExpr* pNewaExpr1,
2105 std::string* pNewAND2,
2106 aExpr* pNewaExpr3
2107 )
2108 : aExpr()
2109 , m_paExpr1(pNewaExpr1)
2110 , m_pAND2(pNewAND2)
2111 , m_paExpr3(pNewaExpr3)
2112 {}
2113
2114 virtual ~aExpr_aExpr_AND_aExpr();
2115
accept(Visitor * v)2116 void accept( Visitor* v ) const
2117 {
2118 v->visit_aExpr_aExpr_AND_aExpr( this );
2119 }
2120
2121 aExpr* m_paExpr1;
2122 std::string* m_pAND2;
2123 aExpr* m_paExpr3;
2124 };
2125
2126 class aExpr_aExpr_OR_aExpr : public aExpr
2127 {
2128 public:
aExpr_aExpr_OR_aExpr(aExpr * pNewaExpr1,std::string * pNewOR2,aExpr * pNewaExpr3)2129 aExpr_aExpr_OR_aExpr(
2130 aExpr* pNewaExpr1,
2131 std::string* pNewOR2,
2132 aExpr* pNewaExpr3
2133 )
2134 : aExpr()
2135 , m_paExpr1(pNewaExpr1)
2136 , m_pOR2(pNewOR2)
2137 , m_paExpr3(pNewaExpr3)
2138 {}
2139
2140 virtual ~aExpr_aExpr_OR_aExpr();
2141
accept(Visitor * v)2142 void accept( Visitor* v ) const
2143 {
2144 v->visit_aExpr_aExpr_OR_aExpr( this );
2145 }
2146
2147 aExpr* m_paExpr1;
2148 std::string* m_pOR2;
2149 aExpr* m_paExpr3;
2150 };
2151
2152 class aExpr_NOT_aExpr : public aExpr
2153 {
2154 public:
aExpr_NOT_aExpr(std::string * pNewNOT1,aExpr * pNewaExpr2)2155 aExpr_NOT_aExpr(
2156 std::string* pNewNOT1,
2157 aExpr* pNewaExpr2
2158 )
2159 : aExpr()
2160 , m_pNOT1(pNewNOT1)
2161 , m_paExpr2(pNewaExpr2)
2162 {}
2163
2164 virtual ~aExpr_NOT_aExpr();
2165
accept(Visitor * v)2166 void accept( Visitor* v ) const
2167 {
2168 v->visit_aExpr_NOT_aExpr( this );
2169 }
2170
2171 std::string* m_pNOT1;
2172 aExpr* m_paExpr2;
2173 };
2174
2175 class aExpr_aExpr_CONCATENATION_aExpr : public aExpr
2176 {
2177 public:
aExpr_aExpr_CONCATENATION_aExpr(aExpr * pNewaExpr1,std::string * pNewCONCATENATION2,aExpr * pNewaExpr3)2178 aExpr_aExpr_CONCATENATION_aExpr(
2179 aExpr* pNewaExpr1,
2180 std::string* pNewCONCATENATION2,
2181 aExpr* pNewaExpr3
2182 )
2183 : aExpr()
2184 , m_paExpr1(pNewaExpr1)
2185 , m_pCONCATENATION2(pNewCONCATENATION2)
2186 , m_paExpr3(pNewaExpr3)
2187 {}
2188
2189 virtual ~aExpr_aExpr_CONCATENATION_aExpr();
2190
accept(Visitor * v)2191 void accept( Visitor* v ) const
2192 {
2193 v->visit_aExpr_aExpr_CONCATENATION_aExpr( this );
2194 }
2195
2196 aExpr* m_paExpr1;
2197 std::string* m_pCONCATENATION2;
2198 aExpr* m_paExpr3;
2199 };
2200
2201 class aExpr_aExpr_LIKE_aExpr : public aExpr
2202 {
2203 public:
aExpr_aExpr_LIKE_aExpr(aExpr * pNewaExpr1,std::string * pNewLIKE2,aExpr * pNewaExpr3)2204 aExpr_aExpr_LIKE_aExpr(
2205 aExpr* pNewaExpr1,
2206 std::string* pNewLIKE2,
2207 aExpr* pNewaExpr3
2208 )
2209 : aExpr()
2210 , m_paExpr1(pNewaExpr1)
2211 , m_pLIKE2(pNewLIKE2)
2212 , m_paExpr3(pNewaExpr3)
2213 {}
2214
2215 virtual ~aExpr_aExpr_LIKE_aExpr();
2216
accept(Visitor * v)2217 void accept( Visitor* v ) const
2218 {
2219 v->visit_aExpr_aExpr_LIKE_aExpr( this );
2220 }
2221
2222 aExpr* m_paExpr1;
2223 std::string* m_pLIKE2;
2224 aExpr* m_paExpr3;
2225 };
2226
2227 class aExpr_aExpr_LIKE_aExpr_ESCAPE_aExpr : public aExpr
2228 {
2229 public:
aExpr_aExpr_LIKE_aExpr_ESCAPE_aExpr(aExpr * pNewaExpr1,std::string * pNewLIKE2,aExpr * pNewaExpr3,std::string * pNewESCAPE4,aExpr * pNewaExpr5)2230 aExpr_aExpr_LIKE_aExpr_ESCAPE_aExpr(
2231 aExpr* pNewaExpr1,
2232 std::string* pNewLIKE2,
2233 aExpr* pNewaExpr3,
2234 std::string* pNewESCAPE4,
2235 aExpr* pNewaExpr5
2236 )
2237 : aExpr()
2238 , m_paExpr1(pNewaExpr1)
2239 , m_pLIKE2(pNewLIKE2)
2240 , m_paExpr3(pNewaExpr3)
2241 , m_pESCAPE4(pNewESCAPE4)
2242 , m_paExpr5(pNewaExpr5)
2243 {}
2244
2245 virtual ~aExpr_aExpr_LIKE_aExpr_ESCAPE_aExpr();
2246
accept(Visitor * v)2247 void accept( Visitor* v ) const
2248 {
2249 v->visit_aExpr_aExpr_LIKE_aExpr_ESCAPE_aExpr( this );
2250 }
2251
2252 aExpr* m_paExpr1;
2253 std::string* m_pLIKE2;
2254 aExpr* m_paExpr3;
2255 std::string* m_pESCAPE4;
2256 aExpr* m_paExpr5;
2257 };
2258
2259 class aExpr_aExpr_NOT_LIKE_aExpr : public aExpr
2260 {
2261 public:
aExpr_aExpr_NOT_LIKE_aExpr(aExpr * pNewaExpr1,std::string * pNewNOT2,std::string * pNewLIKE3,aExpr * pNewaExpr4)2262 aExpr_aExpr_NOT_LIKE_aExpr(
2263 aExpr* pNewaExpr1,
2264 std::string* pNewNOT2,
2265 std::string* pNewLIKE3,
2266 aExpr* pNewaExpr4
2267 )
2268 : aExpr()
2269 , m_paExpr1(pNewaExpr1)
2270 , m_pNOT2(pNewNOT2)
2271 , m_pLIKE3(pNewLIKE3)
2272 , m_paExpr4(pNewaExpr4)
2273 {}
2274
2275 virtual ~aExpr_aExpr_NOT_LIKE_aExpr();
2276
accept(Visitor * v)2277 void accept( Visitor* v ) const
2278 {
2279 v->visit_aExpr_aExpr_NOT_LIKE_aExpr( this );
2280 }
2281
2282 aExpr* m_paExpr1;
2283 std::string* m_pNOT2;
2284 std::string* m_pLIKE3;
2285 aExpr* m_paExpr4;
2286 };
2287
2288 class aExpr_aExpr_NOT_LIKE_aExpr_ESCAPE_aExpr : public aExpr
2289 {
2290 public:
aExpr_aExpr_NOT_LIKE_aExpr_ESCAPE_aExpr(aExpr * pNewaExpr1,std::string * pNewNOT2,std::string * pNewLIKE3,aExpr * pNewaExpr4,std::string * pNewESCAPE5,aExpr * pNewaExpr6)2291 aExpr_aExpr_NOT_LIKE_aExpr_ESCAPE_aExpr(
2292 aExpr* pNewaExpr1,
2293 std::string* pNewNOT2,
2294 std::string* pNewLIKE3,
2295 aExpr* pNewaExpr4,
2296 std::string* pNewESCAPE5,
2297 aExpr* pNewaExpr6
2298 )
2299 : aExpr()
2300 , m_paExpr1(pNewaExpr1)
2301 , m_pNOT2(pNewNOT2)
2302 , m_pLIKE3(pNewLIKE3)
2303 , m_paExpr4(pNewaExpr4)
2304 , m_pESCAPE5(pNewESCAPE5)
2305 , m_paExpr6(pNewaExpr6)
2306 {}
2307
2308 virtual ~aExpr_aExpr_NOT_LIKE_aExpr_ESCAPE_aExpr();
2309
accept(Visitor * v)2310 void accept( Visitor* v ) const
2311 {
2312 v->visit_aExpr_aExpr_NOT_LIKE_aExpr_ESCAPE_aExpr( this );
2313 }
2314
2315 aExpr* m_paExpr1;
2316 std::string* m_pNOT2;
2317 std::string* m_pLIKE3;
2318 aExpr* m_paExpr4;
2319 std::string* m_pESCAPE5;
2320 aExpr* m_paExpr6;
2321 };
2322
2323 class aExpr_aExpr_ISNULL : public aExpr
2324 {
2325 public:
aExpr_aExpr_ISNULL(aExpr * pNewaExpr1,std::string * pNewISNULL2)2326 aExpr_aExpr_ISNULL(
2327 aExpr* pNewaExpr1,
2328 std::string* pNewISNULL2
2329 )
2330 : aExpr()
2331 , m_paExpr1(pNewaExpr1)
2332 , m_pISNULL2(pNewISNULL2)
2333 {}
2334
2335 virtual ~aExpr_aExpr_ISNULL();
2336
accept(Visitor * v)2337 void accept( Visitor* v ) const
2338 {
2339 v->visit_aExpr_aExpr_ISNULL( this );
2340 }
2341
2342 aExpr* m_paExpr1;
2343 std::string* m_pISNULL2;
2344 };
2345
2346 class aExpr_aExpr_IS_NULLP : public aExpr
2347 {
2348 public:
aExpr_aExpr_IS_NULLP(aExpr * pNewaExpr1,std::string * pNewIS2,std::string * pNewNULLP3)2349 aExpr_aExpr_IS_NULLP(
2350 aExpr* pNewaExpr1,
2351 std::string* pNewIS2,
2352 std::string* pNewNULLP3
2353 )
2354 : aExpr()
2355 , m_paExpr1(pNewaExpr1)
2356 , m_pIS2(pNewIS2)
2357 , m_pNULLP3(pNewNULLP3)
2358 {}
2359
2360 virtual ~aExpr_aExpr_IS_NULLP();
2361
accept(Visitor * v)2362 void accept( Visitor* v ) const
2363 {
2364 v->visit_aExpr_aExpr_IS_NULLP( this );
2365 }
2366
2367 aExpr* m_paExpr1;
2368 std::string* m_pIS2;
2369 std::string* m_pNULLP3;
2370 };
2371
2372 class aExpr_aExpr_NOTNULL : public aExpr
2373 {
2374 public:
aExpr_aExpr_NOTNULL(aExpr * pNewaExpr1,std::string * pNewNOTNULL2)2375 aExpr_aExpr_NOTNULL(
2376 aExpr* pNewaExpr1,
2377 std::string* pNewNOTNULL2
2378 )
2379 : aExpr()
2380 , m_paExpr1(pNewaExpr1)
2381 , m_pNOTNULL2(pNewNOTNULL2)
2382 {}
2383
2384 virtual ~aExpr_aExpr_NOTNULL();
2385
accept(Visitor * v)2386 void accept( Visitor* v ) const
2387 {
2388 v->visit_aExpr_aExpr_NOTNULL( this );
2389 }
2390
2391 aExpr* m_paExpr1;
2392 std::string* m_pNOTNULL2;
2393 };
2394
2395 class aExpr_aExpr_IS_NOT_NULLP : public aExpr
2396 {
2397 public:
aExpr_aExpr_IS_NOT_NULLP(aExpr * pNewaExpr1,std::string * pNewIS2,std::string * pNewNOT3,std::string * pNewNULLP4)2398 aExpr_aExpr_IS_NOT_NULLP(
2399 aExpr* pNewaExpr1,
2400 std::string* pNewIS2,
2401 std::string* pNewNOT3,
2402 std::string* pNewNULLP4
2403 )
2404 : aExpr()
2405 , m_paExpr1(pNewaExpr1)
2406 , m_pIS2(pNewIS2)
2407 , m_pNOT3(pNewNOT3)
2408 , m_pNULLP4(pNewNULLP4)
2409 {}
2410
2411 virtual ~aExpr_aExpr_IS_NOT_NULLP();
2412
accept(Visitor * v)2413 void accept( Visitor* v ) const
2414 {
2415 v->visit_aExpr_aExpr_IS_NOT_NULLP( this );
2416 }
2417
2418 aExpr* m_paExpr1;
2419 std::string* m_pIS2;
2420 std::string* m_pNOT3;
2421 std::string* m_pNULLP4;
2422 };
2423
2424 class aExpr_aExpr_IS_TRUEP : public aExpr
2425 {
2426 public:
aExpr_aExpr_IS_TRUEP(aExpr * pNewaExpr1,std::string * pNewIS2,std::string * pNewTRUEP3)2427 aExpr_aExpr_IS_TRUEP(
2428 aExpr* pNewaExpr1,
2429 std::string* pNewIS2,
2430 std::string* pNewTRUEP3
2431 )
2432 : aExpr()
2433 , m_paExpr1(pNewaExpr1)
2434 , m_pIS2(pNewIS2)
2435 , m_pTRUEP3(pNewTRUEP3)
2436 {}
2437
2438 virtual ~aExpr_aExpr_IS_TRUEP();
2439
accept(Visitor * v)2440 void accept( Visitor* v ) const
2441 {
2442 v->visit_aExpr_aExpr_IS_TRUEP( this );
2443 }
2444
2445 aExpr* m_paExpr1;
2446 std::string* m_pIS2;
2447 std::string* m_pTRUEP3;
2448 };
2449
2450 class aExpr_aExpr_IS_NOT_FALSEP : public aExpr
2451 {
2452 public:
aExpr_aExpr_IS_NOT_FALSEP(aExpr * pNewaExpr1,std::string * pNewIS2,std::string * pNewNOT3,std::string * pNewFALSEP4)2453 aExpr_aExpr_IS_NOT_FALSEP(
2454 aExpr* pNewaExpr1,
2455 std::string* pNewIS2,
2456 std::string* pNewNOT3,
2457 std::string* pNewFALSEP4
2458 )
2459 : aExpr()
2460 , m_paExpr1(pNewaExpr1)
2461 , m_pIS2(pNewIS2)
2462 , m_pNOT3(pNewNOT3)
2463 , m_pFALSEP4(pNewFALSEP4)
2464 {}
2465
2466 virtual ~aExpr_aExpr_IS_NOT_FALSEP();
2467
accept(Visitor * v)2468 void accept( Visitor* v ) const
2469 {
2470 v->visit_aExpr_aExpr_IS_NOT_FALSEP( this );
2471 }
2472
2473 aExpr* m_paExpr1;
2474 std::string* m_pIS2;
2475 std::string* m_pNOT3;
2476 std::string* m_pFALSEP4;
2477 };
2478
2479 class aExpr_aExpr_IS_FALSEP : public aExpr
2480 {
2481 public:
aExpr_aExpr_IS_FALSEP(aExpr * pNewaExpr1,std::string * pNewIS2,std::string * pNewFALSEP3)2482 aExpr_aExpr_IS_FALSEP(
2483 aExpr* pNewaExpr1,
2484 std::string* pNewIS2,
2485 std::string* pNewFALSEP3
2486 )
2487 : aExpr()
2488 , m_paExpr1(pNewaExpr1)
2489 , m_pIS2(pNewIS2)
2490 , m_pFALSEP3(pNewFALSEP3)
2491 {}
2492
2493 virtual ~aExpr_aExpr_IS_FALSEP();
2494
accept(Visitor * v)2495 void accept( Visitor* v ) const
2496 {
2497 v->visit_aExpr_aExpr_IS_FALSEP( this );
2498 }
2499
2500 aExpr* m_paExpr1;
2501 std::string* m_pIS2;
2502 std::string* m_pFALSEP3;
2503 };
2504
2505 class aExpr_aExpr_IS_NOT_TRUEP : public aExpr
2506 {
2507 public:
aExpr_aExpr_IS_NOT_TRUEP(aExpr * pNewaExpr1,std::string * pNewIS2,std::string * pNewNOT3,std::string * pNewTRUEP4)2508 aExpr_aExpr_IS_NOT_TRUEP(
2509 aExpr* pNewaExpr1,
2510 std::string* pNewIS2,
2511 std::string* pNewNOT3,
2512 std::string* pNewTRUEP4
2513 )
2514 : aExpr()
2515 , m_paExpr1(pNewaExpr1)
2516 , m_pIS2(pNewIS2)
2517 , m_pNOT3(pNewNOT3)
2518 , m_pTRUEP4(pNewTRUEP4)
2519 {}
2520
2521 virtual ~aExpr_aExpr_IS_NOT_TRUEP();
2522
accept(Visitor * v)2523 void accept( Visitor* v ) const
2524 {
2525 v->visit_aExpr_aExpr_IS_NOT_TRUEP( this );
2526 }
2527
2528 aExpr* m_paExpr1;
2529 std::string* m_pIS2;
2530 std::string* m_pNOT3;
2531 std::string* m_pTRUEP4;
2532 };
2533
2534 class aExpr_rowExpr : public aExpr
2535 {
2536 public:
aExpr_rowExpr(rowExpr * pNewrowExpr1)2537 aExpr_rowExpr(
2538 rowExpr* pNewrowExpr1
2539 )
2540 : aExpr()
2541 , m_prowExpr1(pNewrowExpr1)
2542 {}
2543
2544 virtual ~aExpr_rowExpr();
2545
accept(Visitor * v)2546 void accept( Visitor* v ) const
2547 {
2548 v->visit_aExpr_rowExpr( this );
2549 }
2550
2551 rowExpr* m_prowExpr1;
2552 };
2553
2554 class bExpr: public node
2555 {
2556 public:
bExpr()2557 bExpr()
2558 {}
~bExpr()2559 virtual ~bExpr() {}
2560
2561 };
2562
2563 class bExpr_cExpr : public bExpr
2564 {
2565 public:
bExpr_cExpr(cExpr * pNewcExpr1)2566 bExpr_cExpr(
2567 cExpr* pNewcExpr1
2568 )
2569 : bExpr()
2570 , m_pcExpr1(pNewcExpr1)
2571 {}
2572
2573 virtual ~bExpr_cExpr();
2574
accept(Visitor * v)2575 void accept( Visitor* v ) const
2576 {
2577 v->visit_bExpr_cExpr( this );
2578 }
2579
2580 cExpr* m_pcExpr1;
2581 };
2582
2583 class bExpr_PLUS_bExpr : public bExpr
2584 {
2585 public:
bExpr_PLUS_bExpr(std::string * pNewPLUS1,bExpr * pNewbExpr2)2586 bExpr_PLUS_bExpr(
2587 std::string* pNewPLUS1,
2588 bExpr* pNewbExpr2
2589 )
2590 : bExpr()
2591 , m_pPLUS1(pNewPLUS1)
2592 , m_pbExpr2(pNewbExpr2)
2593 {}
2594
2595 virtual ~bExpr_PLUS_bExpr();
2596
accept(Visitor * v)2597 void accept( Visitor* v ) const
2598 {
2599 v->visit_bExpr_PLUS_bExpr( this );
2600 }
2601
2602 std::string* m_pPLUS1;
2603 bExpr* m_pbExpr2;
2604 };
2605
2606 class bExpr_MINUS_bExpr : public bExpr
2607 {
2608 public:
bExpr_MINUS_bExpr(std::string * pNewMINUS1,bExpr * pNewbExpr2)2609 bExpr_MINUS_bExpr(
2610 std::string* pNewMINUS1,
2611 bExpr* pNewbExpr2
2612 )
2613 : bExpr()
2614 , m_pMINUS1(pNewMINUS1)
2615 , m_pbExpr2(pNewbExpr2)
2616 {}
2617
2618 virtual ~bExpr_MINUS_bExpr();
2619
accept(Visitor * v)2620 void accept( Visitor* v ) const
2621 {
2622 v->visit_bExpr_MINUS_bExpr( this );
2623 }
2624
2625 std::string* m_pMINUS1;
2626 bExpr* m_pbExpr2;
2627 };
2628
2629 class bExpr_BITINVERT_bExpr : public bExpr
2630 {
2631 public:
bExpr_BITINVERT_bExpr(std::string * pNewBITINVERT1,bExpr * pNewbExpr2)2632 bExpr_BITINVERT_bExpr(
2633 std::string* pNewBITINVERT1,
2634 bExpr* pNewbExpr2
2635 )
2636 : bExpr()
2637 , m_pBITINVERT1(pNewBITINVERT1)
2638 , m_pbExpr2(pNewbExpr2)
2639 {}
2640
2641 virtual ~bExpr_BITINVERT_bExpr();
2642
accept(Visitor * v)2643 void accept( Visitor* v ) const
2644 {
2645 v->visit_bExpr_BITINVERT_bExpr( this );
2646 }
2647
2648 std::string* m_pBITINVERT1;
2649 bExpr* m_pbExpr2;
2650 };
2651
2652 class bExpr_bExpr_PLUS_bExpr : public bExpr
2653 {
2654 public:
bExpr_bExpr_PLUS_bExpr(bExpr * pNewbExpr1,std::string * pNewPLUS2,bExpr * pNewbExpr3)2655 bExpr_bExpr_PLUS_bExpr(
2656 bExpr* pNewbExpr1,
2657 std::string* pNewPLUS2,
2658 bExpr* pNewbExpr3
2659 )
2660 : bExpr()
2661 , m_pbExpr1(pNewbExpr1)
2662 , m_pPLUS2(pNewPLUS2)
2663 , m_pbExpr3(pNewbExpr3)
2664 {}
2665
2666 virtual ~bExpr_bExpr_PLUS_bExpr();
2667
accept(Visitor * v)2668 void accept( Visitor* v ) const
2669 {
2670 v->visit_bExpr_bExpr_PLUS_bExpr( this );
2671 }
2672
2673 bExpr* m_pbExpr1;
2674 std::string* m_pPLUS2;
2675 bExpr* m_pbExpr3;
2676 };
2677
2678 class bExpr_bExpr_MINUS_bExpr : public bExpr
2679 {
2680 public:
bExpr_bExpr_MINUS_bExpr(bExpr * pNewbExpr1,std::string * pNewMINUS2,bExpr * pNewbExpr3)2681 bExpr_bExpr_MINUS_bExpr(
2682 bExpr* pNewbExpr1,
2683 std::string* pNewMINUS2,
2684 bExpr* pNewbExpr3
2685 )
2686 : bExpr()
2687 , m_pbExpr1(pNewbExpr1)
2688 , m_pMINUS2(pNewMINUS2)
2689 , m_pbExpr3(pNewbExpr3)
2690 {}
2691
2692 virtual ~bExpr_bExpr_MINUS_bExpr();
2693
accept(Visitor * v)2694 void accept( Visitor* v ) const
2695 {
2696 v->visit_bExpr_bExpr_MINUS_bExpr( this );
2697 }
2698
2699 bExpr* m_pbExpr1;
2700 std::string* m_pMINUS2;
2701 bExpr* m_pbExpr3;
2702 };
2703
2704 class bExpr_bExpr_ASTERISK_bExpr : public bExpr
2705 {
2706 public:
bExpr_bExpr_ASTERISK_bExpr(bExpr * pNewbExpr1,std::string * pNewASTERISK2,bExpr * pNewbExpr3)2707 bExpr_bExpr_ASTERISK_bExpr(
2708 bExpr* pNewbExpr1,
2709 std::string* pNewASTERISK2,
2710 bExpr* pNewbExpr3
2711 )
2712 : bExpr()
2713 , m_pbExpr1(pNewbExpr1)
2714 , m_pASTERISK2(pNewASTERISK2)
2715 , m_pbExpr3(pNewbExpr3)
2716 {}
2717
2718 virtual ~bExpr_bExpr_ASTERISK_bExpr();
2719
accept(Visitor * v)2720 void accept( Visitor* v ) const
2721 {
2722 v->visit_bExpr_bExpr_ASTERISK_bExpr( this );
2723 }
2724
2725 bExpr* m_pbExpr1;
2726 std::string* m_pASTERISK2;
2727 bExpr* m_pbExpr3;
2728 };
2729
2730 class bExpr_bExpr_SOLIDUS_bExpr : public bExpr
2731 {
2732 public:
bExpr_bExpr_SOLIDUS_bExpr(bExpr * pNewbExpr1,std::string * pNewSOLIDUS2,bExpr * pNewbExpr3)2733 bExpr_bExpr_SOLIDUS_bExpr(
2734 bExpr* pNewbExpr1,
2735 std::string* pNewSOLIDUS2,
2736 bExpr* pNewbExpr3
2737 )
2738 : bExpr()
2739 , m_pbExpr1(pNewbExpr1)
2740 , m_pSOLIDUS2(pNewSOLIDUS2)
2741 , m_pbExpr3(pNewbExpr3)
2742 {}
2743
2744 virtual ~bExpr_bExpr_SOLIDUS_bExpr();
2745
accept(Visitor * v)2746 void accept( Visitor* v ) const
2747 {
2748 v->visit_bExpr_bExpr_SOLIDUS_bExpr( this );
2749 }
2750
2751 bExpr* m_pbExpr1;
2752 std::string* m_pSOLIDUS2;
2753 bExpr* m_pbExpr3;
2754 };
2755
2756 class bExpr_bExpr_PERCENT_bExpr : public bExpr
2757 {
2758 public:
bExpr_bExpr_PERCENT_bExpr(bExpr * pNewbExpr1,std::string * pNewPERCENT2,bExpr * pNewbExpr3)2759 bExpr_bExpr_PERCENT_bExpr(
2760 bExpr* pNewbExpr1,
2761 std::string* pNewPERCENT2,
2762 bExpr* pNewbExpr3
2763 )
2764 : bExpr()
2765 , m_pbExpr1(pNewbExpr1)
2766 , m_pPERCENT2(pNewPERCENT2)
2767 , m_pbExpr3(pNewbExpr3)
2768 {}
2769
2770 virtual ~bExpr_bExpr_PERCENT_bExpr();
2771
accept(Visitor * v)2772 void accept( Visitor* v ) const
2773 {
2774 v->visit_bExpr_bExpr_PERCENT_bExpr( this );
2775 }
2776
2777 bExpr* m_pbExpr1;
2778 std::string* m_pPERCENT2;
2779 bExpr* m_pbExpr3;
2780 };
2781
2782 class bExpr_bExpr_BITAND_bExpr : public bExpr
2783 {
2784 public:
bExpr_bExpr_BITAND_bExpr(bExpr * pNewbExpr1,std::string * pNewBITAND2,bExpr * pNewbExpr3)2785 bExpr_bExpr_BITAND_bExpr(
2786 bExpr* pNewbExpr1,
2787 std::string* pNewBITAND2,
2788 bExpr* pNewbExpr3
2789 )
2790 : bExpr()
2791 , m_pbExpr1(pNewbExpr1)
2792 , m_pBITAND2(pNewBITAND2)
2793 , m_pbExpr3(pNewbExpr3)
2794 {}
2795
2796 virtual ~bExpr_bExpr_BITAND_bExpr();
2797
accept(Visitor * v)2798 void accept( Visitor* v ) const
2799 {
2800 v->visit_bExpr_bExpr_BITAND_bExpr( this );
2801 }
2802
2803 bExpr* m_pbExpr1;
2804 std::string* m_pBITAND2;
2805 bExpr* m_pbExpr3;
2806 };
2807
2808 class bExpr_bExpr_BITOR_bExpr : public bExpr
2809 {
2810 public:
bExpr_bExpr_BITOR_bExpr(bExpr * pNewbExpr1,std::string * pNewBITOR2,bExpr * pNewbExpr3)2811 bExpr_bExpr_BITOR_bExpr(
2812 bExpr* pNewbExpr1,
2813 std::string* pNewBITOR2,
2814 bExpr* pNewbExpr3
2815 )
2816 : bExpr()
2817 , m_pbExpr1(pNewbExpr1)
2818 , m_pBITOR2(pNewBITOR2)
2819 , m_pbExpr3(pNewbExpr3)
2820 {}
2821
2822 virtual ~bExpr_bExpr_BITOR_bExpr();
2823
accept(Visitor * v)2824 void accept( Visitor* v ) const
2825 {
2826 v->visit_bExpr_bExpr_BITOR_bExpr( this );
2827 }
2828
2829 bExpr* m_pbExpr1;
2830 std::string* m_pBITOR2;
2831 bExpr* m_pbExpr3;
2832 };
2833
2834 class bExpr_bExpr_BITSHIFTLEFT_bExpr : public bExpr
2835 {
2836 public:
bExpr_bExpr_BITSHIFTLEFT_bExpr(bExpr * pNewbExpr1,std::string * pNewBITSHIFTLEFT2,bExpr * pNewbExpr3)2837 bExpr_bExpr_BITSHIFTLEFT_bExpr(
2838 bExpr* pNewbExpr1,
2839 std::string* pNewBITSHIFTLEFT2,
2840 bExpr* pNewbExpr3
2841 )
2842 : bExpr()
2843 , m_pbExpr1(pNewbExpr1)
2844 , m_pBITSHIFTLEFT2(pNewBITSHIFTLEFT2)
2845 , m_pbExpr3(pNewbExpr3)
2846 {}
2847
2848 virtual ~bExpr_bExpr_BITSHIFTLEFT_bExpr();
2849
accept(Visitor * v)2850 void accept( Visitor* v ) const
2851 {
2852 v->visit_bExpr_bExpr_BITSHIFTLEFT_bExpr( this );
2853 }
2854
2855 bExpr* m_pbExpr1;
2856 std::string* m_pBITSHIFTLEFT2;
2857 bExpr* m_pbExpr3;
2858 };
2859
2860 class bExpr_bExpr_BITSHIFTRIGHT_bExpr : public bExpr
2861 {
2862 public:
bExpr_bExpr_BITSHIFTRIGHT_bExpr(bExpr * pNewbExpr1,std::string * pNewBITSHIFTRIGHT2,bExpr * pNewbExpr3)2863 bExpr_bExpr_BITSHIFTRIGHT_bExpr(
2864 bExpr* pNewbExpr1,
2865 std::string* pNewBITSHIFTRIGHT2,
2866 bExpr* pNewbExpr3
2867 )
2868 : bExpr()
2869 , m_pbExpr1(pNewbExpr1)
2870 , m_pBITSHIFTRIGHT2(pNewBITSHIFTRIGHT2)
2871 , m_pbExpr3(pNewbExpr3)
2872 {}
2873
2874 virtual ~bExpr_bExpr_BITSHIFTRIGHT_bExpr();
2875
accept(Visitor * v)2876 void accept( Visitor* v ) const
2877 {
2878 v->visit_bExpr_bExpr_BITSHIFTRIGHT_bExpr( this );
2879 }
2880
2881 bExpr* m_pbExpr1;
2882 std::string* m_pBITSHIFTRIGHT2;
2883 bExpr* m_pbExpr3;
2884 };
2885
2886 class bExpr_bExpr_LESSTHAN_bExpr : public bExpr
2887 {
2888 public:
bExpr_bExpr_LESSTHAN_bExpr(bExpr * pNewbExpr1,std::string * pNewLESSTHAN2,bExpr * pNewbExpr3)2889 bExpr_bExpr_LESSTHAN_bExpr(
2890 bExpr* pNewbExpr1,
2891 std::string* pNewLESSTHAN2,
2892 bExpr* pNewbExpr3
2893 )
2894 : bExpr()
2895 , m_pbExpr1(pNewbExpr1)
2896 , m_pLESSTHAN2(pNewLESSTHAN2)
2897 , m_pbExpr3(pNewbExpr3)
2898 {}
2899
2900 virtual ~bExpr_bExpr_LESSTHAN_bExpr();
2901
accept(Visitor * v)2902 void accept( Visitor* v ) const
2903 {
2904 v->visit_bExpr_bExpr_LESSTHAN_bExpr( this );
2905 }
2906
2907 bExpr* m_pbExpr1;
2908 std::string* m_pLESSTHAN2;
2909 bExpr* m_pbExpr3;
2910 };
2911
2912 class bExpr_bExpr_LESSTHANOREQUALS_bExpr : public bExpr
2913 {
2914 public:
bExpr_bExpr_LESSTHANOREQUALS_bExpr(bExpr * pNewbExpr1,std::string * pNewLESSTHANOREQUALS2,bExpr * pNewbExpr3)2915 bExpr_bExpr_LESSTHANOREQUALS_bExpr(
2916 bExpr* pNewbExpr1,
2917 std::string* pNewLESSTHANOREQUALS2,
2918 bExpr* pNewbExpr3
2919 )
2920 : bExpr()
2921 , m_pbExpr1(pNewbExpr1)
2922 , m_pLESSTHANOREQUALS2(pNewLESSTHANOREQUALS2)
2923 , m_pbExpr3(pNewbExpr3)
2924 {}
2925
2926 virtual ~bExpr_bExpr_LESSTHANOREQUALS_bExpr();
2927
accept(Visitor * v)2928 void accept( Visitor* v ) const
2929 {
2930 v->visit_bExpr_bExpr_LESSTHANOREQUALS_bExpr( this );
2931 }
2932
2933 bExpr* m_pbExpr1;
2934 std::string* m_pLESSTHANOREQUALS2;
2935 bExpr* m_pbExpr3;
2936 };
2937
2938 class bExpr_bExpr_GREATERTHAN_bExpr : public bExpr
2939 {
2940 public:
bExpr_bExpr_GREATERTHAN_bExpr(bExpr * pNewbExpr1,std::string * pNewGREATERTHAN2,bExpr * pNewbExpr3)2941 bExpr_bExpr_GREATERTHAN_bExpr(
2942 bExpr* pNewbExpr1,
2943 std::string* pNewGREATERTHAN2,
2944 bExpr* pNewbExpr3
2945 )
2946 : bExpr()
2947 , m_pbExpr1(pNewbExpr1)
2948 , m_pGREATERTHAN2(pNewGREATERTHAN2)
2949 , m_pbExpr3(pNewbExpr3)
2950 {}
2951
2952 virtual ~bExpr_bExpr_GREATERTHAN_bExpr();
2953
accept(Visitor * v)2954 void accept( Visitor* v ) const
2955 {
2956 v->visit_bExpr_bExpr_GREATERTHAN_bExpr( this );
2957 }
2958
2959 bExpr* m_pbExpr1;
2960 std::string* m_pGREATERTHAN2;
2961 bExpr* m_pbExpr3;
2962 };
2963
2964 class bExpr_bExpr_GREATERTHANOREQUALS_bExpr : public bExpr
2965 {
2966 public:
bExpr_bExpr_GREATERTHANOREQUALS_bExpr(bExpr * pNewbExpr1,std::string * pNewGREATERTHANOREQUALS2,bExpr * pNewbExpr3)2967 bExpr_bExpr_GREATERTHANOREQUALS_bExpr(
2968 bExpr* pNewbExpr1,
2969 std::string* pNewGREATERTHANOREQUALS2,
2970 bExpr* pNewbExpr3
2971 )
2972 : bExpr()
2973 , m_pbExpr1(pNewbExpr1)
2974 , m_pGREATERTHANOREQUALS2(pNewGREATERTHANOREQUALS2)
2975 , m_pbExpr3(pNewbExpr3)
2976 {}
2977
2978 virtual ~bExpr_bExpr_GREATERTHANOREQUALS_bExpr();
2979
accept(Visitor * v)2980 void accept( Visitor* v ) const
2981 {
2982 v->visit_bExpr_bExpr_GREATERTHANOREQUALS_bExpr( this );
2983 }
2984
2985 bExpr* m_pbExpr1;
2986 std::string* m_pGREATERTHANOREQUALS2;
2987 bExpr* m_pbExpr3;
2988 };
2989
2990 class bExpr_bExpr_EQUALS_bExpr : public bExpr
2991 {
2992 public:
bExpr_bExpr_EQUALS_bExpr(bExpr * pNewbExpr1,std::string * pNewEQUALS2,bExpr * pNewbExpr3)2993 bExpr_bExpr_EQUALS_bExpr(
2994 bExpr* pNewbExpr1,
2995 std::string* pNewEQUALS2,
2996 bExpr* pNewbExpr3
2997 )
2998 : bExpr()
2999 , m_pbExpr1(pNewbExpr1)
3000 , m_pEQUALS2(pNewEQUALS2)
3001 , m_pbExpr3(pNewbExpr3)
3002 {}
3003
3004 virtual ~bExpr_bExpr_EQUALS_bExpr();
3005
accept(Visitor * v)3006 void accept( Visitor* v ) const
3007 {
3008 v->visit_bExpr_bExpr_EQUALS_bExpr( this );
3009 }
3010
3011 bExpr* m_pbExpr1;
3012 std::string* m_pEQUALS2;
3013 bExpr* m_pbExpr3;
3014 };
3015
3016 class bExpr_bExpr_NOTEQUALS_bExpr : public bExpr
3017 {
3018 public:
bExpr_bExpr_NOTEQUALS_bExpr(bExpr * pNewbExpr1,std::string * pNewNOTEQUALS2,bExpr * pNewbExpr3)3019 bExpr_bExpr_NOTEQUALS_bExpr(
3020 bExpr* pNewbExpr1,
3021 std::string* pNewNOTEQUALS2,
3022 bExpr* pNewbExpr3
3023 )
3024 : bExpr()
3025 , m_pbExpr1(pNewbExpr1)
3026 , m_pNOTEQUALS2(pNewNOTEQUALS2)
3027 , m_pbExpr3(pNewbExpr3)
3028 {}
3029
3030 virtual ~bExpr_bExpr_NOTEQUALS_bExpr();
3031
accept(Visitor * v)3032 void accept( Visitor* v ) const
3033 {
3034 v->visit_bExpr_bExpr_NOTEQUALS_bExpr( this );
3035 }
3036
3037 bExpr* m_pbExpr1;
3038 std::string* m_pNOTEQUALS2;
3039 bExpr* m_pbExpr3;
3040 };
3041
3042 class bExpr_bExpr_CONCATENATION_bExpr : public bExpr
3043 {
3044 public:
bExpr_bExpr_CONCATENATION_bExpr(bExpr * pNewbExpr1,std::string * pNewCONCATENATION2,bExpr * pNewbExpr3)3045 bExpr_bExpr_CONCATENATION_bExpr(
3046 bExpr* pNewbExpr1,
3047 std::string* pNewCONCATENATION2,
3048 bExpr* pNewbExpr3
3049 )
3050 : bExpr()
3051 , m_pbExpr1(pNewbExpr1)
3052 , m_pCONCATENATION2(pNewCONCATENATION2)
3053 , m_pbExpr3(pNewbExpr3)
3054 {}
3055
3056 virtual ~bExpr_bExpr_CONCATENATION_bExpr();
3057
accept(Visitor * v)3058 void accept( Visitor* v ) const
3059 {
3060 v->visit_bExpr_bExpr_CONCATENATION_bExpr( this );
3061 }
3062
3063 bExpr* m_pbExpr1;
3064 std::string* m_pCONCATENATION2;
3065 bExpr* m_pbExpr3;
3066 };
3067
3068 class cExpr: public node
3069 {
3070 public:
cExpr()3071 cExpr()
3072 {}
~cExpr()3073 virtual ~cExpr() {}
3074
3075 };
3076
3077 class cExpr_attr : public cExpr
3078 {
3079 public:
cExpr_attr(attr * pNewattr1)3080 cExpr_attr(
3081 attr* pNewattr1
3082 )
3083 : cExpr()
3084 , m_pattr1(pNewattr1)
3085 {}
3086
3087 virtual ~cExpr_attr();
3088
accept(Visitor * v)3089 void accept( Visitor* v ) const
3090 {
3091 v->visit_cExpr_attr( this );
3092 }
3093
3094 attr* m_pattr1;
3095 };
3096
3097 class cExpr_strColId_optIndirection : public cExpr
3098 {
3099 public:
cExpr_strColId_optIndirection(std::string * pNewstrColId1,optIndirection * pNewoptIndirection2)3100 cExpr_strColId_optIndirection(
3101 std::string* pNewstrColId1,
3102 optIndirection* pNewoptIndirection2
3103 )
3104 : cExpr()
3105 , m_pstrColId1(pNewstrColId1)
3106 , m_poptIndirection2(pNewoptIndirection2)
3107 {}
3108
3109 virtual ~cExpr_strColId_optIndirection();
3110
accept(Visitor * v)3111 void accept( Visitor* v ) const
3112 {
3113 v->visit_cExpr_strColId_optIndirection( this );
3114 }
3115
3116 std::string* m_pstrColId1;
3117 optIndirection* m_poptIndirection2;
3118 };
3119
3120 class cExpr_aExprConst : public cExpr
3121 {
3122 public:
cExpr_aExprConst(aExprConst * pNewaExprConst1)3123 cExpr_aExprConst(
3124 aExprConst* pNewaExprConst1
3125 )
3126 : cExpr()
3127 , m_paExprConst1(pNewaExprConst1)
3128 {}
3129
3130 virtual ~cExpr_aExprConst();
3131
accept(Visitor * v)3132 void accept( Visitor* v ) const
3133 {
3134 v->visit_cExpr_aExprConst( this );
3135 }
3136
3137 aExprConst* m_paExprConst1;
3138 };
3139
3140 class cExpr_LEFTPAREN_aExpr_RIGHTPAREN : public cExpr
3141 {
3142 public:
cExpr_LEFTPAREN_aExpr_RIGHTPAREN(std::string * pNewLEFTPAREN1,aExpr * pNewaExpr2,std::string * pNewRIGHTPAREN3)3143 cExpr_LEFTPAREN_aExpr_RIGHTPAREN(
3144 std::string* pNewLEFTPAREN1,
3145 aExpr* pNewaExpr2,
3146 std::string* pNewRIGHTPAREN3
3147 )
3148 : cExpr()
3149 , m_pLEFTPAREN1(pNewLEFTPAREN1)
3150 , m_paExpr2(pNewaExpr2)
3151 , m_pRIGHTPAREN3(pNewRIGHTPAREN3)
3152 {}
3153
3154 virtual ~cExpr_LEFTPAREN_aExpr_RIGHTPAREN();
3155
accept(Visitor * v)3156 void accept( Visitor* v ) const
3157 {
3158 v->visit_cExpr_LEFTPAREN_aExpr_RIGHTPAREN( this );
3159 }
3160
3161 std::string* m_pLEFTPAREN1;
3162 aExpr* m_paExpr2;
3163 std::string* m_pRIGHTPAREN3;
3164 };
3165
3166 class cExpr_strFuncName_LEFTPAREN_RIGHTPAREN : public cExpr
3167 {
3168 public:
cExpr_strFuncName_LEFTPAREN_RIGHTPAREN(std::string * pNewstrFuncName1,std::string * pNewLEFTPAREN2,std::string * pNewRIGHTPAREN3)3169 cExpr_strFuncName_LEFTPAREN_RIGHTPAREN(
3170 std::string* pNewstrFuncName1,
3171 std::string* pNewLEFTPAREN2,
3172 std::string* pNewRIGHTPAREN3
3173 )
3174 : cExpr()
3175 , m_pstrFuncName1(pNewstrFuncName1)
3176 , m_pLEFTPAREN2(pNewLEFTPAREN2)
3177 , m_pRIGHTPAREN3(pNewRIGHTPAREN3)
3178 {}
3179
3180 virtual ~cExpr_strFuncName_LEFTPAREN_RIGHTPAREN();
3181
accept(Visitor * v)3182 void accept( Visitor* v ) const
3183 {
3184 v->visit_cExpr_strFuncName_LEFTPAREN_RIGHTPAREN( this );
3185 }
3186
3187 std::string* m_pstrFuncName1;
3188 std::string* m_pLEFTPAREN2;
3189 std::string* m_pRIGHTPAREN3;
3190 };
3191
3192 class cExpr_strFuncName_LEFTPAREN_exprSeq_RIGHTPAREN : public cExpr
3193 {
3194 public:
cExpr_strFuncName_LEFTPAREN_exprSeq_RIGHTPAREN(std::string * pNewstrFuncName1,std::string * pNewLEFTPAREN2,exprSeq * pNewexprSeq3,std::string * pNewRIGHTPAREN4)3195 cExpr_strFuncName_LEFTPAREN_exprSeq_RIGHTPAREN(
3196 std::string* pNewstrFuncName1,
3197 std::string* pNewLEFTPAREN2,
3198 exprSeq* pNewexprSeq3,
3199 std::string* pNewRIGHTPAREN4
3200 )
3201 : cExpr()
3202 , m_pstrFuncName1(pNewstrFuncName1)
3203 , m_pLEFTPAREN2(pNewLEFTPAREN2)
3204 , m_pexprSeq3(pNewexprSeq3)
3205 , m_pRIGHTPAREN4(pNewRIGHTPAREN4)
3206 {}
3207
3208 virtual ~cExpr_strFuncName_LEFTPAREN_exprSeq_RIGHTPAREN();
3209
accept(Visitor * v)3210 void accept( Visitor* v ) const
3211 {
3212 v->visit_cExpr_strFuncName_LEFTPAREN_exprSeq_RIGHTPAREN( this );
3213 }
3214
3215 std::string* m_pstrFuncName1;
3216 std::string* m_pLEFTPAREN2;
3217 exprSeq* m_pexprSeq3;
3218 std::string* m_pRIGHTPAREN4;
3219 };
3220
3221 class cExpr_strFuncName_LEFTPAREN_ALL_exprSeq_RIGHTPAREN : public cExpr
3222 {
3223 public:
cExpr_strFuncName_LEFTPAREN_ALL_exprSeq_RIGHTPAREN(std::string * pNewstrFuncName1,std::string * pNewLEFTPAREN2,std::string * pNewALL3,exprSeq * pNewexprSeq4,std::string * pNewRIGHTPAREN5)3224 cExpr_strFuncName_LEFTPAREN_ALL_exprSeq_RIGHTPAREN(
3225 std::string* pNewstrFuncName1,
3226 std::string* pNewLEFTPAREN2,
3227 std::string* pNewALL3,
3228 exprSeq* pNewexprSeq4,
3229 std::string* pNewRIGHTPAREN5
3230 )
3231 : cExpr()
3232 , m_pstrFuncName1(pNewstrFuncName1)
3233 , m_pLEFTPAREN2(pNewLEFTPAREN2)
3234 , m_pALL3(pNewALL3)
3235 , m_pexprSeq4(pNewexprSeq4)
3236 , m_pRIGHTPAREN5(pNewRIGHTPAREN5)
3237 {}
3238
3239 virtual ~cExpr_strFuncName_LEFTPAREN_ALL_exprSeq_RIGHTPAREN();
3240
accept(Visitor * v)3241 void accept( Visitor* v ) const
3242 {
3243 v->visit_cExpr_strFuncName_LEFTPAREN_ALL_exprSeq_RIGHTPAREN( this );
3244 }
3245
3246 std::string* m_pstrFuncName1;
3247 std::string* m_pLEFTPAREN2;
3248 std::string* m_pALL3;
3249 exprSeq* m_pexprSeq4;
3250 std::string* m_pRIGHTPAREN5;
3251 };
3252
3253 class cExpr_strFuncName_LEFTPAREN_DISTINCT_exprSeq_RIGHTPAREN : public cExpr
3254 {
3255 public:
cExpr_strFuncName_LEFTPAREN_DISTINCT_exprSeq_RIGHTPAREN(std::string * pNewstrFuncName1,std::string * pNewLEFTPAREN2,std::string * pNewDISTINCT3,exprSeq * pNewexprSeq4,std::string * pNewRIGHTPAREN5)3256 cExpr_strFuncName_LEFTPAREN_DISTINCT_exprSeq_RIGHTPAREN(
3257 std::string* pNewstrFuncName1,
3258 std::string* pNewLEFTPAREN2,
3259 std::string* pNewDISTINCT3,
3260 exprSeq* pNewexprSeq4,
3261 std::string* pNewRIGHTPAREN5
3262 )
3263 : cExpr()
3264 , m_pstrFuncName1(pNewstrFuncName1)
3265 , m_pLEFTPAREN2(pNewLEFTPAREN2)
3266 , m_pDISTINCT3(pNewDISTINCT3)
3267 , m_pexprSeq4(pNewexprSeq4)
3268 , m_pRIGHTPAREN5(pNewRIGHTPAREN5)
3269 {}
3270
3271 virtual ~cExpr_strFuncName_LEFTPAREN_DISTINCT_exprSeq_RIGHTPAREN();
3272
accept(Visitor * v)3273 void accept( Visitor* v ) const
3274 {
3275 v->visit_cExpr_strFuncName_LEFTPAREN_DISTINCT_exprSeq_RIGHTPAREN( this );
3276 }
3277
3278 std::string* m_pstrFuncName1;
3279 std::string* m_pLEFTPAREN2;
3280 std::string* m_pDISTINCT3;
3281 exprSeq* m_pexprSeq4;
3282 std::string* m_pRIGHTPAREN5;
3283 };
3284
3285 class cExpr_strFuncName_LEFTPAREN_ASTERISK_RIGHTPAREN : public cExpr
3286 {
3287 public:
cExpr_strFuncName_LEFTPAREN_ASTERISK_RIGHTPAREN(std::string * pNewstrFuncName1,std::string * pNewLEFTPAREN2,std::string * pNewASTERISK3,std::string * pNewRIGHTPAREN4)3288 cExpr_strFuncName_LEFTPAREN_ASTERISK_RIGHTPAREN(
3289 std::string* pNewstrFuncName1,
3290 std::string* pNewLEFTPAREN2,
3291 std::string* pNewASTERISK3,
3292 std::string* pNewRIGHTPAREN4
3293 )
3294 : cExpr()
3295 , m_pstrFuncName1(pNewstrFuncName1)
3296 , m_pLEFTPAREN2(pNewLEFTPAREN2)
3297 , m_pASTERISK3(pNewASTERISK3)
3298 , m_pRIGHTPAREN4(pNewRIGHTPAREN4)
3299 {}
3300
3301 virtual ~cExpr_strFuncName_LEFTPAREN_ASTERISK_RIGHTPAREN();
3302
accept(Visitor * v)3303 void accept( Visitor* v ) const
3304 {
3305 v->visit_cExpr_strFuncName_LEFTPAREN_ASTERISK_RIGHTPAREN( this );
3306 }
3307
3308 std::string* m_pstrFuncName1;
3309 std::string* m_pLEFTPAREN2;
3310 std::string* m_pASTERISK3;
3311 std::string* m_pRIGHTPAREN4;
3312 };
3313
3314 class cExpr_CURRENTDATE : public cExpr
3315 {
3316 public:
cExpr_CURRENTDATE(std::string * pNewCURRENTDATE1)3317 cExpr_CURRENTDATE(
3318 std::string* pNewCURRENTDATE1
3319 )
3320 : cExpr()
3321 , m_pCURRENTDATE1(pNewCURRENTDATE1)
3322 {}
3323
3324 virtual ~cExpr_CURRENTDATE();
3325
accept(Visitor * v)3326 void accept( Visitor* v ) const
3327 {
3328 v->visit_cExpr_CURRENTDATE( this );
3329 }
3330
3331 std::string* m_pCURRENTDATE1;
3332 };
3333
3334 class cExpr_CURRENTTIME : public cExpr
3335 {
3336 public:
cExpr_CURRENTTIME(std::string * pNewCURRENTTIME1)3337 cExpr_CURRENTTIME(
3338 std::string* pNewCURRENTTIME1
3339 )
3340 : cExpr()
3341 , m_pCURRENTTIME1(pNewCURRENTTIME1)
3342 {}
3343
3344 virtual ~cExpr_CURRENTTIME();
3345
accept(Visitor * v)3346 void accept( Visitor* v ) const
3347 {
3348 v->visit_cExpr_CURRENTTIME( this );
3349 }
3350
3351 std::string* m_pCURRENTTIME1;
3352 };
3353
3354 class cExpr_CURRENTTIME_LEFTPAREN_ICONST_RIGHTPAREN : public cExpr
3355 {
3356 public:
cExpr_CURRENTTIME_LEFTPAREN_ICONST_RIGHTPAREN(std::string * pNewCURRENTTIME1,std::string * pNewLEFTPAREN2,std::string * pNewICONST3,std::string * pNewRIGHTPAREN4)3357 cExpr_CURRENTTIME_LEFTPAREN_ICONST_RIGHTPAREN(
3358 std::string* pNewCURRENTTIME1,
3359 std::string* pNewLEFTPAREN2,
3360 std::string* pNewICONST3,
3361 std::string* pNewRIGHTPAREN4
3362 )
3363 : cExpr()
3364 , m_pCURRENTTIME1(pNewCURRENTTIME1)
3365 , m_pLEFTPAREN2(pNewLEFTPAREN2)
3366 , m_pICONST3(pNewICONST3)
3367 , m_pRIGHTPAREN4(pNewRIGHTPAREN4)
3368 {}
3369
3370 virtual ~cExpr_CURRENTTIME_LEFTPAREN_ICONST_RIGHTPAREN();
3371
accept(Visitor * v)3372 void accept( Visitor* v ) const
3373 {
3374 v->visit_cExpr_CURRENTTIME_LEFTPAREN_ICONST_RIGHTPAREN( this );
3375 }
3376
3377 std::string* m_pCURRENTTIME1;
3378 std::string* m_pLEFTPAREN2;
3379 std::string* m_pICONST3;
3380 std::string* m_pRIGHTPAREN4;
3381 };
3382
3383 class cExpr_CURRENTTIMESTAMP : public cExpr
3384 {
3385 public:
cExpr_CURRENTTIMESTAMP(std::string * pNewCURRENTTIMESTAMP1)3386 cExpr_CURRENTTIMESTAMP(
3387 std::string* pNewCURRENTTIMESTAMP1
3388 )
3389 : cExpr()
3390 , m_pCURRENTTIMESTAMP1(pNewCURRENTTIMESTAMP1)
3391 {}
3392
3393 virtual ~cExpr_CURRENTTIMESTAMP();
3394
accept(Visitor * v)3395 void accept( Visitor* v ) const
3396 {
3397 v->visit_cExpr_CURRENTTIMESTAMP( this );
3398 }
3399
3400 std::string* m_pCURRENTTIMESTAMP1;
3401 };
3402
3403 class cExpr_CURRENTTIMESTAMP_LEFTPAREN_ICONST_RIGHTPAREN : public cExpr
3404 {
3405 public:
cExpr_CURRENTTIMESTAMP_LEFTPAREN_ICONST_RIGHTPAREN(std::string * pNewCURRENTTIMESTAMP1,std::string * pNewLEFTPAREN2,std::string * pNewICONST3,std::string * pNewRIGHTPAREN4)3406 cExpr_CURRENTTIMESTAMP_LEFTPAREN_ICONST_RIGHTPAREN(
3407 std::string* pNewCURRENTTIMESTAMP1,
3408 std::string* pNewLEFTPAREN2,
3409 std::string* pNewICONST3,
3410 std::string* pNewRIGHTPAREN4
3411 )
3412 : cExpr()
3413 , m_pCURRENTTIMESTAMP1(pNewCURRENTTIMESTAMP1)
3414 , m_pLEFTPAREN2(pNewLEFTPAREN2)
3415 , m_pICONST3(pNewICONST3)
3416 , m_pRIGHTPAREN4(pNewRIGHTPAREN4)
3417 {}
3418
3419 virtual ~cExpr_CURRENTTIMESTAMP_LEFTPAREN_ICONST_RIGHTPAREN();
3420
accept(Visitor * v)3421 void accept( Visitor* v ) const
3422 {
3423 v->visit_cExpr_CURRENTTIMESTAMP_LEFTPAREN_ICONST_RIGHTPAREN( this );
3424 }
3425
3426 std::string* m_pCURRENTTIMESTAMP1;
3427 std::string* m_pLEFTPAREN2;
3428 std::string* m_pICONST3;
3429 std::string* m_pRIGHTPAREN4;
3430 };
3431
3432 class cExpr_CURRENTUSER : public cExpr
3433 {
3434 public:
cExpr_CURRENTUSER(std::string * pNewCURRENTUSER1)3435 cExpr_CURRENTUSER(
3436 std::string* pNewCURRENTUSER1
3437 )
3438 : cExpr()
3439 , m_pCURRENTUSER1(pNewCURRENTUSER1)
3440 {}
3441
3442 virtual ~cExpr_CURRENTUSER();
3443
accept(Visitor * v)3444 void accept( Visitor* v ) const
3445 {
3446 v->visit_cExpr_CURRENTUSER( this );
3447 }
3448
3449 std::string* m_pCURRENTUSER1;
3450 };
3451
3452 class cExpr_SESSIONUSER : public cExpr
3453 {
3454 public:
cExpr_SESSIONUSER(std::string * pNewSESSIONUSER1)3455 cExpr_SESSIONUSER(
3456 std::string* pNewSESSIONUSER1
3457 )
3458 : cExpr()
3459 , m_pSESSIONUSER1(pNewSESSIONUSER1)
3460 {}
3461
3462 virtual ~cExpr_SESSIONUSER();
3463
accept(Visitor * v)3464 void accept( Visitor* v ) const
3465 {
3466 v->visit_cExpr_SESSIONUSER( this );
3467 }
3468
3469 std::string* m_pSESSIONUSER1;
3470 };
3471
3472 class cExpr_USER : public cExpr
3473 {
3474 public:
cExpr_USER(std::string * pNewUSER1)3475 cExpr_USER(
3476 std::string* pNewUSER1
3477 )
3478 : cExpr()
3479 , m_pUSER1(pNewUSER1)
3480 {}
3481
3482 virtual ~cExpr_USER();
3483
accept(Visitor * v)3484 void accept( Visitor* v ) const
3485 {
3486 v->visit_cExpr_USER( this );
3487 }
3488
3489 std::string* m_pUSER1;
3490 };
3491
3492 class cExpr_EXTRACT_LEFTPAREN_optExtract_RIGHTPAREN : public cExpr
3493 {
3494 public:
cExpr_EXTRACT_LEFTPAREN_optExtract_RIGHTPAREN(std::string * pNewEXTRACT1,std::string * pNewLEFTPAREN2,optExtract * pNewoptExtract3,std::string * pNewRIGHTPAREN4)3495 cExpr_EXTRACT_LEFTPAREN_optExtract_RIGHTPAREN(
3496 std::string* pNewEXTRACT1,
3497 std::string* pNewLEFTPAREN2,
3498 optExtract* pNewoptExtract3,
3499 std::string* pNewRIGHTPAREN4
3500 )
3501 : cExpr()
3502 , m_pEXTRACT1(pNewEXTRACT1)
3503 , m_pLEFTPAREN2(pNewLEFTPAREN2)
3504 , m_poptExtract3(pNewoptExtract3)
3505 , m_pRIGHTPAREN4(pNewRIGHTPAREN4)
3506 {}
3507
3508 virtual ~cExpr_EXTRACT_LEFTPAREN_optExtract_RIGHTPAREN();
3509
accept(Visitor * v)3510 void accept( Visitor* v ) const
3511 {
3512 v->visit_cExpr_EXTRACT_LEFTPAREN_optExtract_RIGHTPAREN( this );
3513 }
3514
3515 std::string* m_pEXTRACT1;
3516 std::string* m_pLEFTPAREN2;
3517 optExtract* m_poptExtract3;
3518 std::string* m_pRIGHTPAREN4;
3519 };
3520
3521 class cExpr_POSITION_LEFTPAREN_positionExpr_RIGHTPAREN : public cExpr
3522 {
3523 public:
cExpr_POSITION_LEFTPAREN_positionExpr_RIGHTPAREN(std::string * pNewPOSITION1,std::string * pNewLEFTPAREN2,positionExpr * pNewpositionExpr3,std::string * pNewRIGHTPAREN4)3524 cExpr_POSITION_LEFTPAREN_positionExpr_RIGHTPAREN(
3525 std::string* pNewPOSITION1,
3526 std::string* pNewLEFTPAREN2,
3527 positionExpr* pNewpositionExpr3,
3528 std::string* pNewRIGHTPAREN4
3529 )
3530 : cExpr()
3531 , m_pPOSITION1(pNewPOSITION1)
3532 , m_pLEFTPAREN2(pNewLEFTPAREN2)
3533 , m_ppositionExpr3(pNewpositionExpr3)
3534 , m_pRIGHTPAREN4(pNewRIGHTPAREN4)
3535 {}
3536
3537 virtual ~cExpr_POSITION_LEFTPAREN_positionExpr_RIGHTPAREN();
3538
accept(Visitor * v)3539 void accept( Visitor* v ) const
3540 {
3541 v->visit_cExpr_POSITION_LEFTPAREN_positionExpr_RIGHTPAREN( this );
3542 }
3543
3544 std::string* m_pPOSITION1;
3545 std::string* m_pLEFTPAREN2;
3546 positionExpr* m_ppositionExpr3;
3547 std::string* m_pRIGHTPAREN4;
3548 };
3549
3550 class cExpr_SUBSTRING_LEFTPAREN_optSubstrExpr_RIGHTPAREN : public cExpr
3551 {
3552 public:
cExpr_SUBSTRING_LEFTPAREN_optSubstrExpr_RIGHTPAREN(std::string * pNewSUBSTRING1,std::string * pNewLEFTPAREN2,optSubstrExpr * pNewoptSubstrExpr3,std::string * pNewRIGHTPAREN4)3553 cExpr_SUBSTRING_LEFTPAREN_optSubstrExpr_RIGHTPAREN(
3554 std::string* pNewSUBSTRING1,
3555 std::string* pNewLEFTPAREN2,
3556 optSubstrExpr* pNewoptSubstrExpr3,
3557 std::string* pNewRIGHTPAREN4
3558 )
3559 : cExpr()
3560 , m_pSUBSTRING1(pNewSUBSTRING1)
3561 , m_pLEFTPAREN2(pNewLEFTPAREN2)
3562 , m_poptSubstrExpr3(pNewoptSubstrExpr3)
3563 , m_pRIGHTPAREN4(pNewRIGHTPAREN4)
3564 {}
3565
3566 virtual ~cExpr_SUBSTRING_LEFTPAREN_optSubstrExpr_RIGHTPAREN();
3567
accept(Visitor * v)3568 void accept( Visitor* v ) const
3569 {
3570 v->visit_cExpr_SUBSTRING_LEFTPAREN_optSubstrExpr_RIGHTPAREN( this );
3571 }
3572
3573 std::string* m_pSUBSTRING1;
3574 std::string* m_pLEFTPAREN2;
3575 optSubstrExpr* m_poptSubstrExpr3;
3576 std::string* m_pRIGHTPAREN4;
3577 };
3578
3579 class cExpr_TRIM_LEFTPAREN_LEADING_trimExpr_RIGHTPAREN : public cExpr
3580 {
3581 public:
cExpr_TRIM_LEFTPAREN_LEADING_trimExpr_RIGHTPAREN(std::string * pNewTRIM1,std::string * pNewLEFTPAREN2,std::string * pNewLEADING3,trimExpr * pNewtrimExpr4,std::string * pNewRIGHTPAREN5)3582 cExpr_TRIM_LEFTPAREN_LEADING_trimExpr_RIGHTPAREN(
3583 std::string* pNewTRIM1,
3584 std::string* pNewLEFTPAREN2,
3585 std::string* pNewLEADING3,
3586 trimExpr* pNewtrimExpr4,
3587 std::string* pNewRIGHTPAREN5
3588 )
3589 : cExpr()
3590 , m_pTRIM1(pNewTRIM1)
3591 , m_pLEFTPAREN2(pNewLEFTPAREN2)
3592 , m_pLEADING3(pNewLEADING3)
3593 , m_ptrimExpr4(pNewtrimExpr4)
3594 , m_pRIGHTPAREN5(pNewRIGHTPAREN5)
3595 {}
3596
3597 virtual ~cExpr_TRIM_LEFTPAREN_LEADING_trimExpr_RIGHTPAREN();
3598
accept(Visitor * v)3599 void accept( Visitor* v ) const
3600 {
3601 v->visit_cExpr_TRIM_LEFTPAREN_LEADING_trimExpr_RIGHTPAREN( this );
3602 }
3603
3604 std::string* m_pTRIM1;
3605 std::string* m_pLEFTPAREN2;
3606 std::string* m_pLEADING3;
3607 trimExpr* m_ptrimExpr4;
3608 std::string* m_pRIGHTPAREN5;
3609 };
3610
3611 class cExpr_TRIM_LEFTPAREN_TRAILING_trimExpr_RIGHTPAREN : public cExpr
3612 {
3613 public:
cExpr_TRIM_LEFTPAREN_TRAILING_trimExpr_RIGHTPAREN(std::string * pNewTRIM1,std::string * pNewLEFTPAREN2,std::string * pNewTRAILING3,trimExpr * pNewtrimExpr4,std::string * pNewRIGHTPAREN5)3614 cExpr_TRIM_LEFTPAREN_TRAILING_trimExpr_RIGHTPAREN(
3615 std::string* pNewTRIM1,
3616 std::string* pNewLEFTPAREN2,
3617 std::string* pNewTRAILING3,
3618 trimExpr* pNewtrimExpr4,
3619 std::string* pNewRIGHTPAREN5
3620 )
3621 : cExpr()
3622 , m_pTRIM1(pNewTRIM1)
3623 , m_pLEFTPAREN2(pNewLEFTPAREN2)
3624 , m_pTRAILING3(pNewTRAILING3)
3625 , m_ptrimExpr4(pNewtrimExpr4)
3626 , m_pRIGHTPAREN5(pNewRIGHTPAREN5)
3627 {}
3628
3629 virtual ~cExpr_TRIM_LEFTPAREN_TRAILING_trimExpr_RIGHTPAREN();
3630
accept(Visitor * v)3631 void accept( Visitor* v ) const
3632 {
3633 v->visit_cExpr_TRIM_LEFTPAREN_TRAILING_trimExpr_RIGHTPAREN( this );
3634 }
3635
3636 std::string* m_pTRIM1;
3637 std::string* m_pLEFTPAREN2;
3638 std::string* m_pTRAILING3;
3639 trimExpr* m_ptrimExpr4;
3640 std::string* m_pRIGHTPAREN5;
3641 };
3642
3643 class cExpr_TRIM_LEFTPAREN_trimExpr_RIGHTPAREN : public cExpr
3644 {
3645 public:
cExpr_TRIM_LEFTPAREN_trimExpr_RIGHTPAREN(std::string * pNewTRIM1,std::string * pNewLEFTPAREN2,trimExpr * pNewtrimExpr3,std::string * pNewRIGHTPAREN4)3646 cExpr_TRIM_LEFTPAREN_trimExpr_RIGHTPAREN(
3647 std::string* pNewTRIM1,
3648 std::string* pNewLEFTPAREN2,
3649 trimExpr* pNewtrimExpr3,
3650 std::string* pNewRIGHTPAREN4
3651 )
3652 : cExpr()
3653 , m_pTRIM1(pNewTRIM1)
3654 , m_pLEFTPAREN2(pNewLEFTPAREN2)
3655 , m_ptrimExpr3(pNewtrimExpr3)
3656 , m_pRIGHTPAREN4(pNewRIGHTPAREN4)
3657 {}
3658
3659 virtual ~cExpr_TRIM_LEFTPAREN_trimExpr_RIGHTPAREN();
3660
accept(Visitor * v)3661 void accept( Visitor* v ) const
3662 {
3663 v->visit_cExpr_TRIM_LEFTPAREN_trimExpr_RIGHTPAREN( this );
3664 }
3665
3666 std::string* m_pTRIM1;
3667 std::string* m_pLEFTPAREN2;
3668 trimExpr* m_ptrimExpr3;
3669 std::string* m_pRIGHTPAREN4;
3670 };
3671
3672 class optIndirection: public node
3673 {
3674 public:
optIndirection()3675 optIndirection()
3676 {}
~optIndirection()3677 virtual ~optIndirection() {}
3678
3679 };
3680
3681 class optIndirection_empty : public optIndirection
3682 {
3683 public:
optIndirection_empty()3684 optIndirection_empty(
3685 )
3686 : optIndirection()
3687 {}
3688
3689 virtual ~optIndirection_empty();
3690
accept(Visitor * v)3691 void accept( Visitor* v ) const
3692 {
3693 v->visit_optIndirection_empty( this );
3694 }
3695
3696 };
3697
3698 class optIndirection_optIndirection_LEFTBRACKET_aExpr_RIGHTBRACKET : public optIndirection
3699 {
3700 public:
optIndirection_optIndirection_LEFTBRACKET_aExpr_RIGHTBRACKET(optIndirection * pNewoptIndirection1,std::string * pNewLEFTBRACKET2,aExpr * pNewaExpr3,std::string * pNewRIGHTBRACKET4)3701 optIndirection_optIndirection_LEFTBRACKET_aExpr_RIGHTBRACKET(
3702 optIndirection* pNewoptIndirection1,
3703 std::string* pNewLEFTBRACKET2,
3704 aExpr* pNewaExpr3,
3705 std::string* pNewRIGHTBRACKET4
3706 )
3707 : optIndirection()
3708 , m_poptIndirection1(pNewoptIndirection1)
3709 , m_pLEFTBRACKET2(pNewLEFTBRACKET2)
3710 , m_paExpr3(pNewaExpr3)
3711 , m_pRIGHTBRACKET4(pNewRIGHTBRACKET4)
3712 {}
3713
3714 virtual ~optIndirection_optIndirection_LEFTBRACKET_aExpr_RIGHTBRACKET();
3715
accept(Visitor * v)3716 void accept( Visitor* v ) const
3717 {
3718 v->visit_optIndirection_optIndirection_LEFTBRACKET_aExpr_RIGHTBRACKET( this );
3719 }
3720
3721 optIndirection* m_poptIndirection1;
3722 std::string* m_pLEFTBRACKET2;
3723 aExpr* m_paExpr3;
3724 std::string* m_pRIGHTBRACKET4;
3725 };
3726
3727 class optIndirection_optIndirection_LEFTBRACKET_aExpr_COLON_aExpr_RIGHTBRACKET : public optIndirection
3728 {
3729 public:
optIndirection_optIndirection_LEFTBRACKET_aExpr_COLON_aExpr_RIGHTBRACKET(optIndirection * pNewoptIndirection1,std::string * pNewLEFTBRACKET2,aExpr * pNewaExpr3,std::string * pNewCOLON4,aExpr * pNewaExpr5,std::string * pNewRIGHTBRACKET6)3730 optIndirection_optIndirection_LEFTBRACKET_aExpr_COLON_aExpr_RIGHTBRACKET(
3731 optIndirection* pNewoptIndirection1,
3732 std::string* pNewLEFTBRACKET2,
3733 aExpr* pNewaExpr3,
3734 std::string* pNewCOLON4,
3735 aExpr* pNewaExpr5,
3736 std::string* pNewRIGHTBRACKET6
3737 )
3738 : optIndirection()
3739 , m_poptIndirection1(pNewoptIndirection1)
3740 , m_pLEFTBRACKET2(pNewLEFTBRACKET2)
3741 , m_paExpr3(pNewaExpr3)
3742 , m_pCOLON4(pNewCOLON4)
3743 , m_paExpr5(pNewaExpr5)
3744 , m_pRIGHTBRACKET6(pNewRIGHTBRACKET6)
3745 {}
3746
3747 virtual ~optIndirection_optIndirection_LEFTBRACKET_aExpr_COLON_aExpr_RIGHTBRACKET();
3748
accept(Visitor * v)3749 void accept( Visitor* v ) const
3750 {
3751 v->visit_optIndirection_optIndirection_LEFTBRACKET_aExpr_COLON_aExpr_RIGHTBRACKET( this );
3752 }
3753
3754 optIndirection* m_poptIndirection1;
3755 std::string* m_pLEFTBRACKET2;
3756 aExpr* m_paExpr3;
3757 std::string* m_pCOLON4;
3758 aExpr* m_paExpr5;
3759 std::string* m_pRIGHTBRACKET6;
3760 };
3761
3762 class optExtract: public node
3763 {
3764 public:
optExtract()3765 optExtract()
3766 {}
~optExtract()3767 virtual ~optExtract() {}
3768
3769 };
3770
3771 class optExtract_empty : public optExtract
3772 {
3773 public:
optExtract_empty()3774 optExtract_empty(
3775 )
3776 : optExtract()
3777 {}
3778
3779 virtual ~optExtract_empty();
3780
accept(Visitor * v)3781 void accept( Visitor* v ) const
3782 {
3783 v->visit_optExtract_empty( this );
3784 }
3785
3786 };
3787
3788 class optExtract_strExtractArg_FROM_aExpr : public optExtract
3789 {
3790 public:
optExtract_strExtractArg_FROM_aExpr(std::string * pNewstrExtractArg1,std::string * pNewFROM2,aExpr * pNewaExpr3)3791 optExtract_strExtractArg_FROM_aExpr(
3792 std::string* pNewstrExtractArg1,
3793 std::string* pNewFROM2,
3794 aExpr* pNewaExpr3
3795 )
3796 : optExtract()
3797 , m_pstrExtractArg1(pNewstrExtractArg1)
3798 , m_pFROM2(pNewFROM2)
3799 , m_paExpr3(pNewaExpr3)
3800 {}
3801
3802 virtual ~optExtract_strExtractArg_FROM_aExpr();
3803
accept(Visitor * v)3804 void accept( Visitor* v ) const
3805 {
3806 v->visit_optExtract_strExtractArg_FROM_aExpr( this );
3807 }
3808
3809 std::string* m_pstrExtractArg1;
3810 std::string* m_pFROM2;
3811 aExpr* m_paExpr3;
3812 };
3813
3814 class positionExpr: public node
3815 {
3816 public:
positionExpr()3817 positionExpr()
3818 {}
~positionExpr()3819 virtual ~positionExpr() {}
3820
3821 };
3822
3823 class positionExpr_bExpr_IN_bExpr : public positionExpr
3824 {
3825 public:
positionExpr_bExpr_IN_bExpr(bExpr * pNewbExpr1,std::string * pNewIN2,bExpr * pNewbExpr3)3826 positionExpr_bExpr_IN_bExpr(
3827 bExpr* pNewbExpr1,
3828 std::string* pNewIN2,
3829 bExpr* pNewbExpr3
3830 )
3831 : positionExpr()
3832 , m_pbExpr1(pNewbExpr1)
3833 , m_pIN2(pNewIN2)
3834 , m_pbExpr3(pNewbExpr3)
3835 {}
3836
3837 virtual ~positionExpr_bExpr_IN_bExpr();
3838
accept(Visitor * v)3839 void accept( Visitor* v ) const
3840 {
3841 v->visit_positionExpr_bExpr_IN_bExpr( this );
3842 }
3843
3844 bExpr* m_pbExpr1;
3845 std::string* m_pIN2;
3846 bExpr* m_pbExpr3;
3847 };
3848
3849 class positionExpr_empty : public positionExpr
3850 {
3851 public:
positionExpr_empty()3852 positionExpr_empty(
3853 )
3854 : positionExpr()
3855 {}
3856
3857 virtual ~positionExpr_empty();
3858
accept(Visitor * v)3859 void accept( Visitor* v ) const
3860 {
3861 v->visit_positionExpr_empty( this );
3862 }
3863
3864 };
3865
3866 class optSubstrExpr: public node
3867 {
3868 public:
optSubstrExpr()3869 optSubstrExpr()
3870 {}
~optSubstrExpr()3871 virtual ~optSubstrExpr() {}
3872
3873 };
3874
3875 class optSubstrExpr_empty : public optSubstrExpr
3876 {
3877 public:
optSubstrExpr_empty()3878 optSubstrExpr_empty(
3879 )
3880 : optSubstrExpr()
3881 {}
3882
3883 virtual ~optSubstrExpr_empty();
3884
accept(Visitor * v)3885 void accept( Visitor* v ) const
3886 {
3887 v->visit_optSubstrExpr_empty( this );
3888 }
3889
3890 };
3891
3892 class optSubstrExpr_aExpr_substrFrom_substrFor : public optSubstrExpr
3893 {
3894 public:
optSubstrExpr_aExpr_substrFrom_substrFor(aExpr * pNewaExpr1,substrFrom * pNewsubstrFrom2,substrFor * pNewsubstrFor3)3895 optSubstrExpr_aExpr_substrFrom_substrFor(
3896 aExpr* pNewaExpr1,
3897 substrFrom* pNewsubstrFrom2,
3898 substrFor* pNewsubstrFor3
3899 )
3900 : optSubstrExpr()
3901 , m_paExpr1(pNewaExpr1)
3902 , m_psubstrFrom2(pNewsubstrFrom2)
3903 , m_psubstrFor3(pNewsubstrFor3)
3904 {}
3905
3906 virtual ~optSubstrExpr_aExpr_substrFrom_substrFor();
3907
accept(Visitor * v)3908 void accept( Visitor* v ) const
3909 {
3910 v->visit_optSubstrExpr_aExpr_substrFrom_substrFor( this );
3911 }
3912
3913 aExpr* m_paExpr1;
3914 substrFrom* m_psubstrFrom2;
3915 substrFor* m_psubstrFor3;
3916 };
3917
3918 class optSubstrExpr_aExpr_substrFor_substrFrom : public optSubstrExpr
3919 {
3920 public:
optSubstrExpr_aExpr_substrFor_substrFrom(aExpr * pNewaExpr1,substrFor * pNewsubstrFor2,substrFrom * pNewsubstrFrom3)3921 optSubstrExpr_aExpr_substrFor_substrFrom(
3922 aExpr* pNewaExpr1,
3923 substrFor* pNewsubstrFor2,
3924 substrFrom* pNewsubstrFrom3
3925 )
3926 : optSubstrExpr()
3927 , m_paExpr1(pNewaExpr1)
3928 , m_psubstrFor2(pNewsubstrFor2)
3929 , m_psubstrFrom3(pNewsubstrFrom3)
3930 {}
3931
3932 virtual ~optSubstrExpr_aExpr_substrFor_substrFrom();
3933
accept(Visitor * v)3934 void accept( Visitor* v ) const
3935 {
3936 v->visit_optSubstrExpr_aExpr_substrFor_substrFrom( this );
3937 }
3938
3939 aExpr* m_paExpr1;
3940 substrFor* m_psubstrFor2;
3941 substrFrom* m_psubstrFrom3;
3942 };
3943
3944 class optSubstrExpr_aExpr_substrFrom : public optSubstrExpr
3945 {
3946 public:
optSubstrExpr_aExpr_substrFrom(aExpr * pNewaExpr1,substrFrom * pNewsubstrFrom2)3947 optSubstrExpr_aExpr_substrFrom(
3948 aExpr* pNewaExpr1,
3949 substrFrom* pNewsubstrFrom2
3950 )
3951 : optSubstrExpr()
3952 , m_paExpr1(pNewaExpr1)
3953 , m_psubstrFrom2(pNewsubstrFrom2)
3954 {}
3955
3956 virtual ~optSubstrExpr_aExpr_substrFrom();
3957
accept(Visitor * v)3958 void accept( Visitor* v ) const
3959 {
3960 v->visit_optSubstrExpr_aExpr_substrFrom( this );
3961 }
3962
3963 aExpr* m_paExpr1;
3964 substrFrom* m_psubstrFrom2;
3965 };
3966
3967 class optSubstrExpr_aExpr_substrFor : public optSubstrExpr
3968 {
3969 public:
optSubstrExpr_aExpr_substrFor(aExpr * pNewaExpr1,substrFor * pNewsubstrFor2)3970 optSubstrExpr_aExpr_substrFor(
3971 aExpr* pNewaExpr1,
3972 substrFor* pNewsubstrFor2
3973 )
3974 : optSubstrExpr()
3975 , m_paExpr1(pNewaExpr1)
3976 , m_psubstrFor2(pNewsubstrFor2)
3977 {}
3978
3979 virtual ~optSubstrExpr_aExpr_substrFor();
3980
accept(Visitor * v)3981 void accept( Visitor* v ) const
3982 {
3983 v->visit_optSubstrExpr_aExpr_substrFor( this );
3984 }
3985
3986 aExpr* m_paExpr1;
3987 substrFor* m_psubstrFor2;
3988 };
3989
3990 class optSubstrExpr_exprSeq : public optSubstrExpr
3991 {
3992 public:
optSubstrExpr_exprSeq(exprSeq * pNewexprSeq1)3993 optSubstrExpr_exprSeq(
3994 exprSeq* pNewexprSeq1
3995 )
3996 : optSubstrExpr()
3997 , m_pexprSeq1(pNewexprSeq1)
3998 {}
3999
4000 virtual ~optSubstrExpr_exprSeq();
4001
accept(Visitor * v)4002 void accept( Visitor* v ) const
4003 {
4004 v->visit_optSubstrExpr_exprSeq( this );
4005 }
4006
4007 exprSeq* m_pexprSeq1;
4008 };
4009
4010 class substrFrom : public node
4011 {
4012 public:
substrFrom(std::string * pNewFROM1,aExpr * pNewaExpr2)4013 substrFrom(
4014 std::string* pNewFROM1,
4015 aExpr* pNewaExpr2
4016 )
4017 : m_pFROM1(pNewFROM1)
4018 , m_paExpr2(pNewaExpr2)
4019 {}
4020
4021 virtual ~substrFrom();
4022
accept(Visitor * v)4023 void accept( Visitor* v ) const
4024 {
4025 v->visit_substrFrom( this );
4026 }
4027
4028 std::string* m_pFROM1;
4029 aExpr* m_paExpr2;
4030 };
4031
4032 class substrFor : public node
4033 {
4034 public:
substrFor(std::string * pNewFOR1,aExpr * pNewaExpr2)4035 substrFor(
4036 std::string* pNewFOR1,
4037 aExpr* pNewaExpr2
4038 )
4039 : m_pFOR1(pNewFOR1)
4040 , m_paExpr2(pNewaExpr2)
4041 {}
4042
4043 virtual ~substrFor();
4044
accept(Visitor * v)4045 void accept( Visitor* v ) const
4046 {
4047 v->visit_substrFor( this );
4048 }
4049
4050 std::string* m_pFOR1;
4051 aExpr* m_paExpr2;
4052 };
4053
4054 class trimExpr: public node
4055 {
4056 public:
trimExpr()4057 trimExpr()
4058 {}
~trimExpr()4059 virtual ~trimExpr() {}
4060
4061 };
4062
4063 class trimExpr_aExpr_FROM_exprSeq : public trimExpr
4064 {
4065 public:
trimExpr_aExpr_FROM_exprSeq(aExpr * pNewaExpr1,std::string * pNewFROM2,exprSeq * pNewexprSeq3)4066 trimExpr_aExpr_FROM_exprSeq(
4067 aExpr* pNewaExpr1,
4068 std::string* pNewFROM2,
4069 exprSeq* pNewexprSeq3
4070 )
4071 : trimExpr()
4072 , m_paExpr1(pNewaExpr1)
4073 , m_pFROM2(pNewFROM2)
4074 , m_pexprSeq3(pNewexprSeq3)
4075 {}
4076
4077 virtual ~trimExpr_aExpr_FROM_exprSeq();
4078
accept(Visitor * v)4079 void accept( Visitor* v ) const
4080 {
4081 v->visit_trimExpr_aExpr_FROM_exprSeq( this );
4082 }
4083
4084 aExpr* m_paExpr1;
4085 std::string* m_pFROM2;
4086 exprSeq* m_pexprSeq3;
4087 };
4088
4089 class trimExpr_FROM_exprSeq : public trimExpr
4090 {
4091 public:
trimExpr_FROM_exprSeq(std::string * pNewFROM1,exprSeq * pNewexprSeq2)4092 trimExpr_FROM_exprSeq(
4093 std::string* pNewFROM1,
4094 exprSeq* pNewexprSeq2
4095 )
4096 : trimExpr()
4097 , m_pFROM1(pNewFROM1)
4098 , m_pexprSeq2(pNewexprSeq2)
4099 {}
4100
4101 virtual ~trimExpr_FROM_exprSeq();
4102
accept(Visitor * v)4103 void accept( Visitor* v ) const
4104 {
4105 v->visit_trimExpr_FROM_exprSeq( this );
4106 }
4107
4108 std::string* m_pFROM1;
4109 exprSeq* m_pexprSeq2;
4110 };
4111
4112 class trimExpr_exprSeq : public trimExpr
4113 {
4114 public:
trimExpr_exprSeq(exprSeq * pNewexprSeq1)4115 trimExpr_exprSeq(
4116 exprSeq* pNewexprSeq1
4117 )
4118 : trimExpr()
4119 , m_pexprSeq1(pNewexprSeq1)
4120 {}
4121
4122 virtual ~trimExpr_exprSeq();
4123
accept(Visitor * v)4124 void accept( Visitor* v ) const
4125 {
4126 v->visit_trimExpr_exprSeq( this );
4127 }
4128
4129 exprSeq* m_pexprSeq1;
4130 };
4131
4132 class attr : public node
4133 {
4134 public:
attr(std::string * pNewstrRelationName1,std::string * pNewPERIOD2,attrs * pNewattrs3,optIndirection * pNewoptIndirection4)4135 attr(
4136 std::string* pNewstrRelationName1,
4137 std::string* pNewPERIOD2,
4138 attrs* pNewattrs3,
4139 optIndirection* pNewoptIndirection4
4140 )
4141 : m_pstrRelationName1(pNewstrRelationName1)
4142 , m_pPERIOD2(pNewPERIOD2)
4143 , m_pattrs3(pNewattrs3)
4144 , m_poptIndirection4(pNewoptIndirection4)
4145 {}
4146
4147 virtual ~attr();
4148
accept(Visitor * v)4149 void accept( Visitor* v ) const
4150 {
4151 v->visit_attr( this );
4152 }
4153
4154 std::string* m_pstrRelationName1;
4155 std::string* m_pPERIOD2;
4156 attrs* m_pattrs3;
4157 optIndirection* m_poptIndirection4;
4158 };
4159
4160 class attrs: public node
4161 {
4162 public:
attrs()4163 attrs()
4164 {}
~attrs()4165 virtual ~attrs() {}
4166
4167 };
4168
4169 class attrs_strAttrName : public attrs
4170 {
4171 public:
attrs_strAttrName(std::string * pNewstrAttrName1)4172 attrs_strAttrName(
4173 std::string* pNewstrAttrName1
4174 )
4175 : attrs()
4176 , m_pstrAttrName1(pNewstrAttrName1)
4177 {}
4178
4179 virtual ~attrs_strAttrName();
4180
accept(Visitor * v)4181 void accept( Visitor* v ) const
4182 {
4183 v->visit_attrs_strAttrName( this );
4184 }
4185
4186 std::string* m_pstrAttrName1;
4187 };
4188
4189 class attrs_attrs_PERIOD_strAttrName : public attrs
4190 {
4191 public:
attrs_attrs_PERIOD_strAttrName(attrs * pNewattrs1,std::string * pNewPERIOD2,std::string * pNewstrAttrName3)4192 attrs_attrs_PERIOD_strAttrName(
4193 attrs* pNewattrs1,
4194 std::string* pNewPERIOD2,
4195 std::string* pNewstrAttrName3
4196 )
4197 : attrs()
4198 , m_pattrs1(pNewattrs1)
4199 , m_pPERIOD2(pNewPERIOD2)
4200 , m_pstrAttrName3(pNewstrAttrName3)
4201 {}
4202
4203 virtual ~attrs_attrs_PERIOD_strAttrName();
4204
accept(Visitor * v)4205 void accept( Visitor* v ) const
4206 {
4207 v->visit_attrs_attrs_PERIOD_strAttrName( this );
4208 }
4209
4210 attrs* m_pattrs1;
4211 std::string* m_pPERIOD2;
4212 std::string* m_pstrAttrName3;
4213 };
4214
4215 class attrs_attrs_PERIOD_ASTERISK : public attrs
4216 {
4217 public:
attrs_attrs_PERIOD_ASTERISK(attrs * pNewattrs1,std::string * pNewPERIOD2,std::string * pNewASTERISK3)4218 attrs_attrs_PERIOD_ASTERISK(
4219 attrs* pNewattrs1,
4220 std::string* pNewPERIOD2,
4221 std::string* pNewASTERISK3
4222 )
4223 : attrs()
4224 , m_pattrs1(pNewattrs1)
4225 , m_pPERIOD2(pNewPERIOD2)
4226 , m_pASTERISK3(pNewASTERISK3)
4227 {}
4228
4229 virtual ~attrs_attrs_PERIOD_ASTERISK();
4230
accept(Visitor * v)4231 void accept( Visitor* v ) const
4232 {
4233 v->visit_attrs_attrs_PERIOD_ASTERISK( this );
4234 }
4235
4236 attrs* m_pattrs1;
4237 std::string* m_pPERIOD2;
4238 std::string* m_pASTERISK3;
4239 };
4240
4241 class targetEl: public node
4242 {
4243 public:
targetEl()4244 targetEl()
4245 {}
~targetEl()4246 virtual ~targetEl() {}
4247
4248 };
4249
4250 class targetEl_aExpr_AS_strColLabel : public targetEl
4251 {
4252 public:
targetEl_aExpr_AS_strColLabel(aExpr * pNewaExpr1,std::string * pNewAS2,std::string * pNewstrColLabel3)4253 targetEl_aExpr_AS_strColLabel(
4254 aExpr* pNewaExpr1,
4255 std::string* pNewAS2,
4256 std::string* pNewstrColLabel3
4257 )
4258 : targetEl()
4259 , m_paExpr1(pNewaExpr1)
4260 , m_pAS2(pNewAS2)
4261 , m_pstrColLabel3(pNewstrColLabel3)
4262 {}
4263
4264 virtual ~targetEl_aExpr_AS_strColLabel();
4265
accept(Visitor * v)4266 void accept( Visitor* v ) const
4267 {
4268 v->visit_targetEl_aExpr_AS_strColLabel( this );
4269 }
4270
4271 aExpr* m_paExpr1;
4272 std::string* m_pAS2;
4273 std::string* m_pstrColLabel3;
4274 };
4275
4276 class targetEl_aExpr : public targetEl
4277 {
4278 public:
targetEl_aExpr(aExpr * pNewaExpr1)4279 targetEl_aExpr(
4280 aExpr* pNewaExpr1
4281 )
4282 : targetEl()
4283 , m_paExpr1(pNewaExpr1)
4284 {}
4285
4286 virtual ~targetEl_aExpr();
4287
accept(Visitor * v)4288 void accept( Visitor* v ) const
4289 {
4290 v->visit_targetEl_aExpr( this );
4291 }
4292
4293 aExpr* m_paExpr1;
4294 };
4295
4296 class targetEl_strRelationName_PERIOD_ASTERISK : public targetEl
4297 {
4298 public:
targetEl_strRelationName_PERIOD_ASTERISK(std::string * pNewstrRelationName1,std::string * pNewPERIOD2,std::string * pNewASTERISK3)4299 targetEl_strRelationName_PERIOD_ASTERISK(
4300 std::string* pNewstrRelationName1,
4301 std::string* pNewPERIOD2,
4302 std::string* pNewASTERISK3
4303 )
4304 : targetEl()
4305 , m_pstrRelationName1(pNewstrRelationName1)
4306 , m_pPERIOD2(pNewPERIOD2)
4307 , m_pASTERISK3(pNewASTERISK3)
4308 {}
4309
4310 virtual ~targetEl_strRelationName_PERIOD_ASTERISK();
4311
accept(Visitor * v)4312 void accept( Visitor* v ) const
4313 {
4314 v->visit_targetEl_strRelationName_PERIOD_ASTERISK( this );
4315 }
4316
4317 std::string* m_pstrRelationName1;
4318 std::string* m_pPERIOD2;
4319 std::string* m_pASTERISK3;
4320 };
4321
4322 class targetEl_ASTERISK : public targetEl
4323 {
4324 public:
targetEl_ASTERISK(std::string * pNewASTERISK1)4325 targetEl_ASTERISK(
4326 std::string* pNewASTERISK1
4327 )
4328 : targetEl()
4329 , m_pASTERISK1(pNewASTERISK1)
4330 {}
4331
4332 virtual ~targetEl_ASTERISK();
4333
accept(Visitor * v)4334 void accept( Visitor* v ) const
4335 {
4336 v->visit_targetEl_ASTERISK( this );
4337 }
4338
4339 std::string* m_pASTERISK1;
4340 };
4341
4342 class updateTargetEl : public node
4343 {
4344 public:
updateTargetEl(std::string * pNewstrColId1,optIndirection * pNewoptIndirection2,std::string * pNewEQUALS3,aExpr * pNewaExpr4)4345 updateTargetEl(
4346 std::string* pNewstrColId1,
4347 optIndirection* pNewoptIndirection2,
4348 std::string* pNewEQUALS3,
4349 aExpr* pNewaExpr4
4350 )
4351 : m_pstrColId1(pNewstrColId1)
4352 , m_poptIndirection2(pNewoptIndirection2)
4353 , m_pEQUALS3(pNewEQUALS3)
4354 , m_paExpr4(pNewaExpr4)
4355 {}
4356
4357 virtual ~updateTargetEl();
4358
accept(Visitor * v)4359 void accept( Visitor* v ) const
4360 {
4361 v->visit_updateTargetEl( this );
4362 }
4363
4364 std::string* m_pstrColId1;
4365 optIndirection* m_poptIndirection2;
4366 std::string* m_pEQUALS3;
4367 aExpr* m_paExpr4;
4368 };
4369
4370 class aExprConst: public node
4371 {
4372 public:
aExprConst()4373 aExprConst()
4374 {}
~aExprConst()4375 virtual ~aExprConst() {}
4376
4377 };
4378
4379 class aExprConst_ICONST : public aExprConst
4380 {
4381 public:
aExprConst_ICONST(std::string * pNewICONST1)4382 aExprConst_ICONST(
4383 std::string* pNewICONST1
4384 )
4385 : aExprConst()
4386 , m_pICONST1(pNewICONST1)
4387 {}
4388
4389 virtual ~aExprConst_ICONST();
4390
accept(Visitor * v)4391 void accept( Visitor* v ) const
4392 {
4393 v->visit_aExprConst_ICONST( this );
4394 }
4395
4396 std::string* m_pICONST1;
4397 };
4398
4399 class aExprConst_FCONST : public aExprConst
4400 {
4401 public:
aExprConst_FCONST(std::string * pNewFCONST1)4402 aExprConst_FCONST(
4403 std::string* pNewFCONST1
4404 )
4405 : aExprConst()
4406 , m_pFCONST1(pNewFCONST1)
4407 {}
4408
4409 virtual ~aExprConst_FCONST();
4410
accept(Visitor * v)4411 void accept( Visitor* v ) const
4412 {
4413 v->visit_aExprConst_FCONST( this );
4414 }
4415
4416 std::string* m_pFCONST1;
4417 };
4418
4419 class aExprConst_SCONST : public aExprConst
4420 {
4421 public:
aExprConst_SCONST(std::string * pNewSCONST1)4422 aExprConst_SCONST(
4423 std::string* pNewSCONST1
4424 )
4425 : aExprConst()
4426 , m_pSCONST1(pNewSCONST1)
4427 {}
4428
4429 virtual ~aExprConst_SCONST();
4430
accept(Visitor * v)4431 void accept( Visitor* v ) const
4432 {
4433 v->visit_aExprConst_SCONST( this );
4434 }
4435
4436 std::string* m_pSCONST1;
4437 };
4438
4439 class aExprConst_BITCONST : public aExprConst
4440 {
4441 public:
aExprConst_BITCONST(std::string * pNewBITCONST1)4442 aExprConst_BITCONST(
4443 std::string* pNewBITCONST1
4444 )
4445 : aExprConst()
4446 , m_pBITCONST1(pNewBITCONST1)
4447 {}
4448
4449 virtual ~aExprConst_BITCONST();
4450
accept(Visitor * v)4451 void accept( Visitor* v ) const
4452 {
4453 v->visit_aExprConst_BITCONST( this );
4454 }
4455
4456 std::string* m_pBITCONST1;
4457 };
4458
4459 class aExprConst_HEXCONST : public aExprConst
4460 {
4461 public:
aExprConst_HEXCONST(std::string * pNewHEXCONST1)4462 aExprConst_HEXCONST(
4463 std::string* pNewHEXCONST1
4464 )
4465 : aExprConst()
4466 , m_pHEXCONST1(pNewHEXCONST1)
4467 {}
4468
4469 virtual ~aExprConst_HEXCONST();
4470
accept(Visitor * v)4471 void accept( Visitor* v ) const
4472 {
4473 v->visit_aExprConst_HEXCONST( this );
4474 }
4475
4476 std::string* m_pHEXCONST1;
4477 };
4478
4479 class aExprConst_TRUEP : public aExprConst
4480 {
4481 public:
aExprConst_TRUEP(std::string * pNewTRUEP1)4482 aExprConst_TRUEP(
4483 std::string* pNewTRUEP1
4484 )
4485 : aExprConst()
4486 , m_pTRUEP1(pNewTRUEP1)
4487 {}
4488
4489 virtual ~aExprConst_TRUEP();
4490
accept(Visitor * v)4491 void accept( Visitor* v ) const
4492 {
4493 v->visit_aExprConst_TRUEP( this );
4494 }
4495
4496 std::string* m_pTRUEP1;
4497 };
4498
4499 class aExprConst_FALSEP : public aExprConst
4500 {
4501 public:
aExprConst_FALSEP(std::string * pNewFALSEP1)4502 aExprConst_FALSEP(
4503 std::string* pNewFALSEP1
4504 )
4505 : aExprConst()
4506 , m_pFALSEP1(pNewFALSEP1)
4507 {}
4508
4509 virtual ~aExprConst_FALSEP();
4510
accept(Visitor * v)4511 void accept( Visitor* v ) const
4512 {
4513 v->visit_aExprConst_FALSEP( this );
4514 }
4515
4516 std::string* m_pFALSEP1;
4517 };
4518
4519 class aExprConst_NULLP : public aExprConst
4520 {
4521 public:
aExprConst_NULLP(std::string * pNewNULLP1)4522 aExprConst_NULLP(
4523 std::string* pNewNULLP1
4524 )
4525 : aExprConst()
4526 , m_pNULLP1(pNewNULLP1)
4527 {}
4528
4529 virtual ~aExprConst_NULLP();
4530
accept(Visitor * v)4531 void accept( Visitor* v ) const
4532 {
4533 v->visit_aExprConst_NULLP( this );
4534 }
4535
4536 std::string* m_pNULLP1;
4537 };
4538
~stmt_selectStmt_optSemicolon()4539 inline stmt_selectStmt_optSemicolon::~stmt_selectStmt_optSemicolon()
4540 {
4541 delete m_pselectStmt1;
4542 delete m_poptSemicolon2;
4543 }
4544
~stmt_updateStmt_optSemicolon()4545 inline stmt_updateStmt_optSemicolon::~stmt_updateStmt_optSemicolon()
4546 {
4547 delete m_pupdateStmt1;
4548 delete m_poptSemicolon2;
4549 }
4550
~stmt_insertStmt_optSemicolon()4551 inline stmt_insertStmt_optSemicolon::~stmt_insertStmt_optSemicolon()
4552 {
4553 delete m_pinsertStmt1;
4554 delete m_poptSemicolon2;
4555 }
4556
~stmt_deleteStmt_optSemicolon()4557 inline stmt_deleteStmt_optSemicolon::~stmt_deleteStmt_optSemicolon()
4558 {
4559 delete m_pdeleteStmt1;
4560 delete m_poptSemicolon2;
4561 }
4562
~optSemicolon_empty()4563 inline optSemicolon_empty::~optSemicolon_empty()
4564 {
4565 }
4566
~optSemicolon_SEMICOLON()4567 inline optSemicolon_SEMICOLON::~optSemicolon_SEMICOLON()
4568 {
4569 delete m_pSEMICOLON1;
4570 }
4571
~insertStmt()4572 inline insertStmt::~insertStmt()
4573 {
4574 delete m_pINSERT1;
4575 delete m_pINTO2;
4576 delete m_pstrRelationName3;
4577 delete m_pinsertRest4;
4578 }
4579
~insertRest_VALUES_LEFTPAREN_targetList_RIGHTPAREN()4580 inline insertRest_VALUES_LEFTPAREN_targetList_RIGHTPAREN::~insertRest_VALUES_LEFTPAREN_targetList_RIGHTPAREN()
4581 {
4582 delete m_pVALUES1;
4583 delete m_pLEFTPAREN2;
4584 while(!m_ptargetList3->empty())
4585 {
4586 delete m_ptargetList3->front();
4587 m_ptargetList3->pop_front();
4588 }
4589 delete m_ptargetList3;
4590 delete m_pRIGHTPAREN4;
4591 }
4592
~insertRest_DEFAULT_VALUES()4593 inline insertRest_DEFAULT_VALUES::~insertRest_DEFAULT_VALUES()
4594 {
4595 delete m_pDEFAULT1;
4596 delete m_pVALUES2;
4597 }
4598
~insertRest_LEFTPAREN_columnList_RIGHTPAREN_VALUES_LEFTPAREN_targetList_RIGHTPAREN()4599 inline insertRest_LEFTPAREN_columnList_RIGHTPAREN_VALUES_LEFTPAREN_targetList_RIGHTPAREN::~insertRest_LEFTPAREN_columnList_RIGHTPAREN_VALUES_LEFTPAREN_targetList_RIGHTPAREN()
4600 {
4601 delete m_pLEFTPAREN1;
4602 while(!m_pcolumnList2->empty())
4603 {
4604 delete m_pcolumnList2->front();
4605 m_pcolumnList2->pop_front();
4606 }
4607 delete m_pcolumnList2;
4608 delete m_pRIGHTPAREN3;
4609 delete m_pVALUES4;
4610 delete m_pLEFTPAREN5;
4611 while(!m_ptargetList6->empty())
4612 {
4613 delete m_ptargetList6->front();
4614 m_ptargetList6->pop_front();
4615 }
4616 delete m_ptargetList6;
4617 delete m_pRIGHTPAREN7;
4618 }
4619
~deleteStmt()4620 inline deleteStmt::~deleteStmt()
4621 {
4622 delete m_pDELETE1;
4623 delete m_pFROM2;
4624 delete m_pstrRelationName3;
4625 delete m_poptWhereClause4;
4626 }
4627
~updateStmt()4628 inline updateStmt::~updateStmt()
4629 {
4630 delete m_pUPDATE1;
4631 delete m_pstrRelationName2;
4632 delete m_pSET3;
4633 while(!m_pupdateTargetList4->empty())
4634 {
4635 delete m_pupdateTargetList4->front();
4636 m_pupdateTargetList4->pop_front();
4637 }
4638 delete m_pupdateTargetList4;
4639 delete m_poptWhereClause5;
4640 }
4641
~selectStmt()4642 inline selectStmt::~selectStmt()
4643 {
4644 delete m_pSELECT1;
4645 delete m_poptDistinct2;
4646 while(!m_ptargetList3->empty())
4647 {
4648 delete m_ptargetList3->front();
4649 m_ptargetList3->pop_front();
4650 }
4651 delete m_ptargetList3;
4652 delete m_poptFromClause4;
4653 delete m_poptWhereClause5;
4654 delete m_poptGroupClause6;
4655 delete m_poptHavingClause7;
4656 delete m_poptSortClause8;
4657 }
4658
~exprSeq_aExpr()4659 inline exprSeq_aExpr::~exprSeq_aExpr()
4660 {
4661 delete m_paExpr1;
4662 }
4663
~exprSeq_exprSeq_COMMA_aExpr()4664 inline exprSeq_exprSeq_COMMA_aExpr::~exprSeq_exprSeq_COMMA_aExpr()
4665 {
4666 delete m_pexprSeq1;
4667 delete m_pCOMMA2;
4668 delete m_paExpr3;
4669 }
4670
~exprSeq_exprSeq_USING_aExpr()4671 inline exprSeq_exprSeq_USING_aExpr::~exprSeq_exprSeq_USING_aExpr()
4672 {
4673 delete m_pexprSeq1;
4674 delete m_pUSING2;
4675 delete m_paExpr3;
4676 }
4677
~optDistinct_empty()4678 inline optDistinct_empty::~optDistinct_empty()
4679 {
4680 }
4681
~optDistinct_DISTINCT()4682 inline optDistinct_DISTINCT::~optDistinct_DISTINCT()
4683 {
4684 delete m_pDISTINCT1;
4685 }
4686
~optDistinct_DISTINCT_ON_LEFTPAREN_exprSeq_RIGHTPAREN()4687 inline optDistinct_DISTINCT_ON_LEFTPAREN_exprSeq_RIGHTPAREN::~optDistinct_DISTINCT_ON_LEFTPAREN_exprSeq_RIGHTPAREN()
4688 {
4689 delete m_pDISTINCT1;
4690 delete m_pON2;
4691 delete m_pLEFTPAREN3;
4692 delete m_pexprSeq4;
4693 delete m_pRIGHTPAREN5;
4694 }
4695
~optDistinct_ALL()4696 inline optDistinct_ALL::~optDistinct_ALL()
4697 {
4698 delete m_pALL1;
4699 }
4700
~sortClause()4701 inline sortClause::~sortClause()
4702 {
4703 delete m_pORDER1;
4704 delete m_pBY2;
4705 while(!m_psortbyList3->empty())
4706 {
4707 delete m_psortbyList3->front();
4708 m_psortbyList3->pop_front();
4709 }
4710 delete m_psortbyList3;
4711 }
4712
~optSortClause_empty()4713 inline optSortClause_empty::~optSortClause_empty()
4714 {
4715 }
4716
~optSortClause_sortClause()4717 inline optSortClause_sortClause::~optSortClause_sortClause()
4718 {
4719 delete m_psortClause1;
4720 }
4721
~sortby()4722 inline sortby::~sortby()
4723 {
4724 delete m_paExpr1;
4725 delete m_pstrOptOrderSpecification2;
4726 }
4727
~optGroupClause_empty()4728 inline optGroupClause_empty::~optGroupClause_empty()
4729 {
4730 }
4731
~optGroupClause_GROUP_BY_exprSeq()4732 inline optGroupClause_GROUP_BY_exprSeq::~optGroupClause_GROUP_BY_exprSeq()
4733 {
4734 delete m_pGROUP1;
4735 delete m_pBY2;
4736 delete m_pexprSeq3;
4737 }
4738
~optHavingClause_empty()4739 inline optHavingClause_empty::~optHavingClause_empty()
4740 {
4741 }
4742
~optHavingClause_HAVING_aExpr()4743 inline optHavingClause_HAVING_aExpr::~optHavingClause_HAVING_aExpr()
4744 {
4745 delete m_pHAVING1;
4746 delete m_paExpr2;
4747 }
4748
~optFromClause_empty()4749 inline optFromClause_empty::~optFromClause_empty()
4750 {
4751 }
4752
~optFromClause_FROM_fromList()4753 inline optFromClause_FROM_fromList::~optFromClause_FROM_fromList()
4754 {
4755 delete m_pFROM1;
4756 while(!m_pfromList2->empty())
4757 {
4758 delete m_pfromList2->front();
4759 m_pfromList2->pop_front();
4760 }
4761 delete m_pfromList2;
4762 }
4763
~tableRef_relationExpr()4764 inline tableRef_relationExpr::~tableRef_relationExpr()
4765 {
4766 delete m_prelationExpr1;
4767 }
4768
~tableRef_relationExpr_aliasClause()4769 inline tableRef_relationExpr_aliasClause::~tableRef_relationExpr_aliasClause()
4770 {
4771 delete m_prelationExpr1;
4772 delete m_paliasClause2;
4773 }
4774
~tableRef_joinedTable()4775 inline tableRef_joinedTable::~tableRef_joinedTable()
4776 {
4777 delete m_pjoinedTable1;
4778 }
4779
~tableRef_LEFTPAREN_joinedTable_RIGHTPAREN_aliasClause()4780 inline tableRef_LEFTPAREN_joinedTable_RIGHTPAREN_aliasClause::~tableRef_LEFTPAREN_joinedTable_RIGHTPAREN_aliasClause()
4781 {
4782 delete m_pLEFTPAREN1;
4783 delete m_pjoinedTable2;
4784 delete m_pRIGHTPAREN3;
4785 delete m_paliasClause4;
4786 }
4787
~joinedTable_LEFTPAREN_joinedTable_RIGHTPAREN()4788 inline joinedTable_LEFTPAREN_joinedTable_RIGHTPAREN::~joinedTable_LEFTPAREN_joinedTable_RIGHTPAREN()
4789 {
4790 delete m_pLEFTPAREN1;
4791 delete m_pjoinedTable2;
4792 delete m_pRIGHTPAREN3;
4793 }
4794
~joinedTable_tableRef_CROSS_JOIN_tableRef()4795 inline joinedTable_tableRef_CROSS_JOIN_tableRef::~joinedTable_tableRef_CROSS_JOIN_tableRef()
4796 {
4797 delete m_ptableRef1;
4798 delete m_pCROSS2;
4799 delete m_pJOIN3;
4800 delete m_ptableRef4;
4801 }
4802
~joinedTable_tableRef_UNIONJOIN_tableRef()4803 inline joinedTable_tableRef_UNIONJOIN_tableRef::~joinedTable_tableRef_UNIONJOIN_tableRef()
4804 {
4805 delete m_ptableRef1;
4806 delete m_pUNIONJOIN2;
4807 delete m_ptableRef3;
4808 }
4809
~joinedTable_tableRef_joinType_JOIN_tableRef_joinQual()4810 inline joinedTable_tableRef_joinType_JOIN_tableRef_joinQual::~joinedTable_tableRef_joinType_JOIN_tableRef_joinQual()
4811 {
4812 delete m_ptableRef1;
4813 delete m_pjoinType2;
4814 delete m_pJOIN3;
4815 delete m_ptableRef4;
4816 delete m_pjoinQual5;
4817 }
4818
~joinedTable_tableRef_JOIN_tableRef_joinQual()4819 inline joinedTable_tableRef_JOIN_tableRef_joinQual::~joinedTable_tableRef_JOIN_tableRef_joinQual()
4820 {
4821 delete m_ptableRef1;
4822 delete m_pJOIN2;
4823 delete m_ptableRef3;
4824 delete m_pjoinQual4;
4825 }
4826
~joinedTable_tableRef_NATURAL_joinType_JOIN_tableRef()4827 inline joinedTable_tableRef_NATURAL_joinType_JOIN_tableRef::~joinedTable_tableRef_NATURAL_joinType_JOIN_tableRef()
4828 {
4829 delete m_ptableRef1;
4830 delete m_pNATURAL2;
4831 delete m_pjoinType3;
4832 delete m_pJOIN4;
4833 delete m_ptableRef5;
4834 }
4835
~joinedTable_tableRef_NATURAL_JOIN_tableRef()4836 inline joinedTable_tableRef_NATURAL_JOIN_tableRef::~joinedTable_tableRef_NATURAL_JOIN_tableRef()
4837 {
4838 delete m_ptableRef1;
4839 delete m_pNATURAL2;
4840 delete m_pJOIN3;
4841 delete m_ptableRef4;
4842 }
4843
~aliasClause_AS_strColId_LEFTPAREN_nameList_RIGHTPAREN()4844 inline aliasClause_AS_strColId_LEFTPAREN_nameList_RIGHTPAREN::~aliasClause_AS_strColId_LEFTPAREN_nameList_RIGHTPAREN()
4845 {
4846 delete m_pAS1;
4847 delete m_pstrColId2;
4848 delete m_pLEFTPAREN3;
4849 while(!m_pnameList4->empty())
4850 {
4851 delete m_pnameList4->front();
4852 m_pnameList4->pop_front();
4853 }
4854 delete m_pnameList4;
4855 delete m_pRIGHTPAREN5;
4856 }
4857
~aliasClause_AS_strColId()4858 inline aliasClause_AS_strColId::~aliasClause_AS_strColId()
4859 {
4860 delete m_pAS1;
4861 delete m_pstrColId2;
4862 }
4863
~aliasClause_strColId_LEFTPAREN_nameList_RIGHTPAREN()4864 inline aliasClause_strColId_LEFTPAREN_nameList_RIGHTPAREN::~aliasClause_strColId_LEFTPAREN_nameList_RIGHTPAREN()
4865 {
4866 delete m_pstrColId1;
4867 delete m_pLEFTPAREN2;
4868 while(!m_pnameList3->empty())
4869 {
4870 delete m_pnameList3->front();
4871 m_pnameList3->pop_front();
4872 }
4873 delete m_pnameList3;
4874 delete m_pRIGHTPAREN4;
4875 }
4876
~aliasClause_strColId()4877 inline aliasClause_strColId::~aliasClause_strColId()
4878 {
4879 delete m_pstrColId1;
4880 }
4881
~joinType_FULL_strOptJoinOuter()4882 inline joinType_FULL_strOptJoinOuter::~joinType_FULL_strOptJoinOuter()
4883 {
4884 delete m_pFULL1;
4885 delete m_pstrOptJoinOuter2;
4886 }
4887
~joinType_LEFT_strOptJoinOuter()4888 inline joinType_LEFT_strOptJoinOuter::~joinType_LEFT_strOptJoinOuter()
4889 {
4890 delete m_pLEFT1;
4891 delete m_pstrOptJoinOuter2;
4892 }
4893
~joinType_RIGHT_strOptJoinOuter()4894 inline joinType_RIGHT_strOptJoinOuter::~joinType_RIGHT_strOptJoinOuter()
4895 {
4896 delete m_pRIGHT1;
4897 delete m_pstrOptJoinOuter2;
4898 }
4899
~joinType_INNERP()4900 inline joinType_INNERP::~joinType_INNERP()
4901 {
4902 delete m_pINNERP1;
4903 }
4904
~joinQual_USING_LEFTPAREN_nameList_RIGHTPAREN()4905 inline joinQual_USING_LEFTPAREN_nameList_RIGHTPAREN::~joinQual_USING_LEFTPAREN_nameList_RIGHTPAREN()
4906 {
4907 delete m_pUSING1;
4908 delete m_pLEFTPAREN2;
4909 while(!m_pnameList3->empty())
4910 {
4911 delete m_pnameList3->front();
4912 m_pnameList3->pop_front();
4913 }
4914 delete m_pnameList3;
4915 delete m_pRIGHTPAREN4;
4916 }
4917
~joinQual_ON_aExpr()4918 inline joinQual_ON_aExpr::~joinQual_ON_aExpr()
4919 {
4920 delete m_pON1;
4921 delete m_paExpr2;
4922 }
4923
~relationExpr_strRelationName()4924 inline relationExpr_strRelationName::~relationExpr_strRelationName()
4925 {
4926 delete m_pstrRelationName1;
4927 }
4928
~relationExpr_strRelationName_ASTERISK()4929 inline relationExpr_strRelationName_ASTERISK::~relationExpr_strRelationName_ASTERISK()
4930 {
4931 delete m_pstrRelationName1;
4932 delete m_pASTERISK2;
4933 }
4934
~relationExpr_ONLY_strRelationName()4935 inline relationExpr_ONLY_strRelationName::~relationExpr_ONLY_strRelationName()
4936 {
4937 delete m_pONLY1;
4938 delete m_pstrRelationName2;
4939 }
4940
~optWhereClause_empty()4941 inline optWhereClause_empty::~optWhereClause_empty()
4942 {
4943 }
4944
~optWhereClause_WHERE_aExpr()4945 inline optWhereClause_WHERE_aExpr::~optWhereClause_WHERE_aExpr()
4946 {
4947 delete m_pWHERE1;
4948 delete m_paExpr2;
4949 }
4950
~rowExpr()4951 inline rowExpr::~rowExpr()
4952 {
4953 delete m_pLEFTPAREN1;
4954 delete m_prowDescriptor2;
4955 delete m_pRIGHTPAREN3;
4956 delete m_pstrAllOp4;
4957 delete m_pLEFTPAREN5;
4958 delete m_prowDescriptor6;
4959 delete m_pRIGHTPAREN7;
4960 }
4961
~rowDescriptor()4962 inline rowDescriptor::~rowDescriptor()
4963 {
4964 while(!m_prowList1->empty())
4965 {
4966 delete m_prowList1->front();
4967 m_prowList1->pop_front();
4968 }
4969 delete m_prowList1;
4970 delete m_pCOMMA2;
4971 delete m_paExpr3;
4972 }
4973
~aExpr_cExpr()4974 inline aExpr_cExpr::~aExpr_cExpr()
4975 {
4976 delete m_pcExpr1;
4977 }
4978
~aExpr_aExpr_AT_TIME_ZONE_cExpr()4979 inline aExpr_aExpr_AT_TIME_ZONE_cExpr::~aExpr_aExpr_AT_TIME_ZONE_cExpr()
4980 {
4981 delete m_paExpr1;
4982 delete m_pAT2;
4983 delete m_pTIME3;
4984 delete m_pZONE4;
4985 delete m_pcExpr5;
4986 }
4987
~aExpr_PLUS_aExpr()4988 inline aExpr_PLUS_aExpr::~aExpr_PLUS_aExpr()
4989 {
4990 delete m_pPLUS1;
4991 delete m_paExpr2;
4992 }
4993
~aExpr_MINUS_aExpr()4994 inline aExpr_MINUS_aExpr::~aExpr_MINUS_aExpr()
4995 {
4996 delete m_pMINUS1;
4997 delete m_paExpr2;
4998 }
4999
~aExpr_BITINVERT_aExpr()5000 inline aExpr_BITINVERT_aExpr::~aExpr_BITINVERT_aExpr()
5001 {
5002 delete m_pBITINVERT1;
5003 delete m_paExpr2;
5004 }
5005
~aExpr_aExpr_PLUS_aExpr()5006 inline aExpr_aExpr_PLUS_aExpr::~aExpr_aExpr_PLUS_aExpr()
5007 {
5008 delete m_paExpr1;
5009 delete m_pPLUS2;
5010 delete m_paExpr3;
5011 }
5012
~aExpr_aExpr_MINUS_aExpr()5013 inline aExpr_aExpr_MINUS_aExpr::~aExpr_aExpr_MINUS_aExpr()
5014 {
5015 delete m_paExpr1;
5016 delete m_pMINUS2;
5017 delete m_paExpr3;
5018 }
5019
~aExpr_aExpr_ASTERISK_aExpr()5020 inline aExpr_aExpr_ASTERISK_aExpr::~aExpr_aExpr_ASTERISK_aExpr()
5021 {
5022 delete m_paExpr1;
5023 delete m_pASTERISK2;
5024 delete m_paExpr3;
5025 }
5026
~aExpr_aExpr_SOLIDUS_aExpr()5027 inline aExpr_aExpr_SOLIDUS_aExpr::~aExpr_aExpr_SOLIDUS_aExpr()
5028 {
5029 delete m_paExpr1;
5030 delete m_pSOLIDUS2;
5031 delete m_paExpr3;
5032 }
5033
~aExpr_aExpr_PERCENT_aExpr()5034 inline aExpr_aExpr_PERCENT_aExpr::~aExpr_aExpr_PERCENT_aExpr()
5035 {
5036 delete m_paExpr1;
5037 delete m_pPERCENT2;
5038 delete m_paExpr3;
5039 }
5040
~aExpr_aExpr_BITAND_aExpr()5041 inline aExpr_aExpr_BITAND_aExpr::~aExpr_aExpr_BITAND_aExpr()
5042 {
5043 delete m_paExpr1;
5044 delete m_pBITAND2;
5045 delete m_paExpr3;
5046 }
5047
~aExpr_aExpr_BITOR_aExpr()5048 inline aExpr_aExpr_BITOR_aExpr::~aExpr_aExpr_BITOR_aExpr()
5049 {
5050 delete m_paExpr1;
5051 delete m_pBITOR2;
5052 delete m_paExpr3;
5053 }
5054
~aExpr_aExpr_BITSHIFTLEFT_aExpr()5055 inline aExpr_aExpr_BITSHIFTLEFT_aExpr::~aExpr_aExpr_BITSHIFTLEFT_aExpr()
5056 {
5057 delete m_paExpr1;
5058 delete m_pBITSHIFTLEFT2;
5059 delete m_paExpr3;
5060 }
5061
~aExpr_aExpr_BITSHIFTRIGHT_aExpr()5062 inline aExpr_aExpr_BITSHIFTRIGHT_aExpr::~aExpr_aExpr_BITSHIFTRIGHT_aExpr()
5063 {
5064 delete m_paExpr1;
5065 delete m_pBITSHIFTRIGHT2;
5066 delete m_paExpr3;
5067 }
5068
~aExpr_aExpr_LESSTHAN_aExpr()5069 inline aExpr_aExpr_LESSTHAN_aExpr::~aExpr_aExpr_LESSTHAN_aExpr()
5070 {
5071 delete m_paExpr1;
5072 delete m_pLESSTHAN2;
5073 delete m_paExpr3;
5074 }
5075
~aExpr_aExpr_LESSTHANOREQUALS_aExpr()5076 inline aExpr_aExpr_LESSTHANOREQUALS_aExpr::~aExpr_aExpr_LESSTHANOREQUALS_aExpr()
5077 {
5078 delete m_paExpr1;
5079 delete m_pLESSTHANOREQUALS2;
5080 delete m_paExpr3;
5081 }
5082
~aExpr_aExpr_GREATERTHAN_aExpr()5083 inline aExpr_aExpr_GREATERTHAN_aExpr::~aExpr_aExpr_GREATERTHAN_aExpr()
5084 {
5085 delete m_paExpr1;
5086 delete m_pGREATERTHAN2;
5087 delete m_paExpr3;
5088 }
5089
~aExpr_aExpr_GREATERTHANOREQUALS_aExpr()5090 inline aExpr_aExpr_GREATERTHANOREQUALS_aExpr::~aExpr_aExpr_GREATERTHANOREQUALS_aExpr()
5091 {
5092 delete m_paExpr1;
5093 delete m_pGREATERTHANOREQUALS2;
5094 delete m_paExpr3;
5095 }
5096
~aExpr_aExpr_EQUALS_aExpr()5097 inline aExpr_aExpr_EQUALS_aExpr::~aExpr_aExpr_EQUALS_aExpr()
5098 {
5099 delete m_paExpr1;
5100 delete m_pEQUALS2;
5101 delete m_paExpr3;
5102 }
5103
~aExpr_aExpr_NOTEQUALS_aExpr()5104 inline aExpr_aExpr_NOTEQUALS_aExpr::~aExpr_aExpr_NOTEQUALS_aExpr()
5105 {
5106 delete m_paExpr1;
5107 delete m_pNOTEQUALS2;
5108 delete m_paExpr3;
5109 }
5110
~aExpr_aExpr_AND_aExpr()5111 inline aExpr_aExpr_AND_aExpr::~aExpr_aExpr_AND_aExpr()
5112 {
5113 delete m_paExpr1;
5114 delete m_pAND2;
5115 delete m_paExpr3;
5116 }
5117
~aExpr_aExpr_OR_aExpr()5118 inline aExpr_aExpr_OR_aExpr::~aExpr_aExpr_OR_aExpr()
5119 {
5120 delete m_paExpr1;
5121 delete m_pOR2;
5122 delete m_paExpr3;
5123 }
5124
~aExpr_NOT_aExpr()5125 inline aExpr_NOT_aExpr::~aExpr_NOT_aExpr()
5126 {
5127 delete m_pNOT1;
5128 delete m_paExpr2;
5129 }
5130
~aExpr_aExpr_CONCATENATION_aExpr()5131 inline aExpr_aExpr_CONCATENATION_aExpr::~aExpr_aExpr_CONCATENATION_aExpr()
5132 {
5133 delete m_paExpr1;
5134 delete m_pCONCATENATION2;
5135 delete m_paExpr3;
5136 }
5137
~aExpr_aExpr_LIKE_aExpr()5138 inline aExpr_aExpr_LIKE_aExpr::~aExpr_aExpr_LIKE_aExpr()
5139 {
5140 delete m_paExpr1;
5141 delete m_pLIKE2;
5142 delete m_paExpr3;
5143 }
5144
~aExpr_aExpr_LIKE_aExpr_ESCAPE_aExpr()5145 inline aExpr_aExpr_LIKE_aExpr_ESCAPE_aExpr::~aExpr_aExpr_LIKE_aExpr_ESCAPE_aExpr()
5146 {
5147 delete m_paExpr1;
5148 delete m_pLIKE2;
5149 delete m_paExpr3;
5150 delete m_pESCAPE4;
5151 delete m_paExpr5;
5152 }
5153
~aExpr_aExpr_NOT_LIKE_aExpr()5154 inline aExpr_aExpr_NOT_LIKE_aExpr::~aExpr_aExpr_NOT_LIKE_aExpr()
5155 {
5156 delete m_paExpr1;
5157 delete m_pNOT2;
5158 delete m_pLIKE3;
5159 delete m_paExpr4;
5160 }
5161
~aExpr_aExpr_NOT_LIKE_aExpr_ESCAPE_aExpr()5162 inline aExpr_aExpr_NOT_LIKE_aExpr_ESCAPE_aExpr::~aExpr_aExpr_NOT_LIKE_aExpr_ESCAPE_aExpr()
5163 {
5164 delete m_paExpr1;
5165 delete m_pNOT2;
5166 delete m_pLIKE3;
5167 delete m_paExpr4;
5168 delete m_pESCAPE5;
5169 delete m_paExpr6;
5170 }
5171
~aExpr_aExpr_ISNULL()5172 inline aExpr_aExpr_ISNULL::~aExpr_aExpr_ISNULL()
5173 {
5174 delete m_paExpr1;
5175 delete m_pISNULL2;
5176 }
5177
~aExpr_aExpr_IS_NULLP()5178 inline aExpr_aExpr_IS_NULLP::~aExpr_aExpr_IS_NULLP()
5179 {
5180 delete m_paExpr1;
5181 delete m_pIS2;
5182 delete m_pNULLP3;
5183 }
5184
~aExpr_aExpr_NOTNULL()5185 inline aExpr_aExpr_NOTNULL::~aExpr_aExpr_NOTNULL()
5186 {
5187 delete m_paExpr1;
5188 delete m_pNOTNULL2;
5189 }
5190
~aExpr_aExpr_IS_NOT_NULLP()5191 inline aExpr_aExpr_IS_NOT_NULLP::~aExpr_aExpr_IS_NOT_NULLP()
5192 {
5193 delete m_paExpr1;
5194 delete m_pIS2;
5195 delete m_pNOT3;
5196 delete m_pNULLP4;
5197 }
5198
~aExpr_aExpr_IS_TRUEP()5199 inline aExpr_aExpr_IS_TRUEP::~aExpr_aExpr_IS_TRUEP()
5200 {
5201 delete m_paExpr1;
5202 delete m_pIS2;
5203 delete m_pTRUEP3;
5204 }
5205
~aExpr_aExpr_IS_NOT_FALSEP()5206 inline aExpr_aExpr_IS_NOT_FALSEP::~aExpr_aExpr_IS_NOT_FALSEP()
5207 {
5208 delete m_paExpr1;
5209 delete m_pIS2;
5210 delete m_pNOT3;
5211 delete m_pFALSEP4;
5212 }
5213
~aExpr_aExpr_IS_FALSEP()5214 inline aExpr_aExpr_IS_FALSEP::~aExpr_aExpr_IS_FALSEP()
5215 {
5216 delete m_paExpr1;
5217 delete m_pIS2;
5218 delete m_pFALSEP3;
5219 }
5220
~aExpr_aExpr_IS_NOT_TRUEP()5221 inline aExpr_aExpr_IS_NOT_TRUEP::~aExpr_aExpr_IS_NOT_TRUEP()
5222 {
5223 delete m_paExpr1;
5224 delete m_pIS2;
5225 delete m_pNOT3;
5226 delete m_pTRUEP4;
5227 }
5228
~aExpr_rowExpr()5229 inline aExpr_rowExpr::~aExpr_rowExpr()
5230 {
5231 delete m_prowExpr1;
5232 }
5233
~bExpr_cExpr()5234 inline bExpr_cExpr::~bExpr_cExpr()
5235 {
5236 delete m_pcExpr1;
5237 }
5238
~bExpr_PLUS_bExpr()5239 inline bExpr_PLUS_bExpr::~bExpr_PLUS_bExpr()
5240 {
5241 delete m_pPLUS1;
5242 delete m_pbExpr2;
5243 }
5244
~bExpr_MINUS_bExpr()5245 inline bExpr_MINUS_bExpr::~bExpr_MINUS_bExpr()
5246 {
5247 delete m_pMINUS1;
5248 delete m_pbExpr2;
5249 }
5250
~bExpr_BITINVERT_bExpr()5251 inline bExpr_BITINVERT_bExpr::~bExpr_BITINVERT_bExpr()
5252 {
5253 delete m_pBITINVERT1;
5254 delete m_pbExpr2;
5255 }
5256
~bExpr_bExpr_PLUS_bExpr()5257 inline bExpr_bExpr_PLUS_bExpr::~bExpr_bExpr_PLUS_bExpr()
5258 {
5259 delete m_pbExpr1;
5260 delete m_pPLUS2;
5261 delete m_pbExpr3;
5262 }
5263
~bExpr_bExpr_MINUS_bExpr()5264 inline bExpr_bExpr_MINUS_bExpr::~bExpr_bExpr_MINUS_bExpr()
5265 {
5266 delete m_pbExpr1;
5267 delete m_pMINUS2;
5268 delete m_pbExpr3;
5269 }
5270
~bExpr_bExpr_ASTERISK_bExpr()5271 inline bExpr_bExpr_ASTERISK_bExpr::~bExpr_bExpr_ASTERISK_bExpr()
5272 {
5273 delete m_pbExpr1;
5274 delete m_pASTERISK2;
5275 delete m_pbExpr3;
5276 }
5277
~bExpr_bExpr_SOLIDUS_bExpr()5278 inline bExpr_bExpr_SOLIDUS_bExpr::~bExpr_bExpr_SOLIDUS_bExpr()
5279 {
5280 delete m_pbExpr1;
5281 delete m_pSOLIDUS2;
5282 delete m_pbExpr3;
5283 }
5284
~bExpr_bExpr_PERCENT_bExpr()5285 inline bExpr_bExpr_PERCENT_bExpr::~bExpr_bExpr_PERCENT_bExpr()
5286 {
5287 delete m_pbExpr1;
5288 delete m_pPERCENT2;
5289 delete m_pbExpr3;
5290 }
5291
~bExpr_bExpr_BITAND_bExpr()5292 inline bExpr_bExpr_BITAND_bExpr::~bExpr_bExpr_BITAND_bExpr()
5293 {
5294 delete m_pbExpr1;
5295 delete m_pBITAND2;
5296 delete m_pbExpr3;
5297 }
5298
~bExpr_bExpr_BITOR_bExpr()5299 inline bExpr_bExpr_BITOR_bExpr::~bExpr_bExpr_BITOR_bExpr()
5300 {
5301 delete m_pbExpr1;
5302 delete m_pBITOR2;
5303 delete m_pbExpr3;
5304 }
5305
~bExpr_bExpr_BITSHIFTLEFT_bExpr()5306 inline bExpr_bExpr_BITSHIFTLEFT_bExpr::~bExpr_bExpr_BITSHIFTLEFT_bExpr()
5307 {
5308 delete m_pbExpr1;
5309 delete m_pBITSHIFTLEFT2;
5310 delete m_pbExpr3;
5311 }
5312
~bExpr_bExpr_BITSHIFTRIGHT_bExpr()5313 inline bExpr_bExpr_BITSHIFTRIGHT_bExpr::~bExpr_bExpr_BITSHIFTRIGHT_bExpr()
5314 {
5315 delete m_pbExpr1;
5316 delete m_pBITSHIFTRIGHT2;
5317 delete m_pbExpr3;
5318 }
5319
~bExpr_bExpr_LESSTHAN_bExpr()5320 inline bExpr_bExpr_LESSTHAN_bExpr::~bExpr_bExpr_LESSTHAN_bExpr()
5321 {
5322 delete m_pbExpr1;
5323 delete m_pLESSTHAN2;
5324 delete m_pbExpr3;
5325 }
5326
~bExpr_bExpr_LESSTHANOREQUALS_bExpr()5327 inline bExpr_bExpr_LESSTHANOREQUALS_bExpr::~bExpr_bExpr_LESSTHANOREQUALS_bExpr()
5328 {
5329 delete m_pbExpr1;
5330 delete m_pLESSTHANOREQUALS2;
5331 delete m_pbExpr3;
5332 }
5333
~bExpr_bExpr_GREATERTHAN_bExpr()5334 inline bExpr_bExpr_GREATERTHAN_bExpr::~bExpr_bExpr_GREATERTHAN_bExpr()
5335 {
5336 delete m_pbExpr1;
5337 delete m_pGREATERTHAN2;
5338 delete m_pbExpr3;
5339 }
5340
~bExpr_bExpr_GREATERTHANOREQUALS_bExpr()5341 inline bExpr_bExpr_GREATERTHANOREQUALS_bExpr::~bExpr_bExpr_GREATERTHANOREQUALS_bExpr()
5342 {
5343 delete m_pbExpr1;
5344 delete m_pGREATERTHANOREQUALS2;
5345 delete m_pbExpr3;
5346 }
5347
~bExpr_bExpr_EQUALS_bExpr()5348 inline bExpr_bExpr_EQUALS_bExpr::~bExpr_bExpr_EQUALS_bExpr()
5349 {
5350 delete m_pbExpr1;
5351 delete m_pEQUALS2;
5352 delete m_pbExpr3;
5353 }
5354
~bExpr_bExpr_NOTEQUALS_bExpr()5355 inline bExpr_bExpr_NOTEQUALS_bExpr::~bExpr_bExpr_NOTEQUALS_bExpr()
5356 {
5357 delete m_pbExpr1;
5358 delete m_pNOTEQUALS2;
5359 delete m_pbExpr3;
5360 }
5361
~bExpr_bExpr_CONCATENATION_bExpr()5362 inline bExpr_bExpr_CONCATENATION_bExpr::~bExpr_bExpr_CONCATENATION_bExpr()
5363 {
5364 delete m_pbExpr1;
5365 delete m_pCONCATENATION2;
5366 delete m_pbExpr3;
5367 }
5368
~cExpr_attr()5369 inline cExpr_attr::~cExpr_attr()
5370 {
5371 delete m_pattr1;
5372 }
5373
~cExpr_strColId_optIndirection()5374 inline cExpr_strColId_optIndirection::~cExpr_strColId_optIndirection()
5375 {
5376 delete m_pstrColId1;
5377 delete m_poptIndirection2;
5378 }
5379
~cExpr_aExprConst()5380 inline cExpr_aExprConst::~cExpr_aExprConst()
5381 {
5382 delete m_paExprConst1;
5383 }
5384
~cExpr_LEFTPAREN_aExpr_RIGHTPAREN()5385 inline cExpr_LEFTPAREN_aExpr_RIGHTPAREN::~cExpr_LEFTPAREN_aExpr_RIGHTPAREN()
5386 {
5387 delete m_pLEFTPAREN1;
5388 delete m_paExpr2;
5389 delete m_pRIGHTPAREN3;
5390 }
5391
~cExpr_strFuncName_LEFTPAREN_RIGHTPAREN()5392 inline cExpr_strFuncName_LEFTPAREN_RIGHTPAREN::~cExpr_strFuncName_LEFTPAREN_RIGHTPAREN()
5393 {
5394 delete m_pstrFuncName1;
5395 delete m_pLEFTPAREN2;
5396 delete m_pRIGHTPAREN3;
5397 }
5398
~cExpr_strFuncName_LEFTPAREN_exprSeq_RIGHTPAREN()5399 inline cExpr_strFuncName_LEFTPAREN_exprSeq_RIGHTPAREN::~cExpr_strFuncName_LEFTPAREN_exprSeq_RIGHTPAREN()
5400 {
5401 delete m_pstrFuncName1;
5402 delete m_pLEFTPAREN2;
5403 delete m_pexprSeq3;
5404 delete m_pRIGHTPAREN4;
5405 }
5406
~cExpr_strFuncName_LEFTPAREN_ALL_exprSeq_RIGHTPAREN()5407 inline cExpr_strFuncName_LEFTPAREN_ALL_exprSeq_RIGHTPAREN::~cExpr_strFuncName_LEFTPAREN_ALL_exprSeq_RIGHTPAREN()
5408 {
5409 delete m_pstrFuncName1;
5410 delete m_pLEFTPAREN2;
5411 delete m_pALL3;
5412 delete m_pexprSeq4;
5413 delete m_pRIGHTPAREN5;
5414 }
5415
~cExpr_strFuncName_LEFTPAREN_DISTINCT_exprSeq_RIGHTPAREN()5416 inline cExpr_strFuncName_LEFTPAREN_DISTINCT_exprSeq_RIGHTPAREN::~cExpr_strFuncName_LEFTPAREN_DISTINCT_exprSeq_RIGHTPAREN()
5417 {
5418 delete m_pstrFuncName1;
5419 delete m_pLEFTPAREN2;
5420 delete m_pDISTINCT3;
5421 delete m_pexprSeq4;
5422 delete m_pRIGHTPAREN5;
5423 }
5424
~cExpr_strFuncName_LEFTPAREN_ASTERISK_RIGHTPAREN()5425 inline cExpr_strFuncName_LEFTPAREN_ASTERISK_RIGHTPAREN::~cExpr_strFuncName_LEFTPAREN_ASTERISK_RIGHTPAREN()
5426 {
5427 delete m_pstrFuncName1;
5428 delete m_pLEFTPAREN2;
5429 delete m_pASTERISK3;
5430 delete m_pRIGHTPAREN4;
5431 }
5432
~cExpr_CURRENTDATE()5433 inline cExpr_CURRENTDATE::~cExpr_CURRENTDATE()
5434 {
5435 delete m_pCURRENTDATE1;
5436 }
5437
~cExpr_CURRENTTIME()5438 inline cExpr_CURRENTTIME::~cExpr_CURRENTTIME()
5439 {
5440 delete m_pCURRENTTIME1;
5441 }
5442
~cExpr_CURRENTTIME_LEFTPAREN_ICONST_RIGHTPAREN()5443 inline cExpr_CURRENTTIME_LEFTPAREN_ICONST_RIGHTPAREN::~cExpr_CURRENTTIME_LEFTPAREN_ICONST_RIGHTPAREN()
5444 {
5445 delete m_pCURRENTTIME1;
5446 delete m_pLEFTPAREN2;
5447 delete m_pICONST3;
5448 delete m_pRIGHTPAREN4;
5449 }
5450
~cExpr_CURRENTTIMESTAMP()5451 inline cExpr_CURRENTTIMESTAMP::~cExpr_CURRENTTIMESTAMP()
5452 {
5453 delete m_pCURRENTTIMESTAMP1;
5454 }
5455
~cExpr_CURRENTTIMESTAMP_LEFTPAREN_ICONST_RIGHTPAREN()5456 inline cExpr_CURRENTTIMESTAMP_LEFTPAREN_ICONST_RIGHTPAREN::~cExpr_CURRENTTIMESTAMP_LEFTPAREN_ICONST_RIGHTPAREN()
5457 {
5458 delete m_pCURRENTTIMESTAMP1;
5459 delete m_pLEFTPAREN2;
5460 delete m_pICONST3;
5461 delete m_pRIGHTPAREN4;
5462 }
5463
~cExpr_CURRENTUSER()5464 inline cExpr_CURRENTUSER::~cExpr_CURRENTUSER()
5465 {
5466 delete m_pCURRENTUSER1;
5467 }
5468
~cExpr_SESSIONUSER()5469 inline cExpr_SESSIONUSER::~cExpr_SESSIONUSER()
5470 {
5471 delete m_pSESSIONUSER1;
5472 }
5473
~cExpr_USER()5474 inline cExpr_USER::~cExpr_USER()
5475 {
5476 delete m_pUSER1;
5477 }
5478
~cExpr_EXTRACT_LEFTPAREN_optExtract_RIGHTPAREN()5479 inline cExpr_EXTRACT_LEFTPAREN_optExtract_RIGHTPAREN::~cExpr_EXTRACT_LEFTPAREN_optExtract_RIGHTPAREN()
5480 {
5481 delete m_pEXTRACT1;
5482 delete m_pLEFTPAREN2;
5483 delete m_poptExtract3;
5484 delete m_pRIGHTPAREN4;
5485 }
5486
~cExpr_POSITION_LEFTPAREN_positionExpr_RIGHTPAREN()5487 inline cExpr_POSITION_LEFTPAREN_positionExpr_RIGHTPAREN::~cExpr_POSITION_LEFTPAREN_positionExpr_RIGHTPAREN()
5488 {
5489 delete m_pPOSITION1;
5490 delete m_pLEFTPAREN2;
5491 delete m_ppositionExpr3;
5492 delete m_pRIGHTPAREN4;
5493 }
5494
~cExpr_SUBSTRING_LEFTPAREN_optSubstrExpr_RIGHTPAREN()5495 inline cExpr_SUBSTRING_LEFTPAREN_optSubstrExpr_RIGHTPAREN::~cExpr_SUBSTRING_LEFTPAREN_optSubstrExpr_RIGHTPAREN()
5496 {
5497 delete m_pSUBSTRING1;
5498 delete m_pLEFTPAREN2;
5499 delete m_poptSubstrExpr3;
5500 delete m_pRIGHTPAREN4;
5501 }
5502
~cExpr_TRIM_LEFTPAREN_LEADING_trimExpr_RIGHTPAREN()5503 inline cExpr_TRIM_LEFTPAREN_LEADING_trimExpr_RIGHTPAREN::~cExpr_TRIM_LEFTPAREN_LEADING_trimExpr_RIGHTPAREN()
5504 {
5505 delete m_pTRIM1;
5506 delete m_pLEFTPAREN2;
5507 delete m_pLEADING3;
5508 delete m_ptrimExpr4;
5509 delete m_pRIGHTPAREN5;
5510 }
5511
~cExpr_TRIM_LEFTPAREN_TRAILING_trimExpr_RIGHTPAREN()5512 inline cExpr_TRIM_LEFTPAREN_TRAILING_trimExpr_RIGHTPAREN::~cExpr_TRIM_LEFTPAREN_TRAILING_trimExpr_RIGHTPAREN()
5513 {
5514 delete m_pTRIM1;
5515 delete m_pLEFTPAREN2;
5516 delete m_pTRAILING3;
5517 delete m_ptrimExpr4;
5518 delete m_pRIGHTPAREN5;
5519 }
5520
~cExpr_TRIM_LEFTPAREN_trimExpr_RIGHTPAREN()5521 inline cExpr_TRIM_LEFTPAREN_trimExpr_RIGHTPAREN::~cExpr_TRIM_LEFTPAREN_trimExpr_RIGHTPAREN()
5522 {
5523 delete m_pTRIM1;
5524 delete m_pLEFTPAREN2;
5525 delete m_ptrimExpr3;
5526 delete m_pRIGHTPAREN4;
5527 }
5528
~optIndirection_empty()5529 inline optIndirection_empty::~optIndirection_empty()
5530 {
5531 }
5532
~optIndirection_optIndirection_LEFTBRACKET_aExpr_RIGHTBRACKET()5533 inline optIndirection_optIndirection_LEFTBRACKET_aExpr_RIGHTBRACKET::~optIndirection_optIndirection_LEFTBRACKET_aExpr_RIGHTBRACKET()
5534 {
5535 delete m_poptIndirection1;
5536 delete m_pLEFTBRACKET2;
5537 delete m_paExpr3;
5538 delete m_pRIGHTBRACKET4;
5539 }
5540
~optIndirection_optIndirection_LEFTBRACKET_aExpr_COLON_aExpr_RIGHTBRACKET()5541 inline optIndirection_optIndirection_LEFTBRACKET_aExpr_COLON_aExpr_RIGHTBRACKET::~optIndirection_optIndirection_LEFTBRACKET_aExpr_COLON_aExpr_RIGHTBRACKET()
5542 {
5543 delete m_poptIndirection1;
5544 delete m_pLEFTBRACKET2;
5545 delete m_paExpr3;
5546 delete m_pCOLON4;
5547 delete m_paExpr5;
5548 delete m_pRIGHTBRACKET6;
5549 }
5550
~optExtract_empty()5551 inline optExtract_empty::~optExtract_empty()
5552 {
5553 }
5554
~optExtract_strExtractArg_FROM_aExpr()5555 inline optExtract_strExtractArg_FROM_aExpr::~optExtract_strExtractArg_FROM_aExpr()
5556 {
5557 delete m_pstrExtractArg1;
5558 delete m_pFROM2;
5559 delete m_paExpr3;
5560 }
5561
~positionExpr_bExpr_IN_bExpr()5562 inline positionExpr_bExpr_IN_bExpr::~positionExpr_bExpr_IN_bExpr()
5563 {
5564 delete m_pbExpr1;
5565 delete m_pIN2;
5566 delete m_pbExpr3;
5567 }
5568
~positionExpr_empty()5569 inline positionExpr_empty::~positionExpr_empty()
5570 {
5571 }
5572
~optSubstrExpr_empty()5573 inline optSubstrExpr_empty::~optSubstrExpr_empty()
5574 {
5575 }
5576
~optSubstrExpr_aExpr_substrFrom_substrFor()5577 inline optSubstrExpr_aExpr_substrFrom_substrFor::~optSubstrExpr_aExpr_substrFrom_substrFor()
5578 {
5579 delete m_paExpr1;
5580 delete m_psubstrFrom2;
5581 delete m_psubstrFor3;
5582 }
5583
~optSubstrExpr_aExpr_substrFor_substrFrom()5584 inline optSubstrExpr_aExpr_substrFor_substrFrom::~optSubstrExpr_aExpr_substrFor_substrFrom()
5585 {
5586 delete m_paExpr1;
5587 delete m_psubstrFor2;
5588 delete m_psubstrFrom3;
5589 }
5590
~optSubstrExpr_aExpr_substrFrom()5591 inline optSubstrExpr_aExpr_substrFrom::~optSubstrExpr_aExpr_substrFrom()
5592 {
5593 delete m_paExpr1;
5594 delete m_psubstrFrom2;
5595 }
5596
~optSubstrExpr_aExpr_substrFor()5597 inline optSubstrExpr_aExpr_substrFor::~optSubstrExpr_aExpr_substrFor()
5598 {
5599 delete m_paExpr1;
5600 delete m_psubstrFor2;
5601 }
5602
~optSubstrExpr_exprSeq()5603 inline optSubstrExpr_exprSeq::~optSubstrExpr_exprSeq()
5604 {
5605 delete m_pexprSeq1;
5606 }
5607
~substrFrom()5608 inline substrFrom::~substrFrom()
5609 {
5610 delete m_pFROM1;
5611 delete m_paExpr2;
5612 }
5613
~substrFor()5614 inline substrFor::~substrFor()
5615 {
5616 delete m_pFOR1;
5617 delete m_paExpr2;
5618 }
5619
~trimExpr_aExpr_FROM_exprSeq()5620 inline trimExpr_aExpr_FROM_exprSeq::~trimExpr_aExpr_FROM_exprSeq()
5621 {
5622 delete m_paExpr1;
5623 delete m_pFROM2;
5624 delete m_pexprSeq3;
5625 }
5626
~trimExpr_FROM_exprSeq()5627 inline trimExpr_FROM_exprSeq::~trimExpr_FROM_exprSeq()
5628 {
5629 delete m_pFROM1;
5630 delete m_pexprSeq2;
5631 }
5632
~trimExpr_exprSeq()5633 inline trimExpr_exprSeq::~trimExpr_exprSeq()
5634 {
5635 delete m_pexprSeq1;
5636 }
5637
~attr()5638 inline attr::~attr()
5639 {
5640 delete m_pstrRelationName1;
5641 delete m_pPERIOD2;
5642 delete m_pattrs3;
5643 delete m_poptIndirection4;
5644 }
5645
~attrs_strAttrName()5646 inline attrs_strAttrName::~attrs_strAttrName()
5647 {
5648 delete m_pstrAttrName1;
5649 }
5650
~attrs_attrs_PERIOD_strAttrName()5651 inline attrs_attrs_PERIOD_strAttrName::~attrs_attrs_PERIOD_strAttrName()
5652 {
5653 delete m_pattrs1;
5654 delete m_pPERIOD2;
5655 delete m_pstrAttrName3;
5656 }
5657
~attrs_attrs_PERIOD_ASTERISK()5658 inline attrs_attrs_PERIOD_ASTERISK::~attrs_attrs_PERIOD_ASTERISK()
5659 {
5660 delete m_pattrs1;
5661 delete m_pPERIOD2;
5662 delete m_pASTERISK3;
5663 }
5664
~targetEl_aExpr_AS_strColLabel()5665 inline targetEl_aExpr_AS_strColLabel::~targetEl_aExpr_AS_strColLabel()
5666 {
5667 delete m_paExpr1;
5668 delete m_pAS2;
5669 delete m_pstrColLabel3;
5670 }
5671
~targetEl_aExpr()5672 inline targetEl_aExpr::~targetEl_aExpr()
5673 {
5674 delete m_paExpr1;
5675 }
5676
~targetEl_strRelationName_PERIOD_ASTERISK()5677 inline targetEl_strRelationName_PERIOD_ASTERISK::~targetEl_strRelationName_PERIOD_ASTERISK()
5678 {
5679 delete m_pstrRelationName1;
5680 delete m_pPERIOD2;
5681 delete m_pASTERISK3;
5682 }
5683
~targetEl_ASTERISK()5684 inline targetEl_ASTERISK::~targetEl_ASTERISK()
5685 {
5686 delete m_pASTERISK1;
5687 }
5688
~updateTargetEl()5689 inline updateTargetEl::~updateTargetEl()
5690 {
5691 delete m_pstrColId1;
5692 delete m_poptIndirection2;
5693 delete m_pEQUALS3;
5694 delete m_paExpr4;
5695 }
5696
~aExprConst_ICONST()5697 inline aExprConst_ICONST::~aExprConst_ICONST()
5698 {
5699 delete m_pICONST1;
5700 }
5701
~aExprConst_FCONST()5702 inline aExprConst_FCONST::~aExprConst_FCONST()
5703 {
5704 delete m_pFCONST1;
5705 }
5706
~aExprConst_SCONST()5707 inline aExprConst_SCONST::~aExprConst_SCONST()
5708 {
5709 delete m_pSCONST1;
5710 }
5711
~aExprConst_BITCONST()5712 inline aExprConst_BITCONST::~aExprConst_BITCONST()
5713 {
5714 delete m_pBITCONST1;
5715 }
5716
~aExprConst_HEXCONST()5717 inline aExprConst_HEXCONST::~aExprConst_HEXCONST()
5718 {
5719 delete m_pHEXCONST1;
5720 }
5721
~aExprConst_TRUEP()5722 inline aExprConst_TRUEP::~aExprConst_TRUEP()
5723 {
5724 delete m_pTRUEP1;
5725 }
5726
~aExprConst_FALSEP()5727 inline aExprConst_FALSEP::~aExprConst_FALSEP()
5728 {
5729 delete m_pFALSEP1;
5730 }
5731
~aExprConst_NULLP()5732 inline aExprConst_NULLP::~aExprConst_NULLP()
5733 {
5734 delete m_pNULLP1;
5735 }
5736
5737 #endif
5738