| /src/external/apache2/llvm/dist/llvm/utils/unittest/googletest/src/ |
| gtest-matchers.cc | 32 // This file implements just enough of the matcher interface to allow
33 // EXPECT_DEATH and friends to accept a matcher argument.
43 // Constructs a matcher that matches a const std::string& whose value is
45 Matcher<const std::string&>::Matcher(const std::string& s) { *this = Eq(s); }
47 // Constructs a matcher that matches a const std::string& whose value is
49 Matcher<const std::string&>::Matcher(const char* s) {
53 // Constructs a matcher that matches a std::string whose value is equal to
55 Matcher<std::string>::Matcher(const std::string& s) { *this = Eq(s);
[all...] |
| /src/external/apache2/llvm/dist/llvm/include/llvm/Testing/Support/ |
| Error.h | 35 explicit ValueMatchesMono(const testing::Matcher<T> &Matcher)
36 : Matcher(Matcher) {}
43 bool result = Matcher.MatchAndExplain(*Holder.Exp, listener);
48 Matcher.DescribeNegationTo(listener->stream());
55 Matcher.DescribeTo(OS);
61 Matcher.DescribeNegationTo(OS);
66 testing::Matcher<T> Matcher;
[all...] |
| /src/external/apache2/llvm/dist/llvm/utils/TableGen/ |
| DAGISelMatcher.h | 1 //===- DAGISelMatcher.h - Representation of DAG pattern matcher -*- C++ -*-===//
21 class Matcher;
30 Matcher *ConvertPatternToMatcher(const PatternToMatch &Pattern,unsigned Variant,
32 void OptimizeMatcher(std::unique_ptr<Matcher> &Matcher,
34 void EmitMatcherTable(Matcher *Matcher, const CodeGenDAGPatterns &CGP,
38 /// Matcher - Base class for all the DAG ISel Matcher representation
40 class Matcher {
[all...] |
| DAGISelMatcherEmitter.cpp | 1 //===- DAGISelMatcherEmitter.cpp - Matcher Emitter ------------------------===//
9 // This file contains code to generate C++ code for a matcher.
51 SmallVector<unsigned, Matcher::HighestKind+1> OpcodeCounts;
86 OpcodeCounts.assign(Matcher::HighestKind+1, 0);
89 unsigned EmitMatcherList(const Matcher *N, const unsigned Indent,
92 unsigned SizeMatcherList(Matcher *N, raw_ostream &OS);
96 void EmitHistogram(const Matcher *N, raw_ostream &OS);
104 unsigned SizeMatcher(Matcher *N, raw_ostream &OS);
106 unsigned EmitMatcher(const Matcher *N, const unsigned Indent, unsigned CurrentIdx,
242 /// This function traverses the matcher tree and sizes all the node
[all...] |
| DAGISelMatcherOpt.cpp | 1 //===- DAGISelMatcherOpt.cpp - Optimize a DAG Matcher ---------------------===//
9 // This file implements the DAG Matcher optimizer.
22 /// ContractNodes - Turn multiple matcher node patterns like 'MoveChild+Record'
24 static void ContractNodes(std::unique_ptr<Matcher> &MatcherPtr,
27 Matcher *N = MatcherPtr.get();
33 std::unique_ptr<Matcher> Child(Scope->takeChild(i));
43 Matcher *New = nullptr;
152 Matcher *CheckType = MatcherPtr.release();
153 Matcher *CheckOpcode = CheckType->takeNext();
154 Matcher *Tail = CheckOpcode->takeNext()
[all...] |
| DAGISelMatcher.cpp | 1 //===- DAGISelMatcher.cpp - Representation of DAG pattern matcher ---------===//
16 void Matcher::anchor() { }
18 void Matcher::dump() const {
22 void Matcher::print(raw_ostream &OS, unsigned indent) const {
28 void Matcher::printOne(raw_ostream &OS) const {
35 Matcher *Matcher::unlinkNode(Matcher *Other) {
40 Matcher *Cur = this;
50 /// canMoveBefore - Return true if this matcher is the same as Other, or i
[all...] |
| DAGISelEmitter.cpp | 163 // Convert each variant of each pattern into a Matcher.
165 std::vector<Matcher*> PatternMatchers;
168 if (Matcher *M = ConvertPatternToMatcher(*PTM, Variant, CGP))
175 std::unique_ptr<Matcher> TheMatcher =
181 //Matcher->dump();
183 Records.startTimer("Emit matcher table");
|
| /src/external/apache2/llvm/dist/clang/include/clang/ASTMatchers/ |
| ASTMatchersMacros.h | 10 // Since a matcher is a function which returns a Matcher<T> object, where
11 // T is the type of the actual implementation of the matcher, the macros allow
15 // Note that when you define a matcher with an AST_MATCHER* macro, only the
16 // function which creates the matcher goes into the current namespace - the
17 // class that implements the actual matcher, which gets returned by the
22 // To define a matcher in user code, put it into your own namespace. This would
23 // help to prevent ODR violations in case a matcher with the same name is
28 // clang::ast_matchers::internal::Matcher<clang::ValueDecl>,
40 // internal::Matcher<ValueDecl>, InnerMatcher)
[all...] |
| ASTMatchFinder.h | 12 // The general idea is to construct a matcher expression that describes a
14 // expression matches is registered, and the matcher is run over the AST of
146 /// Adds a matcher to execute when running over the AST.
172 /// Adds a matcher to execute when running over the AST.
176 /// a matcher that cannot match anything.
178 /// \returns \c true if the matcher is a valid top-level matcher, \c false
208 /// For each \c Matcher<> a \c MatchCallback that will be called
235 /// Returns the results of matching \p Matcher on \p Node.
238 /// \p Matcher on \p Node and returns the collected results
[all...] |
| ASTMatchers.h | 17 // which returns a matcher that can be used to find all AST nodes that declare
32 // In the given example, each time our matcher finds a match we get a callback
37 // implementation details of the matcher framework.
100 /// Maps string IDs to AST nodes matched by parts of a matcher.
141 using DeclarationMatcher = internal::Matcher<Decl>;
142 using StatementMatcher = internal::Matcher<Stmt>;
143 using TypeMatcher = internal::Matcher<QualType>;
144 using TypeLocMatcher = internal::Matcher<TypeLoc>;
145 using NestedNameSpecifierMatcher = internal::Matcher<NestedNameSpecifier>;
146 using NestedNameSpecifierLocMatcher = internal::Matcher<NestedNameSpecifierLoc>
[all...] |
| ASTMatchersInternal.h | 9 // Implements the base layer of the matcher framework.
11 // Matchers are methods that return a Matcher<T> which provides a method
18 // 1. A function Matcher<T> MatcherName(<arguments>) which returns a Matcher<T>
20 // on the arguments. Matcher<T>s form an implicit reverse hierarchy
21 // to clang's AST class hierarchy, meaning that you can use a Matcher<Base>
22 // everywhere a Matcher<Derived> is required.
25 // The matcher functions are defined in ASTMatchers.h. To make it possible
26 // to implement both the matcher function and the implementation of the matcher
[all...] |
| /src/external/apache2/llvm/dist/llvm/utils/unittest/googletest/include/gtest/ |
| gtest-matchers.h | 32 // This file implements just enough of the matcher interface to allow
33 // EXPECT_DEATH and friends to accept a matcher argument.
65 // To implement a matcher Foo for type T, define:
68 // 2. a factory function that creates a Matcher<T> object from a
72 // to write "v" instead of "Eq(v)" where a Matcher is expected, which
74 // ownership management as Matcher objects can now be copied like
78 // used by a matcher to explain why a value matches or doesn't match.
100 // of the match result. A matcher's MatchAndExplain() method can use
115 // matcher.
120 // Describes this matcher to an ostream. The function should prin
[all...] |
| /src/external/apache2/llvm/dist/clang/lib/ASTMatchers/Dynamic/ |
| VariantValue.cpp | 25 return (Twine("Matcher<") + NodeKind.asStringRef() + ">").str();
58 VariantMatcher::MatcherOps::canConstructFrom(const DynTypedMatcher &Matcher,
60 IsExactMatch = Matcher.getSupportedKind().isSame(NodeKind);
61 return Matcher.canConvertTo(NodeKind);
65 const DynTypedMatcher &Matcher) const {
66 return Matcher.dynCastTo(NodeKind);
76 // Matcher<T>.
92 SinglePayload(const DynTypedMatcher &Matcher) : Matcher(Matcher) {}
[all...] |
| /src/external/apache2/llvm/dist/llvm/tools/llvm-objcopy/ |
| CommonConfig.h | 122 // Matcher that checks symbol or section names against the command line flags
129 Error addMatcher(Expected<NameOrPattern> Matcher) {
130 if (!Matcher)
131 return Matcher.takeError();
132 if (Matcher->isPositiveMatch())
133 PosMatchers.push_back(std::move(*Matcher));
135 NegMatchers.push_back(std::move(*Matcher));
|
| /src/external/apache2/llvm/dist/llvm/include/llvm/Support/ |
| SpecialCaseList.h | 121 class Matcher {
134 using SectionEntries = StringMap<StringMap<Matcher>>;
137 Section(std::unique_ptr<Matcher> M) : SectionMatcher(std::move(M)){};
139 std::unique_ptr<Matcher> SectionMatcher;
|
| /src/external/apache2/llvm/dist/clang/lib/StaticAnalyzer/Core/ |
| LoopUnrolling.cpp | 82 static internal::Matcher<Stmt> simpleCondition(StringRef BindName) {
93 static internal::Matcher<Stmt>
94 changeIntBoundNode(internal::Matcher<Decl> VarNodeMatcher) {
104 static internal::Matcher<Stmt>
105 callByRef(internal::Matcher<Decl> VarNodeMatcher) {
111 static internal::Matcher<Stmt>
112 assignedToRef(internal::Matcher<Decl> VarNodeMatcher) {
120 static internal::Matcher<Stmt>
121 getAddrTo(internal::Matcher<Decl> VarNodeMatcher) {
127 static internal::Matcher<Stmt> hasSuspiciousStmt(StringRef NodeName)
[all...] |
| /src/external/apache2/llvm/dist/clang/lib/Tooling/Transformer/ |
| Transformer.cpp | 25 for (auto &Matcher : transformer::detail::buildMatchers(Rule))
26 MatchFinder->addDynamicMatcher(Matcher, this);
|
| /src/external/apache2/llvm/dist/llvm/utils/unittest/googletest/include/gtest/internal/ |
| gtest-death-test-internal.h | 83 static bool Create(const char* statement, Matcher<const std::string&> matcher,
150 Matcher<const std::string&> matcher, const char* file,
157 bool Create(const char* statement, Matcher<const std::string&> matcher,
166 // and interpreted as a regex (rather than an Eq matcher) for legacy
168 inline Matcher<const ::std::string&> MakeDeathTestMatcher(
172 inline Matcher<const ::std::string&> MakeDeathTestMatcher(const char* regex) {
175 inline Matcher<const ::std::string&> MakeDeathTestMatcher
[all...] |
| /src/external/apache2/llvm/dist/llvm/utils/unittest/googlemock/include/gmock/ |
| gmock-matchers.h | 38 // Matcher, class MatcherInterface, and others.
84 // To implement a matcher Foo for type T, define:
87 // 2. a factory function that creates a Matcher<T> object from a
91 // to write "v" instead of "Eq(v)" where a Matcher is expected, which
93 // ownership management as Matcher objects can now be copied like
124 // polymorphic matcher (i.e. something that can be converted to a
125 // Matcher but is not one yet; for example, Eq(value)) or a value (for
130 static Matcher<T> Cast(const M& polymorphic_matcher_or_value) {
131 // M can be a polymorphic matcher, in which case we want to use
132 // its conversion operator to create Matcher<T>. Or it can be a valu
392 typename std::tuple_element<N - 1, MatcherTuple>::type matcher = local
1322 const Matcher<const T&> matcher = SafeMatcherCast<const T&>(matcher_); local
[all...] |
| gmock-generated-matchers.h | 52 // The MATCHER* family of macros can be used in a namespace scope to
60 // MATCHER(name, description_string) { statements; }
62 // defines a matcher with the given name that executes the statements,
67 // The description string documents what the matcher does, and is used
69 // MATCHER() is usually defined in a header file shared by multiple
72 // case we'll use the sequence of words in the matcher name as the
77 // MATCHER(IsEven, "") { return (arg % 2) == 0; }
96 // matcher name IsEven.
102 // determined by the context in which you use the matcher and is
104 // declaring it (nor can you). This allows the matcher to b
[all...] |
| /src/external/apache2/llvm/dist/clang/include/clang/Tooling/ |
| RefactoringCallbacks.h | 11 // The general idea is to construct a matcher expression that describes a
59 void addMatcher(const T &Matcher, RefactoringCallback *Callback) {
60 MatchFinder.addMatcher(Matcher, Callback);
64 void addDynamicMatcher(const ast_matchers::internal::DynTypedMatcher &Matcher,
|
| /src/external/apache2/llvm/dist/clang/lib/ASTMatchers/ |
| ASTMatchFinder.cpp | 13 // calling the Matches(...) method of each matcher we are running on each
14 // AST node. The matcher can recurse via the ASTMatchFinder interface.
38 // of performance vs. memory consumption by running matcher
53 // We use memoization to avoid running the same matcher on the same
56 // identifying the matcher), a pointer to the AST node and the
57 // bound nodes before the matcher was executed.
92 // Creates an AST visitor that matches 'matcher' on all children or
96 MatchChildASTVisitor(const DynTypedMatcher *Matcher, ASTMatchFinder *Finder,
100 : Matcher(Matcher), Finder(Finder), Builder(Builder), CurrentDepth(0)
[all...] |
| /src/external/apache2/llvm/dist/clang/include/clang/ASTMatchers/Dynamic/ |
| VariantValue.h | 12 /// Supports all the types required for dynamic Matcher construction.
44 /// Constructor for non-matcher types.
47 /// Constructor for matcher types.
92 /// A variant matcher object.
97 /// overloads of the matcher. \c VariantMatcher knows how to select the
99 /// To get a real matcher object out of a \c VariantMatcher you can do:
100 /// - getSingleMatcher() which returns a matcher, only if it is not ambiguous
101 /// to decide which matcher to return. Eg. it contains only a single
102 /// matcher, or a polymorphic one with only one overload.
104 /// the underlying matcher(s) can unambiguously return a Matcher<T>
[all...] |
| /src/external/apache2/llvm/dist/llvm/lib/Support/ |
| SpecialCaseList.cpp | 29 bool SpecialCaseList::Matcher::insert(std::string Regexp,
61 unsigned SpecialCaseList::Matcher::match(StringRef Query) const {
180 std::unique_ptr<Matcher> M = std::make_unique<Matcher>();
227 StringMap<Matcher>::const_iterator II = I->second.find(Category);
|
| /src/sys/external/bsd/compiler_rt/dist/lib/xray/tests/unit/ |
| test_helpers.h | 51 return ::testing::Matcher<decltype(arg.TSC)>(M).MatchAndExplain(
|
