1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290
|
/* This file is part of KDevelop
Copyright 2002-2005 Roberto Raggi <roberto@kdevelop.org>
Copyright 2007-2008 David Nolden <david.nolden.kdevelop@art-master.de>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License version 2 as published by the Free Software Foundation.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public License
along with this library; see the file COPYING.LIB. If not, write to
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA.
*/
#ifndef PARSER_H
#define PARSER_H
#include "ast.h"
#include "lexer.h"
#include "commentparser.h"
#include "cppparser_export.h"
#include <QtCore/QQueue>
#include <QtCore/QSet>
#include <QtCore/QString>
#include <QtCore/QHash>
class TokenStream;
class Control;
/**
The Parser.
LL(k) parser for c++ code.
*/
class CPPPARSER_EXPORT Parser
{
public:
Parser(Control *control);
~Parser();
/**Parses the @p contents of the buffer of given @p size using the
memory pool @p p to store tokens found.
Calls lexer to tokenize all contents buffer, skips the first token
(because the lexer provides Token_EOF as the first token,
creates and fills the AST and returns translation unit or 0
if nothing was parsed.
@sa pool for more information about the memory pool used.*/
TranslationUnitAST *parse(ParseSession* session);
/**
* Same as parse, except that it parses the content as a compound statement.
* This is useful for parsing independent expression-strings that appear for
* example within a function.
*
* parse(..) expects the content to be a valid translation-unit,
* while parseStatement can parse strings like "{a.b = 5;}" as if they
* appeared within a function.
*
* Note: The input must be a valid compound-statement, which means it must
* start at least with "{", and end with ";}"
**/
StatementAST *parseStatement(ParseSession* session);
/**
* Nearly the same as parseStatement, except that it parses the content as a type-id if possible,
* if that fails, as an expression. This is perfect for parsing template-arguements.
* The input can be as simple as "A" or "A::a+2"
* @param forceExpression If this is true, the text will not be considered to be a type-id, only an expression.
* With this parameter, unlike during normal parsing, primary expressions may
* have template parameters even without a function-call behind. That allows evaluating only partial expressions.
* */
AST *parseTypeOrExpression(ParseSession* session, bool forceExpression = false);
/**@return the problem count.*/
int problemCount() const { return _M_problem_count; }
private:
/**Convenience method to report problems. Constructs the problem
using the information about the current line and column in the buffer
that is being parsed. Then stores the problem in the control object.*/
void reportError(const QString& msg);
/**Reports a syntax error about unexpected token. The token
reported is LA (look-ahead) from the stream.*/
void syntaxError();
/**Reports a syntax error about required token when LA is wrong.*/
void tokenRequiredError(int expected);
public:
bool parseAbstractDeclarator(DeclaratorAST *&node);
bool parseAccessSpecifier(DeclarationAST *&node);
bool parseAdditiveExpression(ExpressionAST *&node);
bool parseAndExpression(ExpressionAST *&node, bool templArgs = false);
bool parseAsmDefinition(DeclarationAST *&node);
bool parseAssignmentExpression(ExpressionAST *&node);
bool parseBaseClause(BaseClauseAST *&node);
bool parseBaseSpecifier(BaseSpecifierAST *&node);
bool parseBlockDeclaration(DeclarationAST *&node);
bool parseCastExpression(ExpressionAST *&node);
bool parseClassSpecifier(TypeSpecifierAST *&node);
bool parseSignalSlotExpression(ExpressionAST *&node);
bool parseCommaExpression(ExpressionAST *&node);
bool parseCompoundStatement(StatementAST *&node);
bool parseCondition(ConditionAST *&node, bool initRequired = true);
bool parseConditionalExpression(ExpressionAST *&node);
bool parseConstantExpression(ExpressionAST *&node);
bool parseCtorInitializer(CtorInitializerAST *&node);
bool parseCvQualify(const ListNode<std::size_t> *&node);
bool parseDeclaration(DeclarationAST *&node);
bool parseDeclarationInternal(DeclarationAST *&node);
bool parseDeclarationStatement(StatementAST *&node);
bool parseDeclarator(DeclaratorAST *&node);
bool parseDeleteExpression(ExpressionAST *&node);
bool parseDoStatement(StatementAST *&node);
bool parseElaboratedTypeSpecifier(TypeSpecifierAST *&node);
bool parseEnumSpecifier(TypeSpecifierAST *&node);
bool parseEnumerator(EnumeratorAST *&node);
bool parseEqualityExpression(ExpressionAST *&node,
bool templArgs = false);
bool parseExceptionSpecification(ExceptionSpecificationAST *&node);
bool parseExclusiveOrExpression(ExpressionAST *&node,
bool templArgs = false);
bool parseExpression(ExpressionAST *&node);
bool parseExpressionOrDeclarationStatement(StatementAST *&node);
bool parseExpressionStatement(StatementAST *&node);
bool parseForInitStatement(StatementAST *&node);
bool parseForStatement(StatementAST *&node);
bool parseFunctionBody(StatementAST *&node);
bool parseFunctionSpecifier(const ListNode<std::size_t> *&node);
bool parseIfStatement(StatementAST *&node);
bool parseInclusiveOrExpression(ExpressionAST *&node,
bool templArgs = false);
bool parseInitDeclarator(InitDeclaratorAST *&node);
bool parseInitDeclaratorList(const ListNode<InitDeclaratorAST*> *&node);
bool parseInitializer(InitializerAST *&node);
bool parseInitializerClause(InitializerClauseAST *&node);
bool parseInitializerList(const ListNode<InitializerClauseAST*> *&node);
bool parseJumpStatement(StatementAST *&node);
bool parseLabeledStatement(StatementAST *&node);
bool parseLinkageBody(LinkageBodyAST *&node);
bool parseLinkageSpecification(DeclarationAST *&node);
bool parseLogicalAndExpression(ExpressionAST *&node,
bool templArgs = false);
bool parseLogicalOrExpression(ExpressionAST *&node,
bool templArgs = false);
bool parseMemInitializer(MemInitializerAST *&node);
bool parseMemInitializerList(const ListNode<MemInitializerAST*> *&node);
bool parseMemberSpecification(DeclarationAST *&node);
bool parseMultiplicativeExpression(ExpressionAST *&node);
enum ParseNameAcceptTemplate {
DontAcceptTemplate = 0,
AcceptTemplate = 1,
//If this is given, template-parameters are only accepted if the name is followed by a function call
EventuallyAcceptTemplate = 2
};
bool parseName(NameAST *&node, ParseNameAcceptTemplate acceptTemplateId = DontAcceptTemplate);
bool parseNamespace(DeclarationAST *&node);
bool parseNamespaceAliasDefinition(DeclarationAST *&node);
bool parseNewDeclarator(NewDeclaratorAST *&node);
bool parseNewExpression(ExpressionAST *&node);
bool parseNewInitializer(NewInitializerAST *&node);
bool parseNewTypeId(NewTypeIdAST *&node);
bool parseOperator(OperatorAST *&node);
bool parseOperatorFunctionId(OperatorFunctionIdAST *&node);
bool parseParameterDeclaration(ParameterDeclarationAST *&node);
bool parseParameterDeclarationClause(ParameterDeclarationClauseAST *&node);
bool parseParameterDeclarationList(const ListNode<ParameterDeclarationAST*> *&node);
bool parsePmExpression(ExpressionAST *&node);
bool parsePostfixExpression(ExpressionAST *&node);
bool parsePostfixExpressionInternal(ExpressionAST *&node);
bool parsePrimaryExpression(ExpressionAST *&node);
bool parsePtrOperator(PtrOperatorAST *&node);
bool parsePtrToMember(PtrToMemberAST *&node);
bool parseRelationalExpression(ExpressionAST *&node,
bool templArgs = false);
bool parseShiftExpression(ExpressionAST *&node);
bool parseSimpleTypeSpecifier(TypeSpecifierAST *&node,
bool onlyIntegral = false);
bool parseStatement(StatementAST *&node);
bool parseStorageClassSpecifier(const ListNode<std::size_t> *&node);
bool parseStringLiteral(StringLiteralAST *&node);
bool parseSwitchStatement(StatementAST *&node);
bool parseTemplateArgument(TemplateArgumentAST *&node);
bool parseTemplateArgumentList(const ListNode<TemplateArgumentAST*> *&node,
bool reportError = true);
bool parseTemplateDeclaration(DeclarationAST *&node);
bool parseTemplateParameter(TemplateParameterAST *&node);
bool parseTemplateParameterList(const ListNode<TemplateParameterAST*> *&node);
bool parseThrowExpression(ExpressionAST *&node);
bool parseTranslationUnit(TranslationUnitAST *&node);
bool parseTryBlockStatement(StatementAST *&node);
bool parseTypeId(TypeIdAST *&node);
bool parseTypeIdList(const ListNode<TypeIdAST*> *&node);
bool parseTypeParameter(TypeParameterAST *&node);
bool parseTypeSpecifier(TypeSpecifierAST *&node);
bool parseTypeSpecifierOrClassSpec(TypeSpecifierAST *&node);
bool parseTypedef(DeclarationAST *&node);
bool parseUnaryExpression(ExpressionAST *&node);
bool parseUnqualifiedName(UnqualifiedNameAST *&node,
bool parseTemplateId = true);
bool parseUsing(DeclarationAST *&node);
bool parseUsingDirective(DeclarationAST *&node);
bool parseWhileStatement(StatementAST *&node);
bool parseWinDeclSpec(WinDeclSpecAST *&node);
bool skipUntil(int token);
bool skipUntilDeclaration();
bool skipUntilStatement();
bool skip(int l, int r);
void addComment( CommentAST* ast, const Comment& comment );
//Moves all currently available comments to the given AST, removing them from the comment-store
void moveComments( CommentAST* ast );
void advance(bool skipComment = true);
void rewind(size_t position);
// private:
TokenStream* token_stream;
// private:
Control *control;
Lexer lexer;
private:
enum TokenMarkers {
None = 0,
IsNoTemplateArgumentList = 1
};
TokenMarkers tokenMarkers(size_t tokenNumber) const;
void addTokenMarkers(size_t tokenNumber, TokenMarkers markers);
int lineFromTokenNumber( size_t tokenNumber ) const;
void clear();
///parses all comments until the end of the line
Comment comment();
///Preparses comments in the same line as given token-number
void preparseLineComments( int tokenNumber );
void processComment( int offset = 0, int line = -1 );
void clearComment( );
bool holdErrors(bool hold);
void reportPendingErrors();
Comment m_currentComment;
CommentStore m_commentStore;
QHash<size_t, TokenMarkers> m_tokenMarkers;
int _M_problem_count;
int _M_max_problem_count;
ParseSession* session;
bool _M_hold_errors;
size_t _M_last_valid_token; //Last encountered token that was not a comment
size_t _M_last_parsed_comment;
bool _M_hadMismatchingCompoundTokens;
bool m_primaryExpressionWithTemplateParamsNeedsFunctionCall;
// keeps track of tokens where a syntax error has been found
// so that the same error is not reported twice for a token
QSet<std::size_t> m_syntaxErrorTokens;
// when _M_hold_errors is true, reported errors are held in m_pendingErrors
// rather than being reported to the Control immediately.
//
// this is used, for example, when parsing ambiguous statements.
struct PendingError
{
QString message;
std::size_t cursor;
};
QQueue<PendingError> m_pendingErrors;
private:
Parser(const Parser& source);
void operator = (const Parser& source);
};
#endif
|