cpptoxml/parser/ast.h

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