File: Synopsis/PTree/Lists.hh 1//
2// Copyright (C) 1997-2000 Shigeru Chiba
3// Copyright (C) 2004 Stefan Seefeld
4// All rights reserved.
5// Licensed to the public under the terms of the GNU LGPL (>= 2),
6// see the file COPYING for details.
7//
8#ifndef Synopsis_PTree_Lists_hh_
9#define Synopsis_PTree_Lists_hh_
10
11#include <Synopsis/PTree/operations.hh>
12#include <Synopsis/PTree/Encoding.hh>
13
14namespace Synopsis
15{
16namespace PTree
17{
18
19class Brace : public List
20{
21public:
22 Brace(Node *p, Node *q) : List(p, q) {}
23 Brace(Node *ob, Node *body, Node *cb) : List(ob, list(body, cb)) {}
24 virtual void accept(Visitor *visitor) { visitor->visit(this);}
25};
26
27class Block : public Brace
28{
29public:
30 Block(Node *p, Node *q) : Brace(p, q) {}
31 Block(Node *ob, Node *bdy, Node *cb) : Brace(ob, bdy, cb) {}
32 virtual void accept(Visitor *visitor) { visitor->visit(this);}
33};
34
35class ClassBody : public Brace
36{
37public:
38 ClassBody(Node *p, Node *q) : Brace(p, q) {}
39 ClassBody(Node *ob, Node *bdy, Node *cb) : Brace(ob, bdy, cb) {}
40 virtual void accept(Visitor *visitor) { visitor->visit(this);}
41};
42
43class TemplateDecl : public List
44{
45public:
46 TemplateDecl(Node *p, Node *q) : List(p, q) {}
47 TemplateDecl(Node *p) : List(p, 0) {}
48 virtual void accept(Visitor *visitor) { visitor->visit(this);}
49};
50
51class TemplateInstantiation : public List
52{
53public:
54 TemplateInstantiation(Node *p) : List(p, 0) {}
55 virtual void accept(Visitor *visitor) { visitor->visit(this);}
56};
57
58class ExternTemplate : public List
59{
60public:
61 ExternTemplate(Node *p, Node *q) : List(p, q) {}
62 ExternTemplate(Node *p) : List(p, 0) {}
63 virtual void accept(Visitor *visitor) { visitor->visit(this);}
64};
65
66class MetaclassDecl : public List
67{
68public:
69 MetaclassDecl(Node *p, Node *q) : List(p, q) {}
70 virtual void accept(Visitor *visitor) { visitor->visit(this);}
71};
72
73class LinkageSpec : public List
74{
75public:
76 LinkageSpec(Node *p, Node *q) : List(p, q) {}
77 virtual void accept(Visitor *visitor) { visitor->visit(this);}
78};
79
80class NamespaceSpec : public List
81{
82public:
83 NamespaceSpec(Node *p, Node *q) : List(p, q), my_comments(0) {}
84 virtual void accept(Visitor *visitor) { visitor->visit(this);}
85 Node *get_comments() { return my_comments;}
86 void set_comments(Node *c) { my_comments = c;}
87
88private:
89 Node *my_comments;
90};
91
92class Declaration : public List
93{
94public:
95 Declaration(Node *p, Node *q) : List(p, q), my_comments(0) {}
96 virtual void accept(Visitor *visitor) { visitor->visit(this);}
97 Node *get_comments() { return my_comments;}
98 void set_comments(Node *c) { my_comments = c;}
99
100private:
101 Node *my_comments;
102};
103
104class Typedef : public Declaration
105{
106public:
107 Typedef(Node *p) : Declaration(p, 0) {}
108 Typedef(Node *p, Node *q) : Declaration(p, q) {}
109 virtual void accept(Visitor *visitor) { visitor->visit(this);}
110};
111
112class UsingDirective : public Declaration
113{
114public:
115 UsingDirective(Node *p) : Declaration(p, 0) {}
116 virtual void accept(Visitor *visitor) { visitor->visit(this);}
117};
118
119class UsingDeclaration : public Declaration
120{
121public:
122 UsingDeclaration(Node *p, Node *q) : Declaration(p, q) {}
123 virtual void accept(Visitor *visitor) { visitor->visit(this);}
124};
125
126class NamespaceAlias : public Declaration
127{
128public:
129 NamespaceAlias(Node *p, Node *q) : Declaration(p, q) {}
130 virtual void accept(Visitor *visitor) { visitor->visit(this);}
131};
132
133class FunctionDefinition : public Declaration
134{
135public:
136 FunctionDefinition(Node *p, Node *q) : Declaration(p, q) {}
137 virtual void accept(Visitor *visitor) { visitor->visit(this);}
138};
139
140class ParameterDeclaration : public List
141{
142public:
143 ParameterDeclaration(Node *mod, Node *type, Node *decl)
144 : List(mod, list(type, decl)) {}
145 virtual void accept(Visitor *visitor) { visitor->visit(this);}
146};
147
148class Declarator : public List
149{
150public:
151 Declarator(Node *);
152 Declarator(Node *, Encoding const&, Encoding const&, Node *);
153 Declarator(Encoding const&, Encoding const&, Node *);
154 Declarator(Node *, Node *, Encoding const&, Encoding const&, Node *);
155 Declarator(Node *, Encoding const&);
156 Declarator(Encoding const&);
157 Declarator(Declarator*, Node *, Node *);
158
159 virtual void accept(Visitor *visitor) { visitor->visit(this);}
160 Encoding encoded_type() const { return my_type;}
161 Encoding encoded_name() const { return my_name;}
162 void set_encoded_type(const Encoding &t) { my_type = t;}
163 Node *name() { return my_declared_name;}
164 Node *initializer();
165 Node *get_comments() { return my_comments;}
166 void set_comments(Node *c) { my_comments = c;}
167private:
168 Encoding my_type;
169 Encoding my_name;
170 Node *my_declared_name;
171 Node *my_comments;
172};
173
174class Name : public List
175{
176public:
177 Name(Node *, const Encoding &);
178 virtual void accept(Visitor *visitor) { visitor->visit(this);}
179 Encoding encoded_name() const { return my_name;}
180private:
181 Encoding my_name;
182};
183
184class FstyleCastExpr : public List
185{
186public:
187 FstyleCastExpr(const Encoding &, Node *, Node *);
188 virtual void accept(Visitor *visitor) { visitor->visit(this);}
189 Encoding encoded_type() const { return my_type;}
190private:
191 Encoding my_type;
192};
193
194class ClassSpec : public List
195{
196public:
197 ClassSpec(Node *, Node *, Node *);
198 ClassSpec(const Encoding &, Node *, Node *, Node *);
199 virtual void accept(Visitor *visitor) { visitor->visit(this);}
200 Encoding encoded_name() const { return my_name;}
201 void set_encoded_name(const Encoding &n) { my_name = n;}
202 Node *get_comments() { return my_comments;}
203
204 Node const *base_clause() const
205 { return static_cast<List const *>(PTree::third(this));}
206
207 ClassBody *body();
208private:
209 Encoding my_name;
210 Node *my_comments;
211};
212
213class EnumSpec : public List
214{
215public:
216 EnumSpec(Node *head) : List(head, 0) {}
217 virtual void accept(Visitor *visitor) { visitor->visit(this);}
218 Encoding encoded_name() const { return my_name;}
219 void set_encoded_name(const Encoding &n) { my_name = n;}
220private:
221 Encoding my_name;
222};
223
224class TypeParameter : public List
225{
226public:
227 TypeParameter(Node *p, Node *q) : List(p, q) {}
228 virtual void accept(Visitor *visitor) { visitor->visit(this);}
229};
230
231class AccessSpec : public List
232{
233public:
234 AccessSpec(Node *p, Node *q, Node *c) : List(p, q), my_comments(c) {}
235 virtual void accept(Visitor *visitor) { visitor->visit(this);}
236 Node *get_comments() { return my_comments;}
237private:
238 Node *my_comments;
239};
240
241class AccessDecl : public List
242{
243public:
244 AccessDecl(Node *p, Node *q) : List(p, q) {}
245 virtual void accept(Visitor *visitor) { visitor->visit(this);}
246};
247
248class UserAccessSpec : public List
249{
250public:
251 UserAccessSpec(Node *p, Node *q) : List(p, q) {}
252 virtual void accept(Visitor *visitor) { visitor->visit(this);}
253};
254
255class UserdefKeyword : public List
256{
257public:
258 UserdefKeyword(Node *p, Node *q) : List(p, q) {}
259 virtual void accept(Visitor *visitor) { visitor->visit(this);}
260};
261
262template <typename T>
263class StatementT : public List
264{
265public:
266 StatementT(Node *p, Node *q) : List(p, q) {}
267 virtual void accept(Visitor *visitor) { visitor->visit(static_cast<T *>(this));}
268};
269
270class IfStatement : public StatementT<IfStatement>
271{
272public:
273 IfStatement(Node *p, Node *q) : StatementT<IfStatement>(p, q) {}
274};
275
276class SwitchStatement : public StatementT<SwitchStatement>
277{
278public:
279 SwitchStatement(Node *p, Node *q) : StatementT<SwitchStatement>(p, q) {}
280};
281
282class WhileStatement : public StatementT<WhileStatement>
283{
284public:
285 WhileStatement(Node *p, Node *q) : StatementT<WhileStatement>(p, q) {}
286};
287
288class DoStatement : public StatementT<DoStatement>
289{
290public:
291 DoStatement(Node *p, Node *q) : StatementT<DoStatement>(p, q) {}
292};
293
294class ForStatement : public StatementT<ForStatement>
295{
296public:
297 ForStatement(Node *p, Node *q) : StatementT<ForStatement>(p, q) {}
298};
299
300class TryStatement : public StatementT<TryStatement>
301{
302public:
303 TryStatement(Node *p, Node *q) : StatementT<TryStatement>(p, q) {}
304};
305
306class BreakStatement : public StatementT<BreakStatement>
307{
308public:
309 BreakStatement(Node *p, Node *q) : StatementT<BreakStatement>(p, q) {}
310};
311
312class ContinueStatement : public StatementT<ContinueStatement>
313{
314public:
315 ContinueStatement(Node *p, Node *q) : StatementT<ContinueStatement>(p, q) {}
316};
317
318class ReturnStatement : public StatementT<ReturnStatement>
319{
320public:
321 ReturnStatement(Node *p, Node *q) : StatementT<ReturnStatement>(p, q) {}
322};
323
324class GotoStatement : public StatementT<GotoStatement>
325{
326public:
327 GotoStatement(Node *p, Node *q) : StatementT<GotoStatement>(p, q) {}
328};
329
330class CaseStatement : public StatementT<CaseStatement>
331{
332public:
333 CaseStatement(Node *p, Node *q) : StatementT<CaseStatement>(p, q) {}
334};
335
336class DefaultStatement : public StatementT<DefaultStatement>
337{
338public:
339 DefaultStatement(Node *p, Node *q) : StatementT<DefaultStatement>(p, q) {}
340};
341
342class LabelStatement : public StatementT<LabelStatement>
343{
344public:
345 LabelStatement(Node *p, Node *q) : StatementT<LabelStatement>(p, q) {}
346};
347
348class ExprStatement : public StatementT<ExprStatement>
349{
350public:
351 ExprStatement(Node *p, Node *q) : StatementT<ExprStatement>(p, q) {}
352};
353
354class Expression : public List
355{
356public:
357 Expression(Node *p, Node *q) : List(p, q) {}
358 virtual void accept(Visitor *visitor) { visitor->visit(this);}
359};
360
361template <typename T>
362class ExpressionT : public List
363{
364public:
365 ExpressionT(Node *p, Node *q) : List(p, q) {}
366 virtual void accept(Visitor *visitor) { visitor->visit(static_cast<T *>(this));}
367};
368
369class AssignExpr : public ExpressionT<AssignExpr>
370{
371public:
372 AssignExpr(Node *p, Node *q) : ExpressionT<AssignExpr>(p, q) {}
373};
374
375class CondExpr : public ExpressionT<CondExpr>
376{
377public:
378 CondExpr(Node *p, Node *q) : ExpressionT<CondExpr>(p, q) {}
379};
380
381class InfixExpr : public ExpressionT<InfixExpr>
382{
383public:
384 InfixExpr(Node *p, Node *q) : ExpressionT<InfixExpr>(p, q) {}
385};
386
387class PmExpr : public ExpressionT<PmExpr>
388{
389public:
390 PmExpr(Node *p, Node *q) : ExpressionT<PmExpr>(p, q) {}
391};
392
393class CastExpr : public ExpressionT<CastExpr>
394{
395public:
396 CastExpr(Node *p, Node *q) : ExpressionT<CastExpr>(p, q) {}
397};
398
399class UnaryExpr : public ExpressionT<UnaryExpr>
400{
401public:
402 UnaryExpr(Node *p, Node *q) : ExpressionT<UnaryExpr>(p, q) {}
403};
404
405class ThrowExpr : public ExpressionT<ThrowExpr>
406{
407public:
408 ThrowExpr(Node *p, Node *q) : ExpressionT<ThrowExpr>(p, q) {}
409};
410
411class SizeofExpr : public ExpressionT<SizeofExpr>
412{
413public:
414 SizeofExpr(Node *p, Node *q) : ExpressionT<SizeofExpr>(p, q) {}
415};
416
417class OffsetofExpr : public ExpressionT<OffsetofExpr>
418{
419public:
420 OffsetofExpr(Node *p, Node *q) : ExpressionT<OffsetofExpr>(p, q) {}
421};
422
423class TypeidExpr : public ExpressionT<TypeidExpr>
424{
425public:
426 TypeidExpr(Node *p, Node *q) : ExpressionT<TypeidExpr>(p, q) {}
427};
428
429class TypeofExpr : public ExpressionT<TypeofExpr>
430{
431public:
432 TypeofExpr(Node *p, Node *q) : ExpressionT<TypeofExpr>(p, q) {}
433};
434
435class NewExpr : public ExpressionT<NewExpr>
436{
437public:
438 NewExpr(Node *p, Node *q) : ExpressionT<NewExpr>(p, q) {}
439};
440
441class DeleteExpr : public ExpressionT<DeleteExpr>
442{
443public:
444 DeleteExpr(Node *p, Node *q) : ExpressionT<DeleteExpr>(p, q) {}
445};
446
447class ArrayExpr : public ExpressionT<ArrayExpr>
448{
449public:
450 ArrayExpr(Node *p, Node *q) : ExpressionT<ArrayExpr>(p, q) {}
451};
452
453class FuncallExpr : public ExpressionT<FuncallExpr>
454{
455public:
456 FuncallExpr(Node *p, Node *q) : ExpressionT<FuncallExpr>(p, q) {}
457};
458
459class PostfixExpr : public ExpressionT<PostfixExpr>
460{
461public:
462 PostfixExpr(Node *p, Node *q) : ExpressionT<PostfixExpr>(p, q) {}
463};
464
465class UserStatementExpr : public ExpressionT<UserStatementExpr>
466{
467public:
468 UserStatementExpr(Node *p, Node *q) : ExpressionT<UserStatementExpr>(p, q) {}
469};
470
471class DotMemberExpr : public ExpressionT<DotMemberExpr>
472{
473public:
474 DotMemberExpr(Node *p, Node *q) : ExpressionT<DotMemberExpr>(p, q) {}
475};
476
477class ArrowMemberExpr : public ExpressionT<ArrowMemberExpr>
478{
479public:
480 ArrowMemberExpr(Node *p, Node *q) : ExpressionT<ArrowMemberExpr>(p, q) {}
481};
482
483class ParenExpr : public ExpressionT<ParenExpr>
484{
485public:
486 ParenExpr(Node *p, Node *q) : ExpressionT<ParenExpr>(p, q) {}
487};
488
489class StaticUserStatementExpr : public ExpressionT<StaticUserStatementExpr>
490{
491public:
492 StaticUserStatementExpr(Node *p, Node *q) : ExpressionT<StaticUserStatementExpr>(p, q) {}
493};
494
495}
496}
497
498#endif
Generated on Thu Apr 16 16:28:03 2009 by
synopsis (version devel)