| /external/clang/test/SemaTemplate/ |
| template-decl-fail.cpp | 3 template<typename T> typedef T X; // expected-error{{typedef cannot be a template}}
5 template<typename T>
6 enum t0 { A = T::x }; // expected-error{{enumeration cannot be a template}} \
10 template<int x> enum e0 f0(int a=x) {}
|
| ms-delayed-default-template-args.cpp | 6 template <typename T = Baz> // expected-warning {{using the undeclared type 'Baz' as a default template argument is a Microsoft extension}}
9 template struct Foo<>;
14 template <typename T = Baz> // expected-warning {{using the undeclared type 'Baz' as a default template argument is a Microsoft extension}}
21 template struct nested::Foo<>;
26 template <typename T = Baz> // expected-warning {{using the undeclared type 'Baz' as a default template argument is a Microsoft extension}}
33 template struct Outer::Foo<>;
37 template <typename T> struct Bar { T x; }
[all...] |
| dependent-expr.cpp | 5 template <typename Iterator>
11 template<unsigned int r>
18 template<unsigned int r>
21 template<unsigned int r>
35 template<typename T>
46 template<typename OT> int myMethod()
51 template <typename T> T *addressof(T &v) {
58 template <typename T> class chained_map {
67 template <class _CharT> int test(_CharT t)
76 template<typename T> struct CastDependentIntToPointer
[all...] |
| explicit-instantiation.cpp | 4 template void *; // expected-error{{expected unqualified-id}}
6 template typedef void f0; // expected-error{{explicit instantiation of typedef}}
9 template int v0; // expected-error{{does not refer}}
11 template<typename T>
20 template <typename U> T f0(T, U) { return T(); } // expected-note-re {{candidate template ignored: could not match 'int (int, U){{( __attribute__\(\(thiscall\)\))?}}' against 'int (int){{( __attribute__\(\(thiscall\)\))?}} const'}} \
21 // expected-note {{candidate template ignored: could not match 'int' against 'int *'}}
24 template<typename T>
27 template int X0<int>::value;
33 template NotDefaultConstructible X0<NotDefaultConstructible>::value; // expected-note{{instantiation}
[all...] |
| instantiate-member-template.cpp | 3 template<typename T>
5 template<typename U> T f0(U);
6 template<typename U> U& f1(T*, U); // expected-error{{pointer to a reference}} \
24 template<typename T>
26 template<typename U>
32 template<typename U>
38 template<typename U>
45 template<typename U>
51 template<typename V>
57 template<typename U
[all...] |
| dependent-base-classes.cpp | 3 template<typename T, typename U>
4 struct X0 : T::template apply<U> {
5 X0(U u) : T::template apply<U>(u) { }
8 template<typename T, typename U>
9 struct X1 : T::apply<U> { }; // expected-error{{use 'template' keyword to treat 'apply' as a dependent template name}}
11 template<typename T>
12 struct X2 : vector<T> { }; // expected-error{{unknown template name 'vector'}}
15 template<typename T>
18 template <class X
[all...] |
| alias-templates.cpp | 3 template<typename S>
6 template<typename T> using C = typename T::B;
7 template<typename T> struct D {
8 template<typename U> using E = typename A<U>::template C<A<T>>;
9 template<typename U> using F = A<E<U>>;
10 template<typename U> using G = C<F<U>>;
15 template<typename T> using I = A<decltype(h.g)>;
16 template<typename T> using J = typename A<decltype(h.g)>::template C<I<T>>
[all...] |
| /external/clang/test/CXX/temp/temp.spec/temp.explicit/ |
| p4.cpp | 3 template<typename T> void f0(T); // expected-note{{here}}
4 template void f0(int); // expected-error{{explicit instantiation of undefined function template}}
6 template<typename T>
15 template void X0<int>::f1(); // expected-error{{explicit instantiation of undefined member function}}
17 template int X0<int>::value; // expected-error{{explicit instantiation of undefined static data member}}
19 template<> void f0(long); // expected-note{{previous template specialization is here}}
20 template void f0(long); // expected-warning{{explicit instantiation of 'f0<long>' that occurs after an explicit specialization will be ignored}}
22 template<> void X0<long>::f1(); // expected-note{{previous template specialization is here}
[all...] |
| /external/clang/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.type.elab/ |
| p1.cpp | 5 template<typename T> struct B {};
7 template<typename T> struct C {};
9 template<typename T> struct A {};
13 template<typename T> struct N::B; // expected-error {{cannot have a nested name specifier}}
14 template<typename T> struct N::B<T*>; // FIXME: This is technically ill-formed, but that's not the intent.
15 template<> struct N::B<int>;
16 template struct N::B<float>;
18 template<typename T> struct C;
19 template<typename T> struct C<T*>; // FIXME: This is technically ill-formed, but that's not the intent.
20 template<> struct C<int>
[all...] |
| /external/clang/test/CXX/temp/temp.spec/ |
| p5.cpp | 3 template<typename T> inline void f(T) { }
4 template void f(int); // expected-note{{previous explicit instantiation}}
5 template void f(int); // expected-error{{duplicate explicit instantiation}}
7 template<typename T>
16 template<typename T>
19 template struct X0<int>; // expected-note{{previous explicit instantiation}} \
21 template struct X0<int>; // expected-error{{duplicate explicit instantiation}}
23 template void X0<float>::f(float); // expected-note{{previous explicit instantiation}}
24 template void X0<float>::f(float); // expected-error{{duplicate explicit instantiation}}
26 template union X0<float>::Inner; // expected-note{{previous explicit instantiation}
[all...] |
| /external/clang/test/CXX/temp/temp.decls/temp.friend/ |
| p1.cpp | 4 template <typename T> struct Num {
11 template <typename U> struct Rep {
37 template <typename T> friend bool iszero(const A &a) throw();
40 template <class T> class B_iterator;
41 template <class T> class B {
64 template <typename T> friend bool has(const A&);
66 template <typename T> bool has(const A &x) {
69 template <typename T> bool hasnot(const A &x) {
77 template <typename T> friend class HasChecker;
79 template <typename T> class HasChecker
[all...] |
| /external/clang/test/SemaCXX/ |
| alias-template.cpp | 4 template<typename U> using T = int;
5 template<typename U> using T = int;
6 template<typename U> using T = T<U>;
10 template<typename U> using A = void(int n = 0); // expected-error {{default arguments can only be specified for parameters in a function declaration}}
11 template<typename U> using B = inline void(int n); // expected-error {{type name does not allow function specifier}}
12 template<typename U> using C = virtual void(int n); // expected-error {{type name does not allow function specifier}}
13 template<typename U> using D = explicit void(int n); // expected-error {{type name does not allow function specifier}}
14 template<typename U> using E = void(int n) throw(); // expected-error {{exception specifications are not allowed in type aliases}}
15 template<typename U> using F = void(*)(int n) &&; // expected-error {{pointer to function type cannot have '&&' qualifier}}
16 template<typename U> using G = __thread void(int n); // expected-error {{type name does not allow storage c (…)
[all...] |
| warn-unused-parameters.cpp | 2 template<typename T>
7 template<typename U> U f3(U x);
8 template<typename U> U f4(U x);
9 template<typename U> U f5(U);
12 template<typename T> T X<T>::f0(T x) { return x; }
13 template<typename T> T X<T>::f1(T) { return T(); }
14 template<typename T> T X<T>::f2(T x) { return T(); } // expected-warning{{unused parameter 'x'}}
15 template<typename T> template<typename U> U X<T>::f3(U x) { return x; }
16 template<typename T> template<typename U> U X<T>::f4(U) { return U();
[all...] |
| /external/opencv3/modules/core/include/opencv2/core/cuda/detail/ |
| type_traits_detail.hpp | 55 template <bool, typename T1, typename T2> struct Select { typedef T1 type; };
56 template <typename T1, typename T2> struct Select<false, T1, T2> { typedef T2 type; };
58 template <typename T> struct IsSignedIntergral { enum {value = 0}; };
59 template <> struct IsSignedIntergral<schar> { enum {value = 1}; };
60 template <> struct IsSignedIntergral<char1> { enum {value = 1}; };
61 template <> struct IsSignedIntergral<short> { enum {value = 1}; };
62 template <> struct IsSignedIntergral<short1> { enum {value = 1}; };
63 template <> struct IsSignedIntergral<int> { enum {value = 1}; };
64 template <> struct IsSignedIntergral<int1> { enum {value = 1}; };
66 template <typename T> struct IsUnsignedIntegral { enum {value = 0}; }
[all...] |
| /external/clang/test/Modules/Inputs/ |
| cxx-templates-b.h | 3 template<typename T> T f();
4 template<typename T> T f(T t) { return t; }
6 template<typename T> T f();
7 template<typename T> T f(T t) { return t; }
10 template<typename> int template_param_kinds_1();
11 template<template<typename, int, int...> class> int template_param_kinds_2();
12 template<template<typename T, typename U, U> class> int template_param_kinds_3();
14 template<typename T> struct SomeTemplate<T&> {}
[all...] |
| cxx-templates-common.h | 0 template<typename T> struct SomeTemplate {};
9 template<typename T> struct CommonTemplate {
14 template<typename T> struct WithFriend {
20 template<typename T> void f() {
25 template<typename T> struct TemplateInstantiationVisibility { typedef int type; };
27 template<typename T> struct Outer {
28 template<typename U> struct Inner {
34 template<typename T> struct WithPartialSpecialization {};
35 template<typename T> struct WithPartialSpecialization<void(T)> { typedef int type; };
39 template<typename T> struct WithExplicitSpecialization
[all...] |
| /external/clang/test/CXX/temp/temp.arg/temp.arg.type/ |
| p2.cpp | 2 template<class T> struct A {
8 template<typename T> struct B {
13 template <typename T> int f0(void *, const T&); // expected-note{{candidate template ignored: substitution failure}}
14 enum {e}; // expected-note{{unnamed type used in template argument was declared here}}
17 int i = f0(0, e); // expected-warning{{template argument uses unnamed type}}
23 template <typename R, typename A1> void f0(R (*)(A1));
24 template <typename T> int f1(T);
25 template <typename T, typename U> int f1(T, U);
26 enum {e1}; // expected-note 2{{unnamed type used in template argument was declared here}
[all...] |
| /external/clang/test/Modules/Inputs/submodules-merge-defs/ |
| defs.h | 9 template<typename T> void f();
19 template<typename T> void B::f() {}
20 template<> inline void B::f<int>() {}
23 template<int N> struct C_Base { struct D { constexpr operator int() const { return 0; } }; };
32 template<typename T> int E(T t) { return t; }
34 template<typename T> struct F {
36 template<typename U> int g();
39 template<typename T> int F<T>::f() { return 0; }
40 template<typename T> template<typename U> int F<T>::g() { return 0;
[all...] |
| /ndk/tests/device/issue42891-boost-1_52/jni/boost/boost/type_traits/ |
| is_signed.hpp | 29 template <class T>
42 template <class T>
49 template <bool integral_type>
52 template <class T>
59 template <>
62 template <class T>
69 template <class T>
77 typedef typename selector::template rebind<T> binder;
88 template <class T> struct is_signed_imp : public false_type{};
89 template <> struct is_signed_imp<signed char> : public true_type{}
[all...] |
| is_unsigned.hpp | 29 template <class T>
42 template <class T>
48 template <bool integral_type>
51 template <class T>
58 template <>
61 template <class T>
68 template <class T>
76 typedef typename selector::template rebind<T> binder;
83 template <class T> struct is_unsigned_imp : public false_type{};
84 template <> struct is_unsigned_imp<unsigned char> : public true_type{}
[all...] |
| /external/mesa3d/src/mesa/main/ |
| APIspec.xml | 4 <!-- A function is generated from a template. Multiple functions can be
5 generated from a single template with different arguments. For example,
8 <function name="Color3f" template="Color" gltype="GLfloat" vector_size="3" expand_vector="true"/>
12 <function name="Color4iv" template="Color" gltype="GLint" vector_size="4"/>
14 In a template, there are <desc>s that describe the properties of
26 <template name="Color">
36 </template>
38 <template name="ClipPlane">
44 </template>
46 <template name="CullFace"
[all...] |
| /external/clang/test/Parser/ |
| cxx-concept-declaration.cpp | 6 template<typename T> concept bool C1 = true;
8 template<typename T> concept bool C2() { return true; }
10 template<typename T>
13 template<int N>
16 template<typename T, int = 0>
21 template <typename>
24 template<typename T> concept concept bool C6 = true; // expected-warning {{duplicate 'concept' declaration specifier}}
26 template<typename T> concept concept bool C7() { return true; } // expected-warning {{duplicate 'concept' declaration specifier}}
28 template<concept T> concept bool D1 = true; // expected-error {{unknown type name 'T'}}
|
| /ndk/tests/device/issue42891-boost-1_52/jni/boost/boost/numeric/conversion/detail/preprocessed/ |
| numeric_cast_traits_common.hpp | 14 template <>
26 template <>
38 template <>
50 template <>
62 template <>
74 template <>
86 template <>
98 template <>
110 template <>
122 template <>
[all...] |
| /external/clang/test/CXX/dcl.dcl/dcl.spec/dcl.stc/ |
| p1.cpp | 6 template<typename T> void f(T) {}
7 template<typename T> static void g(T) {}
10 template<> static void f<int>(int); // expected-error{{explicit specialization has extraneous, inconsistent storage class 'static'}}
11 template static void f<float>(float); // expected-error{{explicit instantiation cannot have a storage class}}
13 template<> void f<double>(double);
14 template void f<long>(long);
16 template<> static void g<int>(int); // expected-warning{{explicit specialization cannot have a storage class}}
17 template static void g<float>(float); // expected-error{{explicit instantiation cannot have a storage class}}
19 template<> void g<double>(double);
20 template void g<long>(long)
[all...] |
| /external/clang/test/CodeGenCXX/ |
| template-linkage.cpp | 5 template<typename T> struct A {
13 template void A<int>::g();
18 template struct A<float>;
21 template <typename T> void f(T) { }
22 template void f<int>(int);
25 template <typename T> inline void g(T) { }
26 template void g<int>(int);
28 template<typename T>
33 template<typename T>
38 template<typename T> void X1<T>::blarg() {
[all...] |
