← Back to branch summary

~ubuntu-branches/debian/sid/kdevelop/sid

« back to all changes in this revision

Viewing changes to languages/cpp/parser/ast.h

  • Committer: Bazaar Package Importer
  • Author(s): Jeremy Lainé
  • Date: 2010-05-05 07:21:55 UTC
  • mfrom: (1.2.3 upstream) (5.1.2 squeeze)
  • Revision ID: james.westby@ubuntu.com-20100505072155-h78lx19pu04sbhtn
Tags: 4:4.0.0-2
http://bugs.debian.org/579947
http://bugs.debian.org/481832
http://bugs.debian.org/562410
http://bugs.debian.org/546961
* Upload to unstable (Closes: #579947, #481832).
* Acknowledge obsolete NMU fixes (Closes: #562410, #546961).

Show diffs side-by-side

added added

removed removed

Lines of Context:
languages/cpp/parser/ast.h
 
1
/* This file is part of KDevelop
 
2
    Copyright 2002-2005 Roberto Raggi <roberto@kdevelop.org>
 
3
    Copyright 2007-2008 David Nolden <david.nolden.kdevelop@art-master.de>
 
4
 
 
5
   This library is free software; you can redistribute it and/or
 
6
   modify it under the terms of the GNU Library General Public
 
7
   License version 2 as published by the Free Software Foundation.
 
8
 
 
9
   This library is distributed in the hope that it will be useful,
 
10
   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
11
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
12
   Library General Public License for more details.
 
13
 
 
14
   You should have received a copy of the GNU Library General Public License
 
15
   along with this library; see the file COPYING.LIB.  If not, write to
 
16
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 
17
   Boston, MA 02110-1301, USA.
 
18
*/
 
19
 
 
20
#ifndef AST_H
 
21
#define AST_H
 
22
 
 
23
#include "memorypool.h"
 
24
#include "listnode.h"
 
25
 
 
26
#define DECLARE_AST_NODE(k) \
 
27
    enum { __node_kind = Kind_##k };
 
28
 
 
29
class ParseSession;
 
30
namespace KDevelop
 
31
{
 
32
class DUContext;
 
33
}
 
34
class AccessSpecifierAST;
 
35
class AsmDefinitionAST;
 
36
class BaseClauseAST;
 
37
class BaseSpecifierAST;
 
38
class BinaryExpressionAST;
 
39
class CastExpressionAST;
 
40
class ClassMemberAccessAST;
 
41
class ClassSpecifierAST;
 
42
class CompoundStatementAST;
 
43
class ConditionAST;
 
44
class ConditionalExpressionAST;
 
45
class CppCastExpressionAST;
 
46
class CtorInitializerAST;
 
47
class DeclarationAST;
 
48
class DeclarationStatementAST;
 
49
class DeclaratorAST;
 
50
class DeleteExpressionAST;
 
51
class DoStatementAST;
 
52
class Elaborated;
 
53
class EnumSpecifierAST;
 
54
class EnumeratorAST;
 
55
class ExceptionSpecificationAST;
 
56
class ExpressionAST;
 
57
class ExpressionOrDeclarationStatementAST;
 
58
class ExpressionStatementAST;
 
59
class ForStatementAST;
 
60
class FunctionCallAST;
 
61
class FunctionDefinitionAST;
 
62
class IfStatementAST;
 
63
class IncrDecrExpressionAST;
 
64
class InitDeclaratorAST;
 
65
class InitializerAST;
 
66
class InitializerClauseAST;
 
67
class LabeledStatementAST;
 
68
class LinkageBodyAST;
 
69
class LinkageSpecificationAST;
 
70
class MemInitializerAST;
 
71
class NameAST;
 
72
class NamespaceAST;
 
73
class NamespaceAliasDefinitionAST;
 
74
class NewDeclaratorAST;
 
75
class NewExpressionAST;
 
76
class NewInitializerAST;
 
77
class NewTypeIdAST;
 
78
class OperatorAST;
 
79
class OperatorFunctionIdAST;
 
80
class ParameterDeclarationAST;
 
81
class ParameterDeclarationClauseAST;
 
82
class PostfixExpressionAST;
 
83
class PrimaryExpressionAST;
 
84
class PtrOperatorAST;
 
85
class PtrToMemberAST;
 
86
class ReturnStatementAST;
 
87
class SimpleDeclarationAST;
 
88
class SimpleTypeSpecifierAST;
 
89
class SizeofExpressionAST;
 
90
class StatementAST;
 
91
class StringLiteralAST;
 
92
class SubscriptExpressionAST;
 
93
class SwitchStatementAST;
 
94
class TemplateArgumentAST;
 
95
class TemplateDeclarationAST;
 
96
class TemplateParameterAST;
 
97
class ThrowExpressionAST;
 
98
class TranslationUnitAST;
 
99
class TryBlockStatementAST;
 
100
class CatchStatementAST;
 
101
class TypeIdAST;
 
102
class TypeIdentificationAST;
 
103
class TypeParameterAST;
 
104
class TypeSpecifierAST;
 
105
class TypedefAST;
 
106
class UnaryExpressionAST;
 
107
class UnqualifiedNameAST;
 
108
class UsingAST;
 
109
class UsingDirectiveAST;
 
110
class WhileStatementAST;
 
111
class WinDeclSpecAST;
 
112
 
 
113
class AST
 
114
{///@warning When adding new nodes here, also modify the names[] array in dumptree.cpp
 
115
public:
 
116
 
 
117
  enum NODE_KIND
 
118
    {
 
119
      Kind_UNKNOWN = 0,
 
120
 
 
121
      Kind_AccessSpecifier,                     // 1
 
122
      Kind_AsmDefinition,                       // 2
 
123
      Kind_BaseClause,                          // 3
 
124
      Kind_BaseSpecifier,                       // 4
 
125
      Kind_BinaryExpression,                    // 5
 
126
      Kind_CastExpression,                      // 6
 
127
      Kind_ClassMemberAccess,                   // 7
 
128
      Kind_ClassSpecifier,                      // 8
 
129
      Kind_CompoundStatement,                   // 9
 
130
      Kind_Condition,                           // 10
 
131
      Kind_ConditionalExpression,               // 11
 
132
      Kind_CppCastExpression,                   // 12
 
133
      Kind_CtorInitializer,                     // 13
 
134
      Kind_DeclarationStatement,                // 14
 
135
      Kind_Declarator,                          // 15
 
136
      Kind_DeleteExpression,                    // 16
 
137
      Kind_DoStatement,                         // 17
 
138
      Kind_ElaboratedTypeSpecifier,             // 18
 
139
      Kind_EnumSpecifier,                       // 19
 
140
      Kind_Enumerator,                          // 20
 
141
      Kind_ExceptionSpecification,              // 21
 
142
      Kind_ExpressionOrDeclarationStatement,    // 22
 
143
      Kind_ExpressionStatement,                 // 23
 
144
      Kind_ForStatement,                        // 24
 
145
      Kind_FunctionCall,                        // 25
 
146
      Kind_FunctionDefinition,                  // 26
 
147
      Kind_IfStatement,                         // 27
 
148
      Kind_IncrDecrExpression,                  // 28
 
149
      Kind_InitDeclarator,                      // 29
 
150
      Kind_Initializer,                         // 30
 
151
      Kind_InitializerClause,                   // 31
 
152
      Kind_LabeledStatement,                    // 32
 
153
      Kind_LinkageBody,                         // 33
 
154
      Kind_LinkageSpecification,                // 34
 
155
      Kind_MemInitializer,                      // 35
 
156
      Kind_Name,                                // 36
 
157
      Kind_Namespace,                           // 37
 
158
      Kind_NamespaceAliasDefinition,            // 38
 
159
      Kind_NewDeclarator,                       // 39
 
160
      Kind_NewExpression,                       // 40
 
161
      Kind_NewInitializer,                      // 41
 
162
      Kind_NewTypeId,                           // 42
 
163
      Kind_Operator,                            // 43
 
164
      Kind_OperatorFunctionId,                  // 44
 
165
      Kind_ParameterDeclaration,                // 45
 
166
      Kind_ParameterDeclarationClause,          // 46
 
167
      Kind_PostfixExpression,                   // 47
 
168
      Kind_PrimaryExpression,                   // 48
 
169
      Kind_PtrOperator,                         // 49
 
170
      Kind_PtrToMember,                         // 50
 
171
      Kind_ReturnStatement,                     // 51
 
172
      Kind_SimpleDeclaration,                   // 52
 
173
      Kind_SimpleTypeSpecifier,                 // 53
 
174
      Kind_SizeofExpression,                    // 54
 
175
      Kind_StringLiteral,                       // 55
 
176
      Kind_SubscriptExpression,                 // 56
 
177
      Kind_SwitchStatement,                     // 57
 
178
      Kind_TemplateArgument,                    // 58
 
179
      Kind_TemplateDeclaration,                 // 59
 
180
      Kind_TemplateParameter,                   // 60
 
181
      Kind_ThrowExpression,                     // 61
 
182
      Kind_TranslationUnit,                     // 62
 
183
      Kind_TryBlockStatement,                   // 63
 
184
      Kind_CatchStatement,                      // 64
 
185
      Kind_TypeId,                              // 65
 
186
      Kind_TypeIdentification,                  // 66
 
187
      Kind_TypeParameter,                       // 67
 
188
      Kind_Typedef,                             // 68
 
189
      Kind_UnaryExpression,                     // 69
 
190
      Kind_UnqualifiedName,                     // 70
 
191
      Kind_Using,                               // 71
 
192
      Kind_UsingDirective,                      // 72
 
193
      Kind_WhileStatement,                      // 73
 
194
      Kind_WinDeclSpec,                         // 74
 
195
      Kind_Comment,                             // 75
 
196
      Kind_JumpStatement,                       // 76
 
197
      Kind_SignalSlotExpression,                // 77
 
198
      NODE_KIND_COUNT
 
199
    };
 
200
 
 
201
  int kind;
 
202
 
 
203
  uint start_token;
 
204
  uint end_token;
 
205
 
 
206
  /** Context opened by this AST
 
207
    *This is usually not filled for all AST's, only for those that open a new context
 
208
    */
 
209
  KDevelop::DUContext* ducontext;
 
210
};
 
211
 
 
212
class CommentAST
 
213
{
 
214
public:
 
215
 
 
216
  const ListNode<uint> *comments; //A list of comment-tokens
 
217
};
 
218
 
 
219
class TypeSpecifierAST : public AST
 
220
{
 
221
public:
 
222
 
 
223
  const ListNode<uint> *cv; // const or volatile tokens
 
224
};
 
225
 
 
226
class StatementAST : public AST
 
227
{
 
228
public:
 
229
 
 
230
};
 
231
 
 
232
class ExpressionAST : public AST
 
233
{
 
234
public:
 
235
 
 
236
};
 
237
 
 
238
class DeclarationAST : public AST, public CommentAST
 
239
{
 
240
public:
 
241
 
 
242
};
 
243
 
 
244
class AccessSpecifierAST : public DeclarationAST
 
245
{
 
246
public:
 
247
 
 
248
  DECLARE_AST_NODE(AccessSpecifier)
 
249
 
 
250
  const ListNode<uint> *specs;
 
251
};
 
252
 
 
253
class AsmDefinitionAST : public DeclarationAST
 
254
{
 
255
public:
 
256
 
 
257
  DECLARE_AST_NODE(AsmDefinition)
 
258
 
 
259
  const ListNode<uint> *cv;
 
260
};
 
261
 
 
262
class BaseClauseAST : public AST // ### kill me
 
263
{
 
264
public:
 
265
 
 
266
  DECLARE_AST_NODE(BaseClause)
 
267
 
 
268
  const ListNode<BaseSpecifierAST*> *base_specifiers;
 
269
};
 
270
 
 
271
class BaseSpecifierAST : public AST
 
272
{
 
273
public:
 
274
 
 
275
  DECLARE_AST_NODE(BaseSpecifier)
 
276
 
 
277
  uint virt;
 
278
  uint access_specifier;
 
279
  NameAST *name;
 
280
};
 
281
 
 
282
class BinaryExpressionAST : public ExpressionAST
 
283
{
 
284
public:
 
285
 
 
286
  DECLARE_AST_NODE(BinaryExpression)
 
287
 
 
288
  uint op; //Index of the token that describes the operator
 
289
  ExpressionAST *left_expression;
 
290
  ExpressionAST *right_expression;
 
291
};
 
292
 
 
293
///An expression used to do more detailed processing of SIGNAL(..) and SLOT(..) specifications
 
294
class SignalSlotExpressionAST : public ExpressionAST {
 
295
public:
 
296
 
 
297
  DECLARE_AST_NODE(SignalSlotExpression)
 
298
  //The unqualified name also contains the argument types in its template-arguments
 
299
  UnqualifiedNameAST *name;
 
300
};
 
301
 
 
302
class CastExpressionAST : public ExpressionAST
 
303
{
 
304
public:
 
305
 
 
306
  DECLARE_AST_NODE(CastExpression)
 
307
 
 
308
  TypeIdAST *type_id;
 
309
  ExpressionAST *expression;
 
310
};
 
311
 
 
312
class ClassMemberAccessAST : public ExpressionAST
 
313
{
 
314
public:
 
315
 
 
316
  DECLARE_AST_NODE(ClassMemberAccess)
 
317
 
 
318
  uint op; //Index of the token that describes the operator
 
319
  NameAST *name;
 
320
};
 
321
 
 
322
class ClassSpecifierAST : public TypeSpecifierAST
 
323
{
 
324
public:
 
325
 
 
326
  DECLARE_AST_NODE(ClassSpecifier)
 
327
 
 
328
  WinDeclSpecAST *win_decl_specifiers;
 
329
  uint class_key;
 
330
  NameAST *name;
 
331
  BaseClauseAST *base_clause;
 
332
  const ListNode<DeclarationAST*> *member_specs;
 
333
};
 
334
 
 
335
class CompoundStatementAST : public StatementAST
 
336
{
 
337
public:
 
338
 
 
339
  DECLARE_AST_NODE(CompoundStatement)
 
340
 
 
341
  const ListNode<StatementAST*> *statements;
 
342
};
 
343
 
 
344
class ConditionAST : public AST
 
345
{
 
346
public:
 
347
 
 
348
  DECLARE_AST_NODE(Condition)
 
349
 
 
350
  TypeSpecifierAST *type_specifier;
 
351
  DeclaratorAST *declarator;
 
352
  ExpressionAST *expression;
 
353
};
 
354
 
 
355
class ConditionalExpressionAST : public ExpressionAST
 
356
{
 
357
public:
 
358
 
 
359
  DECLARE_AST_NODE(ConditionalExpression)
 
360
 
 
361
  ExpressionAST *condition;
 
362
  ExpressionAST *left_expression;
 
363
  ExpressionAST *right_expression;
 
364
};
 
365
 
 
366
/**
 
367
 * type_id is the type that should be casted to
 
368
 * expression is the expression casted from
 
369
 * sub_expressions is a list of post-fix expressions, see PostfixExpressionAST
 
370
 */
 
371
class CppCastExpressionAST : public ExpressionAST
 
372
{
 
373
public:
 
374
 
 
375
  DECLARE_AST_NODE(CppCastExpression)
 
376
 
 
377
  uint op; //Index of the token that describes the operator
 
378
  TypeIdAST *type_id;
 
379
  ExpressionAST *expression;
 
380
  const ListNode<ExpressionAST*> *sub_expressions;
 
381
};
 
382
 
 
383
class CtorInitializerAST : public AST
 
384
{
 
385
public:
 
386
 
 
387
  DECLARE_AST_NODE(CtorInitializer)
 
388
 
 
389
  uint colon;
 
390
  const ListNode<MemInitializerAST*> *member_initializers;
 
391
};
 
392
 
 
393
class DeclarationStatementAST : public StatementAST
 
394
{
 
395
public:
 
396
 
 
397
  DECLARE_AST_NODE(DeclarationStatement)
 
398
 
 
399
  DeclarationAST *declaration;
 
400
};
 
401
 
 
402
class DeclaratorAST : public AST
 
403
{
 
404
public:
 
405
 
 
406
  DECLARE_AST_NODE(Declarator)
 
407
 
 
408
  const ListNode<PtrOperatorAST*> *ptr_ops;
 
409
  DeclaratorAST *sub_declarator;
 
410
  NameAST *id;
 
411
  ExpressionAST *bit_expression;
 
412
  const ListNode<ExpressionAST*> *array_dimensions;
 
413
 
 
414
  bool parameter_is_initializer; //Used by the declaration-builder to mark a parameter-declaration clause as a mis-parsed initializer
 
415
  ParameterDeclarationClauseAST *parameter_declaration_clause;
 
416
  const ListNode<uint> *fun_cv;
 
417
  ExceptionSpecificationAST *exception_spec;
 
418
};
 
419
 
 
420
class DeleteExpressionAST : public ExpressionAST
 
421
{
 
422
public:
 
423
 
 
424
  DECLARE_AST_NODE(DeleteExpression)
 
425
 
 
426
  uint scope_token;
 
427
  uint delete_token;
 
428
  uint lbracket_token;
 
429
  uint rbracket_token;
 
430
  ExpressionAST *expression;
 
431
};
 
432
 
 
433
class DoStatementAST : public StatementAST
 
434
{
 
435
public:
 
436
 
 
437
  DECLARE_AST_NODE(DoStatement)
 
438
 
 
439
  StatementAST *statement;
 
440
  ExpressionAST *expression;
 
441
};
 
442
 
 
443
class ElaboratedTypeSpecifierAST : public TypeSpecifierAST
 
444
{
 
445
public:
 
446
 
 
447
  DECLARE_AST_NODE(ElaboratedTypeSpecifier)
 
448
 
 
449
  uint type;
 
450
  NameAST *name;
 
451
  bool isDeclaration; //Whether this type-specifier is a forward declaration rather than use use
 
452
};
 
453
 
 
454
class EnumSpecifierAST : public TypeSpecifierAST
 
455
{
 
456
public:
 
457
 
 
458
  DECLARE_AST_NODE(EnumSpecifier)
 
459
 
 
460
  NameAST *name;
 
461
  const ListNode<EnumeratorAST*> *enumerators;
 
462
};
 
463
 
 
464
class EnumeratorAST : public AST, public  CommentAST
 
465
{
 
466
public:
 
467
 
 
468
  DECLARE_AST_NODE(Enumerator)
 
469
 
 
470
  uint id;
 
471
  ExpressionAST *expression;
 
472
};
 
473
 
 
474
class ExceptionSpecificationAST : public AST
 
475
{
 
476
public:
 
477
 
 
478
  DECLARE_AST_NODE(ExceptionSpecification)
 
479
 
 
480
  uint ellipsis;
 
481
  const ListNode<TypeIdAST*> *type_ids;
 
482
};
 
483
 
 
484
class ExpressionOrDeclarationStatementAST : public StatementAST
 
485
{
 
486
public:
 
487
 
 
488
  DECLARE_AST_NODE(ExpressionOrDeclarationStatement)
 
489
 
 
490
  StatementAST *expression;
 
491
  StatementAST *declaration;
 
492
 
 
493
  // This was not originally part of the AST - added by the context visitor
 
494
  bool expressionChosen;
 
495
};
 
496
 
 
497
///An expression terminated by a semicolon or similar
 
498
class ExpressionStatementAST : public StatementAST
 
499
{
 
500
public:
 
501
 
 
502
  DECLARE_AST_NODE(ExpressionStatement)
 
503
 
 
504
  ExpressionAST *expression;
 
505
};
 
506
 
 
507
class FunctionCallAST : public ExpressionAST
 
508
{
 
509
public:
 
510
 
 
511
  DECLARE_AST_NODE(FunctionCall)
 
512
 
 
513
  ExpressionAST *arguments;
 
514
};
 
515
 
 
516
class FunctionDefinitionAST : public DeclarationAST
 
517
{
 
518
public:
 
519
 
 
520
  DECLARE_AST_NODE(FunctionDefinition)
 
521
 
 
522
  const ListNode<uint> *storage_specifiers;
 
523
  const ListNode<uint> *function_specifiers;
 
524
  TypeSpecifierAST *type_specifier;
 
525
  InitDeclaratorAST *init_declarator;
 
526
  StatementAST *function_body;
 
527
  WinDeclSpecAST *win_decl_specifiers;
 
528
  CtorInitializerAST *constructor_initializers;
 
529
};
 
530
 
 
531
class ForStatementAST : public StatementAST
 
532
{
 
533
public:
 
534
 
 
535
  DECLARE_AST_NODE(ForStatement)
 
536
 
 
537
  StatementAST *init_statement;
 
538
  ConditionAST *condition;
 
539
  ExpressionAST *expression;
 
540
  StatementAST *statement;
 
541
};
 
542
 
 
543
class IfStatementAST : public StatementAST
 
544
{
 
545
public:
 
546
 
 
547
  DECLARE_AST_NODE(IfStatement)
 
548
 
 
549
  ConditionAST *condition;
 
550
  StatementAST *statement;
 
551
  StatementAST *else_statement;
 
552
};
 
553
 
 
554
class IncrDecrExpressionAST : public ExpressionAST
 
555
{
 
556
public:
 
557
 
 
558
  DECLARE_AST_NODE(IncrDecrExpression)
 
559
 
 
560
  uint op; //Index of the token that describes the operator
 
561
};
 
562
 
 
563
class InitDeclaratorAST : public AST
 
564
{
 
565
public:
 
566
 
 
567
  DECLARE_AST_NODE(InitDeclarator)
 
568
 
 
569
  DeclaratorAST *declarator;
 
570
  InitializerAST *initializer;
 
571
};
 
572
 
 
573
class InitializerAST : public AST
 
574
{
 
575
public:
 
576
 
 
577
  DECLARE_AST_NODE(Initializer)
 
578
 
 
579
  InitializerClauseAST *initializer_clause;
 
580
  ExpressionAST *expression;
 
581
};
 
582
 
 
583
class InitializerClauseAST : public AST
 
584
{
 
585
public:
 
586
 
 
587
  DECLARE_AST_NODE(InitializerClause)
 
588
 
 
589
  // either 'expression' or 'initializer_list' or neither are used.
 
590
  // neither are used when the clause represents the empty initializer "{}"
 
591
 
 
592
  // assignment expression
 
593
  ExpressionAST *expression;
 
594
  const ListNode<InitializerClauseAST*> *initializer_list;
 
595
};
 
596
 
 
597
class LabeledStatementAST : public StatementAST
 
598
{
 
599
public:
 
600
 
 
601
  DECLARE_AST_NODE(LabeledStatement)
 
602
 
 
603
  uint label;
 
604
  //The constant label expression
 
605
  ExpressionAST *expression;
 
606
  StatementAST* statement;
 
607
};
 
608
 
 
609
class LinkageBodyAST : public AST
 
610
{
 
611
public:
 
612
 
 
613
  DECLARE_AST_NODE(LinkageBody)
 
614
 
 
615
  const ListNode<DeclarationAST*> *declarations;
 
616
};
 
617
 
 
618
class LinkageSpecificationAST : public DeclarationAST
 
619
{
 
620
public:
 
621
 
 
622
  DECLARE_AST_NODE(LinkageSpecification)
 
623
 
 
624
  uint extern_type;
 
625
  LinkageBodyAST *linkage_body;
 
626
  DeclarationAST *declaration;
 
627
};
 
628
 
 
629
class MemInitializerAST : public AST
 
630
{
 
631
public:
 
632
 
 
633
  DECLARE_AST_NODE(MemInitializer)
 
634
 
 
635
  NameAST *initializer_id;
 
636
  ExpressionAST *expression;
 
637
};
 
638
 
 
639
class NameAST : public AST
 
640
{
 
641
public:
 
642
 
 
643
  DECLARE_AST_NODE(Name)
 
644
 
 
645
  bool global;
 
646
  const ListNode<UnqualifiedNameAST*> *qualified_names;
 
647
  UnqualifiedNameAST *unqualified_name;
 
648
};
 
649
 
 
650
class NamespaceAST : public DeclarationAST
 
651
{
 
652
public:
 
653
 
 
654
  DECLARE_AST_NODE(Namespace)
 
655
 
 
656
  uint namespace_name;
 
657
  LinkageBodyAST *linkage_body;
 
658
};
 
659
 
 
660
class NamespaceAliasDefinitionAST : public DeclarationAST
 
661
{
 
662
public:
 
663
 
 
664
  DECLARE_AST_NODE(NamespaceAliasDefinition)
 
665
 
 
666
  uint namespace_name;
 
667
  NameAST *alias_name;
 
668
};
 
669
 
 
670
class NewDeclaratorAST : public AST
 
671
{
 
672
public:
 
673
 
 
674
  DECLARE_AST_NODE(NewDeclarator)
 
675
 
 
676
  PtrOperatorAST *ptr_op;
 
677
  NewDeclaratorAST *sub_declarator;
 
678
  const ListNode<ExpressionAST*> *expressions;
 
679
};
 
680
 
 
681
class NewExpressionAST : public ExpressionAST
 
682
{
 
683
public:
 
684
 
 
685
  DECLARE_AST_NODE(NewExpression)
 
686
 
 
687
  uint scope_token;
 
688
  uint new_token;
 
689
  ExpressionAST *expression;
 
690
  TypeIdAST *type_id;
 
691
  NewTypeIdAST *new_type_id;
 
692
  NewInitializerAST *new_initializer;
 
693
};
 
694
 
 
695
class NewInitializerAST : public AST
 
696
{
 
697
public:
 
698
 
 
699
  DECLARE_AST_NODE(NewInitializer)
 
700
 
 
701
  ExpressionAST *expression;
 
702
};
 
703
 
 
704
class NewTypeIdAST : public AST
 
705
{
 
706
public:
 
707
 
 
708
  DECLARE_AST_NODE(NewTypeId)
 
709
 
 
710
  TypeSpecifierAST *type_specifier;
 
711
  NewInitializerAST *new_initializer;
 
712
  NewDeclaratorAST *new_declarator;
 
713
};
 
714
 
 
715
class OperatorAST : public AST
 
716
{
 
717
public:
 
718
 
 
719
  DECLARE_AST_NODE(Operator)
 
720
 
 
721
  uint op; //Index of the token that describes the operator
 
722
  uint open;
 
723
  uint close;
 
724
};
 
725
 
 
726
class OperatorFunctionIdAST : public AST
 
727
{
 
728
public:
 
729
 
 
730
  DECLARE_AST_NODE(OperatorFunctionId)
 
731
 
 
732
  OperatorAST *op;
 
733
  TypeSpecifierAST *type_specifier;
 
734
  const ListNode<PtrOperatorAST*> *ptr_ops;
 
735
};
 
736
 
 
737
class ParameterDeclarationAST : public AST
 
738
{
 
739
public:
 
740
 
 
741
  DECLARE_AST_NODE(ParameterDeclaration)
 
742
 
 
743
  TypeSpecifierAST *type_specifier;
 
744
  DeclaratorAST *declarator;
 
745
  ExpressionAST *expression;
 
746
};
 
747
 
 
748
class ParameterDeclarationClauseAST : public AST
 
749
{
 
750
public:
 
751
 
 
752
  DECLARE_AST_NODE(ParameterDeclarationClause)
 
753
 
 
754
  const ListNode<ParameterDeclarationAST*> *parameter_declarations;
 
755
  uint ellipsis;
 
756
};
 
757
 
 
758
/**
 
759
 * A post-fix expression is an expression that consists of one primary expression and multiple sub-expressions that are evaluated from
 
760
 * left to right, each  sub-expression based on the previous expression.
 
761
 *
 
762
 *
 
763
 * Examples:
 
764
 * "a->b"  : "a" is the primary expression, "->b" is a sub-expression
 
765
 * "a->b(5,3)" : "a" is the primary expression, "->b" is a sub-expression, and "(5,3)" is a sub-expression
 
766
 **/
 
767
class PostfixExpressionAST : public ExpressionAST
 
768
{
 
769
public:
 
770
 
 
771
  DECLARE_AST_NODE(PostfixExpression)
 
772
 
 
773
  TypeSpecifierAST *type_specifier;
 
774
  ExpressionAST *expression;
 
775
  const ListNode<ExpressionAST*> *sub_expressions;
 
776
};
 
777
 
 
778
class PrimaryExpressionAST : public ExpressionAST
 
779
{
 
780
public:
 
781
 
 
782
  DECLARE_AST_NODE(PrimaryExpression)
 
783
 
 
784
  StringLiteralAST *literal;
 
785
  uint token;
 
786
  StatementAST *expression_statement;
 
787
  ExpressionAST *sub_expression;
 
788
  NameAST *name;
 
789
};
 
790
 
 
791
class PtrOperatorAST : public AST
 
792
{
 
793
public:
 
794
 
 
795
  DECLARE_AST_NODE(PtrOperator)
 
796
 
 
797
  const ListNode<uint> *cv;
 
798
  uint op; //Index of the token that describes the operator. Is zero when mem_ptr is non-zero.
 
799
  PtrToMemberAST *mem_ptr;
 
800
};
 
801
 
 
802
class PtrToMemberAST : public AST
 
803
{
 
804
public:
 
805
 
 
806
  DECLARE_AST_NODE(PtrToMember)
 
807
};
 
808
 
 
809
class JumpStatementAST : public StatementAST
 
810
{
 
811
public:
 
812
 
 
813
  DECLARE_AST_NODE(JumpStatement)
 
814
 
 
815
  // index of operator token which describes the jump, one of
 
816
  // 'break', 'continue' or 'goto.  Return statements are handled by
 
817
  // ReturnStatementAST
 
818
  uint op;
 
819
  // identifier for 'goto' statements
 
820
  uint identifier;
 
821
};
 
822
 
 
823
class ReturnStatementAST : public StatementAST
 
824
{
 
825
public:
 
826
 
 
827
  DECLARE_AST_NODE(ReturnStatement)
 
828
 
 
829
  ExpressionAST *expression;
 
830
};
 
831
 
 
832
class SimpleDeclarationAST : public DeclarationAST
 
833
{
 
834
public:
 
835
 
 
836
  DECLARE_AST_NODE(SimpleDeclaration)
 
837
 
 
838
  const ListNode<uint> *storage_specifiers;
 
839
  const ListNode<uint> *function_specifiers;
 
840
  TypeSpecifierAST *type_specifier;
 
841
  const ListNode<InitDeclaratorAST*> *init_declarators;
 
842
  WinDeclSpecAST *win_decl_specifiers;
 
843
};
 
844
 
 
845
class SimpleTypeSpecifierAST : public TypeSpecifierAST
 
846
{
 
847
public:
 
848
 
 
849
  DECLARE_AST_NODE(SimpleTypeSpecifier)
 
850
 
 
851
  const ListNode<uint> *integrals;
 
852
  uint type_of;
 
853
  TypeIdAST *type_id;
 
854
  ExpressionAST *expression;
 
855
  NameAST *name;
 
856
};
 
857
 
 
858
class SizeofExpressionAST : public ExpressionAST
 
859
{
 
860
public:
 
861
 
 
862
  DECLARE_AST_NODE(SizeofExpression)
 
863
 
 
864
  uint sizeof_token;
 
865
  TypeIdAST *type_id;
 
866
  ExpressionAST *expression;
 
867
};
 
868
 
 
869
class StringLiteralAST : public AST
 
870
{
 
871
public:
 
872
 
 
873
  DECLARE_AST_NODE(StringLiteral)
 
874
 
 
875
  const ListNode<uint> *literals;
 
876
};
 
877
 
 
878
/// operator []
 
879
class SubscriptExpressionAST : public ExpressionAST
 
880
{
 
881
public:
 
882
 
 
883
  DECLARE_AST_NODE(SubscriptExpression)
 
884
 
 
885
  ExpressionAST *subscript;
 
886
};
 
887
 
 
888
class SwitchStatementAST : public StatementAST
 
889
{
 
890
public:
 
891
 
 
892
  DECLARE_AST_NODE(SwitchStatement)
 
893
 
 
894
  ConditionAST *condition;
 
895
  StatementAST *statement;
 
896
};
 
897
 
 
898
class TemplateArgumentAST : public AST
 
899
{
 
900
public:
 
901
 
 
902
  DECLARE_AST_NODE(TemplateArgument)
 
903
 
 
904
  TypeIdAST *type_id;
 
905
  ExpressionAST *expression;
 
906
};
 
907
 
 
908
class TemplateDeclarationAST : public DeclarationAST
 
909
{
 
910
public:
 
911
 
 
912
  DECLARE_AST_NODE(TemplateDeclaration)
 
913
 
 
914
  uint exported;
 
915
  const ListNode<TemplateParameterAST*> *template_parameters;
 
916
  DeclarationAST* declaration;
 
917
};
 
918
 
 
919
class TemplateParameterAST : public AST
 
920
{
 
921
public:
 
922
 
 
923
  DECLARE_AST_NODE(TemplateParameter)
 
924
 
 
925
  TypeParameterAST *type_parameter; //This is used if this is a template-parameter like "class A"
 
926
  ParameterDeclarationAST *parameter_declaration; //This is used if this is a template-parameter like "int a"
 
927
};
 
928
 
 
929
class ThrowExpressionAST : public ExpressionAST
 
930
{
 
931
public:
 
932
 
 
933
  DECLARE_AST_NODE(ThrowExpression)
 
934
 
 
935
  uint throw_token;
 
936
  ExpressionAST *expression;
 
937
};
 
938
 
 
939
class TranslationUnitAST : public AST, public CommentAST
 
940
{
 
941
public:
 
942
 
 
943
public:
 
944
 
 
945
  DECLARE_AST_NODE(TranslationUnit)
 
946
 
 
947
  const ListNode<DeclarationAST*> *declarations;
 
948
 
 
949
  ///true if either a '}' was missing at the end, or there was a '}' too much.
 
950
  ///This indicates a temporary state where the user is typing, and the document is completely invalid.
 
951
  bool hadMissingCompoundTokens;
 
952
 
 
953
  // Note: non AST related, saves parsing session...
 
954
  ParseSession* session;
 
955
};
 
956
 
 
957
class TryBlockStatementAST : public StatementAST
 
958
{
 
959
public:
 
960
 
 
961
  DECLARE_AST_NODE(TryBlockStatement)
 
962
 
 
963
  StatementAST* try_block;
 
964
  const ListNode<CatchStatementAST*> *catch_blocks;
 
965
};
 
966
 
 
967
class CatchStatementAST : public StatementAST
 
968
{
 
969
public:
 
970
 
 
971
  DECLARE_AST_NODE(CatchStatement)
 
972
 
 
973
  ConditionAST* condition;
 
974
  StatementAST* statement;
 
975
};
 
976
 
 
977
class TypeIdAST : public AST
 
978
{
 
979
public:
 
980
 
 
981
  DECLARE_AST_NODE(TypeId)
 
982
 
 
983
  TypeSpecifierAST *type_specifier;
 
984
  DeclaratorAST *declarator;
 
985
};
 
986
 
 
987
///"typename"
 
988
class TypeIdentificationAST : public ExpressionAST
 
989
{
 
990
public:
 
991
 
 
992
  DECLARE_AST_NODE(TypeIdentification)
 
993
 
 
994
  uint typename_token;
 
995
  NameAST *name;
 
996
  ExpressionAST *expression;
 
997
};
 
998
 
 
999
class TypeParameterAST : public AST
 
1000
{
 
1001
public:
 
1002
 
 
1003
  DECLARE_AST_NODE(TypeParameter)
 
1004
 
 
1005
  uint type;
 
1006
  NameAST *name;
 
1007
  TypeIdAST *type_id;
 
1008
  const ListNode<TemplateParameterAST*> *template_parameters;
 
1009
  NameAST *template_name;
 
1010
};
 
1011
 
 
1012
class TypedefAST : public DeclarationAST
 
1013
{
 
1014
public:
 
1015
 
 
1016
  DECLARE_AST_NODE(Typedef)
 
1017
 
 
1018
  TypeSpecifierAST *type_specifier;
 
1019
  const ListNode<InitDeclaratorAST*> *init_declarators;
 
1020
};
 
1021
 
 
1022
class UnaryExpressionAST : public ExpressionAST
 
1023
{
 
1024
public:
 
1025
 
 
1026
  DECLARE_AST_NODE(UnaryExpression)
 
1027
 
 
1028
  uint op; //Index of the token that describes the operator
 
1029
  ExpressionAST *expression;
 
1030
};
 
1031
 
 
1032
class UnqualifiedNameAST : public AST
 
1033
{
 
1034
public:
 
1035
 
 
1036
  DECLARE_AST_NODE(UnqualifiedName)
 
1037
 
 
1038
  uint tilde;
 
1039
  uint id;
 
1040
  bool ellipsis;
 
1041
  OperatorFunctionIdAST *operator_id;
 
1042
  const ListNode<TemplateArgumentAST*> *template_arguments;
 
1043
};
 
1044
 
 
1045
class UsingAST : public DeclarationAST
 
1046
{
 
1047
public:
 
1048
 
 
1049
  DECLARE_AST_NODE(Using)
 
1050
 
 
1051
  uint type_name;
 
1052
  NameAST *name;
 
1053
};
 
1054
 
 
1055
class UsingDirectiveAST : public DeclarationAST
 
1056
{
 
1057
public:
 
1058
 
 
1059
  DECLARE_AST_NODE(UsingDirective)
 
1060
 
 
1061
  NameAST *name;
 
1062
};
 
1063
 
 
1064
class WhileStatementAST : public StatementAST
 
1065
{
 
1066
public:
 
1067
 
 
1068
  DECLARE_AST_NODE(WhileStatement)
 
1069
 
 
1070
  ConditionAST *condition;
 
1071
  StatementAST *statement;
 
1072
};
 
1073
 
 
1074
class WinDeclSpecAST : public AST
 
1075
{
 
1076
public:
 
1077
 
 
1078
  DECLARE_AST_NODE(WinDeclSpec)
 
1079
 
 
1080
  uint specifier;
 
1081
  uint modifier;
 
1082
};
 
1083
 
 
1084
template <class _Tp>
 
1085
_Tp *CreateNode(pool *memory_pool)
 
1086
{
 
1087
  _Tp *node = reinterpret_cast<_Tp*>(memory_pool->allocate(sizeof(_Tp)));
 
1088
  node->kind = _Tp::__node_kind;
 
1089
  return node;
 
1090
}
 
1091
 
 
1092
template <class _Tp>
 
1093
_Tp ast_cast(AST *item)
 
1094
{
 
1095
  if (item && static_cast<_Tp>(0)->__node_kind == item->kind)
 
1096
    return static_cast<_Tp>(item);
 
1097
 
 
1098
  return 0;
 
1099
}
 
1100
 
 
1101
#endif // AST_H
 
1102