From 388580781782981ccd9c4f0bf3f05ebc90b9f621 Mon Sep 17 00:00:00 2001 From: hjk Date: Fri, 26 Jul 2019 11:20:19 +0200 Subject: CPlusPlus: Modernize frontend generator ... and the generated code. Change-Id: Ib04d98e9c16f7aae96575b3d0c4ee9f27651e138 Reviewed-by: Nikolai Kosjar --- src/libs/3rdparty/cplusplus/AST.h | 324 ++++++++++++------------ src/libs/3rdparty/cplusplus/ASTPatternBuilder.h | 258 +++++++++---------- 2 files changed, 291 insertions(+), 291 deletions(-) (limited to 'src/libs/3rdparty') diff --git a/src/libs/3rdparty/cplusplus/AST.h b/src/libs/3rdparty/cplusplus/AST.h index d013afa544..b3ed935bb8 100644 --- a/src/libs/3rdparty/cplusplus/AST.h +++ b/src/libs/3rdparty/cplusplus/AST.h @@ -123,168 +123,168 @@ public: virtual AST *clone(MemoryPool *pool) const = 0; - virtual AccessDeclarationAST *asAccessDeclaration() { return 0; } - virtual AliasDeclarationAST *asAliasDeclaration() { return 0; } - virtual AlignmentSpecifierAST *asAlignmentSpecifier() { return 0; } - virtual AlignofExpressionAST *asAlignofExpression() { return 0; } - virtual AnonymousNameAST *asAnonymousName() { return 0; } - virtual ArrayAccessAST *asArrayAccess() { return 0; } - virtual ArrayDeclaratorAST *asArrayDeclarator() { return 0; } - virtual ArrayInitializerAST *asArrayInitializer() { return 0; } - virtual AsmDefinitionAST *asAsmDefinition() { return 0; } - virtual AttributeSpecifierAST *asAttributeSpecifier() { return 0; } - virtual BaseSpecifierAST *asBaseSpecifier() { return 0; } - virtual BinaryExpressionAST *asBinaryExpression() { return 0; } - virtual BoolLiteralAST *asBoolLiteral() { return 0; } - virtual BracedInitializerAST *asBracedInitializer() { return 0; } - virtual BracketDesignatorAST *asBracketDesignator() { return 0; } - virtual BreakStatementAST *asBreakStatement() { return 0; } - virtual CallAST *asCall() { return 0; } - virtual CaptureAST *asCapture() { return 0; } - virtual CaseStatementAST *asCaseStatement() { return 0; } - virtual CastExpressionAST *asCastExpression() { return 0; } - virtual CatchClauseAST *asCatchClause() { return 0; } - virtual ClassSpecifierAST *asClassSpecifier() { return 0; } - virtual CompoundExpressionAST *asCompoundExpression() { return 0; } - virtual CompoundLiteralAST *asCompoundLiteral() { return 0; } - virtual CompoundStatementAST *asCompoundStatement() { return 0; } - virtual ConditionAST *asCondition() { return 0; } - virtual ConditionalExpressionAST *asConditionalExpression() { return 0; } - virtual ContinueStatementAST *asContinueStatement() { return 0; } - virtual ConversionFunctionIdAST *asConversionFunctionId() { return 0; } - virtual CoreDeclaratorAST *asCoreDeclarator() { return 0; } - virtual CppCastExpressionAST *asCppCastExpression() { return 0; } - virtual CtorInitializerAST *asCtorInitializer() { return 0; } - virtual DeclarationAST *asDeclaration() { return 0; } - virtual DeclarationStatementAST *asDeclarationStatement() { return 0; } - virtual DeclaratorAST *asDeclarator() { return 0; } - virtual DeclaratorIdAST *asDeclaratorId() { return 0; } - virtual DecltypeSpecifierAST *asDecltypeSpecifier() { return 0; } - virtual DeleteExpressionAST *asDeleteExpression() { return 0; } - virtual DesignatedInitializerAST *asDesignatedInitializer() { return 0; } - virtual DesignatorAST *asDesignator() { return 0; } - virtual DestructorNameAST *asDestructorName() { return 0; } - virtual DoStatementAST *asDoStatement() { return 0; } - virtual DotDesignatorAST *asDotDesignator() { return 0; } - virtual DynamicExceptionSpecificationAST *asDynamicExceptionSpecification() { return 0; } - virtual ElaboratedTypeSpecifierAST *asElaboratedTypeSpecifier() { return 0; } - virtual EmptyDeclarationAST *asEmptyDeclaration() { return 0; } - virtual EnumSpecifierAST *asEnumSpecifier() { return 0; } - virtual EnumeratorAST *asEnumerator() { return 0; } - virtual ExceptionDeclarationAST *asExceptionDeclaration() { return 0; } - virtual ExceptionSpecificationAST *asExceptionSpecification() { return 0; } - virtual ExpressionAST *asExpression() { return 0; } - virtual ExpressionListParenAST *asExpressionListParen() { return 0; } - virtual ExpressionOrDeclarationStatementAST *asExpressionOrDeclarationStatement() { return 0; } - virtual ExpressionStatementAST *asExpressionStatement() { return 0; } - virtual ForStatementAST *asForStatement() { return 0; } - virtual ForeachStatementAST *asForeachStatement() { return 0; } - virtual FunctionDeclaratorAST *asFunctionDeclarator() { return 0; } - virtual FunctionDefinitionAST *asFunctionDefinition() { return 0; } - virtual GnuAttributeAST *asGnuAttribute() { return 0; } - virtual GnuAttributeSpecifierAST *asGnuAttributeSpecifier() { return 0; } - virtual GotoStatementAST *asGotoStatement() { return 0; } - virtual IdExpressionAST *asIdExpression() { return 0; } - virtual IfStatementAST *asIfStatement() { return 0; } - virtual LabeledStatementAST *asLabeledStatement() { return 0; } - virtual LambdaCaptureAST *asLambdaCapture() { return 0; } - virtual LambdaDeclaratorAST *asLambdaDeclarator() { return 0; } - virtual LambdaExpressionAST *asLambdaExpression() { return 0; } - virtual LambdaIntroducerAST *asLambdaIntroducer() { return 0; } - virtual LinkageBodyAST *asLinkageBody() { return 0; } - virtual LinkageSpecificationAST *asLinkageSpecification() { return 0; } - virtual MemInitializerAST *asMemInitializer() { return 0; } - virtual MemberAccessAST *asMemberAccess() { return 0; } - virtual NameAST *asName() { return 0; } - virtual NamedTypeSpecifierAST *asNamedTypeSpecifier() { return 0; } - virtual NamespaceAST *asNamespace() { return 0; } - virtual NamespaceAliasDefinitionAST *asNamespaceAliasDefinition() { return 0; } - virtual NestedDeclaratorAST *asNestedDeclarator() { return 0; } - virtual NestedExpressionAST *asNestedExpression() { return 0; } - virtual NestedNameSpecifierAST *asNestedNameSpecifier() { return 0; } - virtual NewArrayDeclaratorAST *asNewArrayDeclarator() { return 0; } - virtual NewExpressionAST *asNewExpression() { return 0; } - virtual NewTypeIdAST *asNewTypeId() { return 0; } - virtual NoExceptOperatorExpressionAST *asNoExceptOperatorExpression() { return 0; } - virtual NoExceptSpecificationAST *asNoExceptSpecification() { return 0; } - virtual NumericLiteralAST *asNumericLiteral() { return 0; } - virtual ObjCClassDeclarationAST *asObjCClassDeclaration() { return 0; } - virtual ObjCClassForwardDeclarationAST *asObjCClassForwardDeclaration() { return 0; } - virtual ObjCDynamicPropertiesDeclarationAST *asObjCDynamicPropertiesDeclaration() { return 0; } - virtual ObjCEncodeExpressionAST *asObjCEncodeExpression() { return 0; } - virtual ObjCFastEnumerationAST *asObjCFastEnumeration() { return 0; } - virtual ObjCInstanceVariablesDeclarationAST *asObjCInstanceVariablesDeclaration() { return 0; } - virtual ObjCMessageArgumentAST *asObjCMessageArgument() { return 0; } - virtual ObjCMessageArgumentDeclarationAST *asObjCMessageArgumentDeclaration() { return 0; } - virtual ObjCMessageExpressionAST *asObjCMessageExpression() { return 0; } - virtual ObjCMethodDeclarationAST *asObjCMethodDeclaration() { return 0; } - virtual ObjCMethodPrototypeAST *asObjCMethodPrototype() { return 0; } - virtual ObjCPropertyAttributeAST *asObjCPropertyAttribute() { return 0; } - virtual ObjCPropertyDeclarationAST *asObjCPropertyDeclaration() { return 0; } - virtual ObjCProtocolDeclarationAST *asObjCProtocolDeclaration() { return 0; } - virtual ObjCProtocolExpressionAST *asObjCProtocolExpression() { return 0; } - virtual ObjCProtocolForwardDeclarationAST *asObjCProtocolForwardDeclaration() { return 0; } - virtual ObjCProtocolRefsAST *asObjCProtocolRefs() { return 0; } - virtual ObjCSelectorAST *asObjCSelector() { return 0; } - virtual ObjCSelectorArgumentAST *asObjCSelectorArgument() { return 0; } - virtual ObjCSelectorExpressionAST *asObjCSelectorExpression() { return 0; } - virtual ObjCSynchronizedStatementAST *asObjCSynchronizedStatement() { return 0; } - virtual ObjCSynthesizedPropertiesDeclarationAST *asObjCSynthesizedPropertiesDeclaration() { return 0; } - virtual ObjCSynthesizedPropertyAST *asObjCSynthesizedProperty() { return 0; } - virtual ObjCTypeNameAST *asObjCTypeName() { return 0; } - virtual ObjCVisibilityDeclarationAST *asObjCVisibilityDeclaration() { return 0; } - virtual OperatorAST *asOperator() { return 0; } - virtual OperatorFunctionIdAST *asOperatorFunctionId() { return 0; } - virtual ParameterDeclarationAST *asParameterDeclaration() { return 0; } - virtual ParameterDeclarationClauseAST *asParameterDeclarationClause() { return 0; } - virtual PointerAST *asPointer() { return 0; } - virtual PointerLiteralAST *asPointerLiteral() { return 0; } - virtual PointerToMemberAST *asPointerToMember() { return 0; } - virtual PostIncrDecrAST *asPostIncrDecr() { return 0; } - virtual PostfixAST *asPostfix() { return 0; } - virtual PostfixDeclaratorAST *asPostfixDeclarator() { return 0; } - virtual PtrOperatorAST *asPtrOperator() { return 0; } - virtual QtEnumDeclarationAST *asQtEnumDeclaration() { return 0; } - virtual QtFlagsDeclarationAST *asQtFlagsDeclaration() { return 0; } - virtual QtInterfaceNameAST *asQtInterfaceName() { return 0; } - virtual QtInterfacesDeclarationAST *asQtInterfacesDeclaration() { return 0; } - virtual QtMemberDeclarationAST *asQtMemberDeclaration() { return 0; } - virtual QtMethodAST *asQtMethod() { return 0; } - virtual QtObjectTagAST *asQtObjectTag() { return 0; } - virtual QtPrivateSlotAST *asQtPrivateSlot() { return 0; } - virtual QtPropertyDeclarationAST *asQtPropertyDeclaration() { return 0; } - virtual QtPropertyDeclarationItemAST *asQtPropertyDeclarationItem() { return 0; } - virtual QualifiedNameAST *asQualifiedName() { return 0; } - virtual RangeBasedForStatementAST *asRangeBasedForStatement() { return 0; } - virtual ReferenceAST *asReference() { return 0; } - virtual ReturnStatementAST *asReturnStatement() { return 0; } - virtual SimpleDeclarationAST *asSimpleDeclaration() { return 0; } - virtual SimpleNameAST *asSimpleName() { return 0; } - virtual SimpleSpecifierAST *asSimpleSpecifier() { return 0; } - virtual SizeofExpressionAST *asSizeofExpression() { return 0; } - virtual SpecifierAST *asSpecifier() { return 0; } - virtual StatementAST *asStatement() { return 0; } - virtual StaticAssertDeclarationAST *asStaticAssertDeclaration() { return 0; } - virtual StringLiteralAST *asStringLiteral() { return 0; } - virtual SwitchStatementAST *asSwitchStatement() { return 0; } - virtual TemplateDeclarationAST *asTemplateDeclaration() { return 0; } - virtual TemplateIdAST *asTemplateId() { return 0; } - virtual TemplateTypeParameterAST *asTemplateTypeParameter() { return 0; } - virtual ThisExpressionAST *asThisExpression() { return 0; } - virtual ThrowExpressionAST *asThrowExpression() { return 0; } - virtual TrailingReturnTypeAST *asTrailingReturnType() { return 0; } - virtual TranslationUnitAST *asTranslationUnit() { return 0; } - virtual TryBlockStatementAST *asTryBlockStatement() { return 0; } - virtual TypeConstructorCallAST *asTypeConstructorCall() { return 0; } - virtual TypeIdAST *asTypeId() { return 0; } - virtual TypeidExpressionAST *asTypeidExpression() { return 0; } - virtual TypenameCallExpressionAST *asTypenameCallExpression() { return 0; } - virtual TypenameTypeParameterAST *asTypenameTypeParameter() { return 0; } - virtual TypeofSpecifierAST *asTypeofSpecifier() { return 0; } - virtual UnaryExpressionAST *asUnaryExpression() { return 0; } - virtual UsingAST *asUsing() { return 0; } - virtual UsingDirectiveAST *asUsingDirective() { return 0; } - virtual WhileStatementAST *asWhileStatement() { return 0; } + virtual AccessDeclarationAST *asAccessDeclaration() { return nullptr; } + virtual AliasDeclarationAST *asAliasDeclaration() { return nullptr; } + virtual AlignmentSpecifierAST *asAlignmentSpecifier() { return nullptr; } + virtual AlignofExpressionAST *asAlignofExpression() { return nullptr; } + virtual AnonymousNameAST *asAnonymousName() { return nullptr; } + virtual ArrayAccessAST *asArrayAccess() { return nullptr; } + virtual ArrayDeclaratorAST *asArrayDeclarator() { return nullptr; } + virtual ArrayInitializerAST *asArrayInitializer() { return nullptr; } + virtual AsmDefinitionAST *asAsmDefinition() { return nullptr; } + virtual AttributeSpecifierAST *asAttributeSpecifier() { return nullptr; } + virtual BaseSpecifierAST *asBaseSpecifier() { return nullptr; } + virtual BinaryExpressionAST *asBinaryExpression() { return nullptr; } + virtual BoolLiteralAST *asBoolLiteral() { return nullptr; } + virtual BracedInitializerAST *asBracedInitializer() { return nullptr; } + virtual BracketDesignatorAST *asBracketDesignator() { return nullptr; } + virtual BreakStatementAST *asBreakStatement() { return nullptr; } + virtual CallAST *asCall() { return nullptr; } + virtual CaptureAST *asCapture() { return nullptr; } + virtual CaseStatementAST *asCaseStatement() { return nullptr; } + virtual CastExpressionAST *asCastExpression() { return nullptr; } + virtual CatchClauseAST *asCatchClause() { return nullptr; } + virtual ClassSpecifierAST *asClassSpecifier() { return nullptr; } + virtual CompoundExpressionAST *asCompoundExpression() { return nullptr; } + virtual CompoundLiteralAST *asCompoundLiteral() { return nullptr; } + virtual CompoundStatementAST *asCompoundStatement() { return nullptr; } + virtual ConditionAST *asCondition() { return nullptr; } + virtual ConditionalExpressionAST *asConditionalExpression() { return nullptr; } + virtual ContinueStatementAST *asContinueStatement() { return nullptr; } + virtual ConversionFunctionIdAST *asConversionFunctionId() { return nullptr; } + virtual CoreDeclaratorAST *asCoreDeclarator() { return nullptr; } + virtual CppCastExpressionAST *asCppCastExpression() { return nullptr; } + virtual CtorInitializerAST *asCtorInitializer() { return nullptr; } + virtual DeclarationAST *asDeclaration() { return nullptr; } + virtual DeclarationStatementAST *asDeclarationStatement() { return nullptr; } + virtual DeclaratorAST *asDeclarator() { return nullptr; } + virtual DeclaratorIdAST *asDeclaratorId() { return nullptr; } + virtual DecltypeSpecifierAST *asDecltypeSpecifier() { return nullptr; } + virtual DeleteExpressionAST *asDeleteExpression() { return nullptr; } + virtual DesignatedInitializerAST *asDesignatedInitializer() { return nullptr; } + virtual DesignatorAST *asDesignator() { return nullptr; } + virtual DestructorNameAST *asDestructorName() { return nullptr; } + virtual DoStatementAST *asDoStatement() { return nullptr; } + virtual DotDesignatorAST *asDotDesignator() { return nullptr; } + virtual DynamicExceptionSpecificationAST *asDynamicExceptionSpecification() { return nullptr; } + virtual ElaboratedTypeSpecifierAST *asElaboratedTypeSpecifier() { return nullptr; } + virtual EmptyDeclarationAST *asEmptyDeclaration() { return nullptr; } + virtual EnumSpecifierAST *asEnumSpecifier() { return nullptr; } + virtual EnumeratorAST *asEnumerator() { return nullptr; } + virtual ExceptionDeclarationAST *asExceptionDeclaration() { return nullptr; } + virtual ExceptionSpecificationAST *asExceptionSpecification() { return nullptr; } + virtual ExpressionAST *asExpression() { return nullptr; } + virtual ExpressionListParenAST *asExpressionListParen() { return nullptr; } + virtual ExpressionOrDeclarationStatementAST *asExpressionOrDeclarationStatement() { return nullptr; } + virtual ExpressionStatementAST *asExpressionStatement() { return nullptr; } + virtual ForStatementAST *asForStatement() { return nullptr; } + virtual ForeachStatementAST *asForeachStatement() { return nullptr; } + virtual FunctionDeclaratorAST *asFunctionDeclarator() { return nullptr; } + virtual FunctionDefinitionAST *asFunctionDefinition() { return nullptr; } + virtual GnuAttributeAST *asGnuAttribute() { return nullptr; } + virtual GnuAttributeSpecifierAST *asGnuAttributeSpecifier() { return nullptr; } + virtual GotoStatementAST *asGotoStatement() { return nullptr; } + virtual IdExpressionAST *asIdExpression() { return nullptr; } + virtual IfStatementAST *asIfStatement() { return nullptr; } + virtual LabeledStatementAST *asLabeledStatement() { return nullptr; } + virtual LambdaCaptureAST *asLambdaCapture() { return nullptr; } + virtual LambdaDeclaratorAST *asLambdaDeclarator() { return nullptr; } + virtual LambdaExpressionAST *asLambdaExpression() { return nullptr; } + virtual LambdaIntroducerAST *asLambdaIntroducer() { return nullptr; } + virtual LinkageBodyAST *asLinkageBody() { return nullptr; } + virtual LinkageSpecificationAST *asLinkageSpecification() { return nullptr; } + virtual MemInitializerAST *asMemInitializer() { return nullptr; } + virtual MemberAccessAST *asMemberAccess() { return nullptr; } + virtual NameAST *asName() { return nullptr; } + virtual NamedTypeSpecifierAST *asNamedTypeSpecifier() { return nullptr; } + virtual NamespaceAST *asNamespace() { return nullptr; } + virtual NamespaceAliasDefinitionAST *asNamespaceAliasDefinition() { return nullptr; } + virtual NestedDeclaratorAST *asNestedDeclarator() { return nullptr; } + virtual NestedExpressionAST *asNestedExpression() { return nullptr; } + virtual NestedNameSpecifierAST *asNestedNameSpecifier() { return nullptr; } + virtual NewArrayDeclaratorAST *asNewArrayDeclarator() { return nullptr; } + virtual NewExpressionAST *asNewExpression() { return nullptr; } + virtual NewTypeIdAST *asNewTypeId() { return nullptr; } + virtual NoExceptOperatorExpressionAST *asNoExceptOperatorExpression() { return nullptr; } + virtual NoExceptSpecificationAST *asNoExceptSpecification() { return nullptr; } + virtual NumericLiteralAST *asNumericLiteral() { return nullptr; } + virtual ObjCClassDeclarationAST *asObjCClassDeclaration() { return nullptr; } + virtual ObjCClassForwardDeclarationAST *asObjCClassForwardDeclaration() { return nullptr; } + virtual ObjCDynamicPropertiesDeclarationAST *asObjCDynamicPropertiesDeclaration() { return nullptr; } + virtual ObjCEncodeExpressionAST *asObjCEncodeExpression() { return nullptr; } + virtual ObjCFastEnumerationAST *asObjCFastEnumeration() { return nullptr; } + virtual ObjCInstanceVariablesDeclarationAST *asObjCInstanceVariablesDeclaration() { return nullptr; } + virtual ObjCMessageArgumentAST *asObjCMessageArgument() { return nullptr; } + virtual ObjCMessageArgumentDeclarationAST *asObjCMessageArgumentDeclaration() { return nullptr; } + virtual ObjCMessageExpressionAST *asObjCMessageExpression() { return nullptr; } + virtual ObjCMethodDeclarationAST *asObjCMethodDeclaration() { return nullptr; } + virtual ObjCMethodPrototypeAST *asObjCMethodPrototype() { return nullptr; } + virtual ObjCPropertyAttributeAST *asObjCPropertyAttribute() { return nullptr; } + virtual ObjCPropertyDeclarationAST *asObjCPropertyDeclaration() { return nullptr; } + virtual ObjCProtocolDeclarationAST *asObjCProtocolDeclaration() { return nullptr; } + virtual ObjCProtocolExpressionAST *asObjCProtocolExpression() { return nullptr; } + virtual ObjCProtocolForwardDeclarationAST *asObjCProtocolForwardDeclaration() { return nullptr; } + virtual ObjCProtocolRefsAST *asObjCProtocolRefs() { return nullptr; } + virtual ObjCSelectorAST *asObjCSelector() { return nullptr; } + virtual ObjCSelectorArgumentAST *asObjCSelectorArgument() { return nullptr; } + virtual ObjCSelectorExpressionAST *asObjCSelectorExpression() { return nullptr; } + virtual ObjCSynchronizedStatementAST *asObjCSynchronizedStatement() { return nullptr; } + virtual ObjCSynthesizedPropertiesDeclarationAST *asObjCSynthesizedPropertiesDeclaration() { return nullptr; } + virtual ObjCSynthesizedPropertyAST *asObjCSynthesizedProperty() { return nullptr; } + virtual ObjCTypeNameAST *asObjCTypeName() { return nullptr; } + virtual ObjCVisibilityDeclarationAST *asObjCVisibilityDeclaration() { return nullptr; } + virtual OperatorAST *asOperator() { return nullptr; } + virtual OperatorFunctionIdAST *asOperatorFunctionId() { return nullptr; } + virtual ParameterDeclarationAST *asParameterDeclaration() { return nullptr; } + virtual ParameterDeclarationClauseAST *asParameterDeclarationClause() { return nullptr; } + virtual PointerAST *asPointer() { return nullptr; } + virtual PointerLiteralAST *asPointerLiteral() { return nullptr; } + virtual PointerToMemberAST *asPointerToMember() { return nullptr; } + virtual PostIncrDecrAST *asPostIncrDecr() { return nullptr; } + virtual PostfixAST *asPostfix() { return nullptr; } + virtual PostfixDeclaratorAST *asPostfixDeclarator() { return nullptr; } + virtual PtrOperatorAST *asPtrOperator() { return nullptr; } + virtual QtEnumDeclarationAST *asQtEnumDeclaration() { return nullptr; } + virtual QtFlagsDeclarationAST *asQtFlagsDeclaration() { return nullptr; } + virtual QtInterfaceNameAST *asQtInterfaceName() { return nullptr; } + virtual QtInterfacesDeclarationAST *asQtInterfacesDeclaration() { return nullptr; } + virtual QtMemberDeclarationAST *asQtMemberDeclaration() { return nullptr; } + virtual QtMethodAST *asQtMethod() { return nullptr; } + virtual QtObjectTagAST *asQtObjectTag() { return nullptr; } + virtual QtPrivateSlotAST *asQtPrivateSlot() { return nullptr; } + virtual QtPropertyDeclarationAST *asQtPropertyDeclaration() { return nullptr; } + virtual QtPropertyDeclarationItemAST *asQtPropertyDeclarationItem() { return nullptr; } + virtual QualifiedNameAST *asQualifiedName() { return nullptr; } + virtual RangeBasedForStatementAST *asRangeBasedForStatement() { return nullptr; } + virtual ReferenceAST *asReference() { return nullptr; } + virtual ReturnStatementAST *asReturnStatement() { return nullptr; } + virtual SimpleDeclarationAST *asSimpleDeclaration() { return nullptr; } + virtual SimpleNameAST *asSimpleName() { return nullptr; } + virtual SimpleSpecifierAST *asSimpleSpecifier() { return nullptr; } + virtual SizeofExpressionAST *asSizeofExpression() { return nullptr; } + virtual SpecifierAST *asSpecifier() { return nullptr; } + virtual StatementAST *asStatement() { return nullptr; } + virtual StaticAssertDeclarationAST *asStaticAssertDeclaration() { return nullptr; } + virtual StringLiteralAST *asStringLiteral() { return nullptr; } + virtual SwitchStatementAST *asSwitchStatement() { return nullptr; } + virtual TemplateDeclarationAST *asTemplateDeclaration() { return nullptr; } + virtual TemplateIdAST *asTemplateId() { return nullptr; } + virtual TemplateTypeParameterAST *asTemplateTypeParameter() { return nullptr; } + virtual ThisExpressionAST *asThisExpression() { return nullptr; } + virtual ThrowExpressionAST *asThrowExpression() { return nullptr; } + virtual TrailingReturnTypeAST *asTrailingReturnType() { return nullptr; } + virtual TranslationUnitAST *asTranslationUnit() { return nullptr; } + virtual TryBlockStatementAST *asTryBlockStatement() { return nullptr; } + virtual TypeConstructorCallAST *asTypeConstructorCall() { return nullptr; } + virtual TypeIdAST *asTypeId() { return nullptr; } + virtual TypeidExpressionAST *asTypeidExpression() { return nullptr; } + virtual TypenameCallExpressionAST *asTypenameCallExpression() { return nullptr; } + virtual TypenameTypeParameterAST *asTypenameTypeParameter() { return nullptr; } + virtual TypeofSpecifierAST *asTypeofSpecifier() { return nullptr; } + virtual UnaryExpressionAST *asUnaryExpression() { return nullptr; } + virtual UsingAST *asUsing() { return nullptr; } + virtual UsingDirectiveAST *asUsingDirective() { return nullptr; } + virtual WhileStatementAST *asWhileStatement() { return nullptr; } protected: virtual void accept0(ASTVisitor *visitor) = 0; diff --git a/src/libs/3rdparty/cplusplus/ASTPatternBuilder.h b/src/libs/3rdparty/cplusplus/ASTPatternBuilder.h index 9270a3429c..f9ede8834d 100644 --- a/src/libs/3rdparty/cplusplus/ASTPatternBuilder.h +++ b/src/libs/3rdparty/cplusplus/ASTPatternBuilder.h @@ -49,7 +49,7 @@ public: return ast; } - ObjCSelectorAST *ObjCSelector(ObjCSelectorArgumentListAST *selector_argument_list = 0) + ObjCSelectorAST *ObjCSelector(ObjCSelectorArgumentListAST *selector_argument_list = nullptr) { ObjCSelectorAST *ast = new (&pool) ObjCSelectorAST; ast->selector_argument_list = selector_argument_list; @@ -62,42 +62,42 @@ public: return ast; } - AlignmentSpecifierAST *AlignmentSpecifier(ExpressionAST *typeIdExprOrAlignmentExpr = 0) + AlignmentSpecifierAST *AlignmentSpecifier(ExpressionAST *typeIdExprOrAlignmentExpr = nullptr) { AlignmentSpecifierAST *ast = new (&pool) AlignmentSpecifierAST; ast->typeIdExprOrAlignmentExpr = typeIdExprOrAlignmentExpr; return ast; } - GnuAttributeSpecifierAST *GnuAttributeSpecifier(GnuAttributeListAST *attribute_list = 0) + GnuAttributeSpecifierAST *GnuAttributeSpecifier(GnuAttributeListAST *attribute_list = nullptr) { GnuAttributeSpecifierAST *ast = new (&pool) GnuAttributeSpecifierAST; ast->attribute_list = attribute_list; return ast; } - GnuAttributeAST *GnuAttribute(ExpressionListAST *expression_list = 0) + GnuAttributeAST *GnuAttribute(ExpressionListAST *expression_list = nullptr) { GnuAttributeAST *ast = new (&pool) GnuAttributeAST; ast->expression_list = expression_list; return ast; } - TypeofSpecifierAST *TypeofSpecifier(ExpressionAST *expression = 0) + TypeofSpecifierAST *TypeofSpecifier(ExpressionAST *expression = nullptr) { TypeofSpecifierAST *ast = new (&pool) TypeofSpecifierAST; ast->expression = expression; return ast; } - DecltypeSpecifierAST *DecltypeSpecifier(ExpressionAST *expression = 0) + DecltypeSpecifierAST *DecltypeSpecifier(ExpressionAST *expression = nullptr) { DecltypeSpecifierAST *ast = new (&pool) DecltypeSpecifierAST; ast->expression = expression; return ast; } - DeclaratorAST *Declarator(SpecifierListAST *attribute_list = 0, PtrOperatorListAST *ptr_operator_list = 0, CoreDeclaratorAST *core_declarator = 0, PostfixDeclaratorListAST *postfix_declarator_list = 0, SpecifierListAST *post_attribute_list = 0, ExpressionAST *initializer = 0) + DeclaratorAST *Declarator(SpecifierListAST *attribute_list = nullptr, PtrOperatorListAST *ptr_operator_list = nullptr, CoreDeclaratorAST *core_declarator = nullptr, PostfixDeclaratorListAST *postfix_declarator_list = nullptr, SpecifierListAST *post_attribute_list = nullptr, ExpressionAST *initializer = nullptr) { DeclaratorAST *ast = new (&pool) DeclaratorAST; ast->attribute_list = attribute_list; @@ -109,7 +109,7 @@ public: return ast; } - SimpleDeclarationAST *SimpleDeclaration(SpecifierListAST *decl_specifier_list = 0, DeclaratorListAST *declarator_list = 0) + SimpleDeclarationAST *SimpleDeclaration(SpecifierListAST *decl_specifier_list = nullptr, DeclaratorListAST *declarator_list = nullptr) { SimpleDeclarationAST *ast = new (&pool) SimpleDeclarationAST; ast->decl_specifier_list = decl_specifier_list; @@ -135,7 +135,7 @@ public: return ast; } - QtPrivateSlotAST *QtPrivateSlot(SpecifierListAST *type_specifier_list = 0, DeclaratorAST *declarator = 0) + QtPrivateSlotAST *QtPrivateSlot(SpecifierListAST *type_specifier_list = nullptr, DeclaratorAST *declarator = nullptr) { QtPrivateSlotAST *ast = new (&pool) QtPrivateSlotAST; ast->type_specifier_list = type_specifier_list; @@ -143,14 +143,14 @@ public: return ast; } - QtPropertyDeclarationItemAST *QtPropertyDeclarationItem(ExpressionAST *expression = 0) + QtPropertyDeclarationItemAST *QtPropertyDeclarationItem(ExpressionAST *expression = nullptr) { QtPropertyDeclarationItemAST *ast = new (&pool) QtPropertyDeclarationItemAST; ast->expression = expression; return ast; } - QtPropertyDeclarationAST *QtPropertyDeclaration(ExpressionAST *expression = 0, ExpressionAST *type_id = 0, NameAST *property_name = 0, QtPropertyDeclarationItemListAST *property_declaration_item_list = 0) + QtPropertyDeclarationAST *QtPropertyDeclaration(ExpressionAST *expression = nullptr, ExpressionAST *type_id = nullptr, NameAST *property_name = nullptr, QtPropertyDeclarationItemListAST *property_declaration_item_list = nullptr) { QtPropertyDeclarationAST *ast = new (&pool) QtPropertyDeclarationAST; ast->expression = expression; @@ -160,21 +160,21 @@ public: return ast; } - QtEnumDeclarationAST *QtEnumDeclaration(NameListAST *enumerator_list = 0) + QtEnumDeclarationAST *QtEnumDeclaration(NameListAST *enumerator_list = nullptr) { QtEnumDeclarationAST *ast = new (&pool) QtEnumDeclarationAST; ast->enumerator_list = enumerator_list; return ast; } - QtFlagsDeclarationAST *QtFlagsDeclaration(NameListAST *flag_enums_list = 0) + QtFlagsDeclarationAST *QtFlagsDeclaration(NameListAST *flag_enums_list = nullptr) { QtFlagsDeclarationAST *ast = new (&pool) QtFlagsDeclarationAST; ast->flag_enums_list = flag_enums_list; return ast; } - QtInterfaceNameAST *QtInterfaceName(NameAST *interface_name = 0, NameListAST *constraint_list = 0) + QtInterfaceNameAST *QtInterfaceName(NameAST *interface_name = nullptr, NameListAST *constraint_list = nullptr) { QtInterfaceNameAST *ast = new (&pool) QtInterfaceNameAST; ast->interface_name = interface_name; @@ -182,7 +182,7 @@ public: return ast; } - QtInterfacesDeclarationAST *QtInterfacesDeclaration(QtInterfaceNameListAST *interface_name_list = 0) + QtInterfacesDeclarationAST *QtInterfacesDeclaration(QtInterfaceNameListAST *interface_name_list = nullptr) { QtInterfacesDeclarationAST *ast = new (&pool) QtInterfacesDeclarationAST; ast->interface_name_list = interface_name_list; @@ -195,28 +195,28 @@ public: return ast; } - BaseSpecifierAST *BaseSpecifier(NameAST *name = 0) + BaseSpecifierAST *BaseSpecifier(NameAST *name = nullptr) { BaseSpecifierAST *ast = new (&pool) BaseSpecifierAST; ast->name = name; return ast; } - IdExpressionAST *IdExpression(NameAST *name = 0) + IdExpressionAST *IdExpression(NameAST *name = nullptr) { IdExpressionAST *ast = new (&pool) IdExpressionAST; ast->name = name; return ast; } - CompoundExpressionAST *CompoundExpression(CompoundStatementAST *statement = 0) + CompoundExpressionAST *CompoundExpression(CompoundStatementAST *statement = nullptr) { CompoundExpressionAST *ast = new (&pool) CompoundExpressionAST; ast->statement = statement; return ast; } - CompoundLiteralAST *CompoundLiteral(ExpressionAST *type_id = 0, ExpressionAST *initializer = 0) + CompoundLiteralAST *CompoundLiteral(ExpressionAST *type_id = nullptr, ExpressionAST *initializer = nullptr) { CompoundLiteralAST *ast = new (&pool) CompoundLiteralAST; ast->type_id = type_id; @@ -224,21 +224,21 @@ public: return ast; } - QtMethodAST *QtMethod(DeclaratorAST *declarator = 0) + QtMethodAST *QtMethod(DeclaratorAST *declarator = nullptr) { QtMethodAST *ast = new (&pool) QtMethodAST; ast->declarator = declarator; return ast; } - QtMemberDeclarationAST *QtMemberDeclaration(ExpressionAST *type_id = 0) + QtMemberDeclarationAST *QtMemberDeclaration(ExpressionAST *type_id = nullptr) { QtMemberDeclarationAST *ast = new (&pool) QtMemberDeclarationAST; ast->type_id = type_id; return ast; } - BinaryExpressionAST *BinaryExpression(ExpressionAST *left_expression = 0, ExpressionAST *right_expression = 0) + BinaryExpressionAST *BinaryExpression(ExpressionAST *left_expression = nullptr, ExpressionAST *right_expression = nullptr) { BinaryExpressionAST *ast = new (&pool) BinaryExpressionAST; ast->left_expression = left_expression; @@ -246,7 +246,7 @@ public: return ast; } - CastExpressionAST *CastExpression(ExpressionAST *type_id = 0, ExpressionAST *expression = 0) + CastExpressionAST *CastExpression(ExpressionAST *type_id = nullptr, ExpressionAST *expression = nullptr) { CastExpressionAST *ast = new (&pool) CastExpressionAST; ast->type_id = type_id; @@ -254,7 +254,7 @@ public: return ast; } - ClassSpecifierAST *ClassSpecifier(SpecifierListAST *attribute_list = 0, NameAST *name = 0, BaseSpecifierListAST *base_clause_list = 0, DeclarationListAST *member_specifier_list = 0) + ClassSpecifierAST *ClassSpecifier(SpecifierListAST *attribute_list = nullptr, NameAST *name = nullptr, BaseSpecifierListAST *base_clause_list = nullptr, DeclarationListAST *member_specifier_list = nullptr) { ClassSpecifierAST *ast = new (&pool) ClassSpecifierAST; ast->attribute_list = attribute_list; @@ -264,7 +264,7 @@ public: return ast; } - CaseStatementAST *CaseStatement(ExpressionAST *expression = 0, StatementAST *statement = 0) + CaseStatementAST *CaseStatement(ExpressionAST *expression = nullptr, StatementAST *statement = nullptr) { CaseStatementAST *ast = new (&pool) CaseStatementAST; ast->expression = expression; @@ -272,14 +272,14 @@ public: return ast; } - CompoundStatementAST *CompoundStatement(StatementListAST *statement_list = 0) + CompoundStatementAST *CompoundStatement(StatementListAST *statement_list = nullptr) { CompoundStatementAST *ast = new (&pool) CompoundStatementAST; ast->statement_list = statement_list; return ast; } - ConditionAST *Condition(SpecifierListAST *type_specifier_list = 0, DeclaratorAST *declarator = 0) + ConditionAST *Condition(SpecifierListAST *type_specifier_list = nullptr, DeclaratorAST *declarator = nullptr) { ConditionAST *ast = new (&pool) ConditionAST; ast->type_specifier_list = type_specifier_list; @@ -287,7 +287,7 @@ public: return ast; } - ConditionalExpressionAST *ConditionalExpression(ExpressionAST *condition = 0, ExpressionAST *left_expression = 0, ExpressionAST *right_expression = 0) + ConditionalExpressionAST *ConditionalExpression(ExpressionAST *condition = nullptr, ExpressionAST *left_expression = nullptr, ExpressionAST *right_expression = nullptr) { ConditionalExpressionAST *ast = new (&pool) ConditionalExpressionAST; ast->condition = condition; @@ -296,7 +296,7 @@ public: return ast; } - CppCastExpressionAST *CppCastExpression(ExpressionAST *type_id = 0, ExpressionAST *expression = 0) + CppCastExpressionAST *CppCastExpression(ExpressionAST *type_id = nullptr, ExpressionAST *expression = nullptr) { CppCastExpressionAST *ast = new (&pool) CppCastExpressionAST; ast->type_id = type_id; @@ -304,35 +304,35 @@ public: return ast; } - CtorInitializerAST *CtorInitializer(MemInitializerListAST *member_initializer_list = 0) + CtorInitializerAST *CtorInitializer(MemInitializerListAST *member_initializer_list = nullptr) { CtorInitializerAST *ast = new (&pool) CtorInitializerAST; ast->member_initializer_list = member_initializer_list; return ast; } - DeclarationStatementAST *DeclarationStatement(DeclarationAST *declaration = 0) + DeclarationStatementAST *DeclarationStatement(DeclarationAST *declaration = nullptr) { DeclarationStatementAST *ast = new (&pool) DeclarationStatementAST; ast->declaration = declaration; return ast; } - DeclaratorIdAST *DeclaratorId(NameAST *name = 0) + DeclaratorIdAST *DeclaratorId(NameAST *name = nullptr) { DeclaratorIdAST *ast = new (&pool) DeclaratorIdAST; ast->name = name; return ast; } - NestedDeclaratorAST *NestedDeclarator(DeclaratorAST *declarator = 0) + NestedDeclaratorAST *NestedDeclarator(DeclaratorAST *declarator = nullptr) { NestedDeclaratorAST *ast = new (&pool) NestedDeclaratorAST; ast->declarator = declarator; return ast; } - FunctionDeclaratorAST *FunctionDeclarator(ParameterDeclarationClauseAST *parameter_declaration_clause = 0, SpecifierListAST *cv_qualifier_list = 0, ExceptionSpecificationAST *exception_specification = 0, TrailingReturnTypeAST *trailing_return_type = 0, ExpressionAST *as_cpp_initializer = 0) + FunctionDeclaratorAST *FunctionDeclarator(ParameterDeclarationClauseAST *parameter_declaration_clause = nullptr, SpecifierListAST *cv_qualifier_list = nullptr, ExceptionSpecificationAST *exception_specification = nullptr, TrailingReturnTypeAST *trailing_return_type = nullptr, ExpressionAST *as_cpp_initializer = nullptr) { FunctionDeclaratorAST *ast = new (&pool) FunctionDeclaratorAST; ast->parameter_declaration_clause = parameter_declaration_clause; @@ -343,21 +343,21 @@ public: return ast; } - ArrayDeclaratorAST *ArrayDeclarator(ExpressionAST *expression = 0) + ArrayDeclaratorAST *ArrayDeclarator(ExpressionAST *expression = nullptr) { ArrayDeclaratorAST *ast = new (&pool) ArrayDeclaratorAST; ast->expression = expression; return ast; } - DeleteExpressionAST *DeleteExpression(ExpressionAST *expression = 0) + DeleteExpressionAST *DeleteExpression(ExpressionAST *expression = nullptr) { DeleteExpressionAST *ast = new (&pool) DeleteExpressionAST; ast->expression = expression; return ast; } - DoStatementAST *DoStatement(StatementAST *statement = 0, ExpressionAST *expression = 0) + DoStatementAST *DoStatement(StatementAST *statement = nullptr, ExpressionAST *expression = nullptr) { DoStatementAST *ast = new (&pool) DoStatementAST; ast->statement = statement; @@ -365,14 +365,14 @@ public: return ast; } - NamedTypeSpecifierAST *NamedTypeSpecifier(NameAST *name = 0) + NamedTypeSpecifierAST *NamedTypeSpecifier(NameAST *name = nullptr) { NamedTypeSpecifierAST *ast = new (&pool) NamedTypeSpecifierAST; ast->name = name; return ast; } - ElaboratedTypeSpecifierAST *ElaboratedTypeSpecifier(SpecifierListAST *attribute_list = 0, NameAST *name = 0) + ElaboratedTypeSpecifierAST *ElaboratedTypeSpecifier(SpecifierListAST *attribute_list = nullptr, NameAST *name = nullptr) { ElaboratedTypeSpecifierAST *ast = new (&pool) ElaboratedTypeSpecifierAST; ast->attribute_list = attribute_list; @@ -380,7 +380,7 @@ public: return ast; } - EnumSpecifierAST *EnumSpecifier(NameAST *name = 0, SpecifierListAST *type_specifier_list = 0, EnumeratorListAST *enumerator_list = 0) + EnumSpecifierAST *EnumSpecifier(NameAST *name = nullptr, SpecifierListAST *type_specifier_list = nullptr, EnumeratorListAST *enumerator_list = nullptr) { EnumSpecifierAST *ast = new (&pool) EnumSpecifierAST; ast->name = name; @@ -389,14 +389,14 @@ public: return ast; } - EnumeratorAST *Enumerator(ExpressionAST *expression = 0) + EnumeratorAST *Enumerator(ExpressionAST *expression = nullptr) { EnumeratorAST *ast = new (&pool) EnumeratorAST; ast->expression = expression; return ast; } - ExceptionDeclarationAST *ExceptionDeclaration(SpecifierListAST *type_specifier_list = 0, DeclaratorAST *declarator = 0) + ExceptionDeclarationAST *ExceptionDeclaration(SpecifierListAST *type_specifier_list = nullptr, DeclaratorAST *declarator = nullptr) { ExceptionDeclarationAST *ast = new (&pool) ExceptionDeclarationAST; ast->type_specifier_list = type_specifier_list; @@ -404,21 +404,21 @@ public: return ast; } - DynamicExceptionSpecificationAST *DynamicExceptionSpecification(ExpressionListAST *type_id_list = 0) + DynamicExceptionSpecificationAST *DynamicExceptionSpecification(ExpressionListAST *type_id_list = nullptr) { DynamicExceptionSpecificationAST *ast = new (&pool) DynamicExceptionSpecificationAST; ast->type_id_list = type_id_list; return ast; } - NoExceptSpecificationAST *NoExceptSpecification(ExpressionAST *expression = 0) + NoExceptSpecificationAST *NoExceptSpecification(ExpressionAST *expression = nullptr) { NoExceptSpecificationAST *ast = new (&pool) NoExceptSpecificationAST; ast->expression = expression; return ast; } - ExpressionOrDeclarationStatementAST *ExpressionOrDeclarationStatement(ExpressionStatementAST *expression = 0, DeclarationStatementAST *declaration = 0) + ExpressionOrDeclarationStatementAST *ExpressionOrDeclarationStatement(ExpressionStatementAST *expression = nullptr, DeclarationStatementAST *declaration = nullptr) { ExpressionOrDeclarationStatementAST *ast = new (&pool) ExpressionOrDeclarationStatementAST; ast->expression = expression; @@ -426,14 +426,14 @@ public: return ast; } - ExpressionStatementAST *ExpressionStatement(ExpressionAST *expression = 0) + ExpressionStatementAST *ExpressionStatement(ExpressionAST *expression = nullptr) { ExpressionStatementAST *ast = new (&pool) ExpressionStatementAST; ast->expression = expression; return ast; } - FunctionDefinitionAST *FunctionDefinition(SpecifierListAST *decl_specifier_list = 0, DeclaratorAST *declarator = 0, CtorInitializerAST *ctor_initializer = 0, StatementAST *function_body = 0) + FunctionDefinitionAST *FunctionDefinition(SpecifierListAST *decl_specifier_list = nullptr, DeclaratorAST *declarator = nullptr, CtorInitializerAST *ctor_initializer = nullptr, StatementAST *function_body = nullptr) { FunctionDefinitionAST *ast = new (&pool) FunctionDefinitionAST; ast->decl_specifier_list = decl_specifier_list; @@ -443,7 +443,7 @@ public: return ast; } - ForeachStatementAST *ForeachStatement(SpecifierListAST *type_specifier_list = 0, DeclaratorAST *declarator = 0, ExpressionAST *initializer = 0, ExpressionAST *expression = 0, StatementAST *statement = 0) + ForeachStatementAST *ForeachStatement(SpecifierListAST *type_specifier_list = nullptr, DeclaratorAST *declarator = nullptr, ExpressionAST *initializer = nullptr, ExpressionAST *expression = nullptr, StatementAST *statement = nullptr) { ForeachStatementAST *ast = new (&pool) ForeachStatementAST; ast->type_specifier_list = type_specifier_list; @@ -454,7 +454,7 @@ public: return ast; } - RangeBasedForStatementAST *RangeBasedForStatement(SpecifierListAST *type_specifier_list = 0, DeclaratorAST *declarator = 0, ExpressionAST *expression = 0, StatementAST *statement = 0) + RangeBasedForStatementAST *RangeBasedForStatement(SpecifierListAST *type_specifier_list = nullptr, DeclaratorAST *declarator = nullptr, ExpressionAST *expression = nullptr, StatementAST *statement = nullptr) { RangeBasedForStatementAST *ast = new (&pool) RangeBasedForStatementAST; ast->type_specifier_list = type_specifier_list; @@ -464,7 +464,7 @@ public: return ast; } - ForStatementAST *ForStatement(StatementAST *initializer = 0, ExpressionAST *condition = 0, ExpressionAST *expression = 0, StatementAST *statement = 0) + ForStatementAST *ForStatement(StatementAST *initializer = nullptr, ExpressionAST *condition = nullptr, ExpressionAST *expression = nullptr, StatementAST *statement = nullptr) { ForStatementAST *ast = new (&pool) ForStatementAST; ast->initializer = initializer; @@ -474,7 +474,7 @@ public: return ast; } - IfStatementAST *IfStatement(ExpressionAST *condition = 0, StatementAST *statement = 0, StatementAST *else_statement = 0) + IfStatementAST *IfStatement(ExpressionAST *condition = nullptr, StatementAST *statement = nullptr, StatementAST *else_statement = nullptr) { IfStatementAST *ast = new (&pool) IfStatementAST; ast->condition = condition; @@ -483,35 +483,35 @@ public: return ast; } - ArrayInitializerAST *ArrayInitializer(ExpressionListAST *expression_list = 0) + ArrayInitializerAST *ArrayInitializer(ExpressionListAST *expression_list = nullptr) { ArrayInitializerAST *ast = new (&pool) ArrayInitializerAST; ast->expression_list = expression_list; return ast; } - LabeledStatementAST *LabeledStatement(StatementAST *statement = 0) + LabeledStatementAST *LabeledStatement(StatementAST *statement = nullptr) { LabeledStatementAST *ast = new (&pool) LabeledStatementAST; ast->statement = statement; return ast; } - LinkageBodyAST *LinkageBody(DeclarationListAST *declaration_list = 0) + LinkageBodyAST *LinkageBody(DeclarationListAST *declaration_list = nullptr) { LinkageBodyAST *ast = new (&pool) LinkageBodyAST; ast->declaration_list = declaration_list; return ast; } - LinkageSpecificationAST *LinkageSpecification(DeclarationAST *declaration = 0) + LinkageSpecificationAST *LinkageSpecification(DeclarationAST *declaration = nullptr) { LinkageSpecificationAST *ast = new (&pool) LinkageSpecificationAST; ast->declaration = declaration; return ast; } - MemInitializerAST *MemInitializer(NameAST *name = 0, ExpressionAST *expression = 0) + MemInitializerAST *MemInitializer(NameAST *name = nullptr, ExpressionAST *expression = nullptr) { MemInitializerAST *ast = new (&pool) MemInitializerAST; ast->name = name; @@ -519,14 +519,14 @@ public: return ast; } - NestedNameSpecifierAST *NestedNameSpecifier(NameAST *class_or_namespace_name = 0) + NestedNameSpecifierAST *NestedNameSpecifier(NameAST *class_or_namespace_name = nullptr) { NestedNameSpecifierAST *ast = new (&pool) NestedNameSpecifierAST; ast->class_or_namespace_name = class_or_namespace_name; return ast; } - QualifiedNameAST *QualifiedName(NestedNameSpecifierListAST *nested_name_specifier_list = 0, NameAST *unqualified_name = 0) + QualifiedNameAST *QualifiedName(NestedNameSpecifierListAST *nested_name_specifier_list = nullptr, NameAST *unqualified_name = nullptr) { QualifiedNameAST *ast = new (&pool) QualifiedNameAST; ast->nested_name_specifier_list = nested_name_specifier_list; @@ -534,14 +534,14 @@ public: return ast; } - OperatorFunctionIdAST *OperatorFunctionId(OperatorAST *op = 0) + OperatorFunctionIdAST *OperatorFunctionId(OperatorAST *op = nullptr) { OperatorFunctionIdAST *ast = new (&pool) OperatorFunctionIdAST; ast->op = op; return ast; } - ConversionFunctionIdAST *ConversionFunctionId(SpecifierListAST *type_specifier_list = 0, PtrOperatorListAST *ptr_operator_list = 0) + ConversionFunctionIdAST *ConversionFunctionId(SpecifierListAST *type_specifier_list = nullptr, PtrOperatorListAST *ptr_operator_list = nullptr) { ConversionFunctionIdAST *ast = new (&pool) ConversionFunctionIdAST; ast->type_specifier_list = type_specifier_list; @@ -561,21 +561,21 @@ public: return ast; } - DestructorNameAST *DestructorName(NameAST *unqualified_name = 0) + DestructorNameAST *DestructorName(NameAST *unqualified_name = nullptr) { DestructorNameAST *ast = new (&pool) DestructorNameAST; ast->unqualified_name = unqualified_name; return ast; } - TemplateIdAST *TemplateId(ExpressionListAST *template_argument_list = 0) + TemplateIdAST *TemplateId(ExpressionListAST *template_argument_list = nullptr) { TemplateIdAST *ast = new (&pool) TemplateIdAST; ast->template_argument_list = template_argument_list; return ast; } - NamespaceAST *Namespace(SpecifierListAST *attribute_list = 0, DeclarationAST *linkage_body = 0) + NamespaceAST *Namespace(SpecifierListAST *attribute_list = nullptr, DeclarationAST *linkage_body = nullptr) { NamespaceAST *ast = new (&pool) NamespaceAST; ast->attribute_list = attribute_list; @@ -583,14 +583,14 @@ public: return ast; } - NamespaceAliasDefinitionAST *NamespaceAliasDefinition(NameAST *name = 0) + NamespaceAliasDefinitionAST *NamespaceAliasDefinition(NameAST *name = nullptr) { NamespaceAliasDefinitionAST *ast = new (&pool) NamespaceAliasDefinitionAST; ast->name = name; return ast; } - AliasDeclarationAST *AliasDeclaration(NameAST *name = 0, TypeIdAST *typeId = 0) + AliasDeclarationAST *AliasDeclaration(NameAST *name = nullptr, TypeIdAST *typeId = nullptr) { AliasDeclarationAST *ast = new (&pool) AliasDeclarationAST; ast->name = name; @@ -598,21 +598,21 @@ public: return ast; } - ExpressionListParenAST *ExpressionListParen(ExpressionListAST *expression_list = 0) + ExpressionListParenAST *ExpressionListParen(ExpressionListAST *expression_list = nullptr) { ExpressionListParenAST *ast = new (&pool) ExpressionListParenAST; ast->expression_list = expression_list; return ast; } - NewArrayDeclaratorAST *NewArrayDeclarator(ExpressionAST *expression = 0) + NewArrayDeclaratorAST *NewArrayDeclarator(ExpressionAST *expression = nullptr) { NewArrayDeclaratorAST *ast = new (&pool) NewArrayDeclaratorAST; ast->expression = expression; return ast; } - NewExpressionAST *NewExpression(ExpressionListParenAST *new_placement = 0, ExpressionAST *type_id = 0, NewTypeIdAST *new_type_id = 0, ExpressionAST *new_initializer = 0) + NewExpressionAST *NewExpression(ExpressionListParenAST *new_placement = nullptr, ExpressionAST *type_id = nullptr, NewTypeIdAST *new_type_id = nullptr, ExpressionAST *new_initializer = nullptr) { NewExpressionAST *ast = new (&pool) NewExpressionAST; ast->new_placement = new_placement; @@ -622,7 +622,7 @@ public: return ast; } - NewTypeIdAST *NewTypeId(SpecifierListAST *type_specifier_list = 0, PtrOperatorListAST *ptr_operator_list = 0, NewArrayDeclaratorListAST *new_array_declarator_list = 0) + NewTypeIdAST *NewTypeId(SpecifierListAST *type_specifier_list = nullptr, PtrOperatorListAST *ptr_operator_list = nullptr, NewArrayDeclaratorListAST *new_array_declarator_list = nullptr) { NewTypeIdAST *ast = new (&pool) NewTypeIdAST; ast->type_specifier_list = type_specifier_list; @@ -637,7 +637,7 @@ public: return ast; } - ParameterDeclarationAST *ParameterDeclaration(SpecifierListAST *type_specifier_list = 0, DeclaratorAST *declarator = 0, ExpressionAST *expression = 0) + ParameterDeclarationAST *ParameterDeclaration(SpecifierListAST *type_specifier_list = nullptr, DeclaratorAST *declarator = nullptr, ExpressionAST *expression = nullptr) { ParameterDeclarationAST *ast = new (&pool) ParameterDeclarationAST; ast->type_specifier_list = type_specifier_list; @@ -646,14 +646,14 @@ public: return ast; } - ParameterDeclarationClauseAST *ParameterDeclarationClause(ParameterDeclarationListAST *parameter_declaration_list = 0) + ParameterDeclarationClauseAST *ParameterDeclarationClause(ParameterDeclarationListAST *parameter_declaration_list = nullptr) { ParameterDeclarationClauseAST *ast = new (&pool) ParameterDeclarationClauseAST; ast->parameter_declaration_list = parameter_declaration_list; return ast; } - CallAST *Call(ExpressionAST *base_expression = 0, ExpressionListAST *expression_list = 0) + CallAST *Call(ExpressionAST *base_expression = nullptr, ExpressionListAST *expression_list = nullptr) { CallAST *ast = new (&pool) CallAST; ast->base_expression = base_expression; @@ -661,7 +661,7 @@ public: return ast; } - ArrayAccessAST *ArrayAccess(ExpressionAST *base_expression = 0, ExpressionAST *expression = 0) + ArrayAccessAST *ArrayAccess(ExpressionAST *base_expression = nullptr, ExpressionAST *expression = nullptr) { ArrayAccessAST *ast = new (&pool) ArrayAccessAST; ast->base_expression = base_expression; @@ -669,14 +669,14 @@ public: return ast; } - PostIncrDecrAST *PostIncrDecr(ExpressionAST *base_expression = 0) + PostIncrDecrAST *PostIncrDecr(ExpressionAST *base_expression = nullptr) { PostIncrDecrAST *ast = new (&pool) PostIncrDecrAST; ast->base_expression = base_expression; return ast; } - MemberAccessAST *MemberAccess(ExpressionAST *base_expression = 0, NameAST *member_name = 0) + MemberAccessAST *MemberAccess(ExpressionAST *base_expression = nullptr, NameAST *member_name = nullptr) { MemberAccessAST *ast = new (&pool) MemberAccessAST; ast->base_expression = base_expression; @@ -684,14 +684,14 @@ public: return ast; } - TypeidExpressionAST *TypeidExpression(ExpressionAST *expression = 0) + TypeidExpressionAST *TypeidExpression(ExpressionAST *expression = nullptr) { TypeidExpressionAST *ast = new (&pool) TypeidExpressionAST; ast->expression = expression; return ast; } - TypenameCallExpressionAST *TypenameCallExpression(NameAST *name = 0, ExpressionAST *expression = 0) + TypenameCallExpressionAST *TypenameCallExpression(NameAST *name = nullptr, ExpressionAST *expression = nullptr) { TypenameCallExpressionAST *ast = new (&pool) TypenameCallExpressionAST; ast->name = name; @@ -699,7 +699,7 @@ public: return ast; } - TypeConstructorCallAST *TypeConstructorCall(SpecifierListAST *type_specifier_list = 0, ExpressionAST *expression = 0) + TypeConstructorCallAST *TypeConstructorCall(SpecifierListAST *type_specifier_list = nullptr, ExpressionAST *expression = nullptr) { TypeConstructorCallAST *ast = new (&pool) TypeConstructorCallAST; ast->type_specifier_list = type_specifier_list; @@ -707,7 +707,7 @@ public: return ast; } - PointerToMemberAST *PointerToMember(NestedNameSpecifierListAST *nested_name_specifier_list = 0, SpecifierListAST *cv_qualifier_list = 0) + PointerToMemberAST *PointerToMember(NestedNameSpecifierListAST *nested_name_specifier_list = nullptr, SpecifierListAST *cv_qualifier_list = nullptr) { PointerToMemberAST *ast = new (&pool) PointerToMemberAST; ast->nested_name_specifier_list = nested_name_specifier_list; @@ -715,7 +715,7 @@ public: return ast; } - PointerAST *Pointer(SpecifierListAST *cv_qualifier_list = 0) + PointerAST *Pointer(SpecifierListAST *cv_qualifier_list = nullptr) { PointerAST *ast = new (&pool) PointerAST; ast->cv_qualifier_list = cv_qualifier_list; @@ -746,21 +746,21 @@ public: return ast; } - ReturnStatementAST *ReturnStatement(ExpressionAST *expression = 0) + ReturnStatementAST *ReturnStatement(ExpressionAST *expression = nullptr) { ReturnStatementAST *ast = new (&pool) ReturnStatementAST; ast->expression = expression; return ast; } - SizeofExpressionAST *SizeofExpression(ExpressionAST *expression = 0) + SizeofExpressionAST *SizeofExpression(ExpressionAST *expression = nullptr) { SizeofExpressionAST *ast = new (&pool) SizeofExpressionAST; ast->expression = expression; return ast; } - AlignofExpressionAST *AlignofExpression(TypeIdAST *typeId = 0) + AlignofExpressionAST *AlignofExpression(TypeIdAST *typeId = nullptr) { AlignofExpressionAST *ast = new (&pool) AlignofExpressionAST; ast->typeId = typeId; @@ -791,14 +791,14 @@ public: return ast; } - NestedExpressionAST *NestedExpression(ExpressionAST *expression = 0) + NestedExpressionAST *NestedExpression(ExpressionAST *expression = nullptr) { NestedExpressionAST *ast = new (&pool) NestedExpressionAST; ast->expression = expression; return ast; } - StaticAssertDeclarationAST *StaticAssertDeclaration(ExpressionAST *expression = 0, ExpressionAST *string_literal = 0) + StaticAssertDeclarationAST *StaticAssertDeclaration(ExpressionAST *expression = nullptr, ExpressionAST *string_literal = nullptr) { StaticAssertDeclarationAST *ast = new (&pool) StaticAssertDeclarationAST; ast->expression = expression; @@ -806,14 +806,14 @@ public: return ast; } - StringLiteralAST *StringLiteral(StringLiteralAST *next = 0) + StringLiteralAST *StringLiteral(StringLiteralAST *next = nullptr) { StringLiteralAST *ast = new (&pool) StringLiteralAST; ast->next = next; return ast; } - SwitchStatementAST *SwitchStatement(ExpressionAST *condition = 0, StatementAST *statement = 0) + SwitchStatementAST *SwitchStatement(ExpressionAST *condition = nullptr, StatementAST *statement = nullptr) { SwitchStatementAST *ast = new (&pool) SwitchStatementAST; ast->condition = condition; @@ -821,7 +821,7 @@ public: return ast; } - TemplateDeclarationAST *TemplateDeclaration(DeclarationListAST *template_parameter_list = 0, DeclarationAST *declaration = 0) + TemplateDeclarationAST *TemplateDeclaration(DeclarationListAST *template_parameter_list = nullptr, DeclarationAST *declaration = nullptr) { TemplateDeclarationAST *ast = new (&pool) TemplateDeclarationAST; ast->template_parameter_list = template_parameter_list; @@ -829,28 +829,28 @@ public: return ast; } - ThrowExpressionAST *ThrowExpression(ExpressionAST *expression = 0) + ThrowExpressionAST *ThrowExpression(ExpressionAST *expression = nullptr) { ThrowExpressionAST *ast = new (&pool) ThrowExpressionAST; ast->expression = expression; return ast; } - NoExceptOperatorExpressionAST *NoExceptOperatorExpression(ExpressionAST *expression = 0) + NoExceptOperatorExpressionAST *NoExceptOperatorExpression(ExpressionAST *expression = nullptr) { NoExceptOperatorExpressionAST *ast = new (&pool) NoExceptOperatorExpressionAST; ast->expression = expression; return ast; } - TranslationUnitAST *TranslationUnit(DeclarationListAST *declaration_list = 0) + TranslationUnitAST *TranslationUnit(DeclarationListAST *declaration_list = nullptr) { TranslationUnitAST *ast = new (&pool) TranslationUnitAST; ast->declaration_list = declaration_list; return ast; } - TryBlockStatementAST *TryBlockStatement(StatementAST *statement = 0, CatchClauseListAST *catch_clause_list = 0) + TryBlockStatementAST *TryBlockStatement(StatementAST *statement = nullptr, CatchClauseListAST *catch_clause_list = nullptr) { TryBlockStatementAST *ast = new (&pool) TryBlockStatementAST; ast->statement = statement; @@ -858,7 +858,7 @@ public: return ast; } - CatchClauseAST *CatchClause(ExceptionDeclarationAST *exception_declaration = 0, StatementAST *statement = 0) + CatchClauseAST *CatchClause(ExceptionDeclarationAST *exception_declaration = nullptr, StatementAST *statement = nullptr) { CatchClauseAST *ast = new (&pool) CatchClauseAST; ast->exception_declaration = exception_declaration; @@ -866,7 +866,7 @@ public: return ast; } - TypeIdAST *TypeId(SpecifierListAST *type_specifier_list = 0, DeclaratorAST *declarator = 0) + TypeIdAST *TypeId(SpecifierListAST *type_specifier_list = nullptr, DeclaratorAST *declarator = nullptr) { TypeIdAST *ast = new (&pool) TypeIdAST; ast->type_specifier_list = type_specifier_list; @@ -874,7 +874,7 @@ public: return ast; } - TypenameTypeParameterAST *TypenameTypeParameter(NameAST *name = 0, ExpressionAST *type_id = 0) + TypenameTypeParameterAST *TypenameTypeParameter(NameAST *name = nullptr, ExpressionAST *type_id = nullptr) { TypenameTypeParameterAST *ast = new (&pool) TypenameTypeParameterAST; ast->name = name; @@ -882,7 +882,7 @@ public: return ast; } - TemplateTypeParameterAST *TemplateTypeParameter(DeclarationListAST *template_parameter_list = 0, NameAST *name = 0, ExpressionAST *type_id = 0) + TemplateTypeParameterAST *TemplateTypeParameter(DeclarationListAST *template_parameter_list = nullptr, NameAST *name = nullptr, ExpressionAST *type_id = nullptr) { TemplateTypeParameterAST *ast = new (&pool) TemplateTypeParameterAST; ast->template_parameter_list = template_parameter_list; @@ -891,28 +891,28 @@ public: return ast; } - UnaryExpressionAST *UnaryExpression(ExpressionAST *expression = 0) + UnaryExpressionAST *UnaryExpression(ExpressionAST *expression = nullptr) { UnaryExpressionAST *ast = new (&pool) UnaryExpressionAST; ast->expression = expression; return ast; } - UsingAST *Using(NameAST *name = 0) + UsingAST *Using(NameAST *name = nullptr) { UsingAST *ast = new (&pool) UsingAST; ast->name = name; return ast; } - UsingDirectiveAST *UsingDirective(NameAST *name = 0) + UsingDirectiveAST *UsingDirective(NameAST *name = nullptr) { UsingDirectiveAST *ast = new (&pool) UsingDirectiveAST; ast->name = name; return ast; } - WhileStatementAST *WhileStatement(ExpressionAST *condition = 0, StatementAST *statement = 0) + WhileStatementAST *WhileStatement(ExpressionAST *condition = nullptr, StatementAST *statement = nullptr) { WhileStatementAST *ast = new (&pool) WhileStatementAST; ast->condition = condition; @@ -920,7 +920,7 @@ public: return ast; } - ObjCClassForwardDeclarationAST *ObjCClassForwardDeclaration(SpecifierListAST *attribute_list = 0, NameListAST *identifier_list = 0) + ObjCClassForwardDeclarationAST *ObjCClassForwardDeclaration(SpecifierListAST *attribute_list = nullptr, NameListAST *identifier_list = nullptr) { ObjCClassForwardDeclarationAST *ast = new (&pool) ObjCClassForwardDeclarationAST; ast->attribute_list = attribute_list; @@ -928,7 +928,7 @@ public: return ast; } - ObjCClassDeclarationAST *ObjCClassDeclaration(SpecifierListAST *attribute_list = 0, NameAST *class_name = 0, NameAST *category_name = 0, NameAST *superclass = 0, ObjCProtocolRefsAST *protocol_refs = 0, ObjCInstanceVariablesDeclarationAST *inst_vars_decl = 0, DeclarationListAST *member_declaration_list = 0) + ObjCClassDeclarationAST *ObjCClassDeclaration(SpecifierListAST *attribute_list = nullptr, NameAST *class_name = nullptr, NameAST *category_name = nullptr, NameAST *superclass = nullptr, ObjCProtocolRefsAST *protocol_refs = nullptr, ObjCInstanceVariablesDeclarationAST *inst_vars_decl = nullptr, DeclarationListAST *member_declaration_list = nullptr) { ObjCClassDeclarationAST *ast = new (&pool) ObjCClassDeclarationAST; ast->attribute_list = attribute_list; @@ -941,7 +941,7 @@ public: return ast; } - ObjCProtocolForwardDeclarationAST *ObjCProtocolForwardDeclaration(SpecifierListAST *attribute_list = 0, NameListAST *identifier_list = 0) + ObjCProtocolForwardDeclarationAST *ObjCProtocolForwardDeclaration(SpecifierListAST *attribute_list = nullptr, NameListAST *identifier_list = nullptr) { ObjCProtocolForwardDeclarationAST *ast = new (&pool) ObjCProtocolForwardDeclarationAST; ast->attribute_list = attribute_list; @@ -949,7 +949,7 @@ public: return ast; } - ObjCProtocolDeclarationAST *ObjCProtocolDeclaration(SpecifierListAST *attribute_list = 0, NameAST *name = 0, ObjCProtocolRefsAST *protocol_refs = 0, DeclarationListAST *member_declaration_list = 0) + ObjCProtocolDeclarationAST *ObjCProtocolDeclaration(SpecifierListAST *attribute_list = nullptr, NameAST *name = nullptr, ObjCProtocolRefsAST *protocol_refs = nullptr, DeclarationListAST *member_declaration_list = nullptr) { ObjCProtocolDeclarationAST *ast = new (&pool) ObjCProtocolDeclarationAST; ast->attribute_list = attribute_list; @@ -959,21 +959,21 @@ public: return ast; } - ObjCProtocolRefsAST *ObjCProtocolRefs(NameListAST *identifier_list = 0) + ObjCProtocolRefsAST *ObjCProtocolRefs(NameListAST *identifier_list = nullptr) { ObjCProtocolRefsAST *ast = new (&pool) ObjCProtocolRefsAST; ast->identifier_list = identifier_list; return ast; } - ObjCMessageArgumentAST *ObjCMessageArgument(ExpressionAST *parameter_value_expression = 0) + ObjCMessageArgumentAST *ObjCMessageArgument(ExpressionAST *parameter_value_expression = nullptr) { ObjCMessageArgumentAST *ast = new (&pool) ObjCMessageArgumentAST; ast->parameter_value_expression = parameter_value_expression; return ast; } - ObjCMessageExpressionAST *ObjCMessageExpression(ExpressionAST *receiver_expression = 0, ObjCSelectorAST *selector = 0, ObjCMessageArgumentListAST *argument_list = 0) + ObjCMessageExpressionAST *ObjCMessageExpression(ExpressionAST *receiver_expression = nullptr, ObjCSelectorAST *selector = nullptr, ObjCMessageArgumentListAST *argument_list = nullptr) { ObjCMessageExpressionAST *ast = new (&pool) ObjCMessageExpressionAST; ast->receiver_expression = receiver_expression; @@ -988,28 +988,28 @@ public: return ast; } - ObjCTypeNameAST *ObjCTypeName(ExpressionAST *type_id = 0) + ObjCTypeNameAST *ObjCTypeName(ExpressionAST *type_id = nullptr) { ObjCTypeNameAST *ast = new (&pool) ObjCTypeNameAST; ast->type_id = type_id; return ast; } - ObjCEncodeExpressionAST *ObjCEncodeExpression(ObjCTypeNameAST *type_name = 0) + ObjCEncodeExpressionAST *ObjCEncodeExpression(ObjCTypeNameAST *type_name = nullptr) { ObjCEncodeExpressionAST *ast = new (&pool) ObjCEncodeExpressionAST; ast->type_name = type_name; return ast; } - ObjCSelectorExpressionAST *ObjCSelectorExpression(ObjCSelectorAST *selector = 0) + ObjCSelectorExpressionAST *ObjCSelectorExpression(ObjCSelectorAST *selector = nullptr) { ObjCSelectorExpressionAST *ast = new (&pool) ObjCSelectorExpressionAST; ast->selector = selector; return ast; } - ObjCInstanceVariablesDeclarationAST *ObjCInstanceVariablesDeclaration(DeclarationListAST *instance_variable_list = 0) + ObjCInstanceVariablesDeclarationAST *ObjCInstanceVariablesDeclaration(DeclarationListAST *instance_variable_list = nullptr) { ObjCInstanceVariablesDeclarationAST *ast = new (&pool) ObjCInstanceVariablesDeclarationAST; ast->instance_variable_list = instance_variable_list; @@ -1022,14 +1022,14 @@ public: return ast; } - ObjCPropertyAttributeAST *ObjCPropertyAttribute(ObjCSelectorAST *method_selector = 0) + ObjCPropertyAttributeAST *ObjCPropertyAttribute(ObjCSelectorAST *method_selector = nullptr) { ObjCPropertyAttributeAST *ast = new (&pool) ObjCPropertyAttributeAST; ast->method_selector = method_selector; return ast; } - ObjCPropertyDeclarationAST *ObjCPropertyDeclaration(SpecifierListAST *attribute_list = 0, ObjCPropertyAttributeListAST *property_attribute_list = 0, DeclarationAST *simple_declaration = 0) + ObjCPropertyDeclarationAST *ObjCPropertyDeclaration(SpecifierListAST *attribute_list = nullptr, ObjCPropertyAttributeListAST *property_attribute_list = nullptr, DeclarationAST *simple_declaration = nullptr) { ObjCPropertyDeclarationAST *ast = new (&pool) ObjCPropertyDeclarationAST; ast->attribute_list = attribute_list; @@ -1038,7 +1038,7 @@ public: return ast; } - ObjCMessageArgumentDeclarationAST *ObjCMessageArgumentDeclaration(ObjCTypeNameAST *type_name = 0, SpecifierListAST *attribute_list = 0, NameAST *param_name = 0) + ObjCMessageArgumentDeclarationAST *ObjCMessageArgumentDeclaration(ObjCTypeNameAST *type_name = nullptr, SpecifierListAST *attribute_list = nullptr, NameAST *param_name = nullptr) { ObjCMessageArgumentDeclarationAST *ast = new (&pool) ObjCMessageArgumentDeclarationAST; ast->type_name = type_name; @@ -1047,7 +1047,7 @@ public: return ast; } - ObjCMethodPrototypeAST *ObjCMethodPrototype(ObjCTypeNameAST *type_name = 0, ObjCSelectorAST *selector = 0, ObjCMessageArgumentDeclarationListAST *argument_list = 0, SpecifierListAST *attribute_list = 0) + ObjCMethodPrototypeAST *ObjCMethodPrototype(ObjCTypeNameAST *type_name = nullptr, ObjCSelectorAST *selector = nullptr, ObjCMessageArgumentDeclarationListAST *argument_list = nullptr, SpecifierListAST *attribute_list = nullptr) { ObjCMethodPrototypeAST *ast = new (&pool) ObjCMethodPrototypeAST; ast->type_name = type_name; @@ -1057,7 +1057,7 @@ public: return ast; } - ObjCMethodDeclarationAST *ObjCMethodDeclaration(ObjCMethodPrototypeAST *method_prototype = 0, StatementAST *function_body = 0) + ObjCMethodDeclarationAST *ObjCMethodDeclaration(ObjCMethodPrototypeAST *method_prototype = nullptr, StatementAST *function_body = nullptr) { ObjCMethodDeclarationAST *ast = new (&pool) ObjCMethodDeclarationAST; ast->method_prototype = method_prototype; @@ -1071,21 +1071,21 @@ public: return ast; } - ObjCSynthesizedPropertiesDeclarationAST *ObjCSynthesizedPropertiesDeclaration(ObjCSynthesizedPropertyListAST *property_identifier_list = 0) + ObjCSynthesizedPropertiesDeclarationAST *ObjCSynthesizedPropertiesDeclaration(ObjCSynthesizedPropertyListAST *property_identifier_list = nullptr) { ObjCSynthesizedPropertiesDeclarationAST *ast = new (&pool) ObjCSynthesizedPropertiesDeclarationAST; ast->property_identifier_list = property_identifier_list; return ast; } - ObjCDynamicPropertiesDeclarationAST *ObjCDynamicPropertiesDeclaration(NameListAST *property_identifier_list = 0) + ObjCDynamicPropertiesDeclarationAST *ObjCDynamicPropertiesDeclaration(NameListAST *property_identifier_list = nullptr) { ObjCDynamicPropertiesDeclarationAST *ast = new (&pool) ObjCDynamicPropertiesDeclarationAST; ast->property_identifier_list = property_identifier_list; return ast; } - ObjCFastEnumerationAST *ObjCFastEnumeration(SpecifierListAST *type_specifier_list = 0, DeclaratorAST *declarator = 0, ExpressionAST *initializer = 0, ExpressionAST *fast_enumeratable_expression = 0, StatementAST *statement = 0) + ObjCFastEnumerationAST *ObjCFastEnumeration(SpecifierListAST *type_specifier_list = nullptr, DeclaratorAST *declarator = nullptr, ExpressionAST *initializer = nullptr, ExpressionAST *fast_enumeratable_expression = nullptr, StatementAST *statement = nullptr) { ObjCFastEnumerationAST *ast = new (&pool) ObjCFastEnumerationAST; ast->type_specifier_list = type_specifier_list; @@ -1096,7 +1096,7 @@ public: return ast; } - ObjCSynchronizedStatementAST *ObjCSynchronizedStatement(ExpressionAST *synchronized_object = 0, StatementAST *statement = 0) + ObjCSynchronizedStatementAST *ObjCSynchronizedStatement(ExpressionAST *synchronized_object = nullptr, StatementAST *statement = nullptr) { ObjCSynchronizedStatementAST *ast = new (&pool) ObjCSynchronizedStatementAST; ast->synchronized_object = synchronized_object; @@ -1104,7 +1104,7 @@ public: return ast; } - LambdaExpressionAST *LambdaExpression(LambdaIntroducerAST *lambda_introducer = 0, LambdaDeclaratorAST *lambda_declarator = 0, StatementAST *statement = 0) + LambdaExpressionAST *LambdaExpression(LambdaIntroducerAST *lambda_introducer = nullptr, LambdaDeclaratorAST *lambda_declarator = nullptr, StatementAST *statement = nullptr) { LambdaExpressionAST *ast = new (&pool) LambdaExpressionAST; ast->lambda_introducer = lambda_introducer; @@ -1113,28 +1113,28 @@ public: return ast; } - LambdaIntroducerAST *LambdaIntroducer(LambdaCaptureAST *lambda_capture = 0) + LambdaIntroducerAST *LambdaIntroducer(LambdaCaptureAST *lambda_capture = nullptr) { LambdaIntroducerAST *ast = new (&pool) LambdaIntroducerAST; ast->lambda_capture = lambda_capture; return ast; } - LambdaCaptureAST *LambdaCapture(CaptureListAST *capture_list = 0) + LambdaCaptureAST *LambdaCapture(CaptureListAST *capture_list = nullptr) { LambdaCaptureAST *ast = new (&pool) LambdaCaptureAST; ast->capture_list = capture_list; return ast; } - CaptureAST *Capture(NameAST *identifier = 0) + CaptureAST *Capture(NameAST *identifier = nullptr) { CaptureAST *ast = new (&pool) CaptureAST; ast->identifier = identifier; return ast; } - LambdaDeclaratorAST *LambdaDeclarator(ParameterDeclarationClauseAST *parameter_declaration_clause = 0, SpecifierListAST *attributes = 0, ExceptionSpecificationAST *exception_specification = 0, TrailingReturnTypeAST *trailing_return_type = 0) + LambdaDeclaratorAST *LambdaDeclarator(ParameterDeclarationClauseAST *parameter_declaration_clause = nullptr, SpecifierListAST *attributes = nullptr, ExceptionSpecificationAST *exception_specification = nullptr, TrailingReturnTypeAST *trailing_return_type = nullptr) { LambdaDeclaratorAST *ast = new (&pool) LambdaDeclaratorAST; ast->parameter_declaration_clause = parameter_declaration_clause; @@ -1144,7 +1144,7 @@ public: return ast; } - TrailingReturnTypeAST *TrailingReturnType(SpecifierListAST *attributes = 0, SpecifierListAST *type_specifier_list = 0, DeclaratorAST *declarator = 0) + TrailingReturnTypeAST *TrailingReturnType(SpecifierListAST *attributes = nullptr, SpecifierListAST *type_specifier_list = nullptr, DeclaratorAST *declarator = nullptr) { TrailingReturnTypeAST *ast = new (&pool) TrailingReturnTypeAST; ast->attributes = attributes; @@ -1153,7 +1153,7 @@ public: return ast; } - BracedInitializerAST *BracedInitializer(ExpressionListAST *expression_list = 0) + BracedInitializerAST *BracedInitializer(ExpressionListAST *expression_list = nullptr) { BracedInitializerAST *ast = new (&pool) BracedInitializerAST; ast->expression_list = expression_list; @@ -1166,14 +1166,14 @@ public: return ast; } - BracketDesignatorAST *BracketDesignator(ExpressionAST *expression = 0) + BracketDesignatorAST *BracketDesignator(ExpressionAST *expression = nullptr) { BracketDesignatorAST *ast = new (&pool) BracketDesignatorAST; ast->expression = expression; return ast; } - DesignatedInitializerAST *DesignatedInitializer(DesignatorListAST *designator_list = 0, ExpressionAST *initializer = 0) + DesignatedInitializerAST *DesignatedInitializer(DesignatorListAST *designator_list = nullptr, ExpressionAST *initializer = nullptr) { DesignatedInitializerAST *ast = new (&pool) DesignatedInitializerAST; ast->designator_list = designator_list; -- cgit v1.2.3