FCL/sf/mw/qtmobility: comparison tools/icheck/parser/src/shared/cplusplus/AST.cpp

equal deleted inserted replaced

--1:000000000000
+:876b1a06bc25
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the Qt Mobility Components.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+// Copyright (c) 2008 Roberto Raggi <roberto.raggi@gmail.com>
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+#include "AST.h"
+#include "ASTVisitor.h"
+#include "ASTMatcher.h"
+#include "MemoryPool.h"
+#include <cassert>
+#include <algorithm>
+using namespace CPlusPlus;
+AST::AST()
+{ }
+AST::~AST()
+{ assert(0); }
+void AST::accept(ASTVisitor *visitor)
+{
+if (visitor->preVisit(this))
+accept0(visitor);
+visitor->postVisit(this);
+}
+bool AST::match(AST *ast, AST *pattern, ASTMatcher *matcher)
+{
+if (ast == pattern)
+return true;
+else if (! ast || ! pattern)
+return false;
+return ast->match(pattern, matcher);
+}
+bool AST::match(AST *pattern, ASTMatcher *matcher)
+{
+return match0(pattern, matcher);
+}
+unsigned AttributeSpecifierAST::firstToken() const
+{
+return attribute_token;
+}
+unsigned AttributeSpecifierAST::lastToken() const
+{
+if (second_rparen_token)
+return second_rparen_token + 1;
+else if (first_rparen_token)
+return first_rparen_token + 1;
+else if (attribute_list)
+return attribute_list->lastToken();
+else if (second_lparen_token)
+return second_lparen_token + 1;
+else if (first_lparen_token)
+return first_lparen_token + 1;
+return attribute_token + 1;
+}
+unsigned AttributeAST::firstToken() const
+{
+return identifier_token;
+}
+unsigned AttributeAST::lastToken() const
+{
+if (rparen_token)
+return rparen_token + 1;
+else if (expression_list)
+return expression_list->lastToken();
+else if (tag_token)
+return tag_token + 1;
+else if (lparen_token)
+return lparen_token + 1;
+return identifier_token + 1;
+}
+unsigned AccessDeclarationAST::firstToken() const
+{
+return access_specifier_token;
+}
+unsigned AccessDeclarationAST::lastToken() const
+{
+if (colon_token)
+return colon_token + 1;
+else if (slots_token)
+return slots_token + 1;
+return access_specifier_token + 1;
+}
+#ifdef ICHECK_BUILD
+unsigned QPropertyDeclarationAST::firstToken() const
+{
+return property_specifier_token;
+}
+unsigned QPropertyDeclarationAST::lastToken() const
+{
+return rparen_token;
+}
+unsigned QEnumDeclarationAST::firstToken() const
+{
+return enum_specifier_token;
+}
+unsigned QEnumDeclarationAST::lastToken() const
+{
+return rparen_token;
+}
+unsigned QFlagsDeclarationAST::firstToken() const
+{
+return this->flags_specifier_token;
+}
+unsigned QFlagsDeclarationAST::lastToken() const
+{
+return rparen_token;
+}
+unsigned QDeclareFlagsDeclarationAST::firstToken() const
+{
+return declareflags_specifier_token;
+}
+unsigned QDeclareFlagsDeclarationAST::lastToken() const
+{
+return rparen_token;
+}
+#endif
+unsigned ArrayAccessAST::firstToken() const
+{
+return lbracket_token;
+}
+unsigned ArrayAccessAST::lastToken() const
+{
+if (rbracket_token)
+return rbracket_token + 1;
+else if (expression)
+return expression->lastToken();
+return lbracket_token + 1;
+}
+unsigned ArrayDeclaratorAST::firstToken() const
+{
+return lbracket_token;
+}
+unsigned ArrayDeclaratorAST::lastToken() const
+{
+if (rbracket_token)
+return rbracket_token + 1;
+else if (expression)
+return expression->lastToken();
+return lbracket_token + 1;
+}
+unsigned ArrayInitializerAST::firstToken() const
+{
+return lbrace_token;
+}
+unsigned ArrayInitializerAST::lastToken() const
+{
+if (rbrace_token)
+return rbrace_token + 1;
+else if (expression_list)
+return expression_list->lastToken();
+return lbrace_token + 1;
+}
+unsigned AsmDefinitionAST::firstToken() const
+{
+return asm_token;
+}
+unsigned AsmDefinitionAST::lastToken() const
+{
+if (semicolon_token)
+return semicolon_token + 1;
+else if (rparen_token)
+return rparen_token + 1;
+else if (lparen_token)
+return lparen_token + 1;
+else if (volatile_token)
+return volatile_token + 1;
+return asm_token + 1;
+}
+unsigned BaseSpecifierAST::firstToken() const
+{
+if (virtual_token && access_specifier_token)
+return std::min(virtual_token, access_specifier_token);
+return name->firstToken();
+}
+unsigned BaseSpecifierAST::lastToken() const
+{
+if (name)
+return name->lastToken();
+else if (virtual_token && access_specifier_token)
+return std::min(virtual_token, access_specifier_token) + 1;
+else if (virtual_token)
+return virtual_token + 1;
+else if (access_specifier_token)
+return access_specifier_token + 1;
+// assert?
+return 0;
+}
+unsigned QtMethodAST::firstToken() const
+{ return method_token; }
+unsigned QtMethodAST::lastToken() const
+{
+if (rparen_token)
+return rparen_token + 1;
+else if (declarator)
+return declarator->lastToken();
+else if (lparen_token)
+return lparen_token + 1;
+return method_token + 1;
+}
+unsigned QtMemberDeclarationAST::firstToken() const
+{
+return q_token;
+}
+unsigned QtMemberDeclarationAST::lastToken() const
+{
+if (rparen_token)
+return rparen_token + 1;
+else if (type_id)
+return type_id->lastToken();
+else if (lparen_token)
+return lparen_token + 1;
+return q_token + 1;
+}
+unsigned BinaryExpressionAST::firstToken() const
+{
+return left_expression->firstToken();
+}
+unsigned BinaryExpressionAST::lastToken() const
+{
+if (right_expression)
+return right_expression->lastToken();
+else if (binary_op_token)
+return binary_op_token + 1;
+return left_expression->lastToken();
+}
+unsigned BoolLiteralAST::firstToken() const
+{
+return literal_token;
+}
+unsigned BoolLiteralAST::lastToken() const
+{
+return literal_token + 1;
+}
+unsigned CompoundLiteralAST::firstToken() const
+{
+return lparen_token;
+}
+unsigned CompoundLiteralAST::lastToken() const
+{
+if (initializer)
+return initializer->lastToken();
+else if (rparen_token)
+return rparen_token + 1;
+else if (type_id)
+return type_id->lastToken();
+return lparen_token + 1;
+}
+unsigned BreakStatementAST::firstToken() const
+{
+return break_token;
+}
+unsigned BreakStatementAST::lastToken() const
+{
+if (semicolon_token)
+return semicolon_token + 1;
+return break_token + 1;
+}
+unsigned CallAST::firstToken() const
+{
+return lparen_token;
+}
+unsigned CallAST::lastToken() const
+{
+if (rparen_token)
+return rparen_token + 1;
+else if (expression_list)
+return expression_list->lastToken();
+return lparen_token + 1;
+}
+unsigned CaseStatementAST::firstToken() const
+{
+return case_token;
+}
+unsigned CaseStatementAST::lastToken() const
+{
+if (statement)
+return statement->lastToken();
+else if (colon_token)
+return colon_token + 1;
+else if (expression)
+return expression->lastToken();
+return case_token + 1;
+}
+unsigned CastExpressionAST::firstToken() const
+{
+return lparen_token;
+}
+unsigned CastExpressionAST::lastToken() const
+{
+if (expression)
+return expression->lastToken();
+else if (rparen_token)
+return rparen_token + 1;
+else if (type_id)
+return type_id->lastToken();
+return lparen_token + 1;
+}
+unsigned CatchClauseAST::firstToken() const
+{
+return catch_token;
+}
+unsigned CatchClauseAST::lastToken() const
+{
+if (statement)
+return statement->lastToken();
+else if (rparen_token)
+return rparen_token + 1;
+if (exception_declaration)
+return exception_declaration->lastToken();
+if (lparen_token)
+return lparen_token + 1;
+return catch_token + 1;
+}
+unsigned ClassSpecifierAST::firstToken() const
+{
+return classkey_token;
+}
+unsigned ClassSpecifierAST::lastToken() const
+{
+if (rbrace_token)
+return rbrace_token + 1;
+else if (member_specifier_list)
+return member_specifier_list->lastToken();
+else if (lbrace_token)
+return lbrace_token + 1;
+else if (base_clause_list)
+return base_clause_list->lastToken();
+else if (colon_token)
+return colon_token + 1;
+else if (name)
+return name->lastToken();
+else if (attribute_list)
+return attribute_list->lastToken();
+return classkey_token + 1;
+}
+unsigned CompoundStatementAST::firstToken() const
+{
+return lbrace_token;
+}
+unsigned CompoundStatementAST::lastToken() const
+{
+if (rbrace_token)
+return rbrace_token + 1;
+else if (statement_list)
+return statement_list->lastToken();
+return lbrace_token + 1;
+}
+unsigned ConditionAST::firstToken() const
+{
+if (type_specifier_list)
+return type_specifier_list->firstToken();
+return declarator->firstToken();
+}
+unsigned ConditionAST::lastToken() const
+{
+if (declarator)
+return declarator->lastToken();
+else if (type_specifier_list)
+return type_specifier_list->lastToken();
+// ### assert?
+return 0;
+}
+unsigned ConditionalExpressionAST::firstToken() const
+{
+return condition->firstToken();
+}
+unsigned ConditionalExpressionAST::lastToken() const
+{
+if (right_expression)
+return right_expression->lastToken();
+else if (colon_token)
+return colon_token + 1;
+else if (left_expression)
+return left_expression->lastToken();
+else if (question_token)
+return question_token + 1;
+else if (condition)
+return condition->lastToken();
+// ### assert?
+return 0;
+}
+unsigned ContinueStatementAST::firstToken() const
+{
+return continue_token;
+}
+unsigned ContinueStatementAST::lastToken() const
+{
+if (semicolon_token)
+return semicolon_token + 1;
+return continue_token + 1;
+}
+unsigned ConversionFunctionIdAST::firstToken() const
+{
+return operator_token;
+}
+unsigned ConversionFunctionIdAST::lastToken() const
+{
+if (ptr_operator_list)
+return ptr_operator_list->lastToken();
+else if (type_specifier_list)
+return type_specifier_list->lastToken();
+return operator_token + 1;
+}
+unsigned CppCastExpressionAST::firstToken() const
+{
+return cast_token;
+}
+unsigned CppCastExpressionAST::lastToken() const
+{
+if (rparen_token)
+return rparen_token + 1;
+else if (expression)
+return expression->lastToken();
+else if (lparen_token)
+return lparen_token + 1;
+else if (greater_token)
+return greater_token + 1;
+else if (type_id)
+return type_id->lastToken();
+else if (less_token)
+return less_token + 1;
+return cast_token + 1;
+}
+unsigned CtorInitializerAST::firstToken() const
+{
+return colon_token;
+}
+unsigned CtorInitializerAST::lastToken() const
+{
+if (member_initializer_list)
+return member_initializer_list->lastToken();
+return colon_token + 1;
+}
+unsigned DeclaratorAST::firstToken() const
+{
+if (attribute_list)
+return attribute_list->firstToken();
+if (ptr_operator_list)
+return ptr_operator_list->firstToken();
+else if (core_declarator)
+return core_declarator->firstToken();
+else if (postfix_declarator_list)
+return postfix_declarator_list->firstToken();
+else if (attribute_list)
+return attribute_list->firstToken();
+else if (initializer)
+return initializer->firstToken();
+// ### assert?
+return 0;
+}
+unsigned DeclaratorAST::lastToken() const
+{
+if (initializer)
+return initializer->lastToken();
+else if (post_attribute_list)
+return post_attribute_list->lastToken();
+else if (postfix_declarator_list)
+return postfix_declarator_list->lastToken();
+else if (core_declarator)
+return core_declarator->lastToken();
+else if (ptr_operator_list)
+return ptr_operator_list->lastToken();
+else if (attribute_list)
+return attribute_list->lastToken();
+// ### assert?
+return 0;
+}
+unsigned DeclarationStatementAST::firstToken() const
+{
+return declaration->firstToken();
+}
+unsigned DeclarationStatementAST::lastToken() const
+{
+return declaration->lastToken();
+}
+unsigned DeclaratorIdAST::firstToken() const
+{
+return name->firstToken();
+}
+unsigned DeclaratorIdAST::lastToken() const
+{
+return name->lastToken();
+}
+unsigned DeleteExpressionAST::firstToken() const
+{
+if (scope_token)
+return scope_token;
+return delete_token;
+}
+unsigned DeleteExpressionAST::lastToken() const
+{
+if (expression)
+return expression->lastToken();
+else if (rbracket_token)
+return rbracket_token + 1;
+else if (lbracket_token)
+return lbracket_token + 1;
+else if (delete_token)
+return delete_token + 1;
+return scope_token + 1;
+}
+unsigned DestructorNameAST::firstToken() const
+{
+return tilde_token;
+}
+unsigned DestructorNameAST::lastToken() const
+{
+if (identifier_token)
+return identifier_token + 1;
+return tilde_token + 1;
+}
+unsigned DoStatementAST::firstToken() const
+{
+return do_token;
+}
+unsigned DoStatementAST::lastToken() const
+{
+if (semicolon_token)
+return semicolon_token + 1;
+else if (rparen_token)
+return rparen_token + 1;
+else if (expression)
+return expression->lastToken();
+else if (lparen_token)
+return lparen_token + 1;
+else if (while_token)
+return while_token + 1;
+else if (statement)
+return statement->lastToken();
+return do_token + 1;
+}
+unsigned ElaboratedTypeSpecifierAST::firstToken() const
+{
+return classkey_token;
+}
+unsigned ElaboratedTypeSpecifierAST::lastToken() const
+{
+if (name)
+return name->lastToken();
+return classkey_token + 1;
+}
+unsigned EmptyDeclarationAST::firstToken() const
+{
+return semicolon_token;
+}
+unsigned EmptyDeclarationAST::lastToken() const
+{
+return semicolon_token + 1;
+}
+unsigned EnumSpecifierAST::firstToken() const
+{
+return enum_token;
+}
+unsigned EnumSpecifierAST::lastToken() const
+{
+if (rbrace_token)
+return rbrace_token + 1;
+if (enumerator_list)
+return enumerator_list->lastToken();
+if (lbrace_token)
+return lbrace_token + 1;
+if (name)
+return name->lastToken();
+return enum_token + 1;
+}
+unsigned EnumeratorAST::firstToken() const
+{
+return identifier_token;
+}
+unsigned EnumeratorAST::lastToken() const
+{
+if (expression)
+return expression->lastToken();
+else if (equal_token)
+return equal_token + 1;
+return identifier_token + 1;
+}
+unsigned ExceptionDeclarationAST::firstToken() const
+{
+if (type_specifier_list)
+return type_specifier_list->firstToken();
+if (declarator)
+return declarator->firstToken();
+return dot_dot_dot_token;
+}
+unsigned ExceptionDeclarationAST::lastToken() const
+{
+if (dot_dot_dot_token)
+return dot_dot_dot_token + 1;
+else if (declarator)
+return declarator->lastToken();
+else if (type_specifier_list)
+return type_specifier_list->lastToken();
+return 0;
+}
+unsigned ExceptionSpecificationAST::firstToken() const
+{
+return throw_token;
+}
+unsigned ExceptionSpecificationAST::lastToken() const
+{
+if (rparen_token)
+return rparen_token + 1;
+else if (type_id_list)
+return type_id_list->lastToken();
+else if (dot_dot_dot_token)
+return dot_dot_dot_token + 1;
+else if (lparen_token)
+return lparen_token + 1;
+return throw_token + 1;
+}
+unsigned ExpressionOrDeclarationStatementAST::firstToken() const
+{
+return declaration->firstToken();
+}
+unsigned ExpressionOrDeclarationStatementAST::lastToken() const
+{
+return declaration->lastToken();
+}
+unsigned ExpressionStatementAST::firstToken() const
+{
+if (expression)
+return expression->firstToken();
+return semicolon_token;
+}
+unsigned ExpressionStatementAST::lastToken() const
+{
+if (semicolon_token)
+return semicolon_token + 1;
+else if (expression)
+return expression->lastToken();
+// ### assert?
+return 0;
+}
+unsigned ForeachStatementAST::firstToken() const
+{
+return foreach_token;
+}
+unsigned ForeachStatementAST::lastToken() const
+{
+if (statement)
+return statement->lastToken();
+else if (rparen_token)
+return rparen_token + 1;
+else if (expression)
+return expression->lastToken();
+else if (comma_token)
+return comma_token + 1;
+return foreach_token + 1;
+}
+unsigned ForStatementAST::firstToken() const
+{
+return for_token;
+}
+unsigned ForStatementAST::lastToken() const
+{
+if (statement)
+return statement->lastToken();
+else if (rparen_token)
+return rparen_token + 1;
+else if (expression)
+return expression->lastToken();
+else if (semicolon_token)
+return semicolon_token + 1;
+else if (condition)
+return condition->lastToken();
+else if (initializer)
+return initializer->lastToken();
+else if (lparen_token)
+return lparen_token + 1;
+return for_token + 1;
+}
+unsigned FunctionDeclaratorAST::firstToken() const
+{
+return lparen_token;
+}
+unsigned FunctionDeclaratorAST::lastToken() const
+{
+if (exception_specification)
+return exception_specification->lastToken();
+else if (cv_qualifier_list)
+return cv_qualifier_list->lastToken();
+else if (rparen_token)
+return rparen_token + 1;
+else if (parameters)
+return parameters->lastToken();
+return lparen_token + 1;
+}
+unsigned FunctionDefinitionAST::firstToken() const
+{
+if (decl_specifier_list)
+return decl_specifier_list->firstToken();
+else if (declarator)
+return declarator->firstToken();
+else if (ctor_initializer)
+return ctor_initializer->firstToken();
+return function_body->firstToken();
+}
+unsigned FunctionDefinitionAST::lastToken() const
+{
+if (function_body)
+return function_body->lastToken();
+else if (ctor_initializer)
+return ctor_initializer->lastToken();
+else if (declarator)
+return declarator->lastToken();
+else if (decl_specifier_list)
+return decl_specifier_list->lastToken();
+// ### assert
+return 0;
+}
+unsigned GotoStatementAST::firstToken() const
+{
+return goto_token;
+}
+unsigned GotoStatementAST::lastToken() const
+{
+if (semicolon_token)
+return semicolon_token + 1;
+else if (identifier_token)
+return identifier_token + 1;
+else if (goto_token)
+return goto_token + 1;
+return 0;
+}
+unsigned IfStatementAST::firstToken() const
+{
+return if_token;
+}
+unsigned IfStatementAST::lastToken() const
+{
+if (else_statement)
+return else_statement->lastToken();
+else if (else_token)
+return else_token + 1;
+else if (statement)
+return statement->lastToken();
+else if (rparen_token)
+return rparen_token + 1;
+else if (condition)
+return condition->lastToken();
+else if (lparen_token)
+return lparen_token + 1;
+return if_token + 1;
+}
+unsigned LabeledStatementAST::firstToken() const
+{
+return label_token;
+}
+unsigned LabeledStatementAST::lastToken() const
+{
+if (statement)
+return statement->lastToken();
+else if (colon_token)
+return colon_token + 1;
+return label_token + 1;
+}
+unsigned LinkageBodyAST::firstToken() const
+{
+return lbrace_token;
+}
+unsigned LinkageBodyAST::lastToken() const
+{
+if (rbrace_token)
+return rbrace_token + 1;
+else if (declaration_list)
+return declaration_list->lastToken();
+return lbrace_token + 1;
+}
+unsigned LinkageSpecificationAST::firstToken() const
+{
+return extern_token;
+}
+unsigned LinkageSpecificationAST::lastToken() const
+{
+if (declaration)
+return declaration->lastToken();
+else if (extern_type_token)
+return extern_type_token + 1;
+return extern_token + 1;
+}
+unsigned MemInitializerAST::firstToken() const
+{
+return name->firstToken();
+}
+unsigned MemInitializerAST::lastToken() const
+{
+if (rparen_token)
+return rparen_token + 1;
+else if (expression_list)
+return expression_list->lastToken();
+else if (lparen_token)
+return lparen_token + 1;
+return name->lastToken();
+}
+unsigned MemberAccessAST::firstToken() const
+{
+return access_token;
+}
+unsigned MemberAccessAST::lastToken() const
+{
+if (member_name)
+return member_name->lastToken();
+else if (template_token)
+return template_token + 1;
+return access_token + 1;
+}
+unsigned NamedTypeSpecifierAST::firstToken() const
+{
+return name->firstToken();
+}
+unsigned NamedTypeSpecifierAST::lastToken() const
+{
+return name->lastToken();
+}
+unsigned NamespaceAST::firstToken() const
+{
+return namespace_token;
+}
+unsigned NamespaceAST::lastToken() const
+{
+if (linkage_body)
+return linkage_body->lastToken();
+else if (attribute_list)
+return attribute_list->lastToken();
+else if (identifier_token)
+return identifier_token + 1;
+return namespace_token + 1;
+}
+unsigned NamespaceAliasDefinitionAST::firstToken() const
+{
+return namespace_token;
+}
+unsigned NamespaceAliasDefinitionAST::lastToken() const
+{
+if (semicolon_token)
+return semicolon_token + 1;
+else if (name)
+return name->lastToken();
+else if (equal_token)
+return equal_token + 1;
+else if (namespace_name_token)
+return namespace_name_token + 1;
+return namespace_token + 1;
+}
+unsigned NestedDeclaratorAST::firstToken() const
+{
+return lparen_token;
+}
+unsigned NestedDeclaratorAST::lastToken() const
+{
+if (rparen_token)
+return rparen_token + 1;
+else if (declarator)
+return declarator->lastToken();
+return lparen_token + 1;
+}
+unsigned NestedExpressionAST::firstToken() const
+{
+return lparen_token;
+}
+unsigned NestedExpressionAST::lastToken() const
+{
+if (rparen_token)
+return rparen_token + 1;
+else if (expression)
+return expression->lastToken();
+return lparen_token + 1;
+}
+unsigned NestedNameSpecifierAST::firstToken() const
+{
+return class_or_namespace_name->firstToken();
+}
+unsigned NestedNameSpecifierAST::lastToken() const
+{
+if (scope_token)
+return scope_token + 1;
+return class_or_namespace_name->lastToken();
+}
+unsigned NewPlacementAST::firstToken() const
+{
+return lparen_token;
+}
+unsigned NewPlacementAST::lastToken() const
+{
+return rparen_token + 1;
+}
+unsigned NewArrayDeclaratorAST::firstToken() const
+{
+return lbracket_token;
+}
+unsigned NewArrayDeclaratorAST::lastToken() const
+{
+return rbracket_token + 1;
+}
+unsigned NewExpressionAST::firstToken() const
+{
+if (scope_token)
+return scope_token;
+return new_token;
+}
+unsigned NewExpressionAST::lastToken() const
+{
+// ### FIXME
+if (new_token)
+return new_token + 1;
+else if (scope_token)
+return scope_token + 1;
+// ### assert?
+return 0;
+}
+unsigned NewInitializerAST::firstToken() const
+{
+return lparen_token;
+}
+unsigned NewInitializerAST::lastToken() const
+{
+if (rparen_token)
+return rparen_token + 1;
+else if (expression)
+return expression->lastToken();
+return lparen_token + 1;
+}
+unsigned NewTypeIdAST::firstToken() const
+{
+return type_specifier_list->firstToken();
+}
+unsigned NewTypeIdAST::lastToken() const
+{
+if (new_array_declarator_list)
+return new_array_declarator_list->lastToken();
+else if (ptr_operator_list)
+return ptr_operator_list->lastToken();
+else if (type_specifier_list)
+return type_specifier_list->lastToken();
+// ### assert?
+return 0;
+}
+unsigned NumericLiteralAST::firstToken() const
+{
+return literal_token;
+}
+unsigned NumericLiteralAST::lastToken() const
+{
+return literal_token + 1;
+}
+unsigned OperatorAST::firstToken() const
+{
+return op_token;
+}
+unsigned OperatorAST::lastToken() const
+{
+if (close_token)
+return close_token + 1;
+else if (open_token)
+return open_token + 1;
+return op_token + 1;
+}
+unsigned OperatorFunctionIdAST::firstToken() const
+{
+return operator_token;
+}
+unsigned OperatorFunctionIdAST::lastToken() const
+{
+if (op)
+return op->lastToken();
+return operator_token + 1;
+}
+unsigned ParameterDeclarationAST::firstToken() const
+{
+return type_specifier_list->firstToken();
+}
+unsigned ParameterDeclarationAST::lastToken() const
+{
+if (expression)
+return expression->lastToken();
+else if (equal_token)
+return equal_token + 1;
+else if (declarator)
+return declarator->lastToken();
+else if (type_specifier_list)
+return type_specifier_list->lastToken();
+// ### assert?
+return 0;
+}
+unsigned ParameterDeclarationClauseAST::firstToken() const
+{
+if (parameter_declaration_list)
+return parameter_declaration_list->firstToken();
+return dot_dot_dot_token;
+}
+unsigned ParameterDeclarationClauseAST::lastToken() const
+{
+if (dot_dot_dot_token)
+return dot_dot_dot_token + 1;
+return parameter_declaration_list->lastToken();
+}
+unsigned PointerAST::firstToken() const
+{
+return star_token;
+}
+unsigned PointerAST::lastToken() const
+{
+if (cv_qualifier_list)
+return cv_qualifier_list->lastToken();
+return star_token + 1;
+}
+unsigned PointerToMemberAST::firstToken() const
+{
+if (global_scope_token)
+return global_scope_token;
+else if (nested_name_specifier_list)
+return nested_name_specifier_list->firstToken();
+return star_token;
+}
+unsigned PointerToMemberAST::lastToken() const
+{
+if (cv_qualifier_list)
+return cv_qualifier_list->lastToken();
+else if (star_token)
+return star_token + 1;
+else if (nested_name_specifier_list)
+return nested_name_specifier_list->lastToken();
+else if (global_scope_token)
+return global_scope_token + 1;
+// ### assert(0);
+return 0;
+}
+unsigned PostIncrDecrAST::firstToken() const
+{
+return incr_decr_token;
+}
+unsigned PostIncrDecrAST::lastToken() const
+{
+return incr_decr_token + 1;
+}
+unsigned PostfixExpressionAST::firstToken() const
+{
+return base_expression->firstToken();
+}
+unsigned PostfixExpressionAST::lastToken() const
+{
+if (postfix_expression_list)
+return postfix_expression_list->lastToken();
+return base_expression->lastToken();
+}
+unsigned QualifiedNameAST::firstToken() const
+{
+if (global_scope_token)
+return global_scope_token;
+else if (nested_name_specifier_list)
+return nested_name_specifier_list->firstToken();
+return unqualified_name->firstToken();
+}
+unsigned QualifiedNameAST::lastToken() const
+{
+if (unqualified_name)
+return unqualified_name->lastToken();
+if (nested_name_specifier_list)
+return nested_name_specifier_list->lastToken();
+if (global_scope_token)
+return global_scope_token + 1;
+return 0;
+}
+unsigned ReferenceAST::firstToken() const
+{
+return amp_token;
+}
+unsigned ReferenceAST::lastToken() const
+{
+return amp_token + 1;
+}
+unsigned ReturnStatementAST::firstToken() const
+{
+return return_token;
+}
+unsigned ReturnStatementAST::lastToken() const
+{
+if (semicolon_token)
+return semicolon_token + 1;
+else if (expression)
+return expression->lastToken();
+return return_token + 1;
+}
+unsigned SimpleDeclarationAST::firstToken() const
+{
+if (decl_specifier_list)
+return decl_specifier_list->firstToken();
+else if (declarator_list)
+return declarator_list->firstToken();
+return semicolon_token;
+}
+unsigned SimpleDeclarationAST::lastToken() const
+{
+if (semicolon_token)
+return semicolon_token + 1;
+else if (declarator_list)
+return declarator_list->lastToken();
+else if (decl_specifier_list)
+return decl_specifier_list->lastToken();
+// ### assert(0);
+return 0;
+}
+unsigned SimpleNameAST::firstToken() const
+{
+return identifier_token;
+}
+unsigned SimpleNameAST::lastToken() const
+{
+return identifier_token + 1;
+}
+unsigned SimpleSpecifierAST::firstToken() const
+{
+return specifier_token;
+}
+unsigned SimpleSpecifierAST::lastToken() const
+{
+return specifier_token + 1;
+}
+unsigned TypeofSpecifierAST::firstToken() const
+{
+return typeof_token;
+}
+unsigned TypeofSpecifierAST::lastToken() const
+{
+if (expression)
+return expression->lastToken();
+return typeof_token + 1;
+}
+unsigned SizeofExpressionAST::firstToken() const
+{
+return sizeof_token;
+}
+unsigned SizeofExpressionAST::lastToken() const
+{
+if (expression)
+return expression->lastToken();
+return sizeof_token + 1;
+}
+unsigned StringLiteralAST::firstToken() const
+{
+return literal_token;
+}
+unsigned StringLiteralAST::lastToken() const
+{
+if (next)
+return next->lastToken();
+return literal_token + 1;
+}
+unsigned SwitchStatementAST::firstToken() const
+{
+return switch_token;
+}
+unsigned SwitchStatementAST::lastToken() const
+{
+if (statement)
+return statement->lastToken();
+else if (rparen_token)
+return rparen_token + 1;
+else if (condition)
+return condition->lastToken();
+else if (lparen_token)
+return lparen_token + 1;
+return switch_token + 1;
+}
+unsigned TemplateDeclarationAST::firstToken() const
+{
+if (export_token)
+return export_token;
+return template_token;
+}
+unsigned TemplateDeclarationAST::lastToken() const
+{
+if (declaration)
+return declaration->lastToken();
+else if (greater_token)
+return greater_token + 1;
+else if (template_parameter_list)
+return template_parameter_list->lastToken();
+else if (less_token)
+return less_token + 1;
+else if (template_token)
+return template_token + 1;
+else if (export_token)
+return export_token + 1;
+// ### assert(0);
+return 0;
+}
+unsigned TemplateIdAST::firstToken() const
+{
+return identifier_token;
+}
+unsigned TemplateIdAST::lastToken() const
+{
+if (greater_token)
+return greater_token + 1;
+else if (template_argument_list)
+return template_argument_list->lastToken();
+else if (less_token)
+return less_token + 1;
+return identifier_token + 1;
+}
+unsigned TemplateTypeParameterAST::firstToken() const
+{
+return template_token;
+}
+unsigned TemplateTypeParameterAST::lastToken() const
+{
+if (type_id)
+return type_id->lastToken();
+else if (equal_token)
+return equal_token + 1;
+else if (name)
+return name->lastToken();
+else if (class_token)
+return class_token + 1;
+else if (greater_token)
+return greater_token + 1;
+else if (template_parameter_list)
+return template_parameter_list->lastToken();
+else if (less_token)
+return less_token + 1;
+return template_token + 1;
+}
+unsigned ThisExpressionAST::firstToken() const
+{
+return this_token;
+}
+unsigned ThisExpressionAST::lastToken() const
+{
+return this_token + 1;
+}
+unsigned ThrowExpressionAST::firstToken() const
+{
+return throw_token;
+}
+unsigned ThrowExpressionAST::lastToken() const
+{
+if (expression)
+return expression->lastToken();
+return throw_token + 1;
+}
+unsigned TranslationUnitAST::firstToken() const
+{
+if(declaration_list)
+return declaration_list->firstToken();
+return 0;
+}
+unsigned TranslationUnitAST::lastToken() const
+{
+if (declaration_list)
+return declaration_list->lastToken();
+// ### assert(0);
+return 0;
+}
+unsigned TryBlockStatementAST::firstToken() const
+{
+return try_token;
+}
+unsigned TryBlockStatementAST::lastToken() const
+{
+if (catch_clause_list)
+return catch_clause_list->lastToken();
+else if (statement)
+return statement->lastToken();
+return try_token + 1;
+}
+unsigned TypeConstructorCallAST::firstToken() const
+{
+return type_specifier_list->firstToken();
+}
+unsigned TypeConstructorCallAST::lastToken() const
+{
+if (rparen_token)
+return rparen_token + 1;
+else if (expression_list)
+return expression_list->lastToken();
+else if (lparen_token)
+return lparen_token + 1;
+else if (type_specifier_list)
+return type_specifier_list->lastToken();
+// ### assert(0);
+return 0;
+}
+unsigned TypeIdAST::firstToken() const
+{
+return type_specifier_list->firstToken();
+}
+unsigned TypeIdAST::lastToken() const
+{
+if (declarator)
+return declarator->lastToken();
+else if (type_specifier_list)
+return type_specifier_list->lastToken();
+// ### assert(0);
+return 0;
+}
+unsigned TypeidExpressionAST::firstToken() const
+{
+return typeid_token;
+}
+unsigned TypeidExpressionAST::lastToken() const
+{
+if (rparen_token)
+return rparen_token + 1;
+else if (expression)
+return expression->lastToken();
+else if (lparen_token)
+return lparen_token + 1;
+return typeid_token + 1;
+}
+unsigned TypenameCallExpressionAST::firstToken() const
+{
+return typename_token;
+}
+unsigned TypenameCallExpressionAST::lastToken() const
+{
+if (rparen_token)
+return rparen_token + 1;
+else if (expression_list)
+return expression_list->lastToken();
+else if (lparen_token)
+return lparen_token + 1;
+else if (name)
+return name->lastToken();
+return typename_token + 1;
+}
+unsigned TypenameTypeParameterAST::firstToken() const
+{
+return classkey_token;
+}
+unsigned TypenameTypeParameterAST::lastToken() const
+{
+if (type_id)
+return type_id->lastToken();
+else if (equal_token)
+return equal_token + 1;
+else if (name)
+return name->lastToken();
+return classkey_token + 1;
+}
+unsigned UnaryExpressionAST::firstToken() const
+{
+return unary_op_token;
+}
+unsigned UnaryExpressionAST::lastToken() const
+{
+if (expression)
+return expression->lastToken();
+return unary_op_token + 1;
+}
+unsigned UsingAST::firstToken() const
+{
+return using_token;
+}
+unsigned UsingAST::lastToken() const
+{
+if (semicolon_token)
+return semicolon_token + 1;
+else if (name)
+return name->lastToken();
+else if (typename_token)
+return typename_token + 1;
+return using_token + 1;
+}
+unsigned UsingDirectiveAST::firstToken() const
+{
+return using_token;
+}
+unsigned UsingDirectiveAST::lastToken() const
+{
+if (semicolon_token)
+return semicolon_token + 1;
+else if (name)
+return name->lastToken();
+else if (namespace_token)
+return namespace_token + 1;
+return using_token + 1;
+}
+unsigned WhileStatementAST::firstToken() const
+{
+return while_token;
+}
+unsigned WhileStatementAST::lastToken() const
+{
+if (statement)
+return statement->lastToken();
+else if (rparen_token)
+return rparen_token + 1;
+else if (condition)
+return condition->lastToken();
+else if (lparen_token)
+return lparen_token + 1;
+return while_token + 1;
+}
+// ObjC++
+unsigned ObjCClassForwardDeclarationAST::firstToken() const
+{
+if (attribute_list)
+return attribute_list->firstToken();
+return class_token;
+}
+unsigned ObjCClassForwardDeclarationAST::lastToken() const
+{
+if (semicolon_token)
+return semicolon_token + 1;
+else if (identifier_list)
+return identifier_list->lastToken();
+return class_token + 1;
+}
+unsigned ObjCProtocolForwardDeclarationAST::firstToken() const
+{
+if (attribute_list)
+return attribute_list->firstToken();
+return protocol_token;
+}
+unsigned ObjCProtocolForwardDeclarationAST::lastToken() const
+{
+if (semicolon_token)
+return semicolon_token + 1;
+else if (identifier_list)
+return identifier_list->lastToken();
+return protocol_token + 1;
+}
+unsigned ObjCClassDeclarationAST::firstToken() const
+{
+if (attribute_list)
+return attribute_list->firstToken();
+if (interface_token)
+return interface_token;
+else
+return implementation_token;
+}
+unsigned ObjCClassDeclarationAST::lastToken() const
+{
+if (end_token)                   return end_token + 1;
+if (member_declaration_list)         return member_declaration_list->lastToken();
+if (inst_vars_decl)              return inst_vars_decl->lastToken();
+if (protocol_refs)
+return protocol_refs->lastToken();
+if (superclass)
+return superclass->lastToken();
+if (colon_token)                 return colon_token + 1;
+if (rparen_token)
+return rparen_token + 1;
+if (category_name)
+return category_name->lastToken();
+if (lparen_token)
+return lparen_token + 1;
+if (class_name)                  return class_name->lastToken();
+if (interface_token)
+return interface_token + 1;
+else
+return implementation_token + 1;
+}
+unsigned ObjCProtocolDeclarationAST::firstToken() const
+{
+if (attribute_list)
+return attribute_list->firstToken();
+return protocol_token;
+}
+unsigned ObjCProtocolDeclarationAST::lastToken() const
+{
+if (end_token)
+return end_token + 1;
+else if (member_declaration_list)
+return member_declaration_list->lastToken();
+else if (protocol_refs)
+return protocol_refs->lastToken();
+else if (name)
+return name->lastToken();
+else if (attribute_list)
+return attribute_list->lastToken();
+return protocol_token + 1;
+}
+unsigned ObjCProtocolRefsAST::firstToken() const
+{
+return less_token;
+}
+unsigned ObjCProtocolRefsAST::lastToken() const
+{
+if (greater_token)
+return greater_token + 1;
+else if (identifier_list)
+return identifier_list->lastToken();
+return less_token + 1;
+}
+unsigned ObjCMessageExpressionAST::firstToken() const
+{
+return lbracket_token;
+}
+unsigned ObjCMessageExpressionAST::lastToken() const
+{
+if (rbracket_token)
+return rbracket_token + 1;
+if (receiver_expression)
+return receiver_expression->lastToken();
+if (selector)
+return selector->lastToken();
+if (argument_list)
+return argument_list->lastToken();
+return lbracket_token + 1;
+}
+unsigned ObjCMessageArgumentAST::firstToken() const
+{
+if (parameter_value_expression)
+return parameter_value_expression->firstToken();
+// ### assert?
+return 0;
+}
+unsigned ObjCMessageArgumentAST::lastToken() const
+{
+if (parameter_value_expression)
+return parameter_value_expression->lastToken();
+// ### assert?
+return 0;
+}
+unsigned ObjCProtocolExpressionAST::firstToken() const
+{
+return protocol_token;
+}
+unsigned ObjCProtocolExpressionAST::lastToken() const
+{
+if (rparen_token)
+return rparen_token + 1;
+if (identifier_token)
+return identifier_token + 1;
+if (lparen_token)
+return lparen_token + 1;
+return protocol_token + 1;
+}
+unsigned ObjCTypeNameAST::firstToken() const
+{
+return lparen_token;
+}
+unsigned ObjCTypeNameAST::lastToken() const
+{
+if (rparen_token)
+return rparen_token + 1;
+if (type_id)
+return type_id->lastToken();
+if (type_qualifier_token)
+return type_qualifier_token + 1;
+return lparen_token + 1;
+}
+unsigned ObjCEncodeExpressionAST::firstToken() const
+{
+return encode_token;
+}
+unsigned ObjCEncodeExpressionAST::lastToken() const
+{
+if (type_name)
+return type_name->lastToken();
+return encode_token + 1;
+}
+unsigned ObjCSelectorWithoutArgumentsAST::firstToken() const
+{
+return name_token;
+}
+unsigned ObjCSelectorWithoutArgumentsAST::lastToken() const
+{
+return name_token + 1;
+}
+unsigned ObjCSelectorArgumentAST::firstToken() const
+{
+return name_token;
+}
+unsigned ObjCSelectorArgumentAST::lastToken() const
+{
+if (colon_token)
+return colon_token + 1;
+else
+return name_token + 1;
+}
+unsigned ObjCSelectorWithArgumentsAST::firstToken() const
+{
+return selector_argument_list->firstToken();
+}
+unsigned ObjCSelectorWithArgumentsAST::lastToken() const
+{
+return selector_argument_list->lastToken();
+}
+unsigned ObjCSelectorExpressionAST::firstToken() const
+{
+return selector_token;
+}
+unsigned ObjCSelectorExpressionAST::lastToken() const
+{
+if (rparen_token)
+return rparen_token + 1;
+if (selector)
+return selector->lastToken();
+if (lparen_token)
+return rparen_token + 1;
+return selector_token + 1;
+}
+unsigned ObjCInstanceVariablesDeclarationAST::firstToken() const
+{
+return lbrace_token;
+}
+unsigned ObjCInstanceVariablesDeclarationAST::lastToken() const
+{
+if (rbrace_token)
+return rbrace_token + 1;
+if (instance_variable_list)
+return instance_variable_list->lastToken();
+return lbrace_token + 1;
+}
+unsigned ObjCVisibilityDeclarationAST::firstToken() const
+{
+return visibility_token;
+}
+unsigned ObjCVisibilityDeclarationAST::lastToken() const
+{
+return visibility_token + 1;
+}
+unsigned ObjCPropertyAttributeAST::firstToken() const
+{
+return attribute_identifier_token;
+}
+unsigned ObjCPropertyAttributeAST::lastToken() const
+{
+if (method_selector)
+return method_selector->lastToken();
+if (equals_token)
+return equals_token + 1;
+return attribute_identifier_token + 1;
+}
+unsigned ObjCPropertyDeclarationAST::firstToken() const
+{
+if (attribute_list)
+return attribute_list->firstToken();
+return property_token;
+}
+unsigned ObjCPropertyDeclarationAST::lastToken() const
+{
+if (simple_declaration)
+return simple_declaration->lastToken();
+else if (rparen_token)
+return rparen_token + 1;
+else if (property_attribute_list)
+return property_attribute_list->lastToken();
+else if (lparen_token)
+return lparen_token + 1;
+return property_token + 1;
+}
+unsigned ObjCMessageArgumentDeclarationAST::firstToken() const
+{
+if (type_name)
+return type_name->firstToken();
+else
+return param_name_token;
+}
+unsigned ObjCMessageArgumentDeclarationAST::lastToken() const
+{
+if (param_name_token)
+return param_name_token + 1;
+else if (type_name)
+return type_name->lastToken();
+// ### assert?
+return 0;
+}
+unsigned ObjCMethodPrototypeAST::firstToken() const
+{
+return method_type_token;
+}
+unsigned ObjCMethodPrototypeAST::lastToken() const
+{
+if (attribute_list)
+return attribute_list->lastToken();
+else if (dot_dot_dot_token)
+return dot_dot_dot_token + 1;
+else if (argument_list)
+return argument_list->lastToken();
+else if (type_name)
+return type_name->lastToken();
+return method_type_token + 1;
+}
+unsigned ObjCMethodDeclarationAST::firstToken() const
+{
+return method_prototype->firstToken();
+}
+unsigned ObjCMethodDeclarationAST::lastToken() const
+{
+if (semicolon_token)
+return semicolon_token + 1;
+if (function_body)
+return function_body->lastToken();
+return method_prototype->lastToken();
+}
+unsigned ObjCSynthesizedPropertyAST::firstToken() const
+{
+if (property_identifier_token)
+return property_identifier_token;
+else if (equals_token)
+return equals_token;
+else
+return alias_identifier_token;
+}
+unsigned ObjCSynthesizedPropertyAST::lastToken() const
+{
+if (alias_identifier_token)
+return alias_identifier_token + 1;
+else if (equals_token)
+return equals_token + 1;
+else
+return property_identifier_token + 1;
+}
+unsigned ObjCSynthesizedPropertiesDeclarationAST::firstToken() const
+{
+return synthesized_token;
+}
+unsigned ObjCSynthesizedPropertiesDeclarationAST::lastToken() const
+{
+if (semicolon_token)
+return semicolon_token + 1;
+else if (property_identifier_list)
+return property_identifier_list->lastToken();
+else
+return synthesized_token + 1;
+}
+unsigned ObjCDynamicPropertiesDeclarationAST::firstToken() const
+{
+return dynamic_token;
+}
+unsigned ObjCDynamicPropertiesDeclarationAST::lastToken() const
+{
+if (semicolon_token)
+return semicolon_token + 1;
+else if (property_identifier_list)
+return property_identifier_list->lastToken();
+else
+return dynamic_token + 1;
+}
+unsigned ObjCFastEnumerationAST::firstToken() const
+{
+return for_token;
+}
+unsigned ObjCFastEnumerationAST::lastToken() const
+{
+if (statement)
+return statement->lastToken();
+else if (rparen_token)
+return rparen_token + 1;
+else if (fast_enumeratable_expression)
+return fast_enumeratable_expression->lastToken();
+else if (in_token)
+return in_token + 1;
+else if (initializer)
+return initializer->lastToken();
+else if (declarator)
+return declarator->lastToken();
+else if (type_specifier_list)
+return type_specifier_list->lastToken();
+else if (lparen_token)
+return lparen_token + 1;
+else
+return for_token + 1;
+}
+unsigned ObjCSynchronizedStatementAST::firstToken() const
+{
+return synchronized_token;
+}
+unsigned ObjCSynchronizedStatementAST::lastToken() const
+{
+if (statement) return statement->lastToken();
+if (rparen_token) return rparen_token + 1;
+if (synchronized_object) return synchronized_object->lastToken();
+if (lparen_token) return lparen_token + 1;
+return synchronized_token + 1;
+}