pimhwang
/
CppSharp
mirror of https://github.com/mono/CppSharp.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
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
0af26773de
commit
e38ebdd55c
2 changed files with 34 additions and 34 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 44
      src/CppParser/Parser.cpp
  2. 24
      src/CppParser/Parser.h

44
src/CppParser/Parser.cpp
Unescape View File

@ -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
Unescape View File

@ -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,

Write Preview
Loading…
Cancel
Save