src/ast.h

   1 /****************************************************************************
   2 **
   3 ** Copyright (C) 1992-2007 Trolltech ASA. All rights reserved.
   4 **
   5 ** This file is part of Qt Jambi.
   6 **
   7 ** ** This file may be used under the terms of the GNU General Public
   8 ** License version 2.0 as published by the Free Software Foundation
   9 ** and appearing in the file LICENSE.GPL included in the packaging of
  10 ** this file.  Please review the following information to ensure GNU
  11 ** General Public Licensing requirements will be met:
  12 ** http://www.trolltech.com/products/qt/opensource.html
  13 **
  14 ** If you are unsure which license is appropriate for your use, please
  15 ** review the following information:
  16 ** http://www.trolltech.com/products/qt/licensing.html or contact the
  17 ** sales department at sales@trolltech.com.
  18
  19 **
  20 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
  21 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  22 **
  23 ****************************************************************************/
  24
  25 /* This file is part of KDevelop
  26     Copyright (C) 2002-2005 Roberto Raggi <roberto@kdevelop.org>
  27
  28    This library is free software; you can redistribute it and/or
  29    modify it under the terms of the GNU Library General Public
  30    License version 2 as published by the Free Software Foundation.
  31
  32    This library is distributed in the hope that it will be useful,
  33    but WITHOUT ANY WARRANTY; without even the implied warranty of
  34    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  35    Library General Public License for more details.
  36
  37    You should have received a copy of the GNU Library General Public License
  38    along with this library; see the file COPYING.LIB.  If not, write to
  39    the Free Software Foundation, Inc., 51 Franklin Steet, Fifth Floor,
  40    Boston, MA 02110-1301, USA.
  41 */
  42
  43 #ifndef AST_H
  44 #define AST_H
  45
  46 #include "smallobject.h"
  47 #include "list.h"
  48
  49 #define DECLARE_AST_NODE(k) \
  50     enum { __node_kind = Kind_##k };
  51
  52 struct AccessSpecifierAST;
  53 struct AsmDefinitionAST;
  54 struct BaseClauseAST;
  55 struct BaseSpecifierAST;
  56 struct BinaryExpressionAST;
  57 struct CastExpressionAST;
  58 struct ClassMemberAccessAST;
  59 struct ClassSpecifierAST;
  60 struct CompoundStatementAST;
  61 struct ConditionAST;
  62 struct ConditionalExpressionAST;
  63 struct CppCastExpressionAST;
  64 struct CtorInitializerAST;
  65 struct DeclarationAST;
  66 struct DeclarationStatementAST;
  67 struct DeclaratorAST;
  68 struct DeleteExpressionAST;
  69 struct DoStatementAST;
  70 struct ElaboratedTypeSpecifierAST;
  71 struct EnumSpecifierAST;
  72 struct EnumeratorAST;
  73 struct ExceptionSpecificationAST;
  74 struct ExpressionAST;
  75 struct ExpressionOrDeclarationStatementAST;
  76 struct ExpressionStatementAST;
  77 struct ForStatementAST;
  78 struct FunctionCallAST;
  79 struct FunctionDefinitionAST;
  80 struct IfStatementAST;
  81 struct IncrDecrExpressionAST;
  82 struct InitDeclaratorAST;
  83 struct InitializerAST;
  84 struct InitializerClauseAST;
  85 struct LabeledStatementAST;
  86 struct LinkageBodyAST;
  87 struct LinkageSpecificationAST;
  88 struct MemInitializerAST;
  89 struct NameAST;
  90 struct NamespaceAST;
  91 struct NamespaceAliasDefinitionAST;
  92 struct NewDeclaratorAST;
  93 struct NewExpressionAST;
  94 struct NewInitializerAST;
  95 struct NewTypeIdAST;
  96 struct OperatorAST;
  97 struct OperatorFunctionIdAST;
  98 struct ParameterDeclarationAST;
  99 struct ParameterDeclarationClauseAST;
 100 struct PostfixExpressionAST;
 101 struct PrimaryExpressionAST;
 102 struct PtrOperatorAST;
 103 struct PtrToMemberAST;
 104 struct ReturnStatementAST;
 105 struct SimpleDeclarationAST;
 106 struct SimpleTypeSpecifierAST;
 107 struct SizeofExpressionAST;
 108 struct StatementAST;
 109 struct StringLiteralAST;
 110 struct SubscriptExpressionAST;
 111 struct SwitchStatementAST;
 112 struct TemplateArgumentAST;
 113 struct TemplateDeclarationAST;
 114 struct TemplateParameterAST;
 115 struct ThrowExpressionAST;
 116 struct TranslationUnitAST;
 117 struct TryBlockStatementAST;
 118 struct TypeIdAST;
 119 struct TypeIdentificationAST;
 120 struct TypeParameterAST;
 121 struct TypeSpecifierAST;
 122 struct TypedefAST;
 123 struct UnaryExpressionAST;
 124 struct UnqualifiedNameAST;
 125 struct UsingAST;
 126 struct UsingDirectiveAST;
 127 struct WhileStatementAST;
 128 struct WinDeclSpecAST;
 129 struct QPropertyAST;
 130
 131 struct AST
 132 {
 133   enum NODE_KIND
 134     {
 135       Kind_UNKNOWN = 0,
 136
 137       Kind_AccessSpecifier,
 138       Kind_AsmDefinition,
 139       Kind_BaseClause,
 140       Kind_BaseSpecifier,
 141       Kind_BinaryExpression,
 142       Kind_CastExpression,
 143       Kind_ClassMemberAccess,
 144       Kind_ClassSpecifier,
 145       Kind_CompoundStatement,
 146       Kind_Condition,
 147       Kind_ConditionalExpression,
 148       Kind_CppCastExpression,
 149       Kind_CtorInitializer,
 150       Kind_DeclarationStatement,
 151       Kind_Declarator,
 152       Kind_DeleteExpression,
 153       Kind_DoStatement,
 154       Kind_ElaboratedTypeSpecifier,
 155       Kind_EnumSpecifier,
 156       Kind_Enumerator,
 157       Kind_ExceptionSpecification,
 158       Kind_ExpressionOrDeclarationStatement,
 159       Kind_ExpressionStatement,
 160       Kind_ForStatement,
 161       Kind_FunctionCall,
 162       Kind_FunctionDefinition,
 163       Kind_IfStatement,
 164       Kind_IncrDecrExpression,
 165       Kind_InitDeclarator,
 166       Kind_Initializer,
 167       Kind_InitializerClause,
 168       Kind_LabeledStatement,
 169       Kind_LinkageBody,
 170       Kind_LinkageSpecification,
 171       Kind_MemInitializer,
 172       Kind_Name,
 173       Kind_Namespace,
 174       Kind_NamespaceAliasDefinition,
 175       Kind_NewDeclarator,
 176       Kind_NewExpression,
 177       Kind_NewInitializer,
 178       Kind_NewTypeId,
 179       Kind_Operator,
 180       Kind_OperatorFunctionId,
 181       Kind_ParameterDeclaration,
 182       Kind_ParameterDeclarationClause,
 183       Kind_PostfixExpression,
 184       Kind_PrimaryExpression,
 185       Kind_PtrOperator,
 186       Kind_PtrToMember,
 187       Kind_ReturnStatement,
 188       Kind_SimpleDeclaration,
 189       Kind_SimpleTypeSpecifier,
 190       Kind_SizeofExpression,
 191       Kind_StringLiteral,
 192       Kind_SubscriptExpression,
 193       Kind_SwitchStatement,
 194       Kind_TemplateArgument,
 195       Kind_TemplateDeclaration,
 196       Kind_TemplateParameter,
 197       Kind_ThrowExpression,
 198       Kind_TranslationUnit,
 199       Kind_TryBlockStatement,
 200       Kind_TypeId,
 201       Kind_TypeIdentification,
 202       Kind_TypeParameter,
 203       Kind_Typedef,
 204       Kind_UnaryExpression,
 205       Kind_UnqualifiedName,
 206       Kind_Using,
 207       Kind_UsingDirective,
 208       Kind_WhileStatement,
 209       Kind_WinDeclSpec,
 210       Kind_QPropertyAST,
 211
 212       NODE_KIND_COUNT
 213     };
 214
 215   int kind;
 216
 217   std::size_t start_token;
 218   std::size_t end_token;
 219 };
 220
 221 struct TypeSpecifierAST: public AST
 222 {
 223   const ListNode<std::size_t> *cv;
 224 };
 225
 226 struct StatementAST: public AST
 227 {
 228 };
 229
 230 struct ExpressionAST: public AST
 231 {
 232 };
 233
 234 struct DeclarationAST: public AST
 235 {
 236 };
 237
 238 struct AccessSpecifierAST: public DeclarationAST
 239 {
 240   DECLARE_AST_NODE(AccessSpecifier)
 241
 242   const ListNode<std::size_t> *specs;
 243 };
 244
 245 struct AsmDefinitionAST: public DeclarationAST
 246 {
 247   DECLARE_AST_NODE(AsmDefinition)
 248
 249   const ListNode<std::size_t> *cv;
 250 };
 251
 252 struct BaseClauseAST: public AST // ### kill me
 253 {
 254   DECLARE_AST_NODE(BaseClause)
 255
 256   const ListNode<BaseSpecifierAST*> *base_specifiers;
 257 };
 258
 259 struct BaseSpecifierAST: public AST
 260 {
 261   DECLARE_AST_NODE(BaseSpecifier)
 262
 263   std::size_t virt;
 264   std::size_t access_specifier;
 265   NameAST *name;
 266 };
 267
 268 struct BinaryExpressionAST: public ExpressionAST
 269 {
 270   DECLARE_AST_NODE(BinaryExpression)
 271
 272   std::size_t op;
 273   ExpressionAST *left_expression;
 274   ExpressionAST *right_expression;
 275 };
 276
 277 struct CastExpressionAST: public ExpressionAST
 278 {
 279   DECLARE_AST_NODE(CastExpression)
 280
 281   TypeIdAST *type_id;
 282   ExpressionAST *expression;
 283 };
 284
 285 struct ClassMemberAccessAST: public ExpressionAST
 286 {
 287   DECLARE_AST_NODE(ClassMemberAccess)
 288
 289   std::size_t op;
 290   NameAST *name;
 291 };
 292
 293 struct ClassSpecifierAST: public TypeSpecifierAST
 294 {
 295   DECLARE_AST_NODE(ClassSpecifier)
 296
 297   WinDeclSpecAST *win_decl_specifiers;
 298   std::size_t class_key;
 299   NameAST *name;
 300   BaseClauseAST *base_clause;
 301   const ListNode<DeclarationAST*> *member_specs;
 302 };
 303
 304 struct CompoundStatementAST: public StatementAST
 305 {
 306   DECLARE_AST_NODE(CompoundStatement)
 307
 308   const ListNode<StatementAST*> *statements;
 309 };
 310
 311 struct ConditionAST: public AST
 312 {
 313   DECLARE_AST_NODE(Condition)
 314
 315   TypeSpecifierAST *type_specifier;
 316   DeclaratorAST *declarator;
 317   ExpressionAST *expression;
 318 };
 319
 320 struct ConditionalExpressionAST: public ExpressionAST
 321 {
 322   DECLARE_AST_NODE(ConditionalExpression)
 323
 324   ExpressionAST *condition;
 325   ExpressionAST *left_expression;
 326   ExpressionAST *right_expression;
 327 };
 328
 329 struct CppCastExpressionAST: public ExpressionAST
 330 {
 331   DECLARE_AST_NODE(CppCastExpression)
 332
 333   std::size_t op;
 334   TypeIdAST *type_id;
 335   ExpressionAST *expression;
 336   const ListNode<ExpressionAST*> *sub_expressions;
 337 };
 338
 339 struct CtorInitializerAST: public AST
 340 {
 341   DECLARE_AST_NODE(CtorInitializer)
 342
 343   std::size_t colon;
 344   const ListNode<MemInitializerAST*> *member_initializers;
 345 };
 346
 347 struct DeclarationStatementAST: public StatementAST
 348 {
 349   DECLARE_AST_NODE(DeclarationStatement)
 350
 351   DeclarationAST *declaration;
 352 };
 353
 354 struct DeclaratorAST: public AST
 355 {
 356   DECLARE_AST_NODE(Declarator)
 357
 358   const ListNode<PtrOperatorAST*> *ptr_ops;
 359   DeclaratorAST *sub_declarator;
 360   NameAST *id;
 361   ExpressionAST *bit_expression;
 362   const ListNode<ExpressionAST*> *array_dimensions;
 363   ParameterDeclarationClauseAST *parameter_declaration_clause;
 364   const ListNode<std::size_t> *fun_cv;
 365   ExceptionSpecificationAST *exception_spec;
 366 };
 367
 368 struct DeleteExpressionAST: public ExpressionAST
 369 {
 370   DECLARE_AST_NODE(DeleteExpression)
 371
 372   std::size_t scope_token;
 373   std::size_t delete_token;
 374   std::size_t lbracket_token;
 375   std::size_t rbracket_token;
 376   ExpressionAST *expression;
 377 };
 378
 379 struct DoStatementAST: public StatementAST
 380 {
 381   DECLARE_AST_NODE(DoStatement)
 382
 383   StatementAST *statement;
 384   ExpressionAST *expression;
 385 };
 386
 387 struct ElaboratedTypeSpecifierAST: public TypeSpecifierAST
 388 {
 389   DECLARE_AST_NODE(ElaboratedTypeSpecifier)
 390
 391   std::size_t type;
 392   NameAST *name;
 393 };
 394
 395 struct EnumSpecifierAST: public TypeSpecifierAST
 396 {
 397   DECLARE_AST_NODE(EnumSpecifier)
 398
 399   NameAST *name;
 400   const ListNode<EnumeratorAST*> *enumerators;
 401 };
 402
 403 struct EnumeratorAST: public AST
 404 {
 405   DECLARE_AST_NODE(Enumerator)
 406
 407   std::size_t id;
 408   ExpressionAST *expression;
 409 };
 410
 411 struct ExceptionSpecificationAST: public AST
 412 {
 413   DECLARE_AST_NODE(ExceptionSpecification)
 414
 415   std::size_t ellipsis;
 416   const ListNode<TypeIdAST*> *type_ids;
 417 };
 418
 419 struct ExpressionOrDeclarationStatementAST: public StatementAST
 420 {
 421   DECLARE_AST_NODE(ExpressionOrDeclarationStatement)
 422
 423   StatementAST *expression;
 424   StatementAST *declaration;
 425 };
 426
 427 struct ExpressionStatementAST: public StatementAST
 428 {
 429   DECLARE_AST_NODE(ExpressionStatement)
 430
 431   ExpressionAST *expression;
 432 };
 433
 434 struct FunctionCallAST: public ExpressionAST
 435 {
 436   DECLARE_AST_NODE(FunctionCall)
 437
 438   ExpressionAST *arguments;
 439 };
 440
 441 struct FunctionDefinitionAST: public DeclarationAST
 442 {
 443   DECLARE_AST_NODE(FunctionDefinition)
 444
 445   const ListNode<std::size_t> *storage_specifiers;
 446   const ListNode<std::size_t> *function_specifiers;
 447   TypeSpecifierAST *type_specifier;
 448   InitDeclaratorAST *init_declarator;
 449   StatementAST *function_body;
 450   WinDeclSpecAST *win_decl_specifiers;
 451 };
 452
 453 struct ForStatementAST: public StatementAST
 454 {
 455   DECLARE_AST_NODE(ForStatement)
 456
 457   StatementAST *init_statement;
 458   ConditionAST *condition;
 459   ExpressionAST *expression;
 460   StatementAST *statement;
 461 };
 462
 463 struct IfStatementAST: public StatementAST
 464 {
 465   DECLARE_AST_NODE(IfStatement)
 466
 467   ConditionAST *condition;
 468   StatementAST *statement;
 469   StatementAST *else_statement;
 470 };
 471
 472 struct IncrDecrExpressionAST: public ExpressionAST
 473 {
 474   DECLARE_AST_NODE(IncrDecrExpression)
 475
 476   std::size_t op;
 477 };
 478
 479 struct InitDeclaratorAST: public AST
 480 {
 481   DECLARE_AST_NODE(InitDeclarator)
 482
 483   DeclaratorAST *declarator;
 484   InitializerAST *initializer;
 485 };
 486
 487 struct InitializerAST: public AST
 488 {
 489   DECLARE_AST_NODE(Initializer)
 490
 491   InitializerClauseAST *initializer_clause;
 492   ExpressionAST *expression;
 493 };
 494
 495 struct InitializerClauseAST: public AST
 496 {
 497   DECLARE_AST_NODE(InitializerClause)
 498
 499   ExpressionAST *expression;
 500 };
 501
 502 struct LabeledStatementAST: public StatementAST
 503 {
 504   DECLARE_AST_NODE(LabeledStatement)
 505 };
 506
 507 struct LinkageBodyAST: public AST
 508 {
 509   DECLARE_AST_NODE(LinkageBody)
 510
 511   const ListNode<DeclarationAST*> *declarations;
 512 };
 513
 514 struct LinkageSpecificationAST: public DeclarationAST
 515 {
 516   DECLARE_AST_NODE(LinkageSpecification)
 517
 518   std::size_t extern_type;
 519   LinkageBodyAST *linkage_body;
 520   DeclarationAST *declaration;
 521 };
 522
 523 struct MemInitializerAST: public AST
 524 {
 525   DECLARE_AST_NODE(MemInitializer)
 526
 527   NameAST *initializer_id;
 528   ExpressionAST *expression;
 529 };
 530
 531 struct NameAST: public AST
 532 {
 533   DECLARE_AST_NODE(Name)
 534
 535   bool global;
 536   const ListNode<UnqualifiedNameAST*> *qualified_names;
 537   UnqualifiedNameAST *unqualified_name;
 538 };
 539
 540 struct NamespaceAST: public DeclarationAST
 541 {
 542   DECLARE_AST_NODE(Namespace)
 543
 544   std::size_t namespace_name;
 545   LinkageBodyAST *linkage_body;
 546 };
 547
 548 struct NamespaceAliasDefinitionAST: public DeclarationAST
 549 {
 550   DECLARE_AST_NODE(NamespaceAliasDefinition)
 551
 552   std::size_t namespace_name;
 553   NameAST *alias_name;
 554 };
 555
 556 struct NewDeclaratorAST: public AST
 557 {
 558   DECLARE_AST_NODE(NewDeclarator)
 559
 560   PtrOperatorAST *ptr_op;
 561   NewDeclaratorAST *sub_declarator;
 562   const ListNode<ExpressionAST*> *expressions;
 563 };
 564
 565 struct NewExpressionAST: public ExpressionAST
 566 {
 567   DECLARE_AST_NODE(NewExpression)
 568
 569   std::size_t scope_token;
 570   std::size_t new_token;
 571   ExpressionAST *expression;
 572   TypeIdAST *type_id;
 573   NewTypeIdAST *new_type_id;
 574   NewInitializerAST *new_initializer;
 575 };
 576
 577 struct NewInitializerAST: public AST
 578 {
 579   DECLARE_AST_NODE(NewInitializer)
 580
 581   ExpressionAST *expression;
 582 };
 583
 584 struct NewTypeIdAST: public AST
 585 {
 586   DECLARE_AST_NODE(NewTypeId)
 587
 588   TypeSpecifierAST *type_specifier;
 589   NewInitializerAST *new_initializer;
 590   NewDeclaratorAST *new_declarator;
 591 };
 592
 593 struct OperatorAST: public AST
 594 {
 595   DECLARE_AST_NODE(Operator)
 596
 597   std::size_t op;
 598   std::size_t open;
 599   std::size_t close;
 600 };
 601
 602 struct OperatorFunctionIdAST: public AST
 603 {
 604   DECLARE_AST_NODE(OperatorFunctionId)
 605
 606   OperatorAST *op;
 607   TypeSpecifierAST *type_specifier;
 608   const ListNode<PtrOperatorAST*> *ptr_ops;
 609 };
 610
 611 struct ParameterDeclarationAST: public AST
 612 {
 613   DECLARE_AST_NODE(ParameterDeclaration)
 614
 615   TypeSpecifierAST *type_specifier;
 616   DeclaratorAST *declarator;
 617   ExpressionAST *expression;
 618 };
 619
 620 struct ParameterDeclarationClauseAST: public AST
 621 {
 622   DECLARE_AST_NODE(ParameterDeclarationClause)
 623
 624   const ListNode<ParameterDeclarationAST*> *parameter_declarations;
 625   std::size_t ellipsis;
 626 };
 627
 628 struct PostfixExpressionAST: public ExpressionAST
 629 {
 630   DECLARE_AST_NODE(PostfixExpression)
 631
 632   TypeSpecifierAST *type_specifier;
 633   ExpressionAST *expression;
 634   const ListNode<ExpressionAST*> *sub_expressions;
 635 };
 636
 637 struct PrimaryExpressionAST: public ExpressionAST
 638 {
 639   DECLARE_AST_NODE(PrimaryExpression)
 640
 641   StringLiteralAST *literal;
 642   std::size_t token;
 643   StatementAST *expression_statement;
 644   ExpressionAST *sub_expression;
 645   NameAST *name;
 646 };
 647
 648 struct PtrOperatorAST: public AST
 649 {
 650   DECLARE_AST_NODE(PtrOperator)
 651
 652   const ListNode<std::size_t> *cv;
 653   std::size_t op;
 654   PtrToMemberAST *mem_ptr;
 655 };
 656
 657 struct PtrToMemberAST: public AST
 658 {
 659   DECLARE_AST_NODE(PtrToMember)
 660 };
 661
 662 struct ReturnStatementAST: public StatementAST
 663 {
 664   DECLARE_AST_NODE(ReturnStatement)
 665
 666   ExpressionAST *expression;
 667 };
 668
 669 struct SimpleDeclarationAST: public DeclarationAST
 670 {
 671   DECLARE_AST_NODE(SimpleDeclaration)
 672
 673   const ListNode<std::size_t> *storage_specifiers;
 674   const ListNode<std::size_t> *function_specifiers;
 675   TypeSpecifierAST *type_specifier;
 676   const ListNode<InitDeclaratorAST*> *init_declarators;
 677   WinDeclSpecAST *win_decl_specifiers;
 678 };
 679
 680 struct SimpleTypeSpecifierAST: public TypeSpecifierAST
 681 {
 682   DECLARE_AST_NODE(SimpleTypeSpecifier)
 683
 684   const ListNode<std::size_t> *integrals;
 685   std::size_t type_of;
 686   TypeIdAST *type_id;
 687   ExpressionAST *expression;
 688   NameAST *name;
 689 };
 690
 691 struct SizeofExpressionAST: public ExpressionAST
 692 {
 693   DECLARE_AST_NODE(SizeofExpression)
 694
 695   std::size_t sizeof_token;
 696   TypeIdAST *type_id;
 697   ExpressionAST *expression;
 698 };
 699
 700 struct StringLiteralAST: public AST
 701 {
 702   DECLARE_AST_NODE(StringLiteral)
 703
 704   const ListNode<std::size_t> *literals;
 705 };
 706
 707 struct SubscriptExpressionAST: public ExpressionAST
 708 {
 709   DECLARE_AST_NODE(SubscriptExpression)
 710
 711   ExpressionAST *subscript;
 712 };
 713
 714 struct SwitchStatementAST: public StatementAST
 715 {
 716   DECLARE_AST_NODE(SwitchStatement)
 717
 718   ConditionAST *condition;
 719   StatementAST *statement;
 720 };
 721
 722 struct TemplateArgumentAST: public AST
 723 {
 724   DECLARE_AST_NODE(TemplateArgument)
 725
 726   TypeIdAST *type_id;
 727   ExpressionAST *expression;
 728 };
 729
 730 struct TemplateDeclarationAST: public DeclarationAST
 731 {
 732   DECLARE_AST_NODE(TemplateDeclaration)
 733
 734   std::size_t exported;
 735   const ListNode<TemplateParameterAST*> *template_parameters;
 736   DeclarationAST* declaration;
 737 };
 738
 739 struct TemplateParameterAST: public AST
 740 {
 741   DECLARE_AST_NODE(TemplateParameter)
 742
 743   TypeParameterAST *type_parameter;
 744   ParameterDeclarationAST *parameter_declaration;
 745 };
 746
 747 struct ThrowExpressionAST: public ExpressionAST
 748 {
 749   DECLARE_AST_NODE(ThrowExpression)
 750
 751   std::size_t throw_token;
 752   ExpressionAST *expression;
 753 };
 754
 755 struct TranslationUnitAST: public AST
 756 {
 757   DECLARE_AST_NODE(TranslationUnit)
 758
 759   const ListNode<DeclarationAST*> *declarations;
 760 };
 761
 762 struct TryBlockStatementAST: public StatementAST
 763 {
 764   DECLARE_AST_NODE(TryBlockStatement)
 765 };
 766
 767 struct TypeIdAST: public AST
 768 {
 769   DECLARE_AST_NODE(TypeId)
 770
 771   TypeSpecifierAST *type_specifier;
 772   DeclaratorAST *declarator;
 773 };
 774
 775 struct TypeIdentificationAST: public ExpressionAST
 776 {
 777   DECLARE_AST_NODE(TypeIdentification)
 778
 779   std::size_t typename_token;
 780   NameAST *name;
 781   ExpressionAST *expression;
 782 };
 783
 784 struct TypeParameterAST: public AST
 785 {
 786   DECLARE_AST_NODE(TypeParameter)
 787
 788   std::size_t type;
 789   NameAST *name;
 790   TypeIdAST *type_id;
 791   const ListNode<TemplateParameterAST*> *template_parameters;
 792   NameAST *template_name;
 793 };
 794
 795 struct TypedefAST: public DeclarationAST
 796 {
 797   DECLARE_AST_NODE(Typedef)
 798
 799   TypeSpecifierAST *type_specifier;
 800   const ListNode<InitDeclaratorAST*> *init_declarators;
 801 };
 802
 803 struct UnaryExpressionAST: public ExpressionAST
 804 {
 805   DECLARE_AST_NODE(UnaryExpression)
 806
 807   std::size_t op;
 808   ExpressionAST *expression;
 809 };
 810
 811 struct UnqualifiedNameAST: public AST
 812 {
 813   DECLARE_AST_NODE(UnqualifiedName)
 814
 815   std::size_t tilde;
 816   std::size_t id;
 817   OperatorFunctionIdAST *operator_id;
 818   const ListNode<TemplateArgumentAST*> *template_arguments;
 819 };
 820
 821 struct UsingAST: public DeclarationAST
 822 {
 823   DECLARE_AST_NODE(Using)
 824
 825   std::size_t type_name;
 826   NameAST *name;
 827 };
 828
 829 struct UsingDirectiveAST: public DeclarationAST
 830 {
 831   DECLARE_AST_NODE(UsingDirective)
 832
 833   NameAST *name;
 834 };
 835
 836 struct WhileStatementAST: public StatementAST
 837 {
 838   DECLARE_AST_NODE(WhileStatement)
 839
 840   ConditionAST *condition;
 841   StatementAST *statement;
 842 };
 843
 844 struct WinDeclSpecAST: public AST
 845 {
 846   DECLARE_AST_NODE(WinDeclSpec)
 847
 848   std::size_t specifier;
 849   std::size_t modifier;
 850 };
 851
 852 struct QPropertyAST : public DeclarationAST
 853 {
 854   DECLARE_AST_NODE(QPropertyAST)
 855 };
 856
 857 template <class _Tp>
 858 _Tp *CreateNode(pool *memory_pool)
 859 {
 860   _Tp *node = reinterpret_cast<_Tp*>(memory_pool->allocate(sizeof(_Tp)));
 861   node->kind = _Tp::__node_kind;
 862   return node;
 863 }
 864
 865 template <class _Tp>
 866 _Tp ast_cast(AST *item)
 867 {
 868   if (item && static_cast<_Tp>(0)->__node_kind == item->kind)
 869     return static_cast<_Tp>(item);
 870
 871   return 0;
 872 }
 873
 874 #endif // AST_H
 875
 876 // kate: space-indent on; indent-width 2; replace-tabs on;