void RemoveDefaultArgsOf(Decl* D, Sema* S) { m_Sema = S; auto cursor = D->getMostRecentDecl(); m_IsAutloadEntry = IsAutoloadEntry(cursor); TraverseDecl(cursor); while (cursor != D && (cursor = cursor->getPreviousDecl())) { m_IsAutloadEntry = IsAutoloadEntry(cursor); TraverseDecl(cursor); } m_IsAutloadEntry = false; }
// DECLSTMT Allows mix of decl and statements bool SuperastCPP::TraverseDeclStmt(clang::DeclStmt* declStmt) { if (declStmt->isSingleDecl()) { TRY_TO(TraverseDecl(declStmt->getSingleDecl())); } else { // Group of declStmt rapidjson::Value arrayValue(rapidjson::kArrayType); const clang::DeclGroupRef declGroup = declStmt->getDeclGroup(); for (auto iterator = declGroup.begin(); iterator != declGroup.end(); ++iterator) { TRY_TO(TraverseDecl(*iterator)); arrayValue.PushBack(sonValue, allocator); } sonValue = arrayValue; } return true; }
// MEMBER EXPR. Access to a member of a struct or class. // Translate to binary operator with operator [] bool SuperastCPP::TraverseMemberExpr(clang::MemberExpr* memberExpr) { // Accessing a member. Translate into binary operator [] // Save current status const std::string opString = "[]"; rapidjson::Value leftValue; TRY_TO(TraverseStmt(memberExpr->getBase())); leftValue = sonValue; // Build right value from Declaration rapidjson::Value rightValue; TRY_TO(TraverseDecl(memberExpr->getMemberDecl())); rightValue = sonValue; // Instead of data-type, just a type 'string' rightValue.AddMember("type", "string", allocator); rightValue.EraseMember(rightValue.FindMember("data-type")); // The id as 'value', not 'name' rightValue.AddMember("value", rightValue["name"], allocator); rightValue.EraseMember(rightValue.FindMember("name")); rapidjson::Value memberExprValue = createBinOpValue(opString, leftValue, rightValue); addPos(memberExprValue, memberExpr); sonValue = memberExprValue; return true; }
// this method is called to analyze the entire AST void HandleTranslationUnit(ASTContext &Ctx) { // the visitor functions will be invoked by this //llvm::errs() << "handling translation unit\n"; TraverseDecl(Ctx.getTranslationUnitDecl()); //llvm::errs() << "DONE VISITING\n"; OutputAnnotation(); //llvm::errs() << "DONE ANNOTATING\n"; }
void TrackDefaultArgStateOf(Decl* D, AutoloadCallback::FwdDeclsMap& map, Preprocessor& PP) { m_IsStoringState = true; m_Map = ↦ m_PP = &PP; TraverseDecl(D); m_PP = 0; m_Map = 0; m_IsStoringState = false; }
bool VisitTemplateDecl(TemplateDecl* D) { if (D->getTemplatedDecl() && !D->getTemplatedDecl()->hasAttr<AnnotateAttr>()) return true; VisitDecl(D); for(auto P: D->getTemplateParameters()->asArray()) TraverseDecl(P); return true; }
bool SuperastCPP::TraverseFunctionDecl(clang::FunctionDecl* functionDecl) { const std::string functionName = functionDecl->getNameInfo().getAsString(); rapidjson::Value functionValue(rapidjson::kObjectType); addId(functionValue); addPos(functionValue, functionDecl); functionValue.AddMember("type", "function-declaration", allocator); // Add the name functionValue.AddMember( "name", rapidjson::Value().SetString(functionName.c_str(), functionName.size(), allocator), allocator); // Add the return type clang::QualType qualType = functionDecl->getCallResultType().getNonLValueExprType(*context); functionValue.AddMember("return-type", createTypeValue((qualType.getTypePtr())), allocator); // Array of parameters rapidjson::Value parametersValue(rapidjson::kArrayType); // Traverse parameters for (unsigned int i = 0; i < functionDecl->param_size(); ++i) { TRY_TO(TraverseDecl(functionDecl->getParamDecl(i))); // Add the parameter to array parametersValue.PushBack(sonValue, allocator); } // Add parameters to functionValue functionValue.AddMember("parameters", parametersValue, allocator); // If this is a function definition, traverse definition. if (functionDecl->isThisDeclarationADefinition()) { TRY_TO(TraverseStmt(functionDecl->getBody())); ensureSonIsArray(); rapidjson::Value blockValue = createBlockValue(sonValue); functionValue.AddMember("block", blockValue, allocator); } else { // If not definition, add empty block rapidjson::Value emptyArray(rapidjson::kArrayType); functionValue.AddMember("block", createBlockValue(emptyArray), allocator); } // END BODY TRAVERSE sonValue = functionValue; return true; }
bool VisitTemplateDecl(TemplateDecl* D) { if (D->getTemplatedDecl() && !D->getTemplatedDecl()->hasAttr<AnnotateAttr>()) return true; // If we have a definition we might be about to re-#include the // same header containing definition that was #included previously, // i.e. we might have multiple fwd decls for the same template. // DO NOT remove the defaults here; the definition needs to keep it. // (ROOT-7037) if (ClassTemplateDecl* CTD = dyn_cast<ClassTemplateDecl>(D)) if (CXXRecordDecl* TemplatedD = CTD->getTemplatedDecl()) if (TemplatedD->getDefinition()) return true; for(auto P: D->getTemplateParameters()->asArray()) TraverseDecl(P); return true; }
void RewriterASTConsumer::HandleTranslationUnit(ASTContext& Context) { TranslationUnitDecl* D = Context.getTranslationUnitDecl(); TraverseDecl(D); const RewriteBuffer& RewriteBufG = TheGpuRewriter.getEditBuffer(TheGpuRewriter.getSourceMgr().getMainFileID()); RewritenGpuSource = std::string(RewriteBufG.begin(), RewriteBufG.end()); const RewriteBuffer& RewriteBufC = TheCpuRewriter.getEditBuffer(TheCpuRewriter.getSourceMgr().getMainFileID()); RewritenCpuSource = std::string(RewriteBufC.begin(), RewriteBufC.end()); #ifdef Out llvm::errs() << "______________________________ CPU _____________________ \n"; llvm::errs() << std::string(RewriteBufC.begin(), RewriteBufC.end()); llvm::errs() << "\n\n______________________________ GPU _____________________ \n"; llvm::errs() << std::string(RewriteBufG.begin(), RewriteBufG.end()); #endif }
// The AST entry point. Here begins everything. bool SuperastCPP::TraverseTranslationUnitDecl( clang::TranslationUnitDecl* unitDecl) { // Create the block object at root of DOM document.SetObject(); // Set the pointer. Statements from root will be added here addId(document); document.AddMember("statements", rapidjson::kArrayType, allocator); for (auto declaration : unitDecl->decls()) { TRY_TO(TraverseDecl(declaration)); if (!sonValue.IsNull()) { if (sonValue.IsArray()) { addElemsToArray(document["statements"], sonValue); } else { document["statements"].PushBack(sonValue, allocator); } } } return true; }
void RemoveDefaultArgsOf(Decl* D) { //D = D->getMostRecentDecl(); TraverseDecl(D); //while ((D = D->getPreviousDecl())) // TraverseDecl(D); }
void Consumer::HandleTranslationUnit( ASTContext& context ) { if( context.getDiagnostics().hasErrorOccurred()) return; TraverseDecl( compiler.getASTContext().getTranslationUnitDecl()); }
/// \brief Whether or not the parameter variable is referred only once in /// the /// given constructor. bool hasExactlyOneUsageIn(const CXXConstructorDecl *Ctor) { Count = 0; TraverseDecl(const_cast<CXXConstructorDecl *>(Ctor)); return Count == 1; }