cpptoxml/parser/parser.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 PARSER_H
  27 #define PARSER_H
  28
  29 #include "ast.h"
  30 #include "lexer.h"
  31
  32 #include <QtCore/QString>
  33
  34 class FileSymbol;
  35 class Control;
  36
  37 class Parser
  38 {
  39 public:
  40   Parser(Control *control);
  41   ~Parser();
  42
  43   LocationManager &location() { return _M_location; }
  44
  45   TranslationUnitAST *parse(const char *contents, std::size_t size, pool *p);
  46
  47 private:
  48   void reportError(const QString& msg);
  49   void syntaxError();
  50   void tokenRequiredError(int expected);
  51
  52 public:
  53   bool skipFunctionBody(StatementAST *&node);
  54
  55 public:
  56   bool parse_Attribute__();
  57   bool parseAbstractDeclarator(DeclaratorAST *&node);
  58   bool parseAccessSpecifier(DeclarationAST *&node);
  59   bool parseAdditiveExpression(ExpressionAST *&node);
  60   bool parseAndExpression(ExpressionAST *&node, bool templArgs = false);
  61   bool parseAsmDefinition(DeclarationAST *&node);
  62   bool parseAssignmentExpression(ExpressionAST *&node);
  63   bool parseBaseClause(BaseClauseAST *&node);
  64   bool parseBaseSpecifier(BaseSpecifierAST *&node);
  65   bool parseBlockDeclaration(DeclarationAST *&node);
  66   bool parseCastExpression(ExpressionAST *&node);
  67   bool parseClassSpecifier(TypeSpecifierAST *&node);
  68   bool parseForwardDeclarationSpecifier(TypeSpecifierAST *&node);
  69   bool parseCommaExpression(ExpressionAST *&node);
  70   bool parseCompoundStatement(StatementAST *&node);
  71   bool parseCondition(ConditionAST *&node, bool initRequired = true);
  72   bool parseConditionalExpression(ExpressionAST *&node);
  73   bool parseConstantExpression(ExpressionAST *&node);
  74   bool parseCtorInitializer(CtorInitializerAST *&node);
  75   bool parseCvQualify(const ListNode<std::size_t> *&node);
  76   bool parseDeclaration(DeclarationAST *&node);
  77   bool parseDeclarationInternal(DeclarationAST *&node);
  78   bool parseDeclarationStatement(StatementAST *&node);
  79   bool parseDeclarator(DeclaratorAST *&node);
  80   bool parseDeleteExpression(ExpressionAST *&node);
  81   bool parseDoStatement(StatementAST *&node);
  82   bool parseElaboratedTypeSpecifier(TypeSpecifierAST *&node);
  83   bool parseEnumSpecifier(TypeSpecifierAST *&node);
  84   bool parseEnumerator(EnumeratorAST *&node);
  85   bool parseEqualityExpression(ExpressionAST *&node,
  86                                bool templArgs = false);
  87   bool parseExceptionSpecification(ExceptionSpecificationAST *&node);
  88   bool parseExclusiveOrExpression(ExpressionAST *&node,
  89                                   bool templArgs = false);
  90   bool parseExpression(ExpressionAST *&node);
  91   bool parseExpressionOrDeclarationStatement(StatementAST *&node);
  92   bool parseExpressionStatement(StatementAST *&node);
  93   bool parseForInitStatement(StatementAST *&node);
  94   bool parseForStatement(StatementAST *&node);
  95   bool parseFunctionBody(StatementAST *&node);
  96   bool parseFunctionSpecifier(const ListNode<std::size_t> *&node);
  97   bool parseIfStatement(StatementAST *&node);
  98   bool parseInclusiveOrExpression(ExpressionAST *&node,
  99                                   bool templArgs = false);
 100   bool parseInitDeclarator(InitDeclaratorAST *&node);
 101   bool parseInitDeclaratorList(const ListNode<InitDeclaratorAST*> *&node);
 102   bool parseInitializer(InitializerAST *&node);
 103   bool parseInitializerClause(InitializerClauseAST *&node);
 104   bool parseLabeledStatement(StatementAST *&node);
 105   bool parseLinkageBody(LinkageBodyAST *&node);
 106   bool parseLinkageSpecification(DeclarationAST *&node);
 107   bool parseLogicalAndExpression(ExpressionAST *&node,
 108                                  bool templArgs = false);
 109   bool parseLogicalOrExpression(ExpressionAST *&node,
 110                                 bool templArgs = false);
 111   bool parseMemInitializer(MemInitializerAST *&node);
 112   bool parseMemInitializerList(const ListNode<MemInitializerAST*> *&node);
 113   bool parseMemberSpecification(DeclarationAST *&node);
 114   bool parseMultiplicativeExpression(ExpressionAST *&node);
 115   bool parseName(NameAST *&node, bool acceptTemplateId = false);
 116   bool parseNamespace(DeclarationAST *&node);
 117   bool parseNamespaceAliasDefinition(DeclarationAST *&node);
 118   bool parseNewDeclarator(NewDeclaratorAST *&node);
 119   bool parseNewExpression(ExpressionAST *&node);
 120   bool parseNewInitializer(NewInitializerAST *&node);
 121   bool parseNewTypeId(NewTypeIdAST *&node);
 122   bool parseOperator(OperatorAST *&node);
 123   bool parseOperatorFunctionId(OperatorFunctionIdAST *&node);
 124   bool parseParameterDeclaration(ParameterDeclarationAST *&node);
 125   bool parseParameterDeclarationClause(ParameterDeclarationClauseAST *&node);
 126   bool parseParameterDeclarationList(const ListNode<ParameterDeclarationAST*> *&node);
 127   bool parsePmExpression(ExpressionAST *&node);
 128   bool parsePostfixExpression(ExpressionAST *&node);
 129   bool parsePostfixExpressionInternal(ExpressionAST *&node);
 130   bool parsePrimaryExpression(ExpressionAST *&node);
 131   bool parsePtrOperator(PtrOperatorAST *&node);
 132   bool parsePtrToMember(PtrToMemberAST *&node);
 133   bool parseRelationalExpression(ExpressionAST *&node,
 134                                  bool templArgs = false);
 135   bool parseShiftExpression(ExpressionAST *&node);
 136   bool parseSimpleTypeSpecifier(TypeSpecifierAST *&node,
 137                                 bool onlyIntegral = false);
 138   bool parseStatement(StatementAST *&node);
 139   bool parseStorageClassSpecifier(const ListNode<std::size_t> *&node);
 140   bool parseStringLiteral(StringLiteralAST *&node);
 141   bool parseSwitchStatement(StatementAST *&node);
 142   bool parseTemplateArgument(TemplateArgumentAST *&node);
 143   bool parseTemplateArgumentList(const ListNode<TemplateArgumentAST*> *&node,
 144                                  bool reportError = true);
 145   bool parseTemplateDeclaration(DeclarationAST *&node);
 146   bool parseTemplateParameter(TemplateParameterAST *&node);
 147   bool parseTemplateParameterList(const ListNode<TemplateParameterAST*> *&node);
 148   bool parseThrowExpression(ExpressionAST *&node);
 149   bool parseTranslationUnit(TranslationUnitAST *&node);
 150   bool parseTryBlockStatement(StatementAST *&node);
 151   bool parseTypeId(TypeIdAST *&node);
 152   bool parseTypeIdList(const ListNode<TypeIdAST*> *&node);
 153   bool parseTypeParameter(TypeParameterAST *&node);
 154   bool parseTypeSpecifier(TypeSpecifierAST *&node);
 155   bool parseTypeSpecifierOrClassSpec(TypeSpecifierAST *&node);
 156   bool parseTypedef(DeclarationAST *&node);
 157   bool parseUnaryExpression(ExpressionAST *&node);
 158   bool parseUnqualifiedName(UnqualifiedNameAST *&node,
 159                             bool parseTemplateId = true);
 160   bool parseUsing(DeclarationAST *&node);
 161   bool parseUsingDirective(DeclarationAST *&node);
 162   bool parseWhileStatement(StatementAST *&node);
 163   bool parseWinDeclSpec(WinDeclSpecAST *&node);
 164
 165   bool parseQ_PROPERTY(DeclarationAST *&node);
 166   bool parseQ_ENUMS(DeclarationAST *&node);
 167
 168   bool skipUntil(int token);
 169   bool skipUntilDeclaration();
 170   bool skipUntilStatement();
 171   bool skip(int l, int r);
 172
 173   void advance();
 174
 175   // private:
 176   TokenStream token_stream;
 177   LocationTable location_table;
 178   LocationTable line_table;
 179
 180   bool block_errors(bool block);
 181
 182 private:
 183   QString tokenText(AST *) const;
 184
 185   LocationManager _M_location;
 186   Control *control;
 187   Lexer lexer;
 188   pool *_M_pool;
 189   bool _M_block_errors;
 190
 191 private:
 192   Parser(const Parser& source);
 193   void operator = (const Parser& source);
 194 };
 195
 196 #endif
 197
 198 // kate: space-indent on; indent-width 2; replace-tabs on;