annotate clang/utils/ClangVisualizers/clang.natvis @ 206:f17a3b42b08b

Added tag before-12 for changeset b7591485f4cd
author Shinji KONO <kono@ie.u-ryukyu.ac.jp>
date Mon, 07 Jun 2021 21:25:57 +0900
parents 1d019706d866
children c4bab56944e8
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
150
anatofuz
parents:
diff changeset
1 <?xml version="1.0" encoding="utf-8"?>
anatofuz
parents:
diff changeset
2 <!--
anatofuz
parents:
diff changeset
3 Visual Studio Native Debugging Visualizers for LLVM
anatofuz
parents:
diff changeset
4
anatofuz
parents:
diff changeset
5 For Visual Studio 2013 only, put this file into
anatofuz
parents:
diff changeset
6 "%USERPROFILE%\Documents\Visual Studio 2013\Visualizers" or create a symbolic link so it updates automatically.
anatofuz
parents:
diff changeset
7
anatofuz
parents:
diff changeset
8 For later versions of Visual Studio, no setup is required-->
anatofuz
parents:
diff changeset
9 <AutoVisualizer xmlns="http://schemas.microsoft.com/vstudio/debugger/natvis/2010">
anatofuz
parents:
diff changeset
10
anatofuz
parents:
diff changeset
11 <Type Name="clang::Type">
anatofuz
parents:
diff changeset
12 <!-- To visualize clang::Types, we need to look at TypeBits.TC to determine the actual
anatofuz
parents:
diff changeset
13 type subclass and manually dispatch accordingly (Visual Studio can't identify the real type
anatofuz
parents:
diff changeset
14 because clang::Type has no virtual members hence no RTTI).
anatofuz
parents:
diff changeset
15
anatofuz
parents:
diff changeset
16 Views:
anatofuz
parents:
diff changeset
17 "cmn": Visualization that is common to all clang::Type subclasses
anatofuz
parents:
diff changeset
18 "poly": Visualization that is specific to the actual clang::Type subclass. The subtype-specific
anatofuz
parents:
diff changeset
19 <DisplayString> is typically as C++-like as possible (like in dump()) with <Expand>
anatofuz
parents:
diff changeset
20 containing all the gory details.
anatofuz
parents:
diff changeset
21 "cpp": Only occasionally used when we need to distinguish between an ordinary view and a C++-like view.
anatofuz
parents:
diff changeset
22 -->
anatofuz
parents:
diff changeset
23 <DisplayString IncludeView="cmn" Condition="TypeBits.TC==clang::LocInfoType::LocInfo">LocInfoType</DisplayString>
anatofuz
parents:
diff changeset
24 <DisplayString IncludeView="cmn">{(clang::Type::TypeClass)TypeBits.TC, en}Type</DisplayString>
anatofuz
parents:
diff changeset
25 <!-- Dispatch to visualizers for the actual Type subclass -->
anatofuz
parents:
diff changeset
26 <DisplayString Condition="TypeBits.TC==clang::Type::TypeClass::Builtin" IncludeView="poly">{*(clang::BuiltinType *)this}</DisplayString>
anatofuz
parents:
diff changeset
27 <DisplayString Condition="TypeBits.TC==clang::Type::TypeClass::Pointer" IncludeView="poly">{*(clang::PointerType *)this}</DisplayString>
anatofuz
parents:
diff changeset
28 <DisplayString Condition="TypeBits.TC==clang::Type::TypeClass::LValueReference" IncludeView="poly">{*(clang::LValueReferenceType *)this}</DisplayString>
anatofuz
parents:
diff changeset
29 <DisplayString Condition="TypeBits.TC==clang::Type::TypeClass::RValueReference" IncludeView="poly">{*(clang::RValueReferenceType *)this}</DisplayString>
anatofuz
parents:
diff changeset
30 <DisplayString Condition="TypeBits.TC==clang::Type::TypeClass::ConstantArray" IncludeView="poly">{(clang::ConstantArrayType *)this,na}</DisplayString>
anatofuz
parents:
diff changeset
31 <DisplayString Condition="TypeBits.TC==clang::Type::TypeClass::ConstantArray" IncludeView="left">{(clang::ConstantArrayType *)this,view(left)na}</DisplayString>
anatofuz
parents:
diff changeset
32 <DisplayString Condition="TypeBits.TC==clang::Type::TypeClass::ConstantArray" IncludeView="right">{(clang::ConstantArrayType *)this,view(right)na}</DisplayString>
anatofuz
parents:
diff changeset
33 <DisplayString Condition="TypeBits.TC==clang::Type::TypeClass::IncompleteArray" IncludeView="poly">{(clang::IncompleteArrayType *)this,na}</DisplayString>
anatofuz
parents:
diff changeset
34 <DisplayString Condition="TypeBits.TC==clang::Type::TypeClass::IncompleteArray" IncludeView="left">{(clang::IncompleteArrayType *)this,view(left)na}</DisplayString>
anatofuz
parents:
diff changeset
35 <DisplayString Condition="TypeBits.TC==clang::Type::TypeClass::IncompleteArray" IncludeView="right">{(clang::IncompleteArrayType *)this,view(right)na}</DisplayString>
anatofuz
parents:
diff changeset
36 <DisplayString Condition="TypeBits.TC==clang::Type::TypeClass::Typedef" IncludeView="poly">{(clang::TypedefType *)this,na}</DisplayString>
anatofuz
parents:
diff changeset
37 <DisplayString Condition="TypeBits.TC==clang::Type::TypeClass::Typedef" IncludeView="cpp">{(clang::TypedefType *)this,view(cpp)na}</DisplayString>
anatofuz
parents:
diff changeset
38 <DisplayString Condition="TypeBits.TC==clang::Type::TypeClass::Attributed" IncludeView="poly">{*(clang::AttributedType *)this}</DisplayString>
anatofuz
parents:
diff changeset
39 <DisplayString Condition="TypeBits.TC==clang::Type::TypeClass::Decayed" IncludeView="poly">{(clang::DecayedType *)this,na}</DisplayString>
anatofuz
parents:
diff changeset
40 <DisplayString Condition="TypeBits.TC==clang::Type::TypeClass::Decayed" IncludeView="left">{(clang::DecayedType *)this,view(left)na}</DisplayString>
anatofuz
parents:
diff changeset
41 <DisplayString Condition="TypeBits.TC==clang::Type::TypeClass::Decayed" IncludeView="right">{(clang::DecayedType *)this,view(right)na}</DisplayString>
anatofuz
parents:
diff changeset
42 <DisplayString Condition="TypeBits.TC==clang::Type::TypeClass::TemplateTypeParm" IncludeView="poly">{*(clang::TemplateTypeParmType *)this}</DisplayString>
anatofuz
parents:
diff changeset
43 <DisplayString Condition="TypeBits.TC==clang::Type::TypeClass::TemplateTypeParm" IncludeView="cpp">{*(clang::TemplateTypeParmType *)this,view(cpp)}</DisplayString>
anatofuz
parents:
diff changeset
44 <DisplayString Condition="TypeBits.TC==clang::Type::TypeClass::SubstTemplateTypeParm" IncludeView="poly">{*(clang::SubstTemplateTypeParmType *)this}</DisplayString>
anatofuz
parents:
diff changeset
45 <DisplayString Condition="TypeBits.TC==clang::Type::TypeClass::Record" IncludeView="poly">{*(clang::RecordType *)this}</DisplayString>
anatofuz
parents:
diff changeset
46 <DisplayString Condition="TypeBits.TC==clang::Type::TypeClass::Record" IncludeView="cpp">{*(clang::RecordType *)this,view(cpp)}</DisplayString>
anatofuz
parents:
diff changeset
47 <DisplayString Condition="TypeBits.TC==clang::Type::TypeClass::FunctionProto" IncludeView="poly">{(clang::FunctionProtoType *)this,na}</DisplayString>
anatofuz
parents:
diff changeset
48 <DisplayString Condition="TypeBits.TC==clang::Type::TypeClass::FunctionProto" IncludeView="left">{(clang::FunctionProtoType *)this,view(left)na}</DisplayString>
anatofuz
parents:
diff changeset
49 <DisplayString Condition="TypeBits.TC==clang::Type::TypeClass::FunctionProto" IncludeView="right">{(clang::FunctionProtoType *)this,view(right)na}</DisplayString>
anatofuz
parents:
diff changeset
50 <DisplayString Condition="TypeBits.TC==clang::Type::TypeClass::TemplateSpecialization" IncludeView="poly">{*(clang::TemplateSpecializationType *)this}</DisplayString>
anatofuz
parents:
diff changeset
51 <DisplayString Condition="TypeBits.TC==clang::Type::TypeClass::DeducedTemplateSpecialization" IncludeView="poly">{*(clang::DeducedTemplateSpecializationType *)this}</DisplayString>
anatofuz
parents:
diff changeset
52 <DisplayString Condition="TypeBits.TC==clang::Type::TypeClass::DeducedTemplateSpecialization" IncludeView="cpp">{*(clang::DeducedTemplateSpecializationType *)this,view(cpp)}</DisplayString>
anatofuz
parents:
diff changeset
53 <DisplayString Condition="TypeBits.TC==clang::Type::TypeClass::InjectedClassName" IncludeView="poly">{*(clang::InjectedClassNameType *)this}</DisplayString>
anatofuz
parents:
diff changeset
54 <DisplayString Condition="TypeBits.TC==clang::Type::TypeClass::DependentName" IncludeView="poly">{*(clang::DependentNameType *)this}</DisplayString>
anatofuz
parents:
diff changeset
55 <DisplayString Condition="TypeBits.TC==clang::Type::TypeClass::PackExpansion" IncludeView="poly">{*(clang::PackExpansionType *)this}</DisplayString>
anatofuz
parents:
diff changeset
56 <DisplayString Condition="TypeBits.TC==clang::LocInfoType::LocInfo" IncludeView="poly">{(clang::LocInfoType *)this,na}</DisplayString>
anatofuz
parents:
diff changeset
57 <DisplayString Condition="TypeBits.TC==clang::LocInfoType::LocInfo" IncludeView="cpp">{(clang::LocInfoType *)this,view(cpp)na}</DisplayString>
anatofuz
parents:
diff changeset
58 <DisplayString IncludeView="cpp">{this,view(poly)na}</DisplayString>
anatofuz
parents:
diff changeset
59 <DisplayString IncludeView="left">{*this,view(cpp)}</DisplayString>
anatofuz
parents:
diff changeset
60 <DisplayString IncludeView="right"></DisplayString>
anatofuz
parents:
diff changeset
61 <DisplayString IncludeView="poly">No visualizer yet for {(clang::Type::TypeClass)TypeBits.TC,en}Type</DisplayString> <!-- Not yet implemented Type subclass -->
anatofuz
parents:
diff changeset
62 <DisplayString IncludeView="Dependent" Condition="TypeBits.Dependent">Dependent{" ",sb}</DisplayString>
anatofuz
parents:
diff changeset
63 <DisplayString IncludeView="Dependent"></DisplayString>
anatofuz
parents:
diff changeset
64 <DisplayString IncludeView="InstantiationDependent" Condition="TypeBits.InstantiationDependent">InstantiationDependent{" ",sb}</DisplayString>
anatofuz
parents:
diff changeset
65 <DisplayString IncludeView="InstantiationDependent"></DisplayString>
anatofuz
parents:
diff changeset
66 <DisplayString IncludeView="VariablyModified" Condition="TypeBits.VariablyModified">VariablyModified{" ",sb}</DisplayString>
anatofuz
parents:
diff changeset
67 <DisplayString IncludeView="VariablyModified"></DisplayString>
anatofuz
parents:
diff changeset
68 <DisplayString IncludeView="ContainsUnexpandedParameterPack" Condition="TypeBits.ContainsUnexpandedParameterPack">ContainsUnexpandedParameterPack{" ",sb}</DisplayString>
anatofuz
parents:
diff changeset
69 <DisplayString IncludeView="ContainsUnexpandedParameterPack"></DisplayString>
anatofuz
parents:
diff changeset
70 <DisplayString IncludeView="Cache" Condition="TypeBits.CacheValid &amp;&amp; TypeBits.CachedLocalOrUnnamed">CachedLinkage: {(clang::Linkage)TypeBits.CachedLinkage,en} CachedLocalOrUnnamed</DisplayString>
anatofuz
parents:
diff changeset
71 <DisplayString IncludeView="Cache" Condition="TypeBits.CacheValid &amp;&amp; !TypeBits.CachedLocalOrUnnamed">CachedLinkage: {(clang::Linkage)TypeBits.CachedLinkage,en}{" ",sb}</DisplayString>
anatofuz
parents:
diff changeset
72 <DisplayString IncludeView="Cache"></DisplayString>
anatofuz
parents:
diff changeset
73 <DisplayString IncludeView="FromAST" Condition="TypeBits.FromAST">FromAST</DisplayString>
anatofuz
parents:
diff changeset
74 <DisplayString IncludeView="FromAST"></DisplayString>
anatofuz
parents:
diff changeset
75 <DisplayString IncludeView="flags" Condition="!TypeBits.Dependent &amp;&amp; !TypeBits.InstantiationDependent &amp;&amp; !TypeBits.VariablyModified &amp;&amp; !TypeBits.ContainsUnexpandedParameterPack &amp;&amp; !TypeBits.CacheValid &amp;&amp; !TypeBits.FromAST">
anatofuz
parents:
diff changeset
76 No TypeBits set beyond TypeClass
anatofuz
parents:
diff changeset
77 </DisplayString>
anatofuz
parents:
diff changeset
78 <DisplayString IncludeView="flags">
anatofuz
parents:
diff changeset
79 {*this, view(Dependent)}{*this, view(InstantiationDependent)}{*this, view(VariablyModified)}
anatofuz
parents:
diff changeset
80 {*this, view(ContainsUnexpandedParameterPack)}{*this, view(Cache)}{*this, view(FromAST)}</DisplayString>
anatofuz
parents:
diff changeset
81 <DisplayString>{*this,view(cmn)} {{{*this,view(poly)}}}</DisplayString>
anatofuz
parents:
diff changeset
82 <Expand>
anatofuz
parents:
diff changeset
83 <Item Name="TypeClass" IncludeView="cmn">(clang::Type::TypeClass)TypeBits.TC</Item>
anatofuz
parents:
diff changeset
84 <Item Name="Flags" IncludeView="cmn">this,view(flags)na</Item>
anatofuz
parents:
diff changeset
85 <Item Name="Canonical" IncludeView="cmn">CanonicalType</Item>
anatofuz
parents:
diff changeset
86 <ExpandedItem ExcludeView="cmn" Condition="TypeBits.TC==clang::Type::TypeClass::Builtin">*(clang::BuiltinType *)this</ExpandedItem>
anatofuz
parents:
diff changeset
87 <ExpandedItem ExcludeView="cmn" Condition="TypeBits.TC==clang::Type::TypeClass::Pointer">*(clang::PointerType *)this</ExpandedItem>
anatofuz
parents:
diff changeset
88 <ExpandedItem ExcludeView="cmn" Condition="TypeBits.TC==clang::Type::TypeClass::LValueReference">*(clang::LValueReferenceType *)this</ExpandedItem>
anatofuz
parents:
diff changeset
89 <ExpandedItem ExcludeView="cmn" Condition="TypeBits.TC==clang::Type::TypeClass::RValueReference">*(clang::RValueReferenceType *)this</ExpandedItem>
anatofuz
parents:
diff changeset
90 <ExpandedItem ExcludeView="cmn" Condition="TypeBits.TC==clang::Type::TypeClass::ConstantArray">(clang::ConstantArrayType *)this</ExpandedItem>
anatofuz
parents:
diff changeset
91 <ExpandedItem ExcludeView="cmn" Condition="TypeBits.TC==clang::Type::TypeClass::IncompleteArray">(clang::IncompleteArrayType *)this</ExpandedItem>
anatofuz
parents:
diff changeset
92 <ExpandedItem ExcludeView="cmn" Condition="TypeBits.TC==clang::Type::TypeClass::Attributed">*(clang::AttributedType *)this</ExpandedItem>
anatofuz
parents:
diff changeset
93 <ExpandedItem ExcludeView="cmn" Condition="TypeBits.TC==clang::Type::TypeClass::Decayed">(clang::DecayedType *)this</ExpandedItem>
anatofuz
parents:
diff changeset
94 <ExpandedItem ExcludeView="cmn" Condition="TypeBits.TC==clang::Type::TypeClass::TemplateTypeParm">(clang::TemplateTypeParmType *)this</ExpandedItem>
anatofuz
parents:
diff changeset
95 <ExpandedItem ExcludeView="cmn" Condition="TypeBits.TC==clang::Type::TypeClass::SubstTemplateTypeParm">(clang::SubstTemplateTypeParmType *)this</ExpandedItem>
anatofuz
parents:
diff changeset
96 <ExpandedItem ExcludeView="cmn" Condition="TypeBits.TC==clang::Type::TypeClass::Record">(clang::RecordType *)this</ExpandedItem>
anatofuz
parents:
diff changeset
97 <ExpandedItem ExcludeView="cmn" Condition="TypeBits.TC==clang::Type::TypeClass::FunctionProto">(clang::FunctionProtoType *)this</ExpandedItem>
anatofuz
parents:
diff changeset
98 <ExpandedItem ExcludeView="cmn" Condition="TypeBits.TC==clang::Type::TypeClass::TemplateSpecialization">(clang::TemplateSpecializationType *)this</ExpandedItem>
anatofuz
parents:
diff changeset
99 <ExpandedItem ExcludeView="cmn" Condition="TypeBits.TC==clang::Type::TypeClass::DeducedTemplateSpecialization">(clang::DeducedTemplateSpecializationType *)this</ExpandedItem>
anatofuz
parents:
diff changeset
100 <ExpandedItem ExcludeView="cmn" Condition="TypeBits.TC==clang::Type::TypeClass::InjectedClassName">(clang::InjectedClassNameType *)this</ExpandedItem>
anatofuz
parents:
diff changeset
101 <ExpandedItem ExcludeView="cmn" Condition="TypeBits.TC==clang::Type::TypeClass::DependentName">(clang::DependentNameType *)this</ExpandedItem>
anatofuz
parents:
diff changeset
102 <ExpandedItem ExcludeView="cmn" Condition="TypeBits.TC==clang::Type::TypeClass::PackExpansion">(clang::PackExpansionType *)this</ExpandedItem>
anatofuz
parents:
diff changeset
103 <ExpandedItem ExcludeView="cmn" Condition="TypeBits.TC==clang::LocInfoType::LocInfo">(clang::LocInfoType *)this</ExpandedItem>
anatofuz
parents:
diff changeset
104 </Expand>
anatofuz
parents:
diff changeset
105 </Type>
anatofuz
parents:
diff changeset
106 <Type Name="clang::ArrayType">
anatofuz
parents:
diff changeset
107 <Expand>
anatofuz
parents:
diff changeset
108 <Item Name="ElementType">ElementType</Item>
anatofuz
parents:
diff changeset
109 </Expand>
anatofuz
parents:
diff changeset
110 </Type>
anatofuz
parents:
diff changeset
111 <Type Name="clang::ConstantArrayType">
anatofuz
parents:
diff changeset
112 <DisplayString IncludeView="left">{ElementType,view(cpp)}</DisplayString>
anatofuz
parents:
diff changeset
113 <DisplayString IncludeView="right">[{Size}]</DisplayString>
anatofuz
parents:
diff changeset
114 <DisplayString>{ElementType,view(cpp)}[{Size}]</DisplayString>
anatofuz
parents:
diff changeset
115 <Expand>
anatofuz
parents:
diff changeset
116 <Item Name="Size">Size</Item>
anatofuz
parents:
diff changeset
117 <ExpandedItem>(clang::ArrayType *)this</ExpandedItem>
anatofuz
parents:
diff changeset
118 </Expand>
anatofuz
parents:
diff changeset
119 </Type>
anatofuz
parents:
diff changeset
120 <Type Name="clang::IncompleteArrayType">
anatofuz
parents:
diff changeset
121 <DisplayString IncludeView="left">{ElementType,view(cpp)}</DisplayString>
anatofuz
parents:
diff changeset
122 <DisplayString IncludeView="right">[]</DisplayString>
anatofuz
parents:
diff changeset
123 <DisplayString>{ElementType,view(cpp)}[]</DisplayString>
anatofuz
parents:
diff changeset
124 <Expand>
anatofuz
parents:
diff changeset
125 <ExpandedItem>(clang::ArrayType *)this</ExpandedItem>
anatofuz
parents:
diff changeset
126 </Expand>
anatofuz
parents:
diff changeset
127 </Type>
anatofuz
parents:
diff changeset
128 <Type Name="clang::TypedefType">
anatofuz
parents:
diff changeset
129 <DisplayString IncludeView="cpp">{Decl,view(name)nd}</DisplayString>
anatofuz
parents:
diff changeset
130 <DisplayString>{Decl}</DisplayString>
anatofuz
parents:
diff changeset
131 <Expand>
anatofuz
parents:
diff changeset
132 <Item Name="Decl">Decl</Item>
anatofuz
parents:
diff changeset
133 <ExpandedItem>*(clang::Type *)this, view(cmn)</ExpandedItem>
anatofuz
parents:
diff changeset
134 </Expand>
anatofuz
parents:
diff changeset
135 </Type>
anatofuz
parents:
diff changeset
136 <Type Name="clang::PointerType">
anatofuz
parents:
diff changeset
137 <DisplayString>{PointeeType, view(cpp)} *</DisplayString>
anatofuz
parents:
diff changeset
138 <Expand>
anatofuz
parents:
diff changeset
139 <Item Name="PointeeType">PointeeType</Item>
anatofuz
parents:
diff changeset
140 <ExpandedItem>*(clang::Type *)this, view(cmn)</ExpandedItem>
anatofuz
parents:
diff changeset
141 </Expand>
anatofuz
parents:
diff changeset
142 </Type>
anatofuz
parents:
diff changeset
143 <!-- We visualize all inner types for clang reference types. So a rvalue reference to an lvalue reference
anatofuz
parents:
diff changeset
144 to an int would visual as int &amp; &amp;&amp; This is a little different than GetPointeeType(),
anatofuz
parents:
diff changeset
145 but more clearly displays the data structure and seems natural -->
anatofuz
parents:
diff changeset
146 <Type Name="clang::LValueReferenceType">
anatofuz
parents:
diff changeset
147 <DisplayString>{((clang::ReferenceType *)this)-&gt;PointeeType,view(cpp)} &amp;</DisplayString>
anatofuz
parents:
diff changeset
148 <Expand>
anatofuz
parents:
diff changeset
149 <ExpandedItem>*(clang::Type *)this, view(cmn)</ExpandedItem>
anatofuz
parents:
diff changeset
150 <Item Name="PointeeType">PointeeType</Item>
anatofuz
parents:
diff changeset
151 </Expand>
anatofuz
parents:
diff changeset
152 </Type>
anatofuz
parents:
diff changeset
153 <Type Name="clang::RValueReferenceType">
anatofuz
parents:
diff changeset
154 <DisplayString>{((clang::ReferenceType *)this)-&gt;PointeeType,view(cpp)} &amp;&amp;</DisplayString>
anatofuz
parents:
diff changeset
155 <Expand>
anatofuz
parents:
diff changeset
156 <ExpandedItem>*(clang::Type *)this, view(cmn)</ExpandedItem>
anatofuz
parents:
diff changeset
157 <Item Name="PointeeType">PointeeType</Item>
anatofuz
parents:
diff changeset
158 </Expand>
anatofuz
parents:
diff changeset
159 </Type>
anatofuz
parents:
diff changeset
160 <Type Name="clang::AttributedType">
anatofuz
parents:
diff changeset
161 <DisplayString>{ModifiedType} Attribute={(clang::AttributedType::Kind)AttributedTypeBits.AttrKind}</DisplayString>
anatofuz
parents:
diff changeset
162 </Type>
anatofuz
parents:
diff changeset
163
anatofuz
parents:
diff changeset
164 <!-- Unfortunately, Visual Studio has trouble seeing the PointerBitMask member PointerIntUnion, so I hardwire it to 2 bits-->
anatofuz
parents:
diff changeset
165 <Type Name="clang::DeclContext">
anatofuz
parents:
diff changeset
166 <DisplayString>{(clang::Decl::Kind)DeclContextBits.DeclKind,en}Decl</DisplayString>
anatofuz
parents:
diff changeset
167 <Expand>
anatofuz
parents:
diff changeset
168 <Item Name="DeclKind">(clang::Decl::Kind)DeclContextBits.DeclKind,en</Item>
anatofuz
parents:
diff changeset
169 <Synthetic Name="Members">
anatofuz
parents:
diff changeset
170 <DisplayString></DisplayString>
anatofuz
parents:
diff changeset
171 <Expand>
anatofuz
parents:
diff changeset
172 <LinkedListItems>
anatofuz
parents:
diff changeset
173 <HeadPointer>FirstDecl</HeadPointer>
anatofuz
parents:
diff changeset
174 <NextPointer>(clang::Decl *)(NextInContextAndBits.Value &amp; ~3)</NextPointer>
anatofuz
parents:
diff changeset
175 <ValueNode>*this</ValueNode>
anatofuz
parents:
diff changeset
176 </LinkedListItems>
anatofuz
parents:
diff changeset
177 </Expand>
anatofuz
parents:
diff changeset
178 </Synthetic>
anatofuz
parents:
diff changeset
179 </Expand>
anatofuz
parents:
diff changeset
180 </Type>
anatofuz
parents:
diff changeset
181 <Type Name="clang::FieldDecl">
anatofuz
parents:
diff changeset
182 <DisplayString>Field {{{*(clang::DeclaratorDecl *)this,view(cpp)nd}}}</DisplayString>
anatofuz
parents:
diff changeset
183 </Type>
anatofuz
parents:
diff changeset
184 <Type Name="clang::CXXMethodDecl">
anatofuz
parents:
diff changeset
185 <DisplayString IncludeView="cpp">{*(clang::FunctionDecl *)this,nd}</DisplayString>
anatofuz
parents:
diff changeset
186 <DisplayString>Method {{{*this,view(cpp)}}}</DisplayString>
anatofuz
parents:
diff changeset
187 </Type>
anatofuz
parents:
diff changeset
188 <Type Name="clang::CXXConstructorDecl">
anatofuz
parents:
diff changeset
189 <DisplayString>Constructor {{{Name,view(cpp)}({*(clang::FunctionDecl *)this,view(parm0)nd})}}</DisplayString>
anatofuz
parents:
diff changeset
190 </Type>
anatofuz
parents:
diff changeset
191 <Type Name="clang::CXXDestructorDecl">
anatofuz
parents:
diff changeset
192 <DisplayString>Destructor {{~{Name,view(cpp)}()}}</DisplayString>
anatofuz
parents:
diff changeset
193 </Type>
anatofuz
parents:
diff changeset
194 <Type Name="clang::TemplateTypeParmDecl">
anatofuz
parents:
diff changeset
195 <DisplayString IncludeView="TorC" Condition="Typename">typename</DisplayString>
anatofuz
parents:
diff changeset
196 <DisplayString IncludeView="TorC" Condition="!Typename">class</DisplayString>
anatofuz
parents:
diff changeset
197 <DisplayString IncludeView="MaybeEllipses" Condition="TypeForDecl == nullptr">(not yet known if parameter pack) </DisplayString>
anatofuz
parents:
diff changeset
198 <DisplayString IncludeView="MaybeEllipses" Condition="((TemplateTypeParmType *)(((clang::ExtQualsTypeCommonBase *)(((uintptr_t)TypeForDecl->CanonicalType.Value.Value) &amp; ~(uintptr_t)((1 &lt;&lt; 4) - 1)))-&gt;BaseType))->CanTTPTInfo.ParameterPack">...</DisplayString>
anatofuz
parents:
diff changeset
199 <DisplayString IncludeView="MaybeEllipses" Condition="!((TemplateTypeParmType *)(((clang::ExtQualsTypeCommonBase *)(((uintptr_t)TypeForDecl->CanonicalType.Value.Value) &amp; ~(uintptr_t)((1 &lt;&lt; 4) - 1)))-&gt;BaseType))->CanTTPTInfo.ParameterPack"></DisplayString>
anatofuz
parents:
diff changeset
200 <DisplayString IncludeView="DefaultArg" Condition="(DefaultArgument.ValueOrInherited.Val.Value&amp;3LL) == 0">{(TypeSourceInfo *)(DefaultArgument.ValueOrInherited.Val.Value&amp;~3LL),view(cpp)}</DisplayString>
anatofuz
parents:
diff changeset
201 <DisplayString IncludeView="DefaultArg">{{InheritedInitializer}}</DisplayString>
anatofuz
parents:
diff changeset
202 <DisplayString IncludeView="Initializer" Condition="DefaultArgument.ValueOrInherited.Val.Value&amp;~3LL">= {this,view(DefaultArg)na}</DisplayString>
anatofuz
parents:
diff changeset
203 <DisplayString IncludeView="Initializer"></DisplayString>
anatofuz
parents:
diff changeset
204 <DisplayString>{*this,view(TorC)} {*this,view(MaybeEllipses)}{Name,view(cpp)} {this,view(Initializer)na}</DisplayString>
anatofuz
parents:
diff changeset
205 </Type>
anatofuz
parents:
diff changeset
206 <Type Name="clang::TemplateDecl">
anatofuz
parents:
diff changeset
207 <DisplayString IncludeView="cpp">{*TemplatedDecl,view(cpp)}</DisplayString>
anatofuz
parents:
diff changeset
208 <DisplayString>template{TemplateParams,na} {*TemplatedDecl};</DisplayString>
anatofuz
parents:
diff changeset
209 <Expand>
anatofuz
parents:
diff changeset
210 <Item Name="TemplateParams">TemplateParams,na</Item>
anatofuz
parents:
diff changeset
211 <Item Name="TemplatedDecl">TemplatedDecl,na</Item>
anatofuz
parents:
diff changeset
212 </Expand>
anatofuz
parents:
diff changeset
213 </Type>
anatofuz
parents:
diff changeset
214 <!-- Unfortunately, visualization of PointerIntPair<PointerUnion> doesn't work due to limitations in natvis, so we will barehad it-->
anatofuz
parents:
diff changeset
215 <Type Name="clang::TypedefNameDecl">
anatofuz
parents:
diff changeset
216 <DisplayString Condition="(MaybeModedTInfo.Value &amp; 4)==0" IncludeView="type">{(clang::TypeSourceInfo *)(MaybeModedTInfo.Value &amp; ~7LL),view(cpp)na}</DisplayString>
anatofuz
parents:
diff changeset
217 <DisplayString Condition="(MaybeModedTInfo.Value &amp; 4)!=0" IncludeView="type">{(clang::TypedefNameDecl::ModedTInfo *)(MaybeModedTInfo.Value &amp; ~7LL),view(cpp)na}</DisplayString>
anatofuz
parents:
diff changeset
218 <DisplayString IncludeView="name">{(TypeDecl *)this,view(cpp)nand}</DisplayString>
anatofuz
parents:
diff changeset
219 <DisplayString>typedef {this,view(type)na} {this,view(name)na};</DisplayString>
anatofuz
parents:
diff changeset
220 <Expand>
anatofuz
parents:
diff changeset
221 <Item Name="IsTransparent" Condition="(MaybeModedTInfo.Value &amp; 1)==0">"Not yet calculated",sb</Item>
anatofuz
parents:
diff changeset
222 <Item Name="IsTransparent" Condition="(MaybeModedTInfo.Value &amp; 1)!=0">(bool)(MaybeModedTInfo.Value &amp; 2)</Item>
anatofuz
parents:
diff changeset
223 <Item Name="TypeSourceInfo" Condition="(MaybeModedTInfo.Value &amp; 4)==0">(clang::TypeSourceInfo *)(MaybeModedTInfo.Value &amp; ~7LL)</Item>
anatofuz
parents:
diff changeset
224 <Item Name="ModedTInfo" Condition="(MaybeModedTInfo.Value &amp; 4)!=0">(clang::TypedefNameDecl::ModedTInfo *)(MaybeModedTInfo.Value &amp; ~7LL)</Item>
anatofuz
parents:
diff changeset
225 <ExpandedItem>(TypeDecl *)this,nd</ExpandedItem>
anatofuz
parents:
diff changeset
226 </Expand>
anatofuz
parents:
diff changeset
227 </Type>
anatofuz
parents:
diff changeset
228 <Type Name="clang::TypeAliasDecl">
anatofuz
parents:
diff changeset
229 <DisplayString IncludeView="cpp">{(TypedefNameDecl *)this,view(name)nand}</DisplayString>
anatofuz
parents:
diff changeset
230 <DisplayString>using {(TypedefNameDecl *)this,view(name)nand} = {(TypedefNameDecl *)this,view(type)nand}</DisplayString>
anatofuz
parents:
diff changeset
231 </Type>
anatofuz
parents:
diff changeset
232 <Type Name="clang::AssumedTemplateStorage">
anatofuz
parents:
diff changeset
233 <DisplayString>{Name}</DisplayString>
anatofuz
parents:
diff changeset
234 </Type>
anatofuz
parents:
diff changeset
235 <Type Name="clang::UncommonTemplateNameStorage::BitsTag">
anatofuz
parents:
diff changeset
236 <DisplayString>Kind={(UncommonTemplateNameStorage::Kind)Kind,en}, Size={Size}</DisplayString>
anatofuz
parents:
diff changeset
237 <Expand>
anatofuz
parents:
diff changeset
238 <Item Name="Kind">(UncommonTemplateNameStorage::Kind)Kind</Item>
anatofuz
parents:
diff changeset
239 <Item Name="Size">Size</Item>
anatofuz
parents:
diff changeset
240 </Expand>
anatofuz
parents:
diff changeset
241 </Type>
anatofuz
parents:
diff changeset
242 <Type Name="clang::UncommonTemplateNameStorage">
anatofuz
parents:
diff changeset
243 <DisplayString IncludeView="cmn">{Bits},</DisplayString>
anatofuz
parents:
diff changeset
244 <DisplayString Condition="Bits.Kind==UncommonTemplateNameStorage::Overloaded">{this,view(cmn)na},{(OverloadedTemplateStorage*)this,na}</DisplayString>
anatofuz
parents:
diff changeset
245 <DisplayString Condition="Bits.Kind==UncommonTemplateNameStorage::Assumed">{this,view(cmn)na},{(AssumedTemplateStorage*)this,na}</DisplayString>
anatofuz
parents:
diff changeset
246 <DisplayString Condition="Bits.Kind==UncommonTemplateNameStorage::SubstTemplateTemplateParm">{this,view(cmn)na},{(SubstTemplateTemplateParmStorage*)this,na}</DisplayString>
anatofuz
parents:
diff changeset
247 <DisplayString Condition="Bits.Kind==UncommonTemplateNameStorage::SubstTemplateTemplateParmPack">{this,view(cmn)na},{(SubstTemplateTemplateParmPackStorage*)this,na}</DisplayString>
anatofuz
parents:
diff changeset
248 <DisplayString>{this,view(cmn)na}</DisplayString>
anatofuz
parents:
diff changeset
249 <Expand>
anatofuz
parents:
diff changeset
250 <Item Name="Bits">Bits</Item>
anatofuz
parents:
diff changeset
251 <ExpandedItem Condition="Bits.Kind==UncommonTemplateNameStorage::Overloaded">(OverloadedTemplateStorage*)this</ExpandedItem>
anatofuz
parents:
diff changeset
252 <ExpandedItem Condition="Bits.Kind==UncommonTemplateNameStorage::Assumed">(AssumedTemplateStorage*)this</ExpandedItem>
anatofuz
parents:
diff changeset
253 <ExpandedItem Condition="Bits.Kind==UncommonTemplateNameStorage::SubstTemplateTemplateParm">(SubstTemplateTemplateParmStorage*)this</ExpandedItem>
anatofuz
parents:
diff changeset
254 <ExpandedItem Condition="Bits.Kind==UncommonTemplateNameStorage::SubstTemplateTemplateParmPack">(SubstTemplateTemplateParmPackStorage*)this</ExpandedItem>
anatofuz
parents:
diff changeset
255 </Expand>
anatofuz
parents:
diff changeset
256 </Type>
anatofuz
parents:
diff changeset
257 <!-- clang::TemplateName::StorageType -->
anatofuz
parents:
diff changeset
258 <Type Name="llvm::PointerUnion&lt;clang::TemplateDecl *, clang::UncommonTemplateNameStorage *,
anatofuz
parents:
diff changeset
259 clang::QualifiedTemplateName *, clang::DependentTemplateName *&gt;">
anatofuz
parents:
diff changeset
260 <!-- Expand this out by hand to get cpp view -->
anatofuz
parents:
diff changeset
261 <DisplayString Condition="(Val.Value &amp;3) == 0" IncludeView="cpp">
anatofuz
parents:
diff changeset
262 {(clang::TemplateDecl *)(Val.Value &amp; ~3LL),view(cpp)na}
anatofuz
parents:
diff changeset
263 </DisplayString>
anatofuz
parents:
diff changeset
264 <DisplayString Condition="(Val.Value &amp;3) == 0">
anatofuz
parents:
diff changeset
265 {(clang::TemplateDecl *)(Val.Value &amp; ~3LL),na}
anatofuz
parents:
diff changeset
266 </DisplayString>
anatofuz
parents:
diff changeset
267 <DisplayString Condition="(Val.Value &amp;3) == 1" IncludeView="cpp">
anatofuz
parents:
diff changeset
268 {(clang::UncommonTemplateNameStorage *)(Val.Value &amp; ~3LL),view(cpp)na}
anatofuz
parents:
diff changeset
269 </DisplayString>
anatofuz
parents:
diff changeset
270 <DisplayString Condition="(Val.Value &amp;3) == 1">
anatofuz
parents:
diff changeset
271 {(clang::UncommonTemplateNameStorage *)(Val.Value &amp; ~3LL),na}
anatofuz
parents:
diff changeset
272 </DisplayString>
anatofuz
parents:
diff changeset
273 <DisplayString Condition="(Val.Value &amp;3) == 2" IncludeView="cpp">
anatofuz
parents:
diff changeset
274 {(clang::QualifiedTemplateName *)(Val.Value &amp; ~3LL),view(cpp)na}
anatofuz
parents:
diff changeset
275 </DisplayString>
anatofuz
parents:
diff changeset
276 <DisplayString Condition="(Val.Value &amp;3) == 2">
anatofuz
parents:
diff changeset
277 {(clang::QualifiedTemplateName *)(Val.Value &amp; ~3LL),na}
anatofuz
parents:
diff changeset
278 </DisplayString>
anatofuz
parents:
diff changeset
279 <DisplayString Condition="(Val.Value &amp;3) == 3" IncludeView="cpp">
anatofuz
parents:
diff changeset
280 {(clang::DependentTemplateName *)(Val.Value &amp; ~3LL),view(cpp)na}
anatofuz
parents:
diff changeset
281 </DisplayString>
anatofuz
parents:
diff changeset
282 <DisplayString Condition="(Val.Value &amp;3) == 3">
anatofuz
parents:
diff changeset
283 {(clang::DependentTemplateName *)(Val.Value &amp; ~3LL),na}
anatofuz
parents:
diff changeset
284 </DisplayString>
anatofuz
parents:
diff changeset
285 <Expand>
anatofuz
parents:
diff changeset
286 <Item Name="[Holds]" Condition="(Val.Value &amp;3) == 0">"TemplateDecl",s8b</Item>
anatofuz
parents:
diff changeset
287 <Item Name="[Ptr]" Optional="true" Condition="(Val.Value &amp;3) == 0">
anatofuz
parents:
diff changeset
288 (clang::TemplateDecl *)(Val.Value &amp; ~3LL)
anatofuz
parents:
diff changeset
289 </Item>
anatofuz
parents:
diff changeset
290 <Item Name="[Holds]" Condition="(Val.Value &amp;3) == 1">"UncommonTemplateNameStorage",s8b</Item>
anatofuz
parents:
diff changeset
291 <Item Name="[Ptr]" Optional="true" Condition="(Val.Value &amp;3) == 1">
anatofuz
parents:
diff changeset
292 (clang::UncommonTemplateNameStorage *)(Val.Value &amp; ~3LL)
anatofuz
parents:
diff changeset
293 </Item>
anatofuz
parents:
diff changeset
294 <Item Name="[Holds]" Condition="(Val.Value &amp;3) == 2">"QualifiedTemplateName",s8b</Item>
anatofuz
parents:
diff changeset
295 <Item Name="[Ptr]" Optional="true" Condition="(Val.Value &amp;3) == 2">
anatofuz
parents:
diff changeset
296 (clang::QualifiedTemplateName *)(Val.Value &amp; ~3LL)
anatofuz
parents:
diff changeset
297 </Item>
anatofuz
parents:
diff changeset
298 <Item Name="[Holds]" Condition="(Val.Value &amp;3) == 3">"DependentTemplateName",s8b</Item>
anatofuz
parents:
diff changeset
299 <Item Name="[Ptr]" Optional="true" Condition="(Val.Value &amp;3) == 3">
anatofuz
parents:
diff changeset
300 (clang::DependentTemplateName *)(Val.Value &amp; ~3LL)
anatofuz
parents:
diff changeset
301 </Item>
anatofuz
parents:
diff changeset
302 <Item Name="[Val]">Val</Item>
anatofuz
parents:
diff changeset
303
anatofuz
parents:
diff changeset
304 </Expand>
anatofuz
parents:
diff changeset
305 </Type>
anatofuz
parents:
diff changeset
306 <Type Name="clang::TemplateName">
anatofuz
parents:
diff changeset
307 <DisplayString IncludeView="cpp">{Storage,view(cpp)na}</DisplayString>
anatofuz
parents:
diff changeset
308 <DisplayString>{Storage,na}</DisplayString>
anatofuz
parents:
diff changeset
309 <Expand>
anatofuz
parents:
diff changeset
310 <ExpandedItem>Storage</ExpandedItem>
anatofuz
parents:
diff changeset
311 </Expand>
anatofuz
parents:
diff changeset
312 </Type>
anatofuz
parents:
diff changeset
313 <Type Name="clang::NamedDecl" >
anatofuz
parents:
diff changeset
314 <DisplayString IncludeView="cpp">{Name,view(cpp)}</DisplayString>
anatofuz
parents:
diff changeset
315 <DisplayString>{Name}</DisplayString>
anatofuz
parents:
diff changeset
316 </Type>
anatofuz
parents:
diff changeset
317 <Type Name="clang::TagDecl">
anatofuz
parents:
diff changeset
318 <DisplayString IncludeView="implicit" Condition="Implicit">implicit{" ",sb}</DisplayString>
anatofuz
parents:
diff changeset
319 <DisplayString IncludeView="implicit"></DisplayString>
anatofuz
parents:
diff changeset
320 <DisplayString IncludeView="modifiers">{*this,view(implicit)nd}</DisplayString>
anatofuz
parents:
diff changeset
321 <DisplayString IncludeView="cpp">{*this,view(modifiers)}{Name,view(cpp)}</DisplayString>
anatofuz
parents:
diff changeset
322 <DisplayString Condition="TagDeclBits.TagDeclKind==clang::TagTypeKind::TTK_Struct">{*this,view(modifiers)nd}struct {Name,view(cpp)}</DisplayString>
anatofuz
parents:
diff changeset
323 <DisplayString Condition="TagDeclBits.TagDeclKind==clang::TagTypeKind::TTK_Interface">{*this,view(modifiers)nd}interface {Name,view(cpp)}</DisplayString>
anatofuz
parents:
diff changeset
324 <DisplayString Condition="TagDeclBits.TagDeclKind==clang::TagTypeKind::TTK_Union">{*this,view(modifiers)nd}union {Name,view(cpp)}</DisplayString>
anatofuz
parents:
diff changeset
325 <DisplayString Condition="TagDeclBits.TagDeclKind==clang::TagTypeKind::TTK_Class">{*this,view(modifiers)nd}class {Name,view(cpp)}</DisplayString>
anatofuz
parents:
diff changeset
326 <DisplayString Condition="TagDeclBits.TagDeclKind==clang::TagTypeKind::TTK_Enum">{*this,view(modifiers)nd}enum {Name,view(cpp)}</DisplayString>
anatofuz
parents:
diff changeset
327 <Expand>
anatofuz
parents:
diff changeset
328 <ExpandedItem>(clang::DeclContext *)this</ExpandedItem>
anatofuz
parents:
diff changeset
329 </Expand>
anatofuz
parents:
diff changeset
330 </Type>
anatofuz
parents:
diff changeset
331 <Type Name="clang::TagType">
anatofuz
parents:
diff changeset
332 <DisplayString IncludeView="cpp">{decl,view(cpp)na}</DisplayString>
anatofuz
parents:
diff changeset
333 <DisplayString>{*decl}</DisplayString>
anatofuz
parents:
diff changeset
334 <Expand>
anatofuz
parents:
diff changeset
335 <ExpandedItem>*(clang::Type *)this, view(cmn)</ExpandedItem>
anatofuz
parents:
diff changeset
336 <Item Name="decl">decl</Item>
anatofuz
parents:
diff changeset
337 </Expand>
anatofuz
parents:
diff changeset
338 </Type>
anatofuz
parents:
diff changeset
339 <Type Name="clang::RecordType">
anatofuz
parents:
diff changeset
340 <DisplayString IncludeView="cpp">{(clang::TagType *)this,view(cpp)na}</DisplayString>
anatofuz
parents:
diff changeset
341 <DisplayString>{(clang::TagType *)this,na}</DisplayString>
anatofuz
parents:
diff changeset
342 <Expand>
anatofuz
parents:
diff changeset
343 <Item Name="TagType">*(clang::TagType *)this</Item>
anatofuz
parents:
diff changeset
344 </Expand>
anatofuz
parents:
diff changeset
345 </Type>
anatofuz
parents:
diff changeset
346 <Type Name="clang::SubstTemplateTypeParmType">
anatofuz
parents:
diff changeset
347 <DisplayString>{{{*Replaced,view(cpp)} &lt;= {CanonicalType,view(cpp)}}}</DisplayString>
anatofuz
parents:
diff changeset
348 <Expand>
anatofuz
parents:
diff changeset
349 <ExpandedItem>*(clang::Type *)this, view(cmn)</ExpandedItem>
anatofuz
parents:
diff changeset
350 <Item Name="Replaced">*Replaced</Item>
anatofuz
parents:
diff changeset
351 </Expand>
anatofuz
parents:
diff changeset
352 </Type>
anatofuz
parents:
diff changeset
353 <!-- We only show the first 5 parameter types in the display string (can't figure out how to loop in DisplayString)
anatofuz
parents:
diff changeset
354 but the expansion has all parameters -->
anatofuz
parents:
diff changeset
355 <Type Name="clang::FunctionProtoType">
anatofuz
parents:
diff changeset
356 <DisplayString IncludeView="left" Condition="FunctionTypeBits.HasTrailingReturn"></DisplayString>
anatofuz
parents:
diff changeset
357 <DisplayString IncludeView="left">{ResultType,view(cpp)}</DisplayString>
anatofuz
parents:
diff changeset
358 <DisplayString IncludeView="parm0" Condition="FunctionTypeBits.NumParams==0"></DisplayString>
anatofuz
parents:
diff changeset
359 <DisplayString IncludeView="parm0">{*(clang::QualType *)(this+1),view(cpp)}{*this,view(parm1)}</DisplayString>
anatofuz
parents:
diff changeset
360 <DisplayString IncludeView="parm1" Condition="FunctionTypeBits.NumParams==1"></DisplayString>
anatofuz
parents:
diff changeset
361 <DisplayString IncludeView="parm1">, {*((clang::QualType *)(this+1)+1),view(cpp)}{*this,view(parm2)}</DisplayString>
anatofuz
parents:
diff changeset
362 <DisplayString IncludeView="parm2" Condition="FunctionTypeBits.NumParams==2"></DisplayString>
anatofuz
parents:
diff changeset
363 <DisplayString IncludeView="parm2">, {*((clang::QualType *)(this+1)+2),view(cpp)}{*this,view(parm3)}</DisplayString>
anatofuz
parents:
diff changeset
364 <DisplayString IncludeView="parm3" Condition="FunctionTypeBits.NumParams==3"></DisplayString>
anatofuz
parents:
diff changeset
365 <DisplayString IncludeView="parm3">, {*((clang::QualType *)(this+1)+3),view(cpp)}{*this,view(parm4)}</DisplayString>
anatofuz
parents:
diff changeset
366 <DisplayString IncludeView="parm4" Condition="FunctionTypeBits.NumParams==4"></DisplayString>
anatofuz
parents:
diff changeset
367 <DisplayString IncludeView="parm4">, {*((clang::QualType *)(this+1)+4),view(cpp)}{*this,view(parm5)}</DisplayString>
anatofuz
parents:
diff changeset
368 <DisplayString IncludeView="parm5" Condition="FunctionTypeBits.NumParams==5"></DisplayString>
anatofuz
parents:
diff changeset
369 <DisplayString IncludeView="parm5">, /* expand for more params */</DisplayString>
anatofuz
parents:
diff changeset
370 <DisplayString IncludeView="right" Condition="FunctionTypeBits.HasTrailingReturn">({*this,view(parm0)}) -&gt; {ResultType,view(cpp)}</DisplayString>
anatofuz
parents:
diff changeset
371 <DisplayString IncludeView="right">({*this,view(parm0)})</DisplayString>
anatofuz
parents:
diff changeset
372 <DisplayString>{this,view(left)na}{this,view(right)na}</DisplayString>
anatofuz
parents:
diff changeset
373 <Expand>
anatofuz
parents:
diff changeset
374 <Item Name="ResultType">ResultType</Item>
anatofuz
parents:
diff changeset
375 <Synthetic Name="Parameter Types">
anatofuz
parents:
diff changeset
376 <DisplayString>{*this,view(parm0)}</DisplayString>
anatofuz
parents:
diff changeset
377 <Expand>
anatofuz
parents:
diff changeset
378 <ArrayItems>
anatofuz
parents:
diff changeset
379 <Size>FunctionTypeBits.NumParams</Size>
anatofuz
parents:
diff changeset
380 <ValuePointer>(clang::QualType *)(this+1)</ValuePointer>
anatofuz
parents:
diff changeset
381 </ArrayItems>
anatofuz
parents:
diff changeset
382 </Expand>
anatofuz
parents:
diff changeset
383 </Synthetic>
anatofuz
parents:
diff changeset
384 <ExpandedItem>*(clang::Type *)this, view(cmn)</ExpandedItem>
anatofuz
parents:
diff changeset
385 </Expand>
anatofuz
parents:
diff changeset
386 </Type>
anatofuz
parents:
diff changeset
387
anatofuz
parents:
diff changeset
388 <Type Name="clang::AdjustedType">
anatofuz
parents:
diff changeset
389 <DisplayString>{OriginalTy} adjusted to {AdjustedTy}</DisplayString>
anatofuz
parents:
diff changeset
390 <Expand>
anatofuz
parents:
diff changeset
391 <Item Name="OriginalTy">OriginalTy</Item>
anatofuz
parents:
diff changeset
392 <Item Name="AdjustedTy">AdjustedTy</Item>
anatofuz
parents:
diff changeset
393 </Expand>
anatofuz
parents:
diff changeset
394 </Type>
anatofuz
parents:
diff changeset
395 <Type Name="clang::DecayedType">
anatofuz
parents:
diff changeset
396 <DisplayString IncludeView="left">{OriginalTy,view(left)}</DisplayString>
anatofuz
parents:
diff changeset
397 <DisplayString IncludeView="right">{OriginalTy,view(right)}</DisplayString>
anatofuz
parents:
diff changeset
398 <DisplayString>{OriginalTy}</DisplayString>
anatofuz
parents:
diff changeset
399 <Expand>
anatofuz
parents:
diff changeset
400 <ExpandedItem>(clang::AdjustedType *)this</ExpandedItem>
anatofuz
parents:
diff changeset
401 </Expand>
anatofuz
parents:
diff changeset
402 </Type>
anatofuz
parents:
diff changeset
403 <Type Name="clang::TemplateTypeParmType">
anatofuz
parents:
diff changeset
404 <DisplayString IncludeView="cpp" Condition="CanonicalType.Value.Value != this">{TTPDecl->Name,view(cpp)}</DisplayString>
anatofuz
parents:
diff changeset
405 <DisplayString Condition="CanonicalType.Value.Value != this">Non-canonical: {*TTPDecl}</DisplayString>
anatofuz
parents:
diff changeset
406 <DisplayString>Canonical: {CanTTPTInfo}</DisplayString>
anatofuz
parents:
diff changeset
407 <Expand>
anatofuz
parents:
diff changeset
408 <ExpandedItem>*(clang::Type *)this, view(cmn)</ExpandedItem>
anatofuz
parents:
diff changeset
409 </Expand>
anatofuz
parents:
diff changeset
410 </Type>
anatofuz
parents:
diff changeset
411 <Type Name="clang::InjectedClassNameType">
anatofuz
parents:
diff changeset
412 <DisplayString>{Decl,view(cpp)}</DisplayString>
anatofuz
parents:
diff changeset
413 <Expand>
anatofuz
parents:
diff changeset
414 <Item Name="Decl">Decl</Item>
anatofuz
parents:
diff changeset
415 <Item Name="InjectedType">InjectedType</Item>
anatofuz
parents:
diff changeset
416 <ExpandedItem>*(clang::Type *)this, view(cmn)</ExpandedItem>
anatofuz
parents:
diff changeset
417 </Expand>
anatofuz
parents:
diff changeset
418 </Type>
anatofuz
parents:
diff changeset
419 <Type Name="clang::DependentNameType">
anatofuz
parents:
diff changeset
420 <DisplayString>{NNS}{Name,view(cpp)na}</DisplayString>
anatofuz
parents:
diff changeset
421 <Expand>
anatofuz
parents:
diff changeset
422 <Item Name="NNS">NNS</Item>
anatofuz
parents:
diff changeset
423 <Item Name="Name">Name</Item>
anatofuz
parents:
diff changeset
424 <ExpandedItem>*(clang::Type *)this, view(cmn)</ExpandedItem>
anatofuz
parents:
diff changeset
425 </Expand>
anatofuz
parents:
diff changeset
426 </Type>
anatofuz
parents:
diff changeset
427 <Type Name="clang::NestedNameSpecifier">
anatofuz
parents:
diff changeset
428 <DisplayString Condition="!Specifier"></DisplayString>
anatofuz
parents:
diff changeset
429 <DisplayString Condition="((Prefix.Value&gt;&gt;1)&amp;3) == 0">{(IdentifierInfo*)Specifier,view(cpp)na}::</DisplayString>
anatofuz
parents:
diff changeset
430 <DisplayString Condition="((Prefix.Value&gt;&gt;1)&amp;3) == 1">{(NamedDecl*)Specifier,view(cpp)na}::</DisplayString>
anatofuz
parents:
diff changeset
431 <DisplayString Condition="((Prefix.Value&gt;&gt;1)&amp;2) == 2">{(Type*)Specifier,view(cpp)na}::</DisplayString>
anatofuz
parents:
diff changeset
432 <Expand>
anatofuz
parents:
diff changeset
433 <Item Name="Kind">(NestedNameSpecifier::StoredSpecifierKind)((Prefix.Value&gt;&gt;1)&amp;3)</Item>
anatofuz
parents:
diff changeset
434 </Expand>
anatofuz
parents:
diff changeset
435 </Type>
anatofuz
parents:
diff changeset
436 <Type Name="clang::PackExpansionType">
anatofuz
parents:
diff changeset
437 <DisplayString>{Pattern}</DisplayString>
anatofuz
parents:
diff changeset
438 <Expand>
anatofuz
parents:
diff changeset
439 <Item Name="Pattern">Pattern</Item>
anatofuz
parents:
diff changeset
440 <Item Name="NumExpansions">NumExpansions</Item>
anatofuz
parents:
diff changeset
441 <ExpandedItem>*(clang::Type *)this, view(cmn)</ExpandedItem>
anatofuz
parents:
diff changeset
442 </Expand>
anatofuz
parents:
diff changeset
443 </Type>
anatofuz
parents:
diff changeset
444 <Type Name="clang::QualType">
anatofuz
parents:
diff changeset
445 <!-- When VS2013 support is deprecated, change 4 to clang::TypeAlignmentInBits (not properly recognized by VS2013) -->
anatofuz
parents:
diff changeset
446 <DisplayString IncludeView="poly">{*((clang::ExtQualsTypeCommonBase *)(((uintptr_t)Value.Value) &amp; ~(uintptr_t)((1 &lt;&lt; 4) - 1)))-&gt;BaseType,view(poly)}{*this,view(fastQuals)}</DisplayString>
anatofuz
parents:
diff changeset
447 <DisplayString IncludeView="cpp">{*((clang::ExtQualsTypeCommonBase *)(((uintptr_t)Value.Value) &amp; ~(uintptr_t)((1 &lt;&lt; 4) - 1)))-&gt;BaseType,view(cpp)}{*this,view(fastQuals)}</DisplayString>
anatofuz
parents:
diff changeset
448 <DisplayString IncludeView="left">{*((clang::ExtQualsTypeCommonBase *)(((uintptr_t)Value.Value) &amp; ~(uintptr_t)((1 &lt;&lt; 4) - 1)))-&gt;BaseType,view(left)}{*this,view(fastQuals)}</DisplayString>
anatofuz
parents:
diff changeset
449 <DisplayString IncludeView="right">{*((clang::ExtQualsTypeCommonBase *)(((uintptr_t)Value.Value) &amp; ~(uintptr_t)((1 &lt;&lt; 4) - 1)))-&gt;BaseType,view(right)}{*this,view(fastQuals)}</DisplayString>
anatofuz
parents:
diff changeset
450 <!-- For the Fast Qualifiers, it is simpler (and probably more efficient) just to list all 8 cases than create
anatofuz
parents:
diff changeset
451 views for each qualifier. TODO: Non-fast qualifiers -->
anatofuz
parents:
diff changeset
452 <DisplayString IncludeView="fastQuals" Condition="(Value.Value &amp; 15)==0"></DisplayString>
anatofuz
parents:
diff changeset
453 <DisplayString IncludeView="fastQuals" Condition="(Value.Value &amp; 15)==1">{" ",sb}const</DisplayString>
anatofuz
parents:
diff changeset
454 <DisplayString IncludeView="fastQuals" Condition="(Value.Value &amp; 15)==2">{" ",sb}restrict</DisplayString>
anatofuz
parents:
diff changeset
455 <DisplayString IncludeView="fastQuals" Condition="(Value.Value &amp; 15)==3">{" ",sb}const restrict</DisplayString>
anatofuz
parents:
diff changeset
456 <DisplayString IncludeView="fastQuals" Condition="(Value.Value &amp; 15)==4">{" ",sb}volatile</DisplayString>
anatofuz
parents:
diff changeset
457 <DisplayString IncludeView="fastQuals" Condition="(Value.Value &amp; 15)==5">{" ",sb}const volatile</DisplayString>
anatofuz
parents:
diff changeset
458 <DisplayString IncludeView="fastQuals" Condition="(Value.Value &amp; 15)==6">{" ",sb}volatile restrict</DisplayString>
anatofuz
parents:
diff changeset
459 <DisplayString IncludeView="fastQuals" Condition="(Value.Value &amp; 15)==7">{" ",sb}const volatile restrict</DisplayString>
anatofuz
parents:
diff changeset
460 <DisplayString IncludeView="fastQuals">Cannot visualize non-fast qualifiers</DisplayString>
anatofuz
parents:
diff changeset
461 <DisplayString Condition="(uintptr_t)Value.Value == 0">Null</DisplayString>
anatofuz
parents:
diff changeset
462 <DisplayString>{((clang::ExtQualsTypeCommonBase *)(((uintptr_t)Value.Value) &amp; ~(uintptr_t)((1 &lt;&lt; 4) - 1)))-&gt;BaseType,na}{*this,view(fastQuals)}</DisplayString>
anatofuz
parents:
diff changeset
463 <Expand>
anatofuz
parents:
diff changeset
464 <Item Name="Fast Quals">*this,view(fastQuals)</Item>
anatofuz
parents:
diff changeset
465 <ExpandedItem>((clang::ExtQualsTypeCommonBase *)(((uintptr_t)Value.Value) &amp; ~(uintptr_t)((1 &lt;&lt; 4) - 1)))-&gt;BaseType</ExpandedItem>
anatofuz
parents:
diff changeset
466 </Expand>
anatofuz
parents:
diff changeset
467 </Type>
anatofuz
parents:
diff changeset
468 <Type Name="clang::LocInfoType">
anatofuz
parents:
diff changeset
469 <DisplayString IncludeView="cpp">{DeclInfo,view(cpp)na}</DisplayString>
anatofuz
parents:
diff changeset
470 <DisplayString>{DeclInfo,na}</DisplayString>
anatofuz
parents:
diff changeset
471 <Expand>
anatofuz
parents:
diff changeset
472 <Item Name="DeclInfo">DeclInfo</Item>
anatofuz
parents:
diff changeset
473 <ExpandedItem>*(clang::Type *)this, view(cmn)</ExpandedItem>
anatofuz
parents:
diff changeset
474 </Expand>
anatofuz
parents:
diff changeset
475 </Type>
anatofuz
parents:
diff changeset
476 <Type Name="clang::TypeSourceInfo">
anatofuz
parents:
diff changeset
477 <DisplayString IncludeView="cpp">{Ty,view(cpp)}</DisplayString>
anatofuz
parents:
diff changeset
478 <DisplayString>{Ty}</DisplayString>
anatofuz
parents:
diff changeset
479 <Expand>
anatofuz
parents:
diff changeset
480 <ExpandedItem>Ty</ExpandedItem>
anatofuz
parents:
diff changeset
481 </Expand>
anatofuz
parents:
diff changeset
482 </Type>
anatofuz
parents:
diff changeset
483 <Type Name="clang::TypeLoc">
anatofuz
parents:
diff changeset
484 <DisplayString>{(QualType *)&amp;Ty,na}</DisplayString>
anatofuz
parents:
diff changeset
485 <Expand>
anatofuz
parents:
diff changeset
486 <Item Name="Ty">(QualType *)&amp;Ty</Item>
anatofuz
parents:
diff changeset
487 <Item Name="Data">Data</Item>
anatofuz
parents:
diff changeset
488 </Expand>
anatofuz
parents:
diff changeset
489 </Type>
anatofuz
parents:
diff changeset
490 <Type Name="clang::TypeLocBuilder">
anatofuz
parents:
diff changeset
491 <DisplayString Optional="true" Condition="LastTy.Value.Value==0">Not building anything</DisplayString>
anatofuz
parents:
diff changeset
492 <DisplayString Optional="true">Building a {LastTy}</DisplayString>
anatofuz
parents:
diff changeset
493 </Type>
anatofuz
parents:
diff changeset
494 <Type Name="clang::TemplateArgumentLoc">
anatofuz
parents:
diff changeset
495 <DisplayString IncludeView="cpp">{Argument,view(cpp)}</DisplayString>
anatofuz
parents:
diff changeset
496 <DisplayString>{Argument}</DisplayString>
anatofuz
parents:
diff changeset
497 </Type>
anatofuz
parents:
diff changeset
498 <Type Name="clang::TemplateArgument">
anatofuz
parents:
diff changeset
499 <DisplayString IncludeView="cpp" Condition="Integer.Kind == clang::TemplateArgument::ArgKind::Type">{*(clang::QualType *)&amp;TypeOrValue.V,view(cpp)}</DisplayString>
anatofuz
parents:
diff changeset
500 <DisplayString Condition="Integer.Kind == clang::TemplateArgument::ArgKind::Type">{(clang::TemplateArgument::ArgKind)TypeOrValue.Kind,en} template argument: {*(clang::QualType *)&amp;TypeOrValue.V}</DisplayString>
anatofuz
parents:
diff changeset
501 <DisplayString IncludeView="arg0" Condition="Args.NumArgs==0"></DisplayString>
anatofuz
parents:
diff changeset
502 <DisplayString IncludeView="arg0">{Args.Args[0]}{*this,view(arg1)}</DisplayString>
anatofuz
parents:
diff changeset
503 <DisplayString IncludeView="arg1" Condition="Args.NumArgs==1"></DisplayString>
anatofuz
parents:
diff changeset
504 <DisplayString IncludeView="arg1">, {Args.Args[1]}{*this,view(arg2)}</DisplayString>
anatofuz
parents:
diff changeset
505 <DisplayString IncludeView="arg2" Condition="Args.NumArgs==2"></DisplayString>
anatofuz
parents:
diff changeset
506 <DisplayString IncludeView="arg2">, {Args.Args[2]}, ...</DisplayString>
anatofuz
parents:
diff changeset
507 <DisplayString IncludeView="arg0cpp" Condition="Args.NumArgs==0"></DisplayString>
anatofuz
parents:
diff changeset
508 <DisplayString IncludeView="arg0cpp">{Args.Args[0],view(cpp)}{*this,view(arg1cpp)}</DisplayString>
anatofuz
parents:
diff changeset
509 <DisplayString IncludeView="arg1cpp" Condition="Args.NumArgs==1"></DisplayString>
anatofuz
parents:
diff changeset
510 <DisplayString IncludeView="arg1cpp">, {Args.Args[1],view(cpp)}{*this,view(arg2cpp)}</DisplayString>
anatofuz
parents:
diff changeset
511 <DisplayString IncludeView="arg2cpp" Condition="Args.NumArgs==2"></DisplayString>
anatofuz
parents:
diff changeset
512 <DisplayString IncludeView="arg2cpp">, {Args.Args[2],view(cpp)}, ...</DisplayString>
anatofuz
parents:
diff changeset
513 <DisplayString IncludeView="cpp" Condition="Integer.Kind == clang::TemplateArgument::ArgKind::Pack">{*this,view(arg0cpp)}</DisplayString>
anatofuz
parents:
diff changeset
514 <DisplayString Condition="Integer.Kind == clang::TemplateArgument::ArgKind::Pack">{*this,view(arg0)}</DisplayString>
anatofuz
parents:
diff changeset
515 <DisplayString Condition="Integer.Kind == clang::TemplateArgument::ArgKind::Expression">{(clang::Expr *)TypeOrValue.V,view(cpp)na}</DisplayString>
anatofuz
parents:
diff changeset
516 <DisplayString>{(clang::TemplateArgument::ArgKind)TypeOrValue.Kind,en}</DisplayString>
anatofuz
parents:
diff changeset
517 <Expand>
anatofuz
parents:
diff changeset
518 <Item Name="QualType" Condition="Integer.Kind == clang::TemplateArgument::ArgKind::Type">*(clang::QualType *)&amp;TypeOrValue.V</Item>
anatofuz
parents:
diff changeset
519 <Item Name="Expression" Condition="Integer.Kind == clang::TemplateArgument::ArgKind::Expression">(clang::Expr *)TypeOrValue.V</Item>
anatofuz
parents:
diff changeset
520 <ArrayItems Condition="Integer.Kind == clang::TemplateArgument::ArgKind::Pack">
anatofuz
parents:
diff changeset
521 <Size>Args.NumArgs</Size>
anatofuz
parents:
diff changeset
522 <ValuePointer>Args.Args</ValuePointer>
anatofuz
parents:
diff changeset
523 </ArrayItems>
anatofuz
parents:
diff changeset
524 <!-- TODO: Other kinds-->
anatofuz
parents:
diff changeset
525 </Expand>
anatofuz
parents:
diff changeset
526 </Type>
anatofuz
parents:
diff changeset
527 <Type Name="clang::TemplateArgumentListInfo">
anatofuz
parents:
diff changeset
528 <DisplayString IncludeView ="elt0" Condition="Arguments.Size == 0"></DisplayString>
anatofuz
parents:
diff changeset
529 <DisplayString IncludeView ="elt0">{((TemplateArgumentLoc*)Arguments.BeginX)[0],view(cpp)}{*this,view(elt1)}</DisplayString>
anatofuz
parents:
diff changeset
530 <DisplayString IncludeView ="elt1" Condition="Arguments.Size == 1"></DisplayString>
anatofuz
parents:
diff changeset
531 <DisplayString IncludeView ="elt1">, {((TemplateArgumentLoc*)Arguments.BeginX)[1],view(cpp)}{*this,view(elt2)}</DisplayString>
anatofuz
parents:
diff changeset
532 <DisplayString IncludeView ="elt2" Condition="Arguments.Size == 2"></DisplayString>
anatofuz
parents:
diff changeset
533 <DisplayString IncludeView ="elt2">, {((TemplateArgumentLoc*)Arguments.BeginX)[2],view(cpp)}{*this,view(elt3)}</DisplayString>
anatofuz
parents:
diff changeset
534 <DisplayString IncludeView ="elt3" Condition="Arguments.Size == 3"></DisplayString>
anatofuz
parents:
diff changeset
535 <DisplayString IncludeView ="elt3">, {((TemplateArgumentLoc*)Arguments.BeginX)[3],view(cpp)}{*this,view(elt4)}</DisplayString>
anatofuz
parents:
diff changeset
536 <DisplayString IncludeView ="elt4" Condition="Arguments.Size == 4"></DisplayString>
anatofuz
parents:
diff changeset
537 <DisplayString IncludeView ="elt4">, ...</DisplayString>
anatofuz
parents:
diff changeset
538 <DisplayString Condition="Arguments.Size == 0">empty</DisplayString>
anatofuz
parents:
diff changeset
539 <DisplayString Condition="Arguments.Size != 0">&lt;{*this,view(elt0)}&gt;</DisplayString>
anatofuz
parents:
diff changeset
540 <DisplayString>Uninitialized</DisplayString>
anatofuz
parents:
diff changeset
541 </Type>
anatofuz
parents:
diff changeset
542 <Type Name="clang::TemplateArgumentList">
anatofuz
parents:
diff changeset
543 <DisplayString IncludeView="arg0" Condition="NumArguments==0"></DisplayString>
anatofuz
parents:
diff changeset
544 <DisplayString IncludeView="arg0">{Arguments[0],view(cpp)}{*this,view(arg1)}</DisplayString>
anatofuz
parents:
diff changeset
545 <DisplayString IncludeView="arg1" Condition="NumArguments==1"></DisplayString>
anatofuz
parents:
diff changeset
546 <DisplayString IncludeView="arg1">, {Arguments[1],view(cpp)}{*this,view(arg2)}</DisplayString>
anatofuz
parents:
diff changeset
547 <DisplayString IncludeView="arg2" Condition="NumArguments==2"></DisplayString>
anatofuz
parents:
diff changeset
548 <DisplayString IncludeView="arg2">, {Arguments[1],view(cpp)}, ...</DisplayString>
anatofuz
parents:
diff changeset
549 <DisplayString>&lt;{*this,view(arg0)}&gt;</DisplayString>
anatofuz
parents:
diff changeset
550 <Expand>
anatofuz
parents:
diff changeset
551 <Item Name="NumArguments">NumArguments</Item>
anatofuz
parents:
diff changeset
552 <ArrayItems>
anatofuz
parents:
diff changeset
553 <Size>NumArguments</Size>
anatofuz
parents:
diff changeset
554 <ValuePointer>Arguments</ValuePointer>
anatofuz
parents:
diff changeset
555 </ArrayItems>
anatofuz
parents:
diff changeset
556 </Expand>
anatofuz
parents:
diff changeset
557 </Type>
anatofuz
parents:
diff changeset
558 <Type Name="llvm::ArrayRef&lt;clang::TemplateArgument&gt;">
anatofuz
parents:
diff changeset
559 <DisplayString IncludeView="arg0" Condition="Length==0"></DisplayString>
anatofuz
parents:
diff changeset
560 <DisplayString IncludeView="arg0">{Data[0],view(cpp)}{*this,view(arg1)}</DisplayString>
anatofuz
parents:
diff changeset
561 <DisplayString IncludeView="arg1" Condition="Length==1"></DisplayString>
anatofuz
parents:
diff changeset
562 <DisplayString IncludeView="arg1">, {Data[1],view(cpp)}{*this,view(arg2)}</DisplayString>
anatofuz
parents:
diff changeset
563 <DisplayString IncludeView="arg2" Condition="Length==2"></DisplayString>
anatofuz
parents:
diff changeset
564 <DisplayString IncludeView="arg2">, {Data[2],view(cpp)}, ...</DisplayString>
anatofuz
parents:
diff changeset
565 <DisplayString>&lt;{*this,view(arg0)}&gt;</DisplayString>
anatofuz
parents:
diff changeset
566 <Expand>
anatofuz
parents:
diff changeset
567 <Item Name="Length">Length</Item>
anatofuz
parents:
diff changeset
568 <Synthetic Name="Data">
anatofuz
parents:
diff changeset
569 <Expand>
anatofuz
parents:
diff changeset
570 <ArrayItems>
anatofuz
parents:
diff changeset
571 <Size>Length</Size>
anatofuz
parents:
diff changeset
572 <ValuePointer>Data</ValuePointer>
anatofuz
parents:
diff changeset
573 </ArrayItems>
anatofuz
parents:
diff changeset
574 </Expand>
anatofuz
parents:
diff changeset
575 </Synthetic>
anatofuz
parents:
diff changeset
576 </Expand>
anatofuz
parents:
diff changeset
577 </Type>
anatofuz
parents:
diff changeset
578 <Type Name="clang::MultiLevelTemplateArgumentList">
anatofuz
parents:
diff changeset
579 <DisplayString IncludeView="level0" Condition="(llvm::ArrayRef&lt;clang::TemplateArgument&gt; *)TemplateArgumentLists.EndX - (llvm::ArrayRef&lt;clang::TemplateArgument&gt; *)TemplateArgumentLists.BeginX==0"></DisplayString>
anatofuz
parents:
diff changeset
580 <DisplayString IncludeView="level0">{((llvm::ArrayRef&lt;clang::TemplateArgument&gt; *)TemplateArgumentLists.BeginX)[0],view(cpp)}{*this,view(level1)}</DisplayString>
anatofuz
parents:
diff changeset
581 <DisplayString IncludeView="level1" Condition="(llvm::ArrayRef&lt;clang::TemplateArgument&gt; *)TemplateArgumentLists.EndX - (llvm::ArrayRef&lt;clang::TemplateArgument&gt; *)TemplateArgumentLists.BeginX==1"></DisplayString>
anatofuz
parents:
diff changeset
582 <DisplayString IncludeView="level1">::{((llvm::ArrayRef&lt;clang::TemplateArgument&gt; *)TemplateArgumentLists.BeginX)[1],view(cpp)}{*this,view(level2)}</DisplayString>
anatofuz
parents:
diff changeset
583 <DisplayString IncludeView="level2" Condition="(llvm::ArrayRef&lt;clang::TemplateArgument&gt; *)TemplateArgumentLists.EndX - (llvm::ArrayRef&lt;clang::TemplateArgument&gt; *)TemplateArgumentLists.BeginX==2"></DisplayString>
anatofuz
parents:
diff changeset
584 <DisplayString IncludeView="level2">::{((llvm::ArrayRef&lt;clang::TemplateArgument&gt; *)TemplateArgumentLists.BeginX)[2],view(cpp)}, ...</DisplayString>
anatofuz
parents:
diff changeset
585 <DisplayString>{*this,view(level0)}</DisplayString>
anatofuz
parents:
diff changeset
586 <Expand>
anatofuz
parents:
diff changeset
587 <Item Name="TemplateList">TemplateArgumentLists</Item>
anatofuz
parents:
diff changeset
588 </Expand>
anatofuz
parents:
diff changeset
589 </Type>
anatofuz
parents:
diff changeset
590 <Type Name="clang::ParsedTemplateArgument">
anatofuz
parents:
diff changeset
591 <DisplayString Condition="Kind==clang::ParsedTemplateArgument::Type" IncludeView="cpp">{(clang::QualType *)Arg,view(cpp)na}</DisplayString>
anatofuz
parents:
diff changeset
592 <DisplayString Condition="Kind==clang::ParsedTemplateArgument::Type">Type template argument: {*(clang::QualType *)Arg}</DisplayString>
anatofuz
parents:
diff changeset
593 <DisplayString Condition="Kind==clang::ParsedTemplateArgument::NonType">Non-type template argument: {*(clang::Expr *)Arg}</DisplayString>
anatofuz
parents:
diff changeset
594 <DisplayString Condition="Kind==clang::ParsedTemplateArgument::Template">Template template argument: {*(clang::TemplateName *)Arg</DisplayString>
anatofuz
parents:
diff changeset
595 <Expand>
anatofuz
parents:
diff changeset
596 <Item Name="Kind">Kind,en</Item>
anatofuz
parents:
diff changeset
597 <Item Name="Arg" Condition="Kind==clang::ParsedTemplateArgument::Type">(clang::QualType *)Arg</Item>
anatofuz
parents:
diff changeset
598 <Item Name="Arg" Condition="Kind==clang::ParsedTemplateArgument::NonType">(clang::Expr *)Arg</Item>
anatofuz
parents:
diff changeset
599 <Item Name="Arg" Condition="Kind==clang::ParsedTemplateArgument::Template">(clang::TemplateName *)Arg</Item>
anatofuz
parents:
diff changeset
600 </Expand>
anatofuz
parents:
diff changeset
601 </Type>
anatofuz
parents:
diff changeset
602 <!-- Builtin types that have C++ keywords are manually displayed as that keyword. Otherwise, just use the enum name -->
anatofuz
parents:
diff changeset
603 <Type Name="clang::BuiltinType">
anatofuz
parents:
diff changeset
604 <DisplayString Condition="BuiltinTypeBits.Kind==clang::BuiltinType::Void">void</DisplayString>
anatofuz
parents:
diff changeset
605 <DisplayString Condition="BuiltinTypeBits.Kind==clang::BuiltinType::Bool">bool</DisplayString>
anatofuz
parents:
diff changeset
606 <DisplayString Condition="BuiltinTypeBits.Kind==clang::BuiltinType::Char_U">char</DisplayString>
anatofuz
parents:
diff changeset
607 <DisplayString Condition="BuiltinTypeBits.Kind==clang::BuiltinType::UChar">unsigned char</DisplayString>
anatofuz
parents:
diff changeset
608 <DisplayString Condition="BuiltinTypeBits.Kind==clang::BuiltinType::WChar_U">wchar_t</DisplayString>
anatofuz
parents:
diff changeset
609 <DisplayString Condition="BuiltinTypeBits.Kind==clang::BuiltinType::Char16">char16_t</DisplayString>
anatofuz
parents:
diff changeset
610 <DisplayString Condition="BuiltinTypeBits.Kind==clang::BuiltinType::Char32">char32_t</DisplayString>
anatofuz
parents:
diff changeset
611 <DisplayString Condition="BuiltinTypeBits.Kind==clang::BuiltinType::UShort">unsigned short</DisplayString>
anatofuz
parents:
diff changeset
612 <DisplayString Condition="BuiltinTypeBits.Kind==clang::BuiltinType::UInt">unsigned int</DisplayString>
anatofuz
parents:
diff changeset
613 <DisplayString Condition="BuiltinTypeBits.Kind==clang::BuiltinType::ULong">unsigned long</DisplayString>
anatofuz
parents:
diff changeset
614 <DisplayString Condition="BuiltinTypeBits.Kind==clang::BuiltinType::ULongLong">unsigned long long</DisplayString>
anatofuz
parents:
diff changeset
615 <DisplayString Condition="BuiltinTypeBits.Kind==clang::BuiltinType::UInt128">__uint128_t</DisplayString>
anatofuz
parents:
diff changeset
616 <DisplayString Condition="BuiltinTypeBits.Kind==clang::BuiltinType::Char_S">char</DisplayString>
anatofuz
parents:
diff changeset
617 <DisplayString Condition="BuiltinTypeBits.Kind==clang::BuiltinType::SChar">signed char</DisplayString>
anatofuz
parents:
diff changeset
618 <DisplayString Condition="BuiltinTypeBits.Kind==clang::BuiltinType::WChar_S">wchar_t</DisplayString>
anatofuz
parents:
diff changeset
619 <DisplayString Condition="BuiltinTypeBits.Kind==clang::BuiltinType::Short">short</DisplayString>
anatofuz
parents:
diff changeset
620 <DisplayString Condition="BuiltinTypeBits.Kind==clang::BuiltinType::Int">int</DisplayString>
anatofuz
parents:
diff changeset
621 <DisplayString Condition="BuiltinTypeBits.Kind==clang::BuiltinType::Long">long</DisplayString>
anatofuz
parents:
diff changeset
622 <DisplayString Condition="BuiltinTypeBits.Kind==clang::BuiltinType::LongLong">long long</DisplayString>
anatofuz
parents:
diff changeset
623 <DisplayString Condition="BuiltinTypeBits.Kind==clang::BuiltinType::Int128">__int128_t</DisplayString>
anatofuz
parents:
diff changeset
624 <DisplayString Condition="BuiltinTypeBits.Kind==clang::BuiltinType::Half">__fp16</DisplayString>
anatofuz
parents:
diff changeset
625 <DisplayString Condition="BuiltinTypeBits.Kind==clang::BuiltinType::Float">float</DisplayString>
anatofuz
parents:
diff changeset
626 <DisplayString Condition="BuiltinTypeBits.Kind==clang::BuiltinType::Double">double</DisplayString>
anatofuz
parents:
diff changeset
627 <DisplayString Condition="BuiltinTypeBits.Kind==clang::BuiltinType::LongDouble">long double</DisplayString>
anatofuz
parents:
diff changeset
628 <DisplayString Condition="BuiltinTypeBits.Kind==clang::BuiltinType::NullPtr">nullptr_t</DisplayString>
anatofuz
parents:
diff changeset
629 <DisplayString>{(clang::BuiltinType::Kind)BuiltinTypeBits.Kind, en}</DisplayString>
anatofuz
parents:
diff changeset
630 <Expand>
anatofuz
parents:
diff changeset
631 <Item Name="Kind">(clang::BuiltinType::Kind)BuiltinTypeBits.Kind</Item>
anatofuz
parents:
diff changeset
632 </Expand>
anatofuz
parents:
diff changeset
633 </Type>
anatofuz
parents:
diff changeset
634
anatofuz
parents:
diff changeset
635 <Type Name="clang::TemplateSpecializationType">
anatofuz
parents:
diff changeset
636 <DisplayString IncludeView="arg0" Condition="TemplateSpecializationTypeBits.NumArgs==0"></DisplayString>
anatofuz
parents:
diff changeset
637 <DisplayString IncludeView="arg0">{((clang::TemplateArgument *)(this+1))[0],view(cpp)}{*this,view(arg1)}</DisplayString>
anatofuz
parents:
diff changeset
638 <DisplayString IncludeView="arg1" Condition="TemplateSpecializationTypeBits.NumArgs==1"></DisplayString>
anatofuz
parents:
diff changeset
639 <DisplayString IncludeView="arg1">, {((clang::TemplateArgument *)(this+1))[1],view(cpp)}{*this,view(arg2)}</DisplayString>
anatofuz
parents:
diff changeset
640 <DisplayString IncludeView="arg2" Condition="TemplateSpecializationTypeBits.NumArgs==2"></DisplayString>
anatofuz
parents:
diff changeset
641 <DisplayString IncludeView="arg2">, {((clang::TemplateArgument *)(this+1))[2],view(cpp)}{*this,view(arg3)}</DisplayString>
anatofuz
parents:
diff changeset
642 <DisplayString Condition="(Template.Storage.Val.Value &amp; 3) == 0">
anatofuz
parents:
diff changeset
643 {*((clang::TemplateDecl *)(Template.Storage.Val.Value))->TemplatedDecl,view(cpp)}&lt;{*this,view(arg0)}&gt;
anatofuz
parents:
diff changeset
644 </DisplayString>
anatofuz
parents:
diff changeset
645 <DisplayString>Can't visualize this TemplateSpecializationType</DisplayString>
anatofuz
parents:
diff changeset
646 <Expand>
anatofuz
parents:
diff changeset
647 <Item Name="Template">Template.Storage</Item>
anatofuz
parents:
diff changeset
648 <ArrayItems>
anatofuz
parents:
diff changeset
649 <Size>TemplateSpecializationTypeBits.NumArgs</Size>
anatofuz
parents:
diff changeset
650 <ValuePointer>(clang::TemplateArgument *)(this+1)</ValuePointer>
anatofuz
parents:
diff changeset
651 </ArrayItems>
anatofuz
parents:
diff changeset
652 <ExpandedItem>*(clang::Type *)this, view(cmn)</ExpandedItem>
anatofuz
parents:
diff changeset
653 </Expand>
anatofuz
parents:
diff changeset
654 </Type>
anatofuz
parents:
diff changeset
655 <Type Name="clang::DeducedType">
anatofuz
parents:
diff changeset
656 <Expand>
anatofuz
parents:
diff changeset
657 <Item Name="isDeduced">(CanonicalType.Value.Value != this) || TypeBits.Dependent</Item>
anatofuz
parents:
diff changeset
658 <ExpandedItem>*(clang::Type *)this,view(cmn)</ExpandedItem>
anatofuz
parents:
diff changeset
659 </Expand>
anatofuz
parents:
diff changeset
660 </Type>
anatofuz
parents:
diff changeset
661 <Type Name="clang::DeducedTemplateSpecializationType">
anatofuz
parents:
diff changeset
662 <DisplayString Condition="(CanonicalType.Value.Value != this) || TypeBits.Dependent">{CanonicalType,view(cpp)}</DisplayString>
anatofuz
parents:
diff changeset
663 <DisplayString IncludeView="cpp">{Template,view(cpp)}</DisplayString>
anatofuz
parents:
diff changeset
664 <DisplayString>{Template}</DisplayString>
anatofuz
parents:
diff changeset
665 <Expand>
anatofuz
parents:
diff changeset
666 <Item Name="Template">Template</Item>
anatofuz
parents:
diff changeset
667 <Item Name="Deduced As" Condition="(CanonicalType.Value.Value != this) || TypeBits.Dependent">CanonicalType,view(cpp)</Item>
anatofuz
parents:
diff changeset
668 <ExpandedItem>(clang::DeducedType *)this</ExpandedItem>
anatofuz
parents:
diff changeset
669 <Item Name="Template">Template</Item>
anatofuz
parents:
diff changeset
670 </Expand>
anatofuz
parents:
diff changeset
671 </Type>
anatofuz
parents:
diff changeset
672 <Type Name="clang::ClassTemplateSpecializationDecl">
anatofuz
parents:
diff changeset
673 <DisplayString>{*(CXXRecordDecl *)this,nd}{*TemplateArgs}</DisplayString>
anatofuz
parents:
diff changeset
674 <Expand>
anatofuz
parents:
diff changeset
675 <ExpandedItem>(CXXRecordDecl *)this,nd</ExpandedItem>
anatofuz
parents:
diff changeset
676 <Item Name="TemplateArgs">TemplateArgs</Item>
anatofuz
parents:
diff changeset
677 </Expand>
anatofuz
parents:
diff changeset
678 </Type>
anatofuz
parents:
diff changeset
679 <Type Name="clang::IdentifierInfo">
anatofuz
parents:
diff changeset
680 <DisplayString Condition="Entry != 0">{((llvm::StringMapEntry&lt;clang::IdentifierInfo *&gt;*)Entry)+1,sb}</DisplayString>
anatofuz
parents:
diff changeset
681 <Expand>
anatofuz
parents:
diff changeset
682 <Item Condition="Entry != 0" Name="[Identifier]">((llvm::StringMapEntry&lt;clang::IdentifierInfo *&gt;*)Entry)+1,s</Item>
anatofuz
parents:
diff changeset
683 <Item Name="Token Kind">(clang::tok::TokenKind)TokenID</Item>
anatofuz
parents:
diff changeset
684 </Expand>
anatofuz
parents:
diff changeset
685 </Type>
anatofuz
parents:
diff changeset
686 <Type Name="clang::DeclarationName">
anatofuz
parents:
diff changeset
687 <DisplayString Condition="Ptr == 0" IncludeView="cpp"></DisplayString>
anatofuz
parents:
diff changeset
688 <DisplayString Condition="Ptr == 0">Empty</DisplayString>
anatofuz
parents:
diff changeset
689 <DisplayString Condition="(Ptr &amp; PtrMask) == StoredIdentifier" IncludeView="cpp">{*(clang::IdentifierInfo *)(Ptr &amp; ~PtrMask)}</DisplayString>
anatofuz
parents:
diff changeset
690 <DisplayString Condition="(Ptr &amp; PtrMask) == StoredIdentifier">{{Identifier ({*(clang::IdentifierInfo *)(Ptr &amp; ~PtrMask)})}}</DisplayString>
anatofuz
parents:
diff changeset
691 <DisplayString Condition="(Ptr &amp; PtrMask) == StoredObjCZeroArgSelector">{{ObjC Zero Arg Selector (*{(clang::IdentifierInfo *)(Ptr &amp; ~PtrMask)})}}</DisplayString>
anatofuz
parents:
diff changeset
692 <DisplayString Condition="(Ptr &amp; PtrMask) == StoredObjCOneArgSelector">{{ObjC One Arg Selector (*{(clang::IdentifierInfo *)(Ptr &amp; ~PtrMask)})}}</DisplayString>
anatofuz
parents:
diff changeset
693 <DisplayString Condition="(Ptr &amp; PtrMask) == StoredCXXConstructorName" IncludeView="cpp">{(clang::detail::CXXSpecialNameExtra *)(Ptr &amp; ~PtrMask),view(cpp)na}</DisplayString>
anatofuz
parents:
diff changeset
694 <DisplayString Condition="(Ptr &amp; PtrMask) == StoredCXXConstructorName">C++ Constructor {{{(clang::detail::CXXSpecialNameExtra *)(Ptr &amp; ~PtrMask),view(cpp)na}}}</DisplayString>
anatofuz
parents:
diff changeset
695 <DisplayString Condition="(Ptr &amp; PtrMask) == StoredCXXDestructorName">C++ Destructor {{*(clang::detail::CXXSpecialNameExtra *)(Ptr &amp; ~PtrMask)}}</DisplayString>
anatofuz
parents:
diff changeset
696 <DisplayString Condition="(Ptr &amp; PtrMask) == StoredCXXConversionFunctionName">C++ Conversion function {{*(clang::detail::CXXSpecialNameExtra *)(Ptr &amp; ~PtrMask)}}</DisplayString>
anatofuz
parents:
diff changeset
697 <DisplayString Condition="(Ptr &amp; PtrMask) == StoredCXXOperatorName">C++ Operator {{*(clang::detail::CXXOperatorIdName *)(Ptr &amp; ~PtrMask)}}</DisplayString>
anatofuz
parents:
diff changeset
698 <DisplayString Condition="(Ptr &amp; PtrMask) == StoredDeclarationNameExtra"
anatofuz
parents:
diff changeset
699 IncludeView="cpp">{*(clang::detail::DeclarationNameExtra *)(Ptr &amp; ~PtrMask),view(cpp)}</DisplayString>
anatofuz
parents:
diff changeset
700 <DisplayString Condition="(Ptr &amp; PtrMask) == StoredDeclarationNameExtra">{{Extra ({*(clang::detail::DeclarationNameExtra *)(Ptr &amp; ~PtrMask)})}}</DisplayString>
anatofuz
parents:
diff changeset
701 <Expand>
anatofuz
parents:
diff changeset
702 <Item Name="Kind">StoredNameKind(Ptr &amp; PtrMask),en</Item>
anatofuz
parents:
diff changeset
703 <Item Condition="(Ptr &amp; PtrMask) == StoredIdentifier" Name="[Identifier]">*(clang::IdentifierInfo *)(Ptr &amp; ~PtrMask),na</Item>
anatofuz
parents:
diff changeset
704 <Item Condition="(Ptr &amp; PtrMask) == StoredObjCZeroArgSelector" Name="[ObjC Zero Arg Selector]">*(clang::IdentifierInfo *)(Ptr &amp; ~PtrMask),na</Item>
anatofuz
parents:
diff changeset
705 <Item Condition="(Ptr &amp; PtrMask) == StoredObjCOneArgSelector" Name="[ObjC One Arg Selector]">*(clang::IdentifierInfo *)(Ptr &amp; ~PtrMask),na</Item>
anatofuz
parents:
diff changeset
706 <Item Condition="(Ptr &amp; PtrMask) == StoredCXXConstructorName" Name="[C++ Constructor]">*(clang::detail::CXXSpecialNameExtra *)(Ptr &amp; ~PtrMask),na</Item>
anatofuz
parents:
diff changeset
707 <Item Condition="(Ptr &amp; PtrMask) == StoredCXXDestructorName" Name="[C++ Destructor]">*(clang::detail::CXXSpecialNameExtra *)(Ptr &amp; ~PtrMask),na</Item>
anatofuz
parents:
diff changeset
708 <Item Condition="(Ptr &amp; PtrMask) == StoredCXXConversionFunctionName" Name="[C++ Conversion function]">*(clang::detail::CXXSpecialNameExtra *)(Ptr &amp; ~PtrMask),na</Item>
anatofuz
parents:
diff changeset
709 <Item Condition="(Ptr &amp; PtrMask) == StoredCXXOperatorName" Name="[C++ Operator]">*(clang::detail::CXXOperatorIdName *)(Ptr &amp; ~PtrMask),na</Item>
anatofuz
parents:
diff changeset
710 <Item Condition="(Ptr &amp; PtrMask) == StoredDeclarationNameExtra" Name="[Extra]">(clang::detail::DeclarationNameExtra *)(Ptr &amp; ~PtrMask),na</Item>
anatofuz
parents:
diff changeset
711 </Expand>
anatofuz
parents:
diff changeset
712 </Type>
anatofuz
parents:
diff changeset
713 <Type Name="clang::detail::DeclarationNameExtra">
anatofuz
parents:
diff changeset
714 <DisplayString Condition="ExtraKindOrNumArgs == CXXDeductionGuideName" IncludeView="cpp">
anatofuz
parents:
diff changeset
715 {(CXXDeductionGuideNameExtra *)this,view(cpp)nand}
anatofuz
parents:
diff changeset
716 </DisplayString>
anatofuz
parents:
diff changeset
717 <DisplayString Condition="ExtraKindOrNumArgs == CXXDeductionGuideName">
anatofuz
parents:
diff changeset
718 {(CXXDeductionGuideNameExtra *)this,nand}
anatofuz
parents:
diff changeset
719 </DisplayString>
anatofuz
parents:
diff changeset
720 <DisplayString Condition="ExtraKindOrNumArgs == CXXLiteralOperatorName">C++ Literal operator</DisplayString>
anatofuz
parents:
diff changeset
721 <DisplayString Condition="ExtraKindOrNumArgs == CXXUsingDirective">C++ Using directive</DisplayString>
anatofuz
parents:
diff changeset
722 <DisplayString>{(clang::detail::DeclarationNameExtra::ExtraKind)ExtraKindOrNumArgs,en}{" ",sb}{*this,view(cpp)}</DisplayString>
anatofuz
parents:
diff changeset
723 <Expand>
anatofuz
parents:
diff changeset
724 <ExpandedItem Condition="ExtraKindOrNumArgs == CXXDeductionGuideName">(CXXDeductionGuideNameExtra *)this</ExpandedItem>
anatofuz
parents:
diff changeset
725 <Item Name="ExtraKindOrNumArgs" Condition="ExtraKindOrNumArgs != CXXDeductionGuideName">ExtraKindOrNumArgs</Item>
anatofuz
parents:
diff changeset
726 </Expand>
anatofuz
parents:
diff changeset
727 </Type>
anatofuz
parents:
diff changeset
728 <Type Name="clang::detail::CXXDeductionGuideNameExtra">
anatofuz
parents:
diff changeset
729 <DisplayString IncludeView="cpp">{Template->TemplatedDecl,view(cpp)}</DisplayString>
anatofuz
parents:
diff changeset
730 <DisplayString>C++ Deduction guide for {Template->TemplatedDecl,view(cpp)na}</DisplayString>
anatofuz
parents:
diff changeset
731 </Type>
anatofuz
parents:
diff changeset
732 <Type Name="clang::detail::CXXSpecialNameExtra">
anatofuz
parents:
diff changeset
733 <DisplayString IncludeView="cpp">{Type,view(cpp)}</DisplayString>
anatofuz
parents:
diff changeset
734 <DisplayString>{Type}</DisplayString>
anatofuz
parents:
diff changeset
735 </Type>
anatofuz
parents:
diff changeset
736 <Type Name="clang::DeclarationNameInfo">
anatofuz
parents:
diff changeset
737 <DisplayString>{Name}</DisplayString>
anatofuz
parents:
diff changeset
738 </Type>
anatofuz
parents:
diff changeset
739 <Type Name="clang::TemplateIdAnnotation">
anatofuz
parents:
diff changeset
740 <DisplayString IncludeView="arg0" Condition="NumArgs==0"></DisplayString>
anatofuz
parents:
diff changeset
741 <DisplayString IncludeView="arg0">{(ParsedTemplateArgument *)(this+1),view(cpp)na}{this,view(arg1)na}</DisplayString>
anatofuz
parents:
diff changeset
742 <DisplayString IncludeView="arg1" Condition="NumArgs==1"></DisplayString>
anatofuz
parents:
diff changeset
743 <DisplayString IncludeView="arg1">, {((ParsedTemplateArgument *)(this+1))+1,view(cpp)na}{this,view(arg2)na}</DisplayString>
anatofuz
parents:
diff changeset
744 <DisplayString IncludeView="arg2" Condition="NumArgs==2"></DisplayString>
anatofuz
parents:
diff changeset
745 <DisplayString IncludeView="arg1">, ...</DisplayString>
anatofuz
parents:
diff changeset
746 <DisplayString>{Name,na}&lt;{this,view(arg0)na}&gt;</DisplayString>
anatofuz
parents:
diff changeset
747 <Expand>
anatofuz
parents:
diff changeset
748 <Item Name="Name">Name</Item>
anatofuz
parents:
diff changeset
749 <Synthetic Name="Arguments">
anatofuz
parents:
diff changeset
750 <DisplayString>{this,view(arg0)na}</DisplayString>
anatofuz
parents:
diff changeset
751 <Expand>
anatofuz
parents:
diff changeset
752 <ArrayItems>
anatofuz
parents:
diff changeset
753 <Size>NumArgs</Size>
anatofuz
parents:
diff changeset
754 <ValuePointer>(ParsedTemplateArgument *)(this+1)</ValuePointer>
anatofuz
parents:
diff changeset
755 </ArrayItems>
anatofuz
parents:
diff changeset
756 </Expand>
anatofuz
parents:
diff changeset
757 </Synthetic>
anatofuz
parents:
diff changeset
758 <Item Name="Operator">Operator</Item>
anatofuz
parents:
diff changeset
759 </Expand>
anatofuz
parents:
diff changeset
760 </Type>
anatofuz
parents:
diff changeset
761 <Type Name="clang::Token">
anatofuz
parents:
diff changeset
762 <DisplayString Condition="Kind == clang::tok::annot_template_id">{{annot_template_id ({(clang::TemplateIdAnnotation *)(PtrData),na})}}</DisplayString>
anatofuz
parents:
diff changeset
763 <DisplayString Condition="Kind == clang::tok::identifier">{{Identifier ({(clang::IdentifierInfo *)(PtrData),na})}}</DisplayString>
anatofuz
parents:
diff changeset
764 <DisplayString>{(clang::tok::TokenKind)Kind,en}</DisplayString>
anatofuz
parents:
diff changeset
765 </Type>
anatofuz
parents:
diff changeset
766 <Type Name="clang::Lexer">
anatofuz
parents:
diff changeset
767 <DisplayString>{BufferPtr,nasb}</DisplayString>
anatofuz
parents:
diff changeset
768 </Type>
anatofuz
parents:
diff changeset
769 <Type Name="clang::Preprocessor::IncludeStackInfo">
anatofuz
parents:
diff changeset
770 <DisplayString Condition="TheLexer._Mypair._Myval2 != 0">{TheLexer._Mypair._Myval2,na}</DisplayString>
anatofuz
parents:
diff changeset
771 <DisplayString Condition="TheTokenLexer._Mypair._Myval2 != 0">Expanding Macro: {TheTokenLexer._Mypair._Myval2,na}</DisplayString>
anatofuz
parents:
diff changeset
772 <DisplayString></DisplayString>
anatofuz
parents:
diff changeset
773 </Type>
anatofuz
parents:
diff changeset
774 <Type Name="clang::Preprocessor">
anatofuz
parents:
diff changeset
775 <DisplayString IncludeView="cached" Condition="CachedLexPos &lt; CachedTokens.Size">
anatofuz
parents:
diff changeset
776 [{(Token *)(CachedTokens.BeginX) + CachedLexPos,na}] {IncludeMacroStack._Mypair._Myval2._Mylast - 1,na}
anatofuz
parents:
diff changeset
777 </DisplayString>
anatofuz
parents:
diff changeset
778 <DisplayString IncludeView="cached"> {IncludeMacroStack._Mypair._Myval2._Mylast - 1,na}</DisplayString>
anatofuz
parents:
diff changeset
779 <DisplayString Condition="CurLexer._Mypair._Myval2 != 0">{CurLexer._Mypair._Myval2,na}</DisplayString>
anatofuz
parents:
diff changeset
780 <DisplayString Condition="CurTokenLexer._Mypair._Myval2 != 0">Expanding Macro: {CurTokenLexer._Mypair._Myval2,na}</DisplayString>
anatofuz
parents:
diff changeset
781 <!-- Can't use CurLexerKind because natvis sees the type rather than the variable -->
anatofuz
parents:
diff changeset
782 <DisplayString Condition="IncludeMacroStack._Mypair._Myval2._Mylast - IncludeMacroStack._Mypair._Myval2._Myfirst">
anatofuz
parents:
diff changeset
783 {this,view(cached)}
anatofuz
parents:
diff changeset
784 </DisplayString>
anatofuz
parents:
diff changeset
785 <DisplayString>CLK_LexAfterModuleImport</DisplayString>
anatofuz
parents:
diff changeset
786 </Type>
anatofuz
parents:
diff changeset
787 <Type Name="clang::Parser">
anatofuz
parents:
diff changeset
788 <DisplayString>[{Tok}] {PP,na}</DisplayString>
anatofuz
parents:
diff changeset
789 </Type>
anatofuz
parents:
diff changeset
790 <Type Name="clang::LambdaIntroducer::LambdaCapture">
anatofuz
parents:
diff changeset
791 <DisplayString Condition="Kind == LCK_This">this</DisplayString>
anatofuz
parents:
diff changeset
792 <DisplayString Condition="Kind == LCK_StarThis">*this</DisplayString>
anatofuz
parents:
diff changeset
793 <DisplayString Condition="Kind == LCK_ByCopy">{Id}</DisplayString>
anatofuz
parents:
diff changeset
794 <DisplayString Condition="Kind == LCK_ByRef">&amp;{Id}</DisplayString>
anatofuz
parents:
diff changeset
795 <DisplayString>No visualizer for {Kind}</DisplayString>
anatofuz
parents:
diff changeset
796 </Type>
anatofuz
parents:
diff changeset
797 <Type Name="clang::LambdaIntroducer">
anatofuz
parents:
diff changeset
798 <DisplayString IncludeView="default" Condition="Default==LCD_None"></DisplayString>
anatofuz
parents:
diff changeset
799 <DisplayString IncludeView="default" Condition="Default==LCD_ByCopy">=,</DisplayString>
anatofuz
parents:
diff changeset
800 <DisplayString IncludeView="default" Condition="Default==LCD_ByRef">&amp;,</DisplayString>
anatofuz
parents:
diff changeset
801 <DisplayString IncludeView="capture0" Condition="Captures.Size==0"></DisplayString>
anatofuz
parents:
diff changeset
802 <DisplayString IncludeView="capture0">{(LambdaCapture *)(Captures.BeginX),na}{this,view(capture1)na}</DisplayString>
anatofuz
parents:
diff changeset
803 <DisplayString IncludeView="capture1" Condition="Captures.Size==1"></DisplayString>
anatofuz
parents:
diff changeset
804 <DisplayString IncludeView="capture1">,{(LambdaCapture *)(Captures.BeginX)+1,na}{this,view(capture2)na}</DisplayString>
anatofuz
parents:
diff changeset
805 <DisplayString IncludeView="capture2" Condition="Captures.Size==2"></DisplayString>
anatofuz
parents:
diff changeset
806 <DisplayString IncludeView="capture2">,{(LambdaCapture *)(Captures.BeginX)+2,na}{this,view(capture3)na}</DisplayString>
anatofuz
parents:
diff changeset
807 <DisplayString IncludeView="capture3" Condition="Captures.Size==3"></DisplayString>
anatofuz
parents:
diff changeset
808 <DisplayString IncludeView="capture3">,...</DisplayString>
anatofuz
parents:
diff changeset
809 <DisplayString>[{this,view(default)na}{this,view(capture0)na}]</DisplayString>
anatofuz
parents:
diff changeset
810 </Type>
anatofuz
parents:
diff changeset
811 <Type Name="clang::DeclSpec">
anatofuz
parents:
diff changeset
812 <DisplayString IncludeView="extra" Condition="TypeSpecType == TST_typename || TypeSpecType == TST_typeofType || TypeSpecType == TST_underlyingType || TypeSpecType == TST_atomic">
anatofuz
parents:
diff changeset
813 , [{TypeRep}]
anatofuz
parents:
diff changeset
814 </DisplayString>
anatofuz
parents:
diff changeset
815 <DisplayString IncludeView="extra" Condition="TypeSpecType == TST_typeofExpr || TypeSpecType == TST_decltype">
anatofuz
parents:
diff changeset
816 , [{ExprRep}]
anatofuz
parents:
diff changeset
817 </DisplayString>
anatofuz
parents:
diff changeset
818 <DisplayString IncludeView="extra" Condition="TypeSpecType == TST_enum || TypeSpecType == TST_struct || TypeSpecType == TST_interface || TypeSpecType == TST_union || TypeSpecType == TST_class">
anatofuz
parents:
diff changeset
819 , [{DeclRep}]
anatofuz
parents:
diff changeset
820 </DisplayString>
anatofuz
parents:
diff changeset
821 <DisplayString IncludeView="extra"></DisplayString>
anatofuz
parents:
diff changeset
822 <DisplayString>[{(clang::DeclSpec::SCS)StorageClassSpec,en}], [{(clang::TypeSpecifierType)TypeSpecType,en}]{this,view(extra)na}</DisplayString>
anatofuz
parents:
diff changeset
823 <Expand>
anatofuz
parents:
diff changeset
824 <Item Name="StorageClassSpec">(clang::DeclSpec::SCS)StorageClassSpec</Item>
anatofuz
parents:
diff changeset
825 <Item Name="TypeSpecType">(clang::TypeSpecifierType)TypeSpecType</Item>
anatofuz
parents:
diff changeset
826 <Item Name="TypeRep" Condition="TypeSpecType == TST_typename || TypeSpecType == TST_typeofType || TypeSpecType == TST_underlyingType || TypeSpecType == TST_atomic">
anatofuz
parents:
diff changeset
827 TypeRep
anatofuz
parents:
diff changeset
828 </Item>
anatofuz
parents:
diff changeset
829 <Item Name="ExprRep" Condition="TypeSpecType == TST_typeofExpr || TypeSpecType == TST_decltype">
anatofuz
parents:
diff changeset
830 ExprRep
anatofuz
parents:
diff changeset
831 </Item>
anatofuz
parents:
diff changeset
832 <Item Name="DeclRep" Condition="TypeSpecType == TST_enum || TypeSpecType == TST_struct || TypeSpecType == TST_interface || TypeSpecType == TST_union || TypeSpecType == TST_class">
anatofuz
parents:
diff changeset
833 DeclRep
anatofuz
parents:
diff changeset
834 </Item>
anatofuz
parents:
diff changeset
835
anatofuz
parents:
diff changeset
836 </Expand>
anatofuz
parents:
diff changeset
837 </Type>
anatofuz
parents:
diff changeset
838 <Type Name="clang::PragmaHandler">
anatofuz
parents:
diff changeset
839 <DisplayString>{Name,s}</DisplayString>
anatofuz
parents:
diff changeset
840 </Type>
anatofuz
parents:
diff changeset
841 <Type Name="clang::FileEntry">
anatofuz
parents:
diff changeset
842 <DisplayString>{Name,s}</DisplayString>
anatofuz
parents:
diff changeset
843 </Type>
anatofuz
parents:
diff changeset
844 <Type Name="clang::DirectoryEntry">
anatofuz
parents:
diff changeset
845 <DisplayString>{Name,s}</DisplayString>
anatofuz
parents:
diff changeset
846 </Type>
anatofuz
parents:
diff changeset
847 <Type Name="clang::VarDecl::VarDeclBitfields">
anatofuz
parents:
diff changeset
848 <Expand>
anatofuz
parents:
diff changeset
849 <Item Name="StorageClass">(clang::StorageClass)SClass</Item>
anatofuz
parents:
diff changeset
850 <Item Name="ThreadStorageClass">(clang::ThreadStorageClassSpecifier)TSCSpec</Item>
anatofuz
parents:
diff changeset
851 <Item Name="InitStyle">(clang::VarDecl::InitializationStyle)InitStyle</Item>
anatofuz
parents:
diff changeset
852 </Expand>
anatofuz
parents:
diff changeset
853 </Type>
anatofuz
parents:
diff changeset
854 <Type Name="clang::DeclaratorDecl">
anatofuz
parents:
diff changeset
855 <DisplayString>{DeclType,view(left)} {Name,view(cpp)}{DeclType,view(right)}</DisplayString>
anatofuz
parents:
diff changeset
856 <Expand>
anatofuz
parents:
diff changeset
857 <Item Name="Name">Name</Item>
anatofuz
parents:
diff changeset
858 <Item Name="DeclType">DeclType</Item>
anatofuz
parents:
diff changeset
859 </Expand>
anatofuz
parents:
diff changeset
860 </Type>
anatofuz
parents:
diff changeset
861 <Type Name="clang::VarDecl">
anatofuz
parents:
diff changeset
862 <DisplayString>{(DeclaratorDecl*)this,nand}</DisplayString>
anatofuz
parents:
diff changeset
863 <Expand>
anatofuz
parents:
diff changeset
864 <ExpandedItem>(DeclaratorDecl*)this,nd</ExpandedItem>
anatofuz
parents:
diff changeset
865 <Item Name="Init">Init</Item>
anatofuz
parents:
diff changeset
866 <Item Name="VarDeclBits">VarDeclBits</Item>
anatofuz
parents:
diff changeset
867 </Expand>
anatofuz
parents:
diff changeset
868 </Type>
anatofuz
parents:
diff changeset
869 <Type Name="clang::ParmVarDecl">
anatofuz
parents:
diff changeset
870 <DisplayString>{*(VarDecl*)this,nd}</DisplayString>
anatofuz
parents:
diff changeset
871 <Expand>
anatofuz
parents:
diff changeset
872 <Item Name="ParmVarDeclBits">ParmVarDeclBits</Item>
anatofuz
parents:
diff changeset
873 <ExpandedItem>*(VarDecl*)this,nd</ExpandedItem>
anatofuz
parents:
diff changeset
874 </Expand>
anatofuz
parents:
diff changeset
875 </Type>
anatofuz
parents:
diff changeset
876 <Type Name="clang::ExplicitSpecifier">
anatofuz
parents:
diff changeset
877 <DisplayString Condition="((ExplicitSpec.Value&gt;1) &amp; 3) == ExplicitSpecKind::ResolvedTrue" IncludeView="cpp">{"explicit ",sb}</DisplayString>
anatofuz
parents:
diff changeset
878 <DisplayString Condition="((ExplicitSpec.Value&gt;1) &amp; 3) == ExplicitSpecKind::ResolvedFalse" IncludeView="cpp"></DisplayString>
anatofuz
parents:
diff changeset
879 <DisplayString Condition="((ExplicitSpec.Value&gt;1) &amp; 3) == ExplicitSpecKind::Unresolved" IncludeView="cpp">explicit({ExplicitSpec,view(ptr)na})</DisplayString>
anatofuz
parents:
diff changeset
880 <DisplayString Condition="(ExplicitSpec.Value&amp;~7) == 0">{ExplicitSpec,view(int)en}</DisplayString>
anatofuz
parents:
diff changeset
881 <DisplayString>{ExplicitSpec,view(int)en} : {ExplicitSpec,view(ptr)na}</DisplayString>
anatofuz
parents:
diff changeset
882 </Type>
anatofuz
parents:
diff changeset
883 <Type Name="clang::CXXDeductionGuideDecl">
anatofuz
parents:
diff changeset
884 <DisplayString>{ExplicitSpec,view(cpp)}{Name,view(cpp)nd}({(FunctionDecl*)this,view(parm0)nand}) -&gt; {((clang::FunctionProtoType *)((clang::ExtQualsTypeCommonBase *)(((uintptr_t)DeclType.Value.Value) &amp; ~15))-&gt;BaseType)->ResultType,view(cpp)}</DisplayString>
anatofuz
parents:
diff changeset
885 <Expand>
anatofuz
parents:
diff changeset
886 <Item Name="ExplicitSpec">ExplicitSpec</Item>
anatofuz
parents:
diff changeset
887 <Item Name="IsCopyDeductionCandidate">(bool)FunctionDeclBits.IsCopyDeductionCandidate</Item>
anatofuz
parents:
diff changeset
888 <ExpandedItem>(FunctionDecl*)this,nd</ExpandedItem>
anatofuz
parents:
diff changeset
889 </Expand>
anatofuz
parents:
diff changeset
890 </Type>
anatofuz
parents:
diff changeset
891 <Type Name="clang::FunctionDecl">
anatofuz
parents:
diff changeset
892 <DisplayString IncludeView="retType">{((clang::FunctionProtoType *)((clang::ExtQualsTypeCommonBase *)(((uintptr_t)DeclType.Value.Value) &amp; ~15))-&gt;BaseType)->ResultType,view(cpp)}</DisplayString>
anatofuz
parents:
diff changeset
893 <DisplayString IncludeView="parm0" Condition="0 == ((clang::FunctionProtoType *)((clang::ExtQualsTypeCommonBase *)(((uintptr_t)DeclType.Value.Value) &amp; ~15))-&gt;BaseType)-&gt;FunctionTypeBits.NumParams"></DisplayString>
anatofuz
parents:
diff changeset
894 <DisplayString IncludeView="parm0">{ParamInfo[0],na}{*this,view(parm1)nd}</DisplayString>
anatofuz
parents:
diff changeset
895 <DisplayString IncludeView="parm1" Condition="1 == ((clang::FunctionProtoType *)((clang::ExtQualsTypeCommonBase *)(((uintptr_t)DeclType.Value.Value) &amp; ~15))-&gt;BaseType)-&gt;FunctionTypeBits.NumParams"></DisplayString>
anatofuz
parents:
diff changeset
896 <DisplayString IncludeView="parm1">, {ParamInfo[1],na}{*this,view(parm2)nd}</DisplayString>
anatofuz
parents:
diff changeset
897 <DisplayString IncludeView="parm2" Condition="2 == ((clang::FunctionProtoType *)((clang::ExtQualsTypeCommonBase *)(((uintptr_t)DeclType.Value.Value) &amp; ~15))-&gt;BaseType)-&gt;FunctionTypeBits.NumParams"></DisplayString>
anatofuz
parents:
diff changeset
898 <DisplayString IncludeView="parm2">, {ParamInfo[2],na}{*this,view(parm3)nd}</DisplayString>
anatofuz
parents:
diff changeset
899 <DisplayString IncludeView="parm3" Condition="3 == ((clang::FunctionProtoType *)((clang::ExtQualsTypeCommonBase *)(((uintptr_t)DeclType.Value.Value) &amp; ~15))-&gt;BaseType)-&gt;FunctionTypeBits.NumParams"></DisplayString>
anatofuz
parents:
diff changeset
900 <DisplayString IncludeView="parm3">, {ParamInfo[3],na}{*this,view(parm4)nd}</DisplayString>
anatofuz
parents:
diff changeset
901 <DisplayString IncludeView="parm4" Condition="4 == ((clang::FunctionProtoType *)((clang::ExtQualsTypeCommonBase *)(((uintptr_t)DeclType.Value.Value) &amp; ~15))-&gt;BaseType)-&gt;FunctionTypeBits.NumParams"></DisplayString>
anatofuz
parents:
diff changeset
902 <DisplayString IncludeView="parm4">, {ParamInfo[4],na}{*this,view(parm5)nd}</DisplayString>
anatofuz
parents:
diff changeset
903 <DisplayString IncludeView="parm5" Condition="5 == ((clang::FunctionProtoType *)((clang::ExtQualsTypeCommonBase *)(((uintptr_t)DeclType.Value.Value) &amp; ~15))-&gt;BaseType)-&gt;FunctionTypeBits.NumParams"></DisplayString>
anatofuz
parents:
diff changeset
904 <DisplayString IncludeView="parm5">, /* expand for more params */</DisplayString>
anatofuz
parents:
diff changeset
905 <DisplayString Condition="((clang::FunctionProtoType *)((clang::ExtQualsTypeCommonBase *)(((uintptr_t)DeclType.Value.Value) &amp; ~15))-&gt;BaseType)-&gt;FunctionTypeBits.HasTrailingReturn">
anatofuz
parents:
diff changeset
906 auto {Name,view(cpp)nd}({*this,view(parm0)nd}) -&gt; {((clang::FunctionProtoType *)((clang::ExtQualsTypeCommonBase *)(((uintptr_t)DeclType.Value.Value) &amp; ~15))-&gt;BaseType)->ResultType,view(cpp)}
anatofuz
parents:
diff changeset
907 </DisplayString>
anatofuz
parents:
diff changeset
908 <DisplayString>{this,view(retType)nand} {Name,view(cpp)nd}({*this,view(parm0)nd})</DisplayString>
anatofuz
parents:
diff changeset
909 <Expand>
anatofuz
parents:
diff changeset
910 <ExpandedItem>(clang::DeclaratorDecl *)this,nd</ExpandedItem>
anatofuz
parents:
diff changeset
911 <Item Name="ReturnType">((clang::FunctionProtoType *)((clang::ExtQualsTypeCommonBase *)(((uintptr_t)DeclType.Value.Value) &amp; ~15))-&gt;BaseType)->ResultType</Item>
anatofuz
parents:
diff changeset
912 <Synthetic Name="Parameter Types">
anatofuz
parents:
diff changeset
913 <DisplayString>{*this,view(parm0)nd}</DisplayString>
anatofuz
parents:
diff changeset
914 <Expand>
anatofuz
parents:
diff changeset
915 <ArrayItems>
anatofuz
parents:
diff changeset
916 <Size>((clang::FunctionProtoType *)((clang::ExtQualsTypeCommonBase *)(((uintptr_t)DeclType.Value.Value) &amp; ~15))-&gt;BaseType)-&gt;FunctionTypeBits.NumParams</Size>
anatofuz
parents:
diff changeset
917 <ValuePointer>ParamInfo</ValuePointer>
anatofuz
parents:
diff changeset
918 </ArrayItems>
anatofuz
parents:
diff changeset
919 </Expand>
anatofuz
parents:
diff changeset
920 </Synthetic>
anatofuz
parents:
diff changeset
921 <Item Name="TemplateOrSpecialization">TemplateOrSpecialization</Item>
anatofuz
parents:
diff changeset
922 </Expand>
anatofuz
parents:
diff changeset
923 </Type>
anatofuz
parents:
diff changeset
924 <Type Name="clang::OpaquePtr&lt;*&gt;">
anatofuz
parents:
diff changeset
925 <DisplayString>{*($T1*)&amp;Ptr}</DisplayString>
anatofuz
parents:
diff changeset
926 <Expand>
anatofuz
parents:
diff changeset
927 <ExpandedItem>($T1*)&amp;Ptr</ExpandedItem>
anatofuz
parents:
diff changeset
928 </Expand>
anatofuz
parents:
diff changeset
929 </Type>
anatofuz
parents:
diff changeset
930 <Type Name="clang::UnionOpaquePtr&lt;*&gt;">
anatofuz
parents:
diff changeset
931 <DisplayString>{($T1 *)Ptr}</DisplayString>
anatofuz
parents:
diff changeset
932 <Expand>
anatofuz
parents:
diff changeset
933 <ExpandedItem>($T1 *)Ptr</ExpandedItem>
anatofuz
parents:
diff changeset
934 </Expand>
anatofuz
parents:
diff changeset
935 </Type>
anatofuz
parents:
diff changeset
936 <Type Name="clang::TemplateParameterList">
anatofuz
parents:
diff changeset
937 <DisplayString IncludeView="parm0" Condition="NumParams==0"></DisplayString>
anatofuz
parents:
diff changeset
938 <DisplayString IncludeView="parm0">{*((NamedDecl **)(this+1))[0],view(cpp)}{*this,view(parm1)}</DisplayString>
anatofuz
parents:
diff changeset
939 <DisplayString IncludeView="parm1" Condition="NumParams==1"></DisplayString>
anatofuz
parents:
diff changeset
940 <DisplayString IncludeView="parm1">, {*((NamedDecl **)(this+1))[1],view(cpp)}{*this,view(parm2)}</DisplayString>
anatofuz
parents:
diff changeset
941 <DisplayString IncludeView="parm2" Condition="NumParams==2"></DisplayString>
anatofuz
parents:
diff changeset
942 <DisplayString IncludeView="parm2">, {*((NamedDecl **)(this+1))[2],view(cpp)}{*this,view(parm3)}</DisplayString>
anatofuz
parents:
diff changeset
943 <DisplayString IncludeView="parm3" Condition="NumParams==3"></DisplayString>
anatofuz
parents:
diff changeset
944 <DisplayString IncludeView="parm3">, {*((NamedDecl **)(this+1))[3],view(cpp)}{*this,view(parm4)}</DisplayString>
anatofuz
parents:
diff changeset
945 <DisplayString IncludeView="parm4" Condition="NumParams==4"></DisplayString>
anatofuz
parents:
diff changeset
946 <DisplayString IncludeView="parm4">, {*((NamedDecl **)(this+1))[4],view(cpp)}{*this,view(parm5)}</DisplayString>
anatofuz
parents:
diff changeset
947 <DisplayString IncludeView="parm5" Condition="NumParams==5"></DisplayString>
anatofuz
parents:
diff changeset
948 <DisplayString IncludeView="parm5">, /* Expand for more params */</DisplayString>
anatofuz
parents:
diff changeset
949 <DisplayString>&lt;{*this,view(parm0)}&gt;</DisplayString>
anatofuz
parents:
diff changeset
950 <Expand>
anatofuz
parents:
diff changeset
951 <ArrayItems>
anatofuz
parents:
diff changeset
952 <Size>NumParams</Size>
anatofuz
parents:
diff changeset
953 <ValuePointer>(NamedDecl **)(this+1)</ValuePointer>
anatofuz
parents:
diff changeset
954 </ArrayItems>
anatofuz
parents:
diff changeset
955 </Expand>
anatofuz
parents:
diff changeset
956 </Type>
anatofuz
parents:
diff changeset
957 <Type Name="clang::Stmt">
anatofuz
parents:
diff changeset
958 <DisplayString>{(clang::Stmt::StmtClass)StmtBits.sClass,en}</DisplayString>
anatofuz
parents:
diff changeset
959 <Expand>
anatofuz
parents:
diff changeset
960 <Item Name="Class">(clang::Stmt::StmtClass)StmtBits.sClass,en</Item>
anatofuz
parents:
diff changeset
961 </Expand>
anatofuz
parents:
diff changeset
962 </Type>
anatofuz
parents:
diff changeset
963 <Type Name="clang::Expr">
anatofuz
parents:
diff changeset
964 <DisplayString>Expression of class {(clang::Stmt::StmtClass)StmtBits.sClass,en} and type {TR,view(cpp)}</DisplayString>
anatofuz
parents:
diff changeset
965 </Type>
anatofuz
parents:
diff changeset
966 <Type Name="clang::DeclAccessPair">
anatofuz
parents:
diff changeset
967 <DisplayString IncludeView="access" Condition="(Ptr&amp;Mask) == clang::AS_public">public</DisplayString>
anatofuz
parents:
diff changeset
968 <DisplayString IncludeView="access" Condition="(Ptr&amp;Mask) == clang::AS_protected">protected</DisplayString>
anatofuz
parents:
diff changeset
969 <DisplayString IncludeView="access" Condition="(Ptr&amp;Mask) == clang::AS_private">private</DisplayString>
anatofuz
parents:
diff changeset
970 <DisplayString IncludeView="access" Condition="(Ptr&amp;Mask) == clang::AS_none"></DisplayString>
anatofuz
parents:
diff changeset
971 <DisplayString IncludeView="decl">{*(clang::NamedDecl *)(Ptr&amp;~Mask)}</DisplayString>
anatofuz
parents:
diff changeset
972 <DisplayString>{*this,view(access)} {*this,view(decl)}</DisplayString>
anatofuz
parents:
diff changeset
973 <Expand>
anatofuz
parents:
diff changeset
974 <Item Name="access">(clang::AccessSpecifier)(Ptr&amp;Mask),en</Item>
anatofuz
parents:
diff changeset
975 <Item Name="decl">*(clang::NamedDecl *)(Ptr&amp;~Mask)</Item>
anatofuz
parents:
diff changeset
976 </Expand>
anatofuz
parents:
diff changeset
977 </Type>
anatofuz
parents:
diff changeset
978 <Type Name="clang::UnqualifiedId">
anatofuz
parents:
diff changeset
979 <DisplayString Condition="Kind==UnqualifiedIdKind::IK_Identifier">[IK_Identifier] {*Identifier}</DisplayString>
anatofuz
parents:
diff changeset
980 <DisplayString Condition="Kind==UnqualifiedIdKind::IK_OperatorFunctionId">[IK_OperatorFunctionId] {OperatorFunctionId}</DisplayString>
anatofuz
parents:
diff changeset
981 <DisplayString Condition="Kind==UnqualifiedIdKind::IK_ConversionFunctionId">[IK_ConversionFunctionId] {ConversionFunctionId}</DisplayString>
anatofuz
parents:
diff changeset
982 <DisplayString Condition="Kind==UnqualifiedIdKind::IK_ConstructorName">[IK_ConstructorName] {ConstructorName}</DisplayString>
anatofuz
parents:
diff changeset
983 <DisplayString Condition="Kind==UnqualifiedIdKind::IK_DestructorName">[IK_DestructorName] {DestructorName}</DisplayString>
anatofuz
parents:
diff changeset
984 <DisplayString Condition="Kind==UnqualifiedIdKind::IK_DeductionGuideName">[IK_DeductionGuideName] {TemplateName}</DisplayString>
anatofuz
parents:
diff changeset
985 <DisplayString Condition="Kind==UnqualifiedIdKind::IK_TemplateId">[IK_TemplateId] {TemplateId}</DisplayString>
anatofuz
parents:
diff changeset
986 <DisplayString Condition="Kind==UnqualifiedIdKind::IK_ConstructorTemplateId">[IK_ConstructorTemplateId] {TemplateId}</DisplayString>
anatofuz
parents:
diff changeset
987 <DisplayString>Kind</DisplayString>
anatofuz
parents:
diff changeset
988 <Expand>
anatofuz
parents:
diff changeset
989 <ExpandedItem Condition="Kind==UnqualifiedIdKind::IK_Identifier">Identifier</ExpandedItem>
anatofuz
parents:
diff changeset
990 <ExpandedItem Condition="Kind==UnqualifiedIdKind::IK_OperatorFunctionId">OperatorFunctionId</ExpandedItem>
anatofuz
parents:
diff changeset
991 <ExpandedItem Condition="Kind==UnqualifiedIdKind::IK_ConversionFunctionId">ConversionFunctionId</ExpandedItem>
anatofuz
parents:
diff changeset
992 <ExpandedItem Condition="Kind==UnqualifiedIdKind::IK_ConstructorName">ConstructorName</ExpandedItem>
anatofuz
parents:
diff changeset
993 <ExpandedItem Condition="Kind==UnqualifiedIdKind::IK_DestructorName">DestructorName</ExpandedItem>
anatofuz
parents:
diff changeset
994 <ExpandedItem Condition="Kind==UnqualifiedIdKind::IK_DeductionGuideName">TemplateName</ExpandedItem>
anatofuz
parents:
diff changeset
995 <ExpandedItem Condition="Kind==UnqualifiedIdKind::IK_TemplateId">TemplateId</ExpandedItem>
anatofuz
parents:
diff changeset
996 <ExpandedItem Condition="Kind==UnqualifiedIdKind::IK_ConstructorTemplateId">TemplateId</ExpandedItem>
anatofuz
parents:
diff changeset
997 </Expand>
anatofuz
parents:
diff changeset
998 </Type>
anatofuz
parents:
diff changeset
999 <Type Name="clang::DeclGroup">
anatofuz
parents:
diff changeset
1000 <DisplayString>NumDecls={NumDecls}</DisplayString>
anatofuz
parents:
diff changeset
1001 <Expand>
anatofuz
parents:
diff changeset
1002 <ArrayItems>
anatofuz
parents:
diff changeset
1003 <Size>NumDecls</Size>
anatofuz
parents:
diff changeset
1004 <ValuePointer>(Decl **)(this+1)</ValuePointer>
anatofuz
parents:
diff changeset
1005 </ArrayItems>
anatofuz
parents:
diff changeset
1006 </Expand>
anatofuz
parents:
diff changeset
1007 </Type>
anatofuz
parents:
diff changeset
1008 <Type Name="clang::DeclGroupRef">
anatofuz
parents:
diff changeset
1009 <DisplayString Condition="(Kind)((uintptr_t)D&amp;1)==SingleDeclKind">{*D}</DisplayString>
anatofuz
parents:
diff changeset
1010 <DisplayString>{*(DeclGroup *)((uintptr_t)D&amp;~1)}</DisplayString>
anatofuz
parents:
diff changeset
1011 <Expand>
anatofuz
parents:
diff changeset
1012 <ExpandedItem Condition="(Kind)((uintptr_t)D&amp;1)==SingleDeclKind">D</ExpandedItem>
anatofuz
parents:
diff changeset
1013 <ExpandedItem Condition="(Kind)((uintptr_t)D&amp;1)==DeclGroupKind">(DeclGroup *)((uintptr_t)D&amp;~1)</ExpandedItem>
anatofuz
parents:
diff changeset
1014 </Expand>
anatofuz
parents:
diff changeset
1015 </Type>
anatofuz
parents:
diff changeset
1016 <Type Name="clang::Declarator">
anatofuz
parents:
diff changeset
1017 <DisplayString>{DS} {Name}</DisplayString>
anatofuz
parents:
diff changeset
1018 </Type>
anatofuz
parents:
diff changeset
1019 <Type Name="clang::UnresolvedSet&lt;*&gt;">
anatofuz
parents:
diff changeset
1020 <DisplayString>{Decls}</DisplayString>
anatofuz
parents:
diff changeset
1021 <Expand>
anatofuz
parents:
diff changeset
1022 <ExpandedItem>Decls</ExpandedItem>
anatofuz
parents:
diff changeset
1023 </Expand>
anatofuz
parents:
diff changeset
1024 </Type>
anatofuz
parents:
diff changeset
1025 <Type Name="clang::LookupResult">
anatofuz
parents:
diff changeset
1026 <DisplayString Condition="ResultKind == clang::LookupResult::Ambiguous">{Ambiguity,en}: {Decls}</DisplayString>
anatofuz
parents:
diff changeset
1027 <DisplayString>{ResultKind,en}: {Decls}</DisplayString>
anatofuz
parents:
diff changeset
1028 </Type>
anatofuz
parents:
diff changeset
1029 <Type Name="clang::ActionResult&lt;*, 0&gt;">
anatofuz
parents:
diff changeset
1030 <DisplayString Condition="Invalid">Invalid</DisplayString>
anatofuz
parents:
diff changeset
1031 <DisplayString Condition="!*(void **)&amp;Val">Unset</DisplayString>
anatofuz
parents:
diff changeset
1032 <DisplayString>{Val}</DisplayString>
anatofuz
parents:
diff changeset
1033 </Type>
anatofuz
parents:
diff changeset
1034 <Type Name="clang::ActionResult&lt;*, 1&gt;">
anatofuz
parents:
diff changeset
1035 <DisplayString Condition="PtrWithInvalid&amp;1">Invalid</DisplayString>
anatofuz
parents:
diff changeset
1036 <DisplayString Condition="!PtrWithInvalid">Unset</DisplayString>
anatofuz
parents:
diff changeset
1037 <DisplayString>{($T1)(PtrWithInvalid&amp;~1)}</DisplayString>
anatofuz
parents:
diff changeset
1038 <Expand>
anatofuz
parents:
diff changeset
1039 <Item Name="Invalid">(bool)(PtrWithInvalid&amp;1)</Item>
anatofuz
parents:
diff changeset
1040 <Item Name="Val">($T1)(PtrWithInvalid&amp;~1)</Item>
anatofuz
parents:
diff changeset
1041 </Expand>
anatofuz
parents:
diff changeset
1042 </Type>
anatofuz
parents:
diff changeset
1043 </AutoVisualizer>