Browse Source

Introduced more proper const-ness to the parser.

Signed-off-by: Dimitar Dobrev <dpldobrev@protonmail.com>
pull/658/head
Dimitar Dobrev 9 years ago
parent
commit
e38ebdd55c
  1. 44
      src/CppParser/Parser.cpp
  2. 24
      src/CppParser/Parser.h

44
src/CppParser/Parser.cpp

@ -286,7 +286,7 @@ void Parser::SetupHeader()
//-----------------------------------// //-----------------------------------//
std::string Parser::GetDeclMangledName(clang::Decl* D) std::string Parser::GetDeclMangledName(const clang::Decl* D)
{ {
using namespace clang; using namespace clang;
@ -298,7 +298,7 @@ std::string Parser::GetDeclMangledName(clang::Decl* D)
if (!CanMangle) return ""; if (!CanMangle) return "";
NamedDecl* ND = cast<NamedDecl>(D); auto ND = cast<NamedDecl>(D);
std::unique_ptr<MangleContext> MC; std::unique_ptr<MangleContext> MC;
switch(TargetABI) switch(TargetABI)
@ -971,7 +971,7 @@ std::vector<Declaration*> Parser::WalkTemplateParameterList(const clang::Templat
//-----------------------------------// //-----------------------------------//
ClassTemplate* Parser::WalkClassTemplate(clang::ClassTemplateDecl* TD) ClassTemplate* Parser::WalkClassTemplate(const clang::ClassTemplateDecl* TD)
{ {
auto NS = GetNamespace(TD); auto NS = GetNamespace(TD);
assert(NS && "Expected a valid namespace"); assert(NS && "Expected a valid namespace");
@ -1007,7 +1007,7 @@ ClassTemplate* Parser::WalkClassTemplate(clang::ClassTemplateDecl* TD)
//-----------------------------------// //-----------------------------------//
TemplateTemplateParameter* Parser::WalkTemplateTemplateParameter(clang::TemplateTemplateParmDecl* TTP) TemplateTemplateParameter* Parser::WalkTemplateTemplateParameter(const clang::TemplateTemplateParmDecl* TTP)
{ {
auto TP = new TemplateTemplateParameter(); auto TP = new TemplateTemplateParameter();
HandleDeclaration(TTP, TP); HandleDeclaration(TTP, TP);
@ -1025,7 +1025,7 @@ TemplateTemplateParameter* Parser::WalkTemplateTemplateParameter(clang::Template
//-----------------------------------// //-----------------------------------//
TypeTemplateParameter* Parser::WalkTypeTemplateParameter(clang::TemplateTypeParmDecl* TTPD) TypeTemplateParameter* Parser::WalkTypeTemplateParameter(const clang::TemplateTypeParmDecl* TTPD)
{ {
auto TP = new CppSharp::CppParser::TypeTemplateParameter(); auto TP = new CppSharp::CppParser::TypeTemplateParameter();
TP->Name = GetDeclName(TTPD); TP->Name = GetDeclName(TTPD);
@ -1040,7 +1040,7 @@ TypeTemplateParameter* Parser::WalkTypeTemplateParameter(clang::TemplateTypeParm
//-----------------------------------// //-----------------------------------//
NonTypeTemplateParameter* Parser::WalkNonTypeTemplateParameter(clang::NonTypeTemplateParmDecl* NTTPD) NonTypeTemplateParameter* Parser::WalkNonTypeTemplateParameter(const clang::NonTypeTemplateParmDecl* NTTPD)
{ {
auto NTP = new CppSharp::CppParser::NonTypeTemplateParameter(); auto NTP = new CppSharp::CppParser::NonTypeTemplateParameter();
NTP->Name = GetDeclName(NTTPD); NTP->Name = GetDeclName(NTTPD);
@ -1158,7 +1158,7 @@ Parser::WalkTemplateArgument(const clang::TemplateArgument& TA, clang::TemplateA
//-----------------------------------// //-----------------------------------//
FunctionTemplate* Parser::WalkFunctionTemplate(clang::FunctionTemplateDecl* TD) FunctionTemplate* Parser::WalkFunctionTemplate(const clang::FunctionTemplateDecl* TD)
{ {
using namespace clang; using namespace clang;
@ -1264,7 +1264,7 @@ static CXXOperatorKind GetOperatorKindFromDecl(clang::DeclarationName Name)
llvm_unreachable("Unknown OverloadedOperator"); llvm_unreachable("Unknown OverloadedOperator");
} }
Method* Parser::WalkMethodCXX(clang::CXXMethodDecl* MD) Method* Parser::WalkMethodCXX(const clang::CXXMethodDecl* MD)
{ {
using namespace clang; using namespace clang;
@ -2280,7 +2280,7 @@ Enumeration::Item* Parser::WalkEnumItem(clang::EnumConstantDecl* ECD)
//-----------------------------------// //-----------------------------------//
static const clang::CodeGen::CGFunctionInfo& GetCodeGenFuntionInfo( static const clang::CodeGen::CGFunctionInfo& GetCodeGenFuntionInfo(
clang::CodeGen::CodeGenTypes* CodeGenTypes, clang::FunctionDecl* FD) clang::CodeGen::CodeGenTypes* CodeGenTypes, const clang::FunctionDecl* FD)
{ {
using namespace clang; using namespace clang;
if (auto CD = dyn_cast<clang::CXXConstructorDecl>(FD)) { if (auto CD = dyn_cast<clang::CXXConstructorDecl>(FD)) {
@ -2305,7 +2305,7 @@ static bool CanCheckCodeGenInfo(clang::Sema& S, const clang::Type* Ty)
return true; return true;
} }
void Parser::WalkFunction(clang::FunctionDecl* FD, Function* F, void Parser::WalkFunction(const clang::FunctionDecl* FD, Function* F,
bool IsDependent) bool IsDependent)
{ {
using namespace clang; using namespace clang;
@ -2430,7 +2430,7 @@ void Parser::WalkFunction(clang::FunctionDecl* FD, Function* F,
if (auto FTSI = FD->getTemplateSpecializationInfo()) if (auto FTSI = FD->getTemplateSpecializationInfo())
F->SpecializationInfo = WalkFunctionTemplateSpec(FTSI, F); F->SpecializationInfo = WalkFunctionTemplateSpec(FTSI, F);
CXXMethodDecl* MD; const CXXMethodDecl* MD;
if ((MD = dyn_cast<CXXMethodDecl>(FD)) && !MD->isStatic() && if ((MD = dyn_cast<CXXMethodDecl>(FD)) && !MD->isStatic() &&
!CanCheckCodeGenInfo(C->getSema(), MD->getThisType(C->getASTContext()).getTypePtr())) !CanCheckCodeGenInfo(C->getSema(), MD->getThisType(C->getASTContext()).getTypePtr()))
return; return;
@ -2457,7 +2457,7 @@ void Parser::WalkFunction(clang::FunctionDecl* FD, Function* F,
} }
} }
Function* Parser::WalkFunction(clang::FunctionDecl* FD, bool IsDependent, Function* Parser::WalkFunction(const clang::FunctionDecl* FD, bool IsDependent,
bool AddToNamespace) bool AddToNamespace)
{ {
using namespace clang; using namespace clang;
@ -2530,7 +2530,7 @@ void Parser::WalkAST()
//-----------------------------------// //-----------------------------------//
Variable* Parser::WalkVariable(clang::VarDecl *VD) Variable* Parser::WalkVariable(const clang::VarDecl *VD)
{ {
using namespace clang; using namespace clang;
@ -2561,7 +2561,7 @@ Variable* Parser::WalkVariable(clang::VarDecl *VD)
//-----------------------------------// //-----------------------------------//
Friend* Parser::WalkFriend(clang::FriendDecl *FD) Friend* Parser::WalkFriend(const clang::FriendDecl *FD)
{ {
using namespace clang; using namespace clang;
@ -2912,7 +2912,7 @@ Declaration* Parser::WalkDeclarationDef(clang::Decl* D)
/*CanBeDefinition=*/true); /*CanBeDefinition=*/true);
} }
Declaration* Parser::WalkDeclaration(clang::Decl* D, Declaration* Parser::WalkDeclaration(const clang::Decl* D,
bool IgnoreSystemDecls, bool IgnoreSystemDecls,
bool CanBeDefinition) bool CanBeDefinition)
{ {
@ -2947,7 +2947,7 @@ Declaration* Parser::WalkDeclaration(clang::Decl* D,
{ {
case Decl::Record: case Decl::Record:
{ {
RecordDecl* RD = cast<RecordDecl>(D); auto RD = cast<RecordDecl>(D);
auto Record = WalkRecord(RD); auto Record = WalkRecord(RD);
@ -2968,7 +2968,7 @@ Declaration* Parser::WalkDeclaration(clang::Decl* D,
} }
case Decl::CXXRecord: case Decl::CXXRecord:
{ {
CXXRecordDecl* RD = cast<CXXRecordDecl>(D); auto RD = cast<CXXRecordDecl>(D);
auto Class = WalkRecordCXX(RD); auto Class = WalkRecordCXX(RD);
@ -2989,7 +2989,7 @@ Declaration* Parser::WalkDeclaration(clang::Decl* D,
} }
case Decl::ClassTemplate: case Decl::ClassTemplate:
{ {
ClassTemplateDecl* TD = cast<ClassTemplateDecl>(D); auto TD = cast<ClassTemplateDecl>(D);
auto Template = WalkClassTemplate(TD); auto Template = WalkClassTemplate(TD);
Decl = Template; Decl = Template;
@ -3013,7 +3013,7 @@ Declaration* Parser::WalkDeclaration(clang::Decl* D,
} }
case Decl::FunctionTemplate: case Decl::FunctionTemplate:
{ {
FunctionTemplateDecl* TD = cast<FunctionTemplateDecl>(D); auto TD = cast<FunctionTemplateDecl>(D);
auto FT = WalkFunctionTemplate(TD); auto FT = WalkFunctionTemplate(TD);
Decl = FT; Decl = FT;
@ -3035,7 +3035,7 @@ Declaration* Parser::WalkDeclaration(clang::Decl* D,
} }
case Decl::Function: case Decl::Function:
{ {
FunctionDecl* FD = cast<FunctionDecl>(D); auto FD = cast<FunctionDecl>(D);
// Check for and ignore built-in functions. // Check for and ignore built-in functions.
if (FD->getBuiltinID() != 0) if (FD->getBuiltinID() != 0)
@ -3046,7 +3046,7 @@ Declaration* Parser::WalkDeclaration(clang::Decl* D,
} }
case Decl::LinkageSpec: case Decl::LinkageSpec:
{ {
LinkageSpecDecl* LS = cast<LinkageSpecDecl>(D); auto LS = cast<LinkageSpecDecl>(D);
for (auto it = LS->decls_begin(); it != LS->decls_end(); ++it) for (auto it = LS->decls_begin(); it != LS->decls_end(); ++it)
{ {
@ -3076,7 +3076,7 @@ Declaration* Parser::WalkDeclaration(clang::Decl* D,
} }
case Decl::Namespace: case Decl::Namespace:
{ {
NamespaceDecl* ND = cast<NamespaceDecl>(D); auto ND = cast<NamespaceDecl>(D);
for (auto it = ND->decls_begin(); it != ND->decls_end(); ++it) for (auto it = ND->decls_begin(); it != ND->decls_end(); ++it)
{ {

24
src/CppParser/Parser.h

@ -62,12 +62,12 @@ private:
// AST traversers // AST traversers
void WalkAST(); void WalkAST();
Declaration* WalkDeclaration(clang::Decl* D, Declaration* WalkDeclaration(const clang::Decl* D,
bool IgnoreSystemDecls = true, bool CanBeDefinition = false); bool IgnoreSystemDecls = true, bool CanBeDefinition = false);
Declaration* WalkDeclarationDef(clang::Decl* D); Declaration* WalkDeclarationDef(clang::Decl* D);
Enumeration* WalkEnum(const clang::EnumDecl* ED); Enumeration* WalkEnum(const clang::EnumDecl* ED);
Enumeration::Item* WalkEnumItem(clang::EnumConstantDecl* ECD); Enumeration::Item* WalkEnumItem(clang::EnumConstantDecl* ECD);
Function* WalkFunction(clang::FunctionDecl* FD, bool IsDependent = false, Function* WalkFunction(const clang::FunctionDecl* FD, bool IsDependent = false,
bool AddToNamespace = true); bool AddToNamespace = true);
Class* GetRecord(const clang::RecordDecl* Record, bool& IsComplete); Class* GetRecord(const clang::RecordDecl* Record, bool& IsComplete);
Class* WalkRecord(const clang::RecordDecl* Record); Class* WalkRecord(const clang::RecordDecl* Record);
@ -78,22 +78,22 @@ private:
WalkClassTemplateSpecialization(const clang::ClassTemplateSpecializationDecl* CTS); WalkClassTemplateSpecialization(const clang::ClassTemplateSpecializationDecl* CTS);
ClassTemplatePartialSpecialization* ClassTemplatePartialSpecialization*
WalkClassTemplatePartialSpecialization(const clang::ClassTemplatePartialSpecializationDecl* CTS); WalkClassTemplatePartialSpecialization(const clang::ClassTemplatePartialSpecializationDecl* CTS);
Method* WalkMethodCXX(clang::CXXMethodDecl* MD); Method* WalkMethodCXX(const clang::CXXMethodDecl* MD);
Field* WalkFieldCXX(const clang::FieldDecl* FD, Class* Class); Field* WalkFieldCXX(const clang::FieldDecl* FD, Class* Class);
FunctionTemplateSpecialization* WalkFunctionTemplateSpec(clang::FunctionTemplateSpecializationInfo* FTS, Function* Function); FunctionTemplateSpecialization* WalkFunctionTemplateSpec(clang::FunctionTemplateSpecializationInfo* FTS, Function* Function);
Variable* WalkVariable(clang::VarDecl* VD); Variable* WalkVariable(const clang::VarDecl* VD);
Friend* WalkFriend(clang::FriendDecl* FD); Friend* WalkFriend(const clang::FriendDecl* FD);
RawComment* WalkRawComment(const clang::RawComment* RC); RawComment* WalkRawComment(const clang::RawComment* RC);
bool ShouldCompleteType(const clang::QualType& QualType, bool LocValid); bool ShouldCompleteType(const clang::QualType& QualType, bool LocValid);
Type* WalkType(clang::QualType QualType, clang::TypeLoc* TL = 0, Type* WalkType(clang::QualType QualType, clang::TypeLoc* TL = 0,
bool DesugarType = false); bool DesugarType = false);
TemplateArgument WalkTemplateArgument(const clang::TemplateArgument& TA, clang::TemplateArgumentLoc* ArgLoc); TemplateArgument WalkTemplateArgument(const clang::TemplateArgument& TA, clang::TemplateArgumentLoc* ArgLoc);
TemplateTemplateParameter* WalkTemplateTemplateParameter(clang::TemplateTemplateParmDecl* TTP); TemplateTemplateParameter* WalkTemplateTemplateParameter(const clang::TemplateTemplateParmDecl* TTP);
TypeTemplateParameter* WalkTypeTemplateParameter(clang::TemplateTypeParmDecl* TTPD); TypeTemplateParameter* WalkTypeTemplateParameter(const clang::TemplateTypeParmDecl* TTPD);
NonTypeTemplateParameter* WalkNonTypeTemplateParameter(clang::NonTypeTemplateParmDecl* TTPD); NonTypeTemplateParameter* WalkNonTypeTemplateParameter(const clang::NonTypeTemplateParmDecl* TTPD);
std::vector<Declaration*> WalkTemplateParameterList(const clang::TemplateParameterList* TPL); std::vector<Declaration*> WalkTemplateParameterList(const clang::TemplateParameterList* TPL);
ClassTemplate* WalkClassTemplate(clang::ClassTemplateDecl* TD); ClassTemplate* WalkClassTemplate(const clang::ClassTemplateDecl* TD);
FunctionTemplate* WalkFunctionTemplate(clang::FunctionTemplateDecl* TD); FunctionTemplate* WalkFunctionTemplate(const clang::FunctionTemplateDecl* TD);
std::vector<TemplateArgument> WalkTemplateArgumentList(const clang::TemplateArgumentList* TAL, clang::TemplateSpecializationTypeLoc* TSTL); std::vector<TemplateArgument> WalkTemplateArgumentList(const clang::TemplateArgumentList* TAL, clang::TemplateSpecializationTypeLoc* TSTL);
std::vector<TemplateArgument> WalkTemplateArgumentList(const clang::TemplateArgumentList* TAL, const clang::ASTTemplateArgumentListInfo* TSTL); std::vector<TemplateArgument> WalkTemplateArgumentList(const clang::TemplateArgumentList* TAL, const clang::ASTTemplateArgumentListInfo* TSTL);
void WalkVTable(const clang::CXXRecordDecl* RD, Class* C); void WalkVTable(const clang::CXXRecordDecl* RD, Class* C);
@ -108,9 +108,9 @@ private:
// Clang helpers // Clang helpers
SourceLocationKind GetLocationKind(const clang::SourceLocation& Loc); SourceLocationKind GetLocationKind(const clang::SourceLocation& Loc);
bool IsValidDeclaration(const clang::SourceLocation& Loc); bool IsValidDeclaration(const clang::SourceLocation& Loc);
std::string GetDeclMangledName(clang::Decl* D); std::string GetDeclMangledName(const clang::Decl* D);
std::string GetTypeName(const clang::Type* Type); std::string GetTypeName(const clang::Type* Type);
void WalkFunction(clang::FunctionDecl* FD, Function* F, void WalkFunction(const clang::FunctionDecl* FD, Function* F,
bool IsDependent = false); bool IsDependent = false);
void HandlePreprocessedEntities(Declaration* Decl); void HandlePreprocessedEntities(Declaration* Decl);
void HandlePreprocessedEntities(Declaration* Decl, clang::SourceRange sourceRange, void HandlePreprocessedEntities(Declaration* Decl, clang::SourceRange sourceRange,

Loading…
Cancel
Save