Index: ppapi/tests/clang/find_affected_interfaces.cc |
=================================================================== |
--- ppapi/tests/clang/find_affected_interfaces.cc (revision 0) |
+++ ppapi/tests/clang/find_affected_interfaces.cc (revision 0) |
@@ -0,0 +1,154 @@ |
+// Copyright (c) 2010 The Chromium Authors. All rights reserved. |
+// Use of this source code is governed by a BSD-style license that can be |
+// found in the LICENSE file. |
+ |
+// Clang plugin which finds types that are affected if the types listed in the |
+// plugin parameters are changed. This is for use in determining what PPAPI |
+// C-level interfaces are affected if one or more PPAPI C structs are changed. |
David Springer
2010/12/13 21:23:08
This comment seems a little terse to me - perhaps
|
+ |
+#include <algorithm> |
+#include <cstdio> |
+#include <map> |
+#include <sstream> |
+#include <string> |
+#include <vector> |
+ |
+#include "clang/AST/AST.h" |
+#include "clang/AST/ASTConsumer.h" |
+#include "clang/AST/CharUnits.h" |
+#include "clang/Basic/SourceManager.h" |
+#include "clang/Basic/TargetInfo.h" |
+#include "clang/Frontend/CompilerInstance.h" |
+#include "clang/Frontend/FrontendPluginRegistry.h" |
+ |
+namespace { |
+ |
+typedef std::vector<std::string> StringVec; |
+ |
+class FindAffectedInterfacesConsumer : public clang::ASTConsumer { |
+ public: |
+ explicit FindAffectedInterfacesConsumer(const StringVec& changed_classes) { |
+ StringVec::const_iterator iter(changed_classes.begin()); |
+ StringVec::const_iterator the_end(changed_classes.end()); |
+ for (; iter != the_end; ++iter) { |
+ class_is_affected_map_[*iter] = true; |
+ } |
+ } |
+ |
+ private: |
+ typedef std::map<std::string, bool> StringBoolMap; |
+ StringBoolMap class_is_affected_map_; |
+ |
+ bool IsAffected(const clang::Type& type_to_check) { |
David Springer
2010/12/13 21:23:08
Please comment this method. It appears to be the
|
+ std::string type_string( |
+ type_to_check.getCanonicalTypeInternal().getAsString()); |
+ std::pair<StringBoolMap::iterator, bool> iter_success_pair = |
+ class_is_affected_map_.insert( |
+ StringBoolMap::value_type(type_string, false)); |
+ StringBoolMap::iterator iter(iter_success_pair.first); |
+ bool successfully_inserted(iter_success_pair.second); |
+ // If we were able to insert, then we haven't yet seen this type. Compute |
+ // IsAffected and put it at the newly inserted location in the map. |
+ if (successfully_inserted) { |
+ if (type_to_check.isPointerType()) { |
David Springer
2010/12/13 21:23:08
I am not able to get a clear picture in my head of
|
+ const clang::PointerType* pointer_type = |
+ dyn_cast<clang::PointerType>(&type_to_check); |
David Springer
2010/12/13 21:23:08
Maybe a quick comment on dyn_cast vs. dynamic_cast
|
+ // Recurse to the pointee type. |
+ iter->second = IsAffected(*pointer_type->getPointeeType().getTypePtr()); |
+ } else if (type_to_check.isFunctionProtoType()) { |
+ const clang::FunctionProtoType* func_type = |
David Springer
2010/12/13 21:23:08
An input stream example that triggers this would b
|
+ dyn_cast<clang::FunctionProtoType>(&type_to_check); |
+ // Recurse to the return type and parameter types. |
+ iter->second = IsAffected(*func_type->getResultType().getTypePtr()); |
+ if (!iter->second) { |
+ clang::FunctionProtoType::arg_type_iterator arg_iter = |
+ func_type->arg_type_begin(); |
+ clang::FunctionProtoType::arg_type_iterator arg_end = |
+ func_type->arg_type_end(); |
+ for (; (arg_iter != arg_end) && (!iter->second); ++arg_iter) { |
+ iter->second = IsAffected(*(arg_iter->getTypePtr())); |
+ } |
+ } |
+ } else if (type_to_check.isRecordType()) { |
+ // For records (unions, structs), recurse to the fields. |
David Springer
2010/12/13 21:23:08
Input stream example?
|
+ const clang::RecordType* record = |
+ dyn_cast<clang::RecordType>(&type_to_check); |
+ const clang::RecordDecl* decl = record->getDecl(); |
+ clang::RecordDecl::field_iterator field_iter(decl->field_begin()); |
+ clang::RecordDecl::field_iterator field_end(decl->field_end()); |
+ for (; (field_iter != field_end) && (!iter->second); ++field_iter) { |
+ iter->second = IsAffected(*(field_iter->getType().getTypePtr())); |
+ } |
+ } |
+ } |
+ // By this point, the bool in the map at the location referenced by iter has |
+ // the correct value. Either it was cached, or we computed & inserted it. |
+ return iter->second; |
+ } |
+ |
+ // Virtual function to consume top-level declarations. For each one, we check |
+ // to see if it is a type definition. If it is, we print information about |
+ // it. |
David Springer
2010/12/13 21:23:08
But the above IsAffected() code processes function
|
+ virtual void HandleTopLevelDecl(clang::DeclGroupRef decl_group) { |
+ clang::DeclGroupRef::iterator iter(decl_group.begin()); |
+ clang::DeclGroupRef::iterator the_end(decl_group.end()); |
+ for (; iter != the_end; ++iter) { |
+ const clang::Decl *decl = *iter; |
+ if (const clang::TypeDecl* type_decl = dyn_cast<clang::TypeDecl>(decl)) { |
+ std::string name(type_decl->getNameAsString()); |
+ // TagDecl covers structs, enums, unions, and classes. |
+ if (const clang::TagDecl* tag = dyn_cast<clang::TagDecl>(type_decl)) { |
+ // Only print out info when we find the definition; ignore forward |
+ // references. |
+ if (tag->isDefinition()) { |
+ clang::Type* type = type_decl->getTypeForDecl(); |
+ if (IsAffected(*type)) { |
+ std::printf("%s\n", name.c_str()); |
+ } |
+ } |
+ } else if (const clang::TypedefDecl* td = |
+ dyn_cast<clang::TypedefDecl>(type_decl)) { |
+ clang::Type* type = td->getUnderlyingType().getTypePtr(); |
+ if (IsAffected(*type)) { |
+ std::printf("%s\n", name.c_str()); |
+ } |
+ } |
+ } |
+ } |
+ } |
+}; |
+ |
+class FindAffectedInterfacesAction : public clang::PluginASTAction { |
+ public: |
+ FindAffectedInterfacesAction() {} |
+ |
+ private: |
+ StringVec types_; |
+ |
+ virtual clang::ASTConsumer *CreateASTConsumer( |
+ clang::CompilerInstance &instance, llvm::StringRef /*input_file*/) { |
+ return new FindAffectedInterfacesConsumer(types_); |
+ } |
+ |
+ virtual bool ParseArgs(const clang::CompilerInstance& /*instance*/, |
+ const std::vector<std::string>& args) { |
+ // Every argument is interpreted as a comma-delimited list of names of types |
+ // that have been changed. |
+ StringVec::const_iterator iter(args.begin()), end(args.end()); |
+ for (; iter != end; ++iter) { |
+ std::stringstream stream(*iter); |
+ std::string type_name; |
+ while (std::getline(stream, type_name, ',')) { |
+ types_.push_back(type_name); |
+ } |
+ } |
+ return true; |
+ } |
+}; |
+ |
+} // namespace |
+ |
+static clang::FrontendPluginRegistry::Add<FindAffectedInterfacesAction> |
+X("FindAffectedInterfaces", |
+ "Find interfaces affected by changes to the passes classes."); |
+ |
Property changes on: ppapi/tests/clang/find_affected_interfaces.cc |
___________________________________________________________________ |
Added: svn:eol-style |
+ LF |