From 10bf809e34dfb8f6d9947f8d6d1ee9442a33140e Mon Sep 17 00:00:00 2001 From: Stewart Wonnacott Date: Wed, 3 Nov 2021 15:09:32 +0000 Subject: [PATCH 1/7] Visual Studio 2022 Support --- CPPDebuggerVisualizers.VS2022.sln | 31 + Changelog.txt | 4 + VS2022/CPPDebuggerVisualizers.VS2022.csproj | 199 ++++++ VS2022/Visualizers/TinyXML.natvis | 44 ++ VS2022/Visualizers/TinyXML2.natvis | 42 ++ VS2022/Visualizers/boost.natstepfilter | 11 + VS2022/Visualizers/boost.natvis | 444 +++++++++++++ VS2022/Visualizers/boost_Containers.natvis | 528 +++++++++++++++ VS2022/Visualizers/boost_DateTime.natvis | 214 ++++++ VS2022/Visualizers/boost_Geometry.natvis | 35 + VS2022/Visualizers/boost_Gil.natvis | 408 ++++++++++++ .../boost_IntrusiveContainers.natvis | 459 +++++++++++++ VS2022/Visualizers/boost_MultiArray.natvis | 36 + VS2022/Visualizers/boost_MultiIndex.natvis | 94 +++ .../Visualizers/boost_Multiprecision.natvis | 222 +++++++ .../boost_PointerContainerLibrary.natvis | 165 +++++ VS2022/Visualizers/boost_PropertyTree.natvis | 49 ++ VS2022/Visualizers/boost_Rational.natvis | 14 + VS2022/Visualizers/boost_Regex.natvis | 112 ++++ VS2022/Visualizers/boost_SmartPointers.natvis | 199 ++++++ VS2022/Visualizers/boost_Unordered.natvis | 135 ++++ VS2022/Visualizers/boost_Variant.natvis | 615 +++++++++++++++++ VS2022/Visualizers/boost_uBLAS.natvis | 93 +++ VS2022/Visualizers/directx.natvis | 622 ++++++++++++++++++ VS2022/Visualizers/external.natjmc | 8 + VS2022/Visualizers/gsl.natvis | 60 ++ VS2022/Visualizers/icu.natvis | 44 ++ VS2022/Visualizers/wxWidgets.natvis | 140 ++++ VS2022/packages.config | 4 + VS2022/readme.txt | 1 + VS2022/source.extension.vsixmanifest | 53 ++ 31 files changed, 5085 insertions(+) create mode 100644 CPPDebuggerVisualizers.VS2022.sln create mode 100644 VS2022/CPPDebuggerVisualizers.VS2022.csproj create mode 100644 VS2022/Visualizers/TinyXML.natvis create mode 100644 VS2022/Visualizers/TinyXML2.natvis create mode 100644 VS2022/Visualizers/boost.natstepfilter create mode 100644 VS2022/Visualizers/boost.natvis create mode 100644 VS2022/Visualizers/boost_Containers.natvis create mode 100644 VS2022/Visualizers/boost_DateTime.natvis create mode 100644 VS2022/Visualizers/boost_Geometry.natvis create mode 100644 VS2022/Visualizers/boost_Gil.natvis create mode 100644 VS2022/Visualizers/boost_IntrusiveContainers.natvis create mode 100644 VS2022/Visualizers/boost_MultiArray.natvis create mode 100644 VS2022/Visualizers/boost_MultiIndex.natvis create mode 100644 VS2022/Visualizers/boost_Multiprecision.natvis create mode 100644 VS2022/Visualizers/boost_PointerContainerLibrary.natvis create mode 100644 VS2022/Visualizers/boost_PropertyTree.natvis create mode 100644 VS2022/Visualizers/boost_Rational.natvis create mode 100644 VS2022/Visualizers/boost_Regex.natvis create mode 100644 VS2022/Visualizers/boost_SmartPointers.natvis create mode 100644 VS2022/Visualizers/boost_Unordered.natvis create mode 100644 VS2022/Visualizers/boost_Variant.natvis create mode 100644 VS2022/Visualizers/boost_uBLAS.natvis create mode 100644 VS2022/Visualizers/directx.natvis create mode 100644 VS2022/Visualizers/external.natjmc create mode 100644 VS2022/Visualizers/gsl.natvis create mode 100644 VS2022/Visualizers/icu.natvis create mode 100644 VS2022/Visualizers/wxWidgets.natvis create mode 100644 VS2022/packages.config create mode 100644 VS2022/readme.txt create mode 100644 VS2022/source.extension.vsixmanifest diff --git a/CPPDebuggerVisualizers.VS2022.sln b/CPPDebuggerVisualizers.VS2022.sln new file mode 100644 index 0000000..89cad31 --- /dev/null +++ b/CPPDebuggerVisualizers.VS2022.sln @@ -0,0 +1,31 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 17 +VisualStudioVersion = 17.0.31825.309 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CPPDebuggerVisualizers.VS2022", "VS2022\CPPDebuggerVisualizers.VS2022.csproj", "{D7B13A2C-83D8-4990-83CD-9BEFC36BC80D}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Debug|x86 = Debug|x86 + Release|Any CPU = Release|Any CPU + Release|x86 = Release|x86 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {D7B13A2C-83D8-4990-83CD-9BEFC36BC80D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {D7B13A2C-83D8-4990-83CD-9BEFC36BC80D}.Debug|Any CPU.Build.0 = Debug|Any CPU + {D7B13A2C-83D8-4990-83CD-9BEFC36BC80D}.Debug|x86.ActiveCfg = Debug|x86 + {D7B13A2C-83D8-4990-83CD-9BEFC36BC80D}.Debug|x86.Build.0 = Debug|x86 + {D7B13A2C-83D8-4990-83CD-9BEFC36BC80D}.Release|Any CPU.ActiveCfg = Release|Any CPU + {D7B13A2C-83D8-4990-83CD-9BEFC36BC80D}.Release|Any CPU.Build.0 = Release|Any CPU + {D7B13A2C-83D8-4990-83CD-9BEFC36BC80D}.Release|x86.ActiveCfg = Release|x86 + {D7B13A2C-83D8-4990-83CD-9BEFC36BC80D}.Release|x86.Build.0 = Release|x86 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {C793AD0F-C134-4138-ADF6-37723B848148} + EndGlobalSection +EndGlobal diff --git a/Changelog.txt b/Changelog.txt index 372476b..90fb3cb 100644 --- a/Changelog.txt +++ b/Changelog.txt @@ -3,6 +3,10 @@ Legend: * Changed ! Fixed +1.0.23 - 03.11.2021 +========================= +* Updated version for Visual Studio 2022 + 1.0.22 - 20.06.2020 ========================= * Updated version for Visual Studio 2017 diff --git a/VS2022/CPPDebuggerVisualizers.VS2022.csproj b/VS2022/CPPDebuggerVisualizers.VS2022.csproj new file mode 100644 index 0000000..e210d1d --- /dev/null +++ b/VS2022/CPPDebuggerVisualizers.VS2022.csproj @@ -0,0 +1,199 @@ + + + + + 17.0 + $(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion) + + + + + 4.0 + false + publish\ + true + Disk + false + Foreground + 7 + Days + false + false + true + 0 + 1.0.0.%2a + false + true + + + + + + Debug + AnyCPU + 2.0 + {82b43b9b-a64c-4715-b499-d71e9ca2bd60};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + {D7B13A2C-83D8-4990-83CD-9BEFC36BC80D} + Library + Properties + CPPDebuggerVisualizers + CPPDebuggerVisualizers.VS2022 + v4.5 + false + false + false + false + false + false + + + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + + + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + True + a:\ + + + + Designer + + + + Always + true + + + Always + true + + + Designer + true + + + true + + + true + + + true + + + true + + + true + + + + + + + + False + Microsoft .NET Framework 4.5 %28x86 and x64%29 + true + + + False + .NET Framework 3.5 SP1 Client Profile + false + + + False + .NET Framework 3.5 SP1 + false + + + + + Changelog.txt + true + + + cppVisualizerIcon.png + true + + + cppVisualizerScreenshot.png + true + + + LICENSE.txt + true + + + Designer + true + + + true + + + true + + + true + + + true + + + true + + + true + + + true + + + true + + + true + + + true + + + true + + + Always + true + + + true + + + true + + + true + + + + + + + \ No newline at end of file diff --git a/VS2022/Visualizers/TinyXML.natvis b/VS2022/Visualizers/TinyXML.natvis new file mode 100644 index 0000000..e6096db --- /dev/null +++ b/VS2022/Visualizers/TinyXML.natvis @@ -0,0 +1,44 @@ + + + + [{type}] {value} + value + + + firstChild + next + *this + + + + + [{type}] {value} + value + + attributeSet + + firstChild + next + *this + + + + + {name} = {value} + + + + + + + sentinel.next + next + this + + + + + [{rep_-<size}] {rep_-<str,s} + rep_-<str,s + + \ No newline at end of file diff --git a/VS2022/Visualizers/TinyXML2.natvis b/VS2022/Visualizers/TinyXML2.natvis new file mode 100644 index 0000000..8441070 --- /dev/null +++ b/VS2022/Visualizers/TinyXML2.natvis @@ -0,0 +1,42 @@ + + + + {start, [end-start]s} + start, [end-start]s + + + {value} + value + + + firstChild + next + this + + + + + [CLOSED] {value} + [CLOSING] {value} + [OPEN] {value} + value + + rootAttribute + + firstChild + next + this + + + + + {name} = {value} + + + this + next + this + + + + \ No newline at end of file diff --git a/VS2022/Visualizers/boost.natstepfilter b/VS2022/Visualizers/boost.natstepfilter new file mode 100644 index 0000000..d200ffc --- /dev/null +++ b/VS2022/Visualizers/boost.natstepfilter @@ -0,0 +1,11 @@ + + + boost::forward<.*NoStepInto + boost::move<.*NoStepInto + boost::addressof<.*NoStepInto + boost::foreach_detail_::.*NoStepInto + boost::scoped_ptr<.*::operator->NoStepInto + boost::shared_ptr<.*::operator->NoStepInto + boost::scoped_array<.*::operator\[\]NoStepInto + boost::shared_array<.*::operator\[\]NoStepInto + diff --git a/VS2022/Visualizers/boost.natvis b/VS2022/Visualizers/boost.natvis new file mode 100644 index 0000000..dc65d15 --- /dev/null +++ b/VS2022/Visualizers/boost.natvis @@ -0,0 +1,444 @@ + + + + + + {{edges={m_edges} vertices={m_vertices}}} + + m_edges + m_vertices + + + + + + {*($T1 *)&m_storage} + + *($T1 *)&m_storage + + + + + + {(bool)(m_storage & 1)} + + + + + + {*($T1 *)&m_storage} + + *($T1 *)&m_storage + + + + + + {(bool)(m_storage.value & 1)} + + + + + path={m_pathname} + m_pathname,su + + m_pathname + + + + + type="{m_value}" permissions="{m_perms}" + + m_value + m_perms + + + + + {m_path} status=({m_status}) + {m_path} status=({m_status}) symlink_status=({m_symlink_status}) + + + + empty + {m_imp.px->dir_entry} + + m_imp.px->dir_entry + + + + + true + indeterminate + false + + + + + {held} + + held + + + + + [empty] + {*content} + + *content + + + + + {content_} + + content_ + + + + + {*(($T1 *)dummy_.data)} + + *(($T1 *)dummy_.data) + + + + + + + + nullopt + {value()} + + value() + + + + + + nullopt + {*ptr_} + + *ptr_ + + + + + ($T1*)((($T3)this)+internal.m_offset),na + empty + offset_ptr {*($T1*)((($T3)this)+internal.m_offset)} + + ($T1*)((($T3)this)+internal.m_offset) + + + + + + locked + not locked + + m + + + + + + + + + + atto + + + + + femto + + + + + pico + + + + + nano + + + + + micro + + + + + milli + + + + + centi + + + + + deci + + + + + deca + + + + + hecto + + + + + kilo + + + + + mega + + + + + giga + + + + + tera + + + + + peta + + + + + exa + + + + + ratio {"$T1"} + ratio {$T1}/{$T2} + + + + + + {ptr_,[len_]na} + ptr_,[len_]na + + len_ + + len_ + ptr_ + + + + + + + + ({*this,view(noparens)}) + () + + + + + + {head,na} + ({*this,view(noparens)}) + + head + + + + + + {head,na}, {tail.head,na} + ({*this,view(noparens)}) + + head + tail.head + + + + + + {head,na}, {tail.head,na}, {tail.tail.head,na} + ({*this,view(noparens)}) + + head + tail.head + tail.tail.head + + + + + + {head,na}, {tail.head,na}, {tail.tail.head,na}, {tail.tail.tail.head,na} + ({*this,view(noparens)}) + + head + tail.head + tail.tail.head + tail.tail.tail.head + + + + + + {head,na}, {tail.head,na}, {tail.tail.head,na}, {tail.tail.tail.head,na}, {tail.tail.tail.tail.head,na} + ({*this,view(noparens)}) + + head + tail.head + tail.tail.head + tail.tail.tail.head + tail.tail.tail.tail.head + + + + + + {head,na}, {tail.head,na}, {tail.tail.head,na}, {tail.tail.tail.head,na}, {tail.tail.tail.tail.head,na}, {tail.tail.tail.tail.tail.head,na} + ({*this,view(noparens)}) + + head + tail.head + tail.tail.head + tail.tail.tail.head + tail.tail.tail.tail.tail.head + tail.tail.tail.tail.tail.tail.head + + + + + + {head,na}, {tail.head,na}, {tail.tail.head,na}, {tail.tail.tail.head,na}, {tail.tail.tail.tail.head,na}, {tail.tail.tail.tail.tail.head,na}, {tail.tail.tail.tail.tail.tail.head,na} + ({*this,view(noparens)}) + + head + tail.head + tail.tail.head + tail.tail.tail.head + tail.tail.tail.tail.tail.head + tail.tail.tail.tail.tail.tail.head + tail.tail.tail.tail.tail.tail.tail.head + + + + + + {head,na}, {tail.head,na}, {tail.tail.head,na}, {tail.tail.tail.head,na}, {tail.tail.tail.tail.head,na}, {tail.tail.tail.tail.tail.head,na}, {tail.tail.tail.tail.tail.tail.head,na}, {tail.tail.tail.tail.tail.tail.tail.head,na} + ({*this,view(noparens)}) + + head + tail.head + tail.tail.head + tail.tail.tail.head + tail.tail.tail.tail.tail.head + tail.tail.tail.tail.tail.tail.head + tail.tail.tail.tail.tail.tail.tail.head + tail.tail.tail.tail.tail.tail.tail.tail.head + + + + + + {head,na}, {tail.head,na}, {tail.tail.head,na}, {tail.tail.tail.head,na}, {tail.tail.tail.tail.head,na}, {tail.tail.tail.tail.tail.head,na}, {tail.tail.tail.tail.tail.tail.head,na}, {tail.tail.tail.tail.tail.tail.tail.head,na}, {tail.tail.tail.tail.tail.tail.tail.tail.head,na} + ({*this,view(noparens)}) + + head + tail.head + tail.tail.head + tail.tail.tail.head + tail.tail.tail.tail.tail.head + tail.tail.tail.tail.tail.tail.head + tail.tail.tail.tail.tail.tail.tail.head + tail.tail.tail.tail.tail.tail.tail.tail.head + tail.tail.tail.tail.tail.tail.tail.tail.tail.head + + + + + {head,na}, {tail.head,na}, {tail.tail.head,na}, {tail.tail.tail.head,na}, {tail.tail.tail.tail.head,na}, {tail.tail.tail.tail.tail.head,na}, {tail.tail.tail.tail.tail.tail.head,na}, {tail.tail.tail.tail.tail.tail.tail.head,na}, {tail.tail.tail.tail.tail.tail.tail.tail.head,na}, {tail.tail.tail.tail.tail.tail.tail.tail.tail.head,na} + ({*this,view(noparens)}) + + head + tail.head + tail.tail.head + tail.tail.tail.head + tail.tail.tail.tail.tail.head + tail.tail.tail.tail.tail.tail.head + tail.tail.tail.tail.tail.tail.tail.head + tail.tail.tail.tail.tail.tail.tail.tail.head + tail.tail.tail.tail.tail.tail.tail.tail.tail.head + tail.tail.tail.tail.tail.tail.tail.tail.tail.tail.head + + + + + + + + ncs + + + rfc 4122 + + + microsoft + + + future + + + time based + + + dce security + + + name based md5 + + + random number based + + + name based sha1 + + + 16 + data,x + + + + + + {*(($T1 *)(&m_data.x))} + + m_data + + + + + {*(($T1 *)(&x))} + + x + + + diff --git a/VS2022/Visualizers/boost_Containers.natvis b/VS2022/Visualizers/boost_Containers.natvis new file mode 100644 index 0000000..ce613b8 --- /dev/null +++ b/VS2022/Visualizers/boost_Containers.natvis @@ -0,0 +1,528 @@ + + + + + {{ size={m_size} }} + + m_size + (size_t)(m_end - m_buff) + + m_size + *(m_first + ($i < (m_end - m_first) ? $i : $i - (size_t)(m_end - m_buff))) + + + + + + m_it + {*m_it} + + *m_it + + + + + + {{ bits={m_num_bits} }} + + m_num_bits + + m_num_bits + (bool)((m_bits._Myfirst[$i / bits_per_block] >> ($i % bits_per_block)) & 1) + + + + + + + {{ bits={m_num_bits} }} + + m_num_bits + + m_num_bits + (bool)((m_bits._Mypair._Myval2._Myfirst[$i / bits_per_block] >> ($i % bits_per_block)) & 1) + + + + + + + {{ bits={m_num_bits} }} + + + + + + + + + {{ size={(size_t) $T2} }} + + + $T2 + elems + + + + + + + + + + {data(),s} + data(),s + + size() + capacity() + + size() + data() + + + + + + + + + + + {data(),su} + data(),su + + size() + capacity() + + size() + data() + + + + + + + + + + + {data(),s} + data(),s + + size() + capacity() + + size() + data() + + + + + + + + + + + + {data(),su} + data(),su + + size() + capacity() + + size() + data() + + + + + + {{ size={members_.m_map == 0 ? 0 : ((sizeof($T1) < 512 ? size_t(512 / sizeof($T1)) : size_t(1)) * + (members_.m_finish.m_node - members_.m_start.m_node - 1) + (members_.m_finish.m_cur - members_.m_finish.m_first) + + (members_.m_start.m_last - members_.m_start.m_cur))} }} + + members_.m_map == 0 ? 0 : + ((sizeof($T1) < 512 ? size_t(512 / sizeof($T1)) : size_t(1)) * (members_.m_finish.m_node - members_.m_start.m_node - 1) + + (members_.m_finish.m_cur - members_.m_finish.m_first) + (members_.m_start.m_last - members_.m_start.m_cur)) + members_.m_map == 0 ? 0 : + (sizeof($T1) < 512 ? size_t(512 / sizeof($T1)) : size_t(1)) + + members_.m_map == 0 ? 0 : ((sizeof($T1) < 512 ? size_t(512 / sizeof($T1)) : size_t(1)) * + (members_.m_finish.m_node - members_.m_start.m_node - 1) + (members_.m_finish.m_cur - members_.m_finish.m_first) + + (members_.m_start.m_last - members_.m_start.m_cur)) + members_.m_start.m_node[(($i + (members_.m_start.m_cur - members_.m_start.m_first)) / (sizeof($T1) < 512 ? size_t(512 / sizeof($T1)) : size_t(1)))][($i + (members_.m_start.m_cur - members_.m_start.m_first)) % (sizeof($T1) < 512 ? size_t(512 / sizeof($T1)) : size_t(1))] + + + + + + + + m_cur + + m_cur + + + + + + + + *m_node + {**m_node,na} + + *m_node + + + + + + + {members_.m_icont} + + members_.m_icont + + + + + + + + + {m_icont} + + m_icont + + + + + + + {m_tree.members_.m_icont} + + m_tree.members_.m_icont + + + + + + + {members_.m_icont} + + members_.m_icont + + + + + + + m_it + + m_it + + + + + + + + ($T1*)m_storage.data + {*(($T1*)m_storage.data)} + + *(($T1*)m_storage.data) + + + + + + + + {m_iit} + + m_iit + + + + + + &m_data + {m_data} + + m_data + + + + + &m_data + {m_data} + + m_data + + + + + &m_data + {m_data} + + m_data + + + + + + m_iit + + m_iit + + + + + + {m_flat_tree.m_data.m_vect} + + m_flat_tree.m_data.m_vect + + + + + + + m_flat_tree.m_data.m_seq + + + + + + + + + m_flat_tree.m_data.m_seq.m_holder.m_size + m_flat_tree.m_data.m_seq.m_holder.m_capacity + + size() + &m_flat_tree.m_data.m_seq[0] + this + 1 + *this,view(MapHelper) + + + + + + {first}, {second} + ({first}, {second}) + + first + second + + + + + {second} + + + + + {first}, {second} + ({first}, {second}) + + first + second + + + + + + {second} + + + + + {m_flat_tree.m_data.m_vect} + + m_flat_tree.m_data.m_vect + + + + + + {m_data.m_vect} + + m_data.m_vect + + + + + + {m_data.m_seq} + + m_data.m_seq + + + + + + m_it->m_data + + m_it->m_data + + + + + &*m_iit + {m_iit} + + m_iit + + + + + &*m_iterator + {m_iterator} + + m_iterator + + + + + + {{ size={members_.m_size} }} + + members_.m_size + members_.m_capacity + + members_.m_size + members_.m_start + + + + + + + {{ size={m_holder.m_size} }} + + m_holder.m_size + m_holder.m_capacity + + m_holder.m_size + m_holder.m_start + + + + + + + + + + + + + m_ptr + {*m_ptr} + + m_ptr + + + + + + {{ size={index.members_.m_size ? index.members_.m_size - ExtraPointers : 0} }} + + index.members_.m_size ? index.members_.m_size - ExtraPointers : 0 + + index.members_.m_size ? index.members_.m_size - ExtraPointers : 0 + ((boost::container::stable_vector_detail::node_type<void *,$T1>*)index.members_.m_start[$i])->value + + + + + + + pn->value + + pn->value + + + + + + {{ size={index.m_holder.m_size ? index.m_holder.m_size - ExtraPointers : 0} }} + + index.m_holder.m_size ? index.m_holder.m_size - ExtraPointers : 0 + + index.m_holder.m_size ? index.m_holder.m_size - ExtraPointers : 0 + ((boost::container::stable_vector_detail::node_type<void *,$T1>*)index.m_holder.m_start[$i])->value + + + + + + + pn->value + + m_pn->value + + + + + + {{ size={index.m_holder.m_size ? index.m_holder.m_size - 3 : 0} }} + + index.m_holder.m_size ? index.m_holder.m_size - 3 : 0 + + index.m_holder.m_size ? index.m_holder.m_size - 3 : 0 + ((boost::container::stable_vector_detail::node<$T1 *>*)index.m_holder.m_start[$i])->value + + + + + + + {{ size={index.m_holder.m_size ? index.m_holder.m_size - 3 : 0} }} + + index.m_holder.m_size ? index.m_holder.m_size - 3 : 0 + index.m_holder.m_capacity ? index.m_holder.m_capacity - 3 : 0 + + index.m_holder.m_size ? index.m_holder.m_size - 3 : 0 + *($T1*)((boost::container::stable_vector_detail::node<$T1 *>*)index[$i])->m_storage.data + + + + + + + ($T1)(((boost::container::stable_vector_detail::node<$T1>*)m_pn)->m_storage.data) + {*($T1)(((boost::container::stable_vector_detail::node<$T1>*)m_pn)->m_storage.data)} + + *($T1)(((boost::container::stable_vector_detail::node<$T1>*)m_pn)->m_storage.data) + + + + diff --git a/VS2022/Visualizers/boost_DateTime.natvis b/VS2022/Visualizers/boost_DateTime.natvis new file mode 100644 index 0000000..9d2831b --- /dev/null +++ b/VS2022/Visualizers/boost_DateTime.natvis @@ -0,0 +1,214 @@ + + + + + + + + + + + + + + + + + + + + {year()}-{month()}-{day()} + + {year()} + {month()} + {day()} + + + + + {wn_,en} {dow_} {month_} + + {wn_,en} + {dow_} + {month_} + + + + + {days_.value_} day + {days_.value_} days + + + + + + + + + + + + + {day()}d {hour()/10}{hour()%10}:{minute()/10}{minute()%10}:{second()/10}{second()%10} {millisecond()}ms {nanosecond()}us + + {day()} + {hour()} + {minute()} + {second()} + {millisecond()} + {nanosecond()} + + + + + + + + + + + + + + + + + + + + + + + + {year()}-{month()}-{day()} {hour()/10}{hour()%10}:{minute()/10}{minute()%10}:{second()/10}{second()%10} {millisecond()}ms {nanosecond()}us + + {year()} + {month()} + {day()} + {hour()} + {minute()} + {second()} + {millisecond()} + {nanosecond()} + + + + + {begin_}/{last_} + + begin_ + last_ + + + + + {current_} + + current_ + + + + + {current_} + + current_ + + + + + + + + + + + + + {zone_names_.std_zone_abbrev_,sb}{hour()}:{minute()/10}{minute()%10}:{second()/10}{second()%10} + + + + {zone_} + + zone_ + + + + + {rep_} nanoseconds + + + + + {rep_}*100 nanoseconds + + + + + {rep_} microseconds + + + + + {rep_} milliseconds + + + + + {rep_} seconds + + + + + {rep_} minutes + + + + + {rep_} hours + + + + + {rep_} {*(($T2*)1)} + + rep_ + *(($T2*)1) + + + + + {d_} + + d_ + + + + + {value_} + + value_ + + + + + {(boost::date_time::months_of_year)value_,en} + + (boost::date_time::months_of_year)value_,en + + + + + {(boost::date_time::weekdays)value_,en} + + (boost::date_time::weekdays)value_,en + + + + + {value_} + + value_ + + + diff --git a/VS2022/Visualizers/boost_Geometry.natvis b/VS2022/Visualizers/boost_Geometry.natvis new file mode 100644 index 0000000..0d39b06 --- /dev/null +++ b/VS2022/Visualizers/boost_Geometry.natvis @@ -0,0 +1,35 @@ + + + + + + + + {{x={m_values[0]} y={m_values[1]}}} + + m_values[0] + m_values[1] + + + + + + [{m_values[0]}] + [{m_values[0]}, {m_values[1]}] + [{m_values[0]}, {m_values[1]}, {m_values[2]}] + {{size = {sizeof(m_values)/sizeof(m_values[0])}}} + + sizeof(m_values)/sizeof(m_values[0]) + + sizeof(m_values)/sizeof(m_values[0]) + m_values + + + + + diff --git a/VS2022/Visualizers/boost_Gil.natvis b/VS2022/Visualizers/boost_Gil.natvis new file mode 100644 index 0000000..358af96 --- /dev/null +++ b/VS2022/Visualizers/boost_Gil.natvis @@ -0,0 +1,408 @@ + + + + + + + + + + + RG + + + + + RGB + + + + + BGR + + + + + RGBA + + + + + BGRA + + + + + 1 + + + + + + UINT8 + + + INT8 + + + UINT16 + + + INT16 + + + UINT32 + + + INT32 + + + FLOAT32 + + + {($T2*)1,na} + + + _view._dimensions.x + _view._dimensions.y + _memory + _view._pixels._p._step_fn._step + + + + + + + + + + {*($T1 *)&(_bits)} + + *($T1 *)&(_bits) + + + + + + {*($T1 *)&(_bits)} + {*($T2 *)&(_bits)} + + *($T1 *)&(_bits) + *($T2 *)&(_bits) + + + + + + {*($T1 *)&(_bits)} + {*($T2 *)&(_bits)} + {*($T3 *)&(_bits)} + + *($T1 *)&(_bits) + *($T2 *)&(_bits) + *($T3 *)&(_bits) + + + + + + {*($T1 *)&(_bits)} + {*($T2 *)&(_bits)} + {*($T3 *)&(_bits)} + {*($T4 *)&(_bits)} + + *($T1 *)&(_bits) + *($T2 *)&(_bits) + *($T3 *)&(_bits) + *($T4 *)&(_bits) + + + + + + {*($T1 *)&(_bits)} + {*($T2 *)&(_bits)} + {*($T3 *)&(_bits)} + {*($T4 *)&(_bits)} + {*($T5 *)&(_bits)} + + *($T1 *)&(_bits) + *($T2 *)&(_bits) + *($T3 *)&(_bits) + *($T4 *)&(_bits) + *($T5 *)&(_bits) + + + + + + {*($T1 *)&(_bits)} + {*($T2 *)&(_bits)} + {*($T3 *)&(_bits)} + {*($T4 *)&(_bits)} + {*($T5 *)&(_bits)} + {*($T6 *)&(_bits)} + + *($T1 *)&(_bits) + *($T2 *)&(_bits) + *($T3 *)&(_bits) + *($T4 *)&(_bits) + *($T5 *)&(_bits) + *($T6 *)&(_bits) + + + + + + {*($T1 *)&(_bits)} + {*($T2 *)&(_bits)} + {*($T3 *)&(_bits)} + {*($T4 *)&(_bits)} + {*($T5 *)&(_bits)} + {*($T6 *)&(_bits)} + {*($T7 *)&(_bits)} + + *($T1 *)&(_bits) + *($T2 *)&(_bits) + *($T3 *)&(_bits) + *($T4 *)&(_bits) + *($T5 *)&(_bits) + *($T6 *)&(_bits) + *($T7 *)&(_bits) + + + + + + {*($T1 *)&(_bits)} + {*($T2 *)&(_bits)} + {*($T3 *)&(_bits)} + {*($T4 *)&(_bits)} + {*($T5 *)&(_bits)} + {*($T6 *)&(_bits)} + {*($T7 *)&(_bits)} + {*($T8 *)&(_bits)} + + *($T1 *)&(_bits) + *($T2 *)&(_bits) + *($T3 *)&(_bits) + *($T4 *)&(_bits) + *($T5 *)&(_bits) + *($T6 *)&(_bits) + *($T7 *)&(_bits) + *($T8 *)&(_bits) + + + + + + {*($T1 *)&(_bits)} + {*($T2 *)&(_bits)} + {*($T3 *)&(_bits)} + {*($T4 *)&(_bits)} + {*($T5 *)&(_bits)} + {*($T6 *)&(_bits)} + {*($T7 *)&(_bits)} + {*($T8 *)&(_bits)} + {*($T9 *)&(_bits)} + + *($T1 *)&(_bits) + *($T2 *)&(_bits) + *($T3 *)&(_bits) + *($T4 *)&(_bits) + *($T5 *)&(_bits) + *($T6 *)&(_bits) + *($T7 *)&(_bits) + *($T8 *)&(_bits) + *($T9 *)&(_bits) + + + + + + {*($T1 *)&(_bits)} + {*($T2 *)&(_bits)} + {*($T3 *)&(_bits)} + {*($T4 *)&(_bits)} + {*($T5 *)&(_bits)} + {*($T6 *)&(_bits)} + {*($T7 *)&(_bits)} + {*($T8 *)&(_bits)} + {*($T9 *)&(_bits)} + {*($T10 *)&(_bits)} + + *($T1 *)&(_bits) + *($T2 *)&(_bits) + *($T3 *)&(_bits) + *($T4 *)&(_bits) + *($T5 *)&(_bits) + *($T6 *)&(_bits) + *($T7 *)&(_bits) + *($T8 *)&(_bits) + *($T9 *)&(_bits) + *($T10 *)&(_bits) + + + + + + {*($T1 *)&(_bits)} + {*($T2 *)&(_bits)} + {*($T3 *)&(_bits)} + {*($T4 *)&(_bits)} + {*($T5 *)&(_bits)} + {*($T6 *)&(_bits)} + {*($T7 *)&(_bits)} + {*($T8 *)&(_bits)} + {*($T9 *)&(_bits)} + {*($T10 *)&(_bits)} + {*($T11 *)&(_bits)} + + *($T1 *)&(_bits) + *($T2 *)&(_bits) + *($T3 *)&(_bits) + *($T4 *)&(_bits) + *($T5 *)&(_bits) + *($T6 *)&(_bits) + *($T7 *)&(_bits) + *($T8 *)&(_bits) + *($T9 *)&(_bits) + *($T10 *)&(_bits) + *($T11 *)&(_bits) + + + + + + {*($T1 *)&(_bits)} + {*($T2 *)&(_bits)} + {*($T3 *)&(_bits)} + {*($T4 *)&(_bits)} + {*($T5 *)&(_bits)} + {*($T6 *)&(_bits)} + {*($T7 *)&(_bits)} + {*($T8 *)&(_bits)} + {*($T9 *)&(_bits)} + {*($T10 *)&(_bits)} + {*($T11 *)&(_bits)} + {*($T12 *)&(_bits)} + + *($T1 *)&(_bits) + *($T2 *)&(_bits) + *($T3 *)&(_bits) + *($T4 *)&(_bits) + *($T5 *)&(_bits) + *($T6 *)&(_bits) + *($T7 *)&(_bits) + *($T8 *)&(_bits) + *($T9 *)&(_bits) + *($T10 *)&(_bits) + *($T11 *)&(_bits) + *($T12 *)&(_bits) + + + + + + {*($T1 *)&(_bits)} + {*($T2 *)&(_bits)} + {*($T3 *)&(_bits)} + {*($T4 *)&(_bits)} + {*($T5 *)&(_bits)} + {*($T6 *)&(_bits)} + {*($T7 *)&(_bits)} + {*($T8 *)&(_bits)} + {*($T9 *)&(_bits)} + {*($T10 *)&(_bits)} + {*($T11 *)&(_bits)} + {*($T12 *)&(_bits)} + {*($T13 *)&(_bits)} + + *($T1 *)&(_bits) + *($T2 *)&(_bits) + *($T3 *)&(_bits) + *($T4 *)&(_bits) + *($T5 *)&(_bits) + *($T6 *)&(_bits) + *($T7 *)&(_bits) + *($T8 *)&(_bits) + *($T9 *)&(_bits) + *($T10 *)&(_bits) + *($T11 *)&(_bits) + *($T12 *)&(_bits) + *($T13 *)&(_bits) + + + + + + {*($T1 *)&(_bits)} + {*($T2 *)&(_bits)} + {*($T3 *)&(_bits)} + {*($T4 *)&(_bits)} + {*($T5 *)&(_bits)} + {*($T6 *)&(_bits)} + {*($T7 *)&(_bits)} + {*($T8 *)&(_bits)} + {*($T9 *)&(_bits)} + {*($T10 *)&(_bits)} + {*($T11 *)&(_bits)} + {*($T12 *)&(_bits)} + {*($T13 *)&(_bits)} + {*($T14 *)&(_bits)} + + *($T1 *)&(_bits) + *($T2 *)&(_bits) + *($T3 *)&(_bits) + *($T4 *)&(_bits) + *($T5 *)&(_bits) + *($T6 *)&(_bits) + *($T7 *)&(_bits) + *($T8 *)&(_bits) + *($T9 *)&(_bits) + *($T10 *)&(_bits) + *($T11 *)&(_bits) + *($T12 *)&(_bits) + *($T13 *)&(_bits) + *($T14 *)&(_bits) + + + + + + {*($T1 *)&(_bits)} + {*($T2 *)&(_bits)} + {*($T3 *)&(_bits)} + {*($T4 *)&(_bits)} + {*($T5 *)&(_bits)} + {*($T6 *)&(_bits)} + {*($T7 *)&(_bits)} + {*($T8 *)&(_bits)} + {*($T9 *)&(_bits)} + {*($T10 *)&(_bits)} + {*($T11 *)&(_bits)} + {*($T12 *)&(_bits)} + {*($T13 *)&(_bits)} + {*($T14 *)&(_bits)} + {*($T15 *)&(_bits)} + + *($T1 *)&(_bits) + *($T2 *)&(_bits) + *($T3 *)&(_bits) + *($T4 *)&(_bits) + *($T5 *)&(_bits) + *($T6 *)&(_bits) + *($T7 *)&(_bits) + *($T8 *)&(_bits) + *($T9 *)&(_bits) + *($T10 *)&(_bits) + *($T11 *)&(_bits) + *($T12 *)&(_bits) + *($T13 *)&(_bits) + *($T14 *)&(_bits) + *($T15 *)&(_bits) + + + + diff --git a/VS2022/Visualizers/boost_IntrusiveContainers.natvis b/VS2022/Visualizers/boost_IntrusiveContainers.natvis new file mode 100644 index 0000000..c9858da --- /dev/null +++ b/VS2022/Visualizers/boost_IntrusiveContainers.natvis @@ -0,0 +1,459 @@ + + + + + + + + + + + + + + + + + + + + + {{ size={data_.root_plus_size_.size_} }} + + + data_.root_plus_size_.size_ + data_.root_plus_size_.root_.next_ + next_ + *(($T1 *) this) + + + + + + + + {{ size={data_.root_plus_size_.size_} }} + + + data_.root_plus_size_.size_ + data_.root_plus_size_.root_.next_ + next_ + *(($T1*)this) + + + + + + + {{ size={data_.root_plus_size_.size_} }} + + + data_.root_plus_size_.size_ + data_.root_plus_size_.m_header.next_ + next_ + *(($T1*)this) + + + + + + {{ size={data_.root_plus_size_.size_} }} + + + data_.root_plus_size_.size_ + data_.root_plus_size_.header_holder_.next_ + next_ + *(($T1*)this) + + + + + + + + {*($T1*)(members_.nodeptr_)} + + *($T1*)(members_.nodeptr_) + + + + + + + &(($T1*)(members_.nodeptr_))->m_data + {(($T1*)(members_.nodeptr_))->m_data} + + (($T1*)(members_.nodeptr_))->m_data + + + + + + &*($T1*)(members_.nodeptr_) + {*($T1*)(members_.nodeptr_)} + + *($T1*)(members_.nodeptr_) + + + + + + + + + {{ size={data_.root_plus_size_.size_} }} + + + data_.root_plus_size_.size_ + data_.root_plus_size_.root_.next_ + next_ + *($T1*)((char*)this - (size_t)($T4)) + + + + + + + + + {{ size={data_.root_plus_size_.size_} }} + + + data_.root_plus_size_.size_ + data_.root_plus_size_.m_header.next_ + next_ + *($T1*)((char*)this - (size_t)($T4)) + + + + + + + + + {{ size={data_.root_plus_size_.size_} }} + + + data_.root_plus_size_.size_ + data_.root_plus_size_.header_holder_.next_ + next_ + *($T1*)((char*)this - (size_t)($T4)) + + + + + + + + *($T1*)(((char*)members_.nodeptr_) - (size_t)($T3)) + + *($T1*)(((char*)members_.nodeptr_) - (size_t)($T3)) + + + + + + + &(*($T1*)(((char*)members_.nodeptr_) - (size_t)($T2))) + {*($T1*)(((char*)members_.nodeptr_) - (size_t)($T2))} + + *($T1*)(((char*)members_.nodeptr_) - (size_t)($T2)) + + + + + + + {{ size={data_.node_plus_pred_.header_plus_size_.size_} }} + + + data_.node_plus_pred_.header_plus_size_.header_.parent_ + left_ + right_ + *($T1 *)(this) + + + + + + + {{ size={size_} }} + + + parent_ + left_ + right_ + *($T1 *)(this) + + + + + + + + + {{ size={size_} }} + + + holder.root.parent_ + left_ + right_ + *($T1 *)(this) + + + + + + + + + {{ size={size_} }} + + + holder.root.parent_ + left_ + right_ + (($T1 *)(this))->m_data.second,view(MapHelper) + + + + + + + + {{ size={tree_.data_.node_plus_pred_.header_plus_size_.size_} }} + + + tree_.data_.node_plus_pred_.header_plus_size_.header_.parent_ + left_ + right_ + *($T1 *)(this) + + + + + + + {{ size={size_} }} + + + parent_ + left_ + right_ + *($T1 *)(this) + + + + + + + {{ size={size_} }} + + + holder.root.parent_ + left_ + right_ + *($T1 *)(this) + + + + + + + + {{ empty }} + {{ non-empty }} + + + tree_.data_.node_plus_pred_.header_plus_size_.header_.parent_ + left_ + right_ + *($T1 *)(this) + + + + + + + {{ empty }} + {{ non-empty }} + + + parent_ + left_ + right_ + *($T1*)(this) + + + + + + + + + {{ empty }} + {{ non-empty }} + + + holder.root.parent_ + left_ + right_ + *($T1*)(this) + + + + + + + + *($T1*)(members_.nodeptr_) + + *($T1*)(members_.nodeptr_) + + + + + + &(($T1*)members_.nodeptr_)->m_data + {(($T1*)members_.nodeptr_)->m_data} + + (($T1*)members_.nodeptr_)->m_data + + + + + ($T1*)members_.nodeptr_ + {($T1*)members_.nodeptr_,na} + + ($T1*)members_.nodeptr_,na + + + + + + + {{ size={tree_.data_.node_plus_pred_.header_plus_size_.size_} }} + + + tree_.data_.node_plus_pred_.header_plus_size_.header_.parent_ + left_ + right_ + *($T1*)((char*)this - (size_t)($T4)) + + + + + + + {{ size={size_} }} + + + parent_ + left_ + right_ + *($T1 *)((char*)this - (size_t)($T4)) + + + + + + + {{ size={size_} }} + + + holder.root.parent_ + left_ + right_ + *($T1 *)((char*)this - (size_t)($T4)) + + + + + + + {{ size={size_} }} + + + holder.root.parent_ + left_ + right_ + *($T1 *)((char*)this - (size_t)($T2)) + + + + + + + + + {{ empty }} + {{ non-empty }} + + + tree_.data_.node_plus_pred_.header_plus_size_.header_.parent_ + left_ + right_ + *($T1*)((char*)this - (size_t)($T4)) + + + + + + + {{ empty }} + {{ non-empty }} + + + parent_ + left_ + right_ + *($T1 *)((char*)this - (size_t)($T4)) + + + + + + + + + {{ empty }} + {{ non-empty }} + + + holder.root.parent_ + left_ + right_ + *($T1 *)((char*)this - (size_t)($T4)) + + + + + + + + ($T1*)(((char*)members_.nodeptr_) - (size_t)($T3)) + + *($T1*)(((char*)members_.nodeptr_) - (size_t)($T3)) + + + + + + ($T1*)(((char*)members_.nodeptr_) - (size_t)($T3)) + + *($T1*)(((char*)members_.nodeptr_) - (size_t)($T3)) + + + + + + ($T1*)(((char*)members_.nodeptr_) - (size_t)($T2)) + + *($T1*)(((char*)members_.nodeptr_) - (size_t)($T2)) + + + + diff --git a/VS2022/Visualizers/boost_MultiArray.natvis b/VS2022/Visualizers/boost_MultiArray.natvis new file mode 100644 index 0000000..502b3f5 --- /dev/null +++ b/VS2022/Visualizers/boost_MultiArray.natvis @@ -0,0 +1,36 @@ + + + + + extent = {extent_list_,view(expand)} + + + $T2 + extent_list_[$i] + base_ + + + + + + extent = {extent_list_,view(expand)} + + + 1 + extent_list_[0] + ($T1*)base_ + + + + + + extent = {extent_list_,view(expand)} + + + extent_list_[0] + (base_ + origin_offset_ + stride_list_[0] * $i),[extent_list_[1]]na + + + + + diff --git a/VS2022/Visualizers/boost_MultiIndex.natvis b/VS2022/Visualizers/boost_MultiIndex.natvis new file mode 100644 index 0000000..23517c3 --- /dev/null +++ b/VS2022/Visualizers/boost_MultiIndex.natvis @@ -0,0 +1,94 @@ + + + + + + + + {{ size={(($T2*)this)->node_count} }} + + + (($T2*)this)->node_count + ((boost::multi_index::detail::sequenced_index_node<$T1>*)(member))->next_ + next_ + *reinterpret_cast<$T2::value_type*>(&((boost::multi_index::detail::sequenced_index_node<$T1>*)this)->space) + + + + + + + {{ size={(($T3*)this)->node_count} }} + + + + (($T3*)this)->node_count + (boost::multi_index::detail::ordered_index_node_trampoline<$T1,$T2>*)(((boost::multi_index::detail::ordered_index_node_trampoline<$T1,$T2>*)(member))->parentcolor_&~uintptr_type(1)) + (boost::multi_index::detail::ordered_index_node_trampoline<$T1,$T2>*)left_ + (boost::multi_index::detail::ordered_index_node_trampoline<$T1,$T2>*)right_ + *reinterpret_cast<$T3::value_type*>(&((boost::multi_index::detail::ordered_index_node<$T1,$T2>*)this)->space) + + + + (($T3*)this)->node_count + (boost::multi_index::detail::ordered_index_node_trampoline<$T1,$T2>*)(((boost::multi_index::detail::ordered_index_node_trampoline<$T1,$T2>*)(member))->parent_) + (boost::multi_index::detail::ordered_index_node_trampoline<$T1,$T2>*)left_ + (boost::multi_index::detail::ordered_index_node_trampoline<$T1,$T2>*)right_ + *reinterpret_cast<$T3::value_type*>(&((boost::multi_index::detail::ordered_index_node<$T1,$T2>*)this)->space) + + + + + + + {{ size={(($T2*)this)->node_count} }} + + (($T2*)this)->ptrs.capacity_ + + (($T2*)this)->node_count + *reinterpret_cast<$T2::value_type*>(&((boost::multi_index::detail::random_access_index_node<$T1>*)((($T2*)this)->ptrs.spc.data_[$i]))->space) + + + + + + {{ size={(($T3*)this)->node_count} }} + + + (($T3*)this)->buckets.spc.n_ - 1 + (($T3*)this)->max_load + (($T3*)this)->mlf + (($T3*)this)->eq_ + (($T3*)this)->hash_ + + + + + + + + + + + NodePtr = (boost::multi_index::detail::hashed_index_node_trampoline<$T1>*)((((($T3*)this)->buckets.spc.data_ + BucketIndex))->prior_) + + + + *reinterpret_cast<$T3::value_type*>(&(((boost::multi_index::detail::hashed_index_node<$T1,$T2>*)NodePtr))->space) + + + + NodePtr = (boost::multi_index::detail::hashed_index_node_trampoline<$T1>*)(NodePtr->next_) + + + + ++BucketIndex + + + + + + diff --git a/VS2022/Visualizers/boost_Multiprecision.natvis b/VS2022/Visualizers/boost_Multiprecision.natvis new file mode 100644 index 0000000..91ed8da --- /dev/null +++ b/VS2022/Visualizers/boost_Multiprecision.natvis @@ -0,0 +1,222 @@ + + + + + + + {m_backend.debug_value} + + + + + + {-1 * (__int64)(m_backend.m_wrapper.m_data[0])} + {(__int64)(m_backend.m_wrapper.m_data[0])} + { -1 * (__int64)(m_backend.m_wrapper.m_data[0] | ((__int64)m_backend.m_wrapper.m_data[1] << 32))} + {(__int64)(m_backend.m_wrapper.m_data[0] | ((__int64)m_backend.m_wrapper.m_data[1] << 32))} + + m_backend.m_sign + + m_backend.m_limbs + m_backend.m_wrapper.m_data[m_backend.m_limbs - $i - 1],x + + m_backend.m_limbs + + + + {(__int64)(m_backend.m_wrapper.m_data[0])} + {(__int64)(m_backend.m_wrapper.m_data[0] | ((__int64)m_backend.m_wrapper.m_data[1] << 32))} + + + m_backend.m_limbs + m_backend.m_wrapper.m_data[m_backend.m_limbs - $i - 1],x + + m_backend.m_limbs + + + + {-1 * (__int64)(m_backend.m_data.first)} + {(__int64)(m_backend.m_data.first)} + { -1 * (__int64)(m_backend.m_data.double_first)} + {(__int64)(m_backend.m_data.double_first)} + {-1 * (__int64)(m_backend.m_data.ld.data[0])} + {(__int64)(m_backend.m_data.ld.data[0])} + { -1 * (__int64)(m_backend.m_data.ld.data[0] | ((__int64)m_backend.m_data.ld.data[1] << 32))} + {(__int64)(m_backend.m_data.ld.data[0] | ((__int64)m_backend.m_data.ld.data[1] << 32))} + + m_backend.m_sign + m_backend.m_limbs + + m_backend.m_limbs + m_backend.m_data.la[m_backend.m_limbs - $i - 1],x + + + m_backend.m_limbs + m_backend.m_data.ld.data[m_backend.m_limbs - $i - 1],x + + + + + + + + -{m_backend.data._Elems[0],u}.{m_backend.data._Elems[1],u}{m_backend.data._Elems[2],u}...e{m_backend.exp,d} + {m_backend.data._Elems[0],u}.{m_backend.data._Elems[1],u}{m_backend.data._Elems[2],u}...e{m_backend.exp,d} + -{m_backend.data._Elems[0],u}.{m_backend.data._Elems[1],u}{m_backend.data._Elems[2],u} + {m_backend.data._Elems[0],u}.{m_backend.data._Elems[1],u}{m_backend.data._Elems[2],u} + -INF + +INF + NaN + + m_backend.neg + m_backend.exp + + m_backend.prec_elem + m_backend.data._Elems[$i],u + + + + + + + + {-1 * (__int64)(m_wrapper.m_data[0])} + {(__int64)(m_wrapper.m_data[0])} + { -1 * (__int64)(m_wrapper.m_data[0] | ((__int64)m_wrapper.m_data[1] << 32))} + {(__int64)(m_wrapper.m_data[0] | ((__int64)m_wrapper.m_data[1] << 32))} + + m_sign + + m_limbs + m_wrapper.m_data[m_limbs - $i - 1],x + + m_limbs + + + + {(__int64)(m_wrapper.m_data[0])} + {(__int64)(m_wrapper.m_data[0] | ((__int64)m_wrapper.m_data[1] << 32))} + + + m_limbs + m_wrapper.m_data[m_limbs - $i - 1],x + + m_limbs + + + + {-1 * (__int64)(m_data.first)} + {(__int64)(m_data.first)} + { -1 * (__int64)(m_data.double_first)} + {(__int64)(m_data.double_first)} + {-1 * (__int64)(m_data.ld.data[0])} + {(__int64)(m_data.ld.data[0])} + { -1 * (__int64)(m_data.ld.data[0] | ((__int64)m_data.ld.data[1] << 32))} + {(__int64)(m_data.ld.data[0] | ((__int64)m_data.ld.data[1] << 32))} + + m_sign + m_limbs + + m_limbs + m_data.la[m_limbs - $i - 1],x + + + m_limbs + m_data.ld.data[m_limbs - $i - 1],x + + + + + + + + 0 + +INF + -INF + NaN + + m_backend.m_sign + m_backend.m_exponent + m_backend.m_data + + + + + + + {m_backend.m_value} + + m_backend.m_value + + + + + + + + + {m_backend.m_data[0]} + + m_backend.m_data[0] + + + + + {_mp_d[0]} + {-((long long)_mp_d[0])} + 0 + + 1 + 0 + 0 + + -_mp_size + _mp_d[-_mp_size - $i - 1],x + + + _mp_size + _mp_d[_mp_size - $i - 1],x + + + + + + + + {m_backend.m_data[0]} + + m_backend.m_data[0] + + + + + {_mp_num} / {_mp_den} + + _mp_num + _mp_den + + + + + + + {m_backend.m_data[0]} + + m_backend.m_data[0] + + + + + + + + + {m_backend.m_data[0]} + + m_backend.m_data[0] + + + + + + diff --git a/VS2022/Visualizers/boost_PointerContainerLibrary.natvis b/VS2022/Visualizers/boost_PointerContainerLibrary.natvis new file mode 100644 index 0000000..39e7ffd --- /dev/null +++ b/VS2022/Visualizers/boost_PointerContainerLibrary.natvis @@ -0,0 +1,165 @@ + + + + + + + + + + + {{ size={(size_t) $T2} }} + + + $T2 + ($T1**)c_.elems + + + + + + ($T1*)(*iter_) + {($T1*)(*iter_),na} + + ($T1*)(*iter_) + + + + + + + {{ size={c_._Mypair._Myval2._Mylast - c_._Mypair._Myval2._Myfirst} }} + + c_._Mypair._Myval2._Mylast - c_._Mypair._Myval2._Myfirst + c_._Mypair._Myval2._Myend - c_._Mypair._Myval2._Myfirst + + c_._Mypair._Myval2._Mylast - c_._Mypair._Myval2._Myfirst + ($T1**)c_._Mypair._Myval2._Myfirst + + + + + + + ($T2*)(*iter_._Ptr) + {($T2*)(*iter_._Ptr)} + + ($T2*)(*iter_._Ptr) + + + + + + + + + {{ size={c_._Mypair._Myval2._Myval2._Mysize} }} + + + c_._Mypair._Myval2._Myval2._Mysize + c_._Mypair._Myval2._Myval2._Myhead->_Parent + _Left + _Right + *(std::pair<$T1,$T2 *>*)&(_Myval) + + + + + + + + + + {{ size={c_._Mypair._Myval2._Myval2._Mysize} }} + + + c_._Mypair._Myval2._Myval2._Mysize + c_._Mypair._Myval2._Myval2._Myhead->_Parent + _Left + _Right + *(std::pair<$T1,$T2 *>*)&(_Myval),view(MapHelper) + + + + + + + + + m_iterator._Ptr->_Isnil ? nullptr : &(m_iterator._Ptr->_Myval) + ({first()}, {second()}) + end + + ({first()}, {second()}) + + + + + + + {{ size={c_._Mypair._Myval2._Myval2._Mysize} }} + + + c_._Mypair._Myval2._Myval2._Mysize + c_._Mypair._Myval2._Myval2._Myhead->_Parent + _Left + _Right + ($T1*)_Myval + + + + + + + ($T2*)(iter_._Ptr->_Myval) + + ($T2*)(iter_._Ptr->_Myval) + + + + + + + {{ size={c_._Mypair._Myval2._Mysize} }} + + + c_._Mypair._Myval2._Mysize + c_._Mypair._Myval2._Myhead->_Next + _Next + ($T1*)_Myval + + + + + + + ($T2*)(iter_._Ptr->_Myval) + + ($T2*)(iter_._Ptr->_Myval) + + + + + + + {{ size={c_._Mypair._Myval2._Mysize} }} + + + c_._Mypair._Myval2._Mysize + ($T1*)c_._Mypair._Myval2._Map[(($i + c_._Mypair._Myval2._Myoff) / c_._EEN_DS) % c_._Mypair._Myval2._Mapsize][($i + c_._Mypair._Myval2._Myoff) % c_._EEN_DS] + + + + + + + {($T2*)(($T1 *)iter_._Myproxy->_Mycont)->_Map[(iter_._Myoff / iter_._EEN_DS) % (($T1 *)iter_._Myproxy->_Mycont)->_Mapsize][iter_._Myoff % iter_._EEN_DS]} + end + + iter_._Myoff - (($T1 *)iter_._Myproxy->_Mycont)->_Myoff + ($T2*)(($T1 *)iter_._Myproxy->_Mycont)->_Map[(iter_._Myoff / iter_._EEN_DS) % (($T1 *)iter_._Myproxy->_Mycont)->_Mapsize][iter_._Myoff % iter_._EEN_DS] + + + diff --git a/VS2022/Visualizers/boost_PropertyTree.natvis b/VS2022/Visualizers/boost_PropertyTree.natvis new file mode 100644 index 0000000..0e6ccf2 --- /dev/null +++ b/VS2022/Visualizers/boost_PropertyTree.natvis @@ -0,0 +1,49 @@ + + + + + + + {m_data}:{*static_cast<subs::base_container*>(this->m_children)} + {*static_cast<subs::base_container*>(this->m_children)} + + m_data + + *static_cast<subs::base_container*>(this->m_children),view(ptree) + *this,view(raw) + + + + + + {m_data}:{*static_cast<subs::base_container*>(m_children)} + {*static_cast<subs::base_container*>(m_children)} + + m_data + static_cast<subs::base_container*>(m_children) + + + + + + {{ size={(($T2*)this)->node_count} }} + + + (($T2*)this)->node_count + ((boost::multi_index::detail::sequenced_index_node<$T1>*)(member))->next_ + next_ + *reinterpret_cast<$T2::value_type*>(&((boost::multi_index::detail::sequenced_index_node<$T1>*)this)->space),view(ptree) + + + + + + + {second} + + first + second + + + + diff --git a/VS2022/Visualizers/boost_Rational.natvis b/VS2022/Visualizers/boost_Rational.natvis new file mode 100644 index 0000000..32281bd --- /dev/null +++ b/VS2022/Visualizers/boost_Rational.natvis @@ -0,0 +1,14 @@ + + + + + + + {num}/{den} + + num + den + + + + diff --git a/VS2022/Visualizers/boost_Regex.natvis b/VS2022/Visualizers/boost_Regex.natvis new file mode 100644 index 0000000..9de412f --- /dev/null +++ b/VS2022/Visualizers/boost_Regex.natvis @@ -0,0 +1,112 @@ + + + + + + + empty + regex {m_pimpl.px->m_expression,s} + m_pimpl.px->m_expression,s + + m_pimpl.px->m_mark_count + m_pimpl.px->m_expression + 1 + 0 + 1 + 0 + 1 + 0 + *(m_pimpl.px) + + + + + empty + regex {m_pimpl.px->m_expression,su} + m_pimpl.px->m_expression,su + + m_pimpl.px->m_mark_count + m_pimpl.px->m_expression + 1 + 0 + 1 + 0 + 1 + 0 + *(m_pimpl.px) + + + + + + + This item is empty. + m_subs._Mypair._Myval2._Mylast - m_subs._Mypair._Myval2._Myfirst - 3 + m_subs._Mypair._Myval2._Myfirst[2].first - m_subs._Mypair._Myval2._Myfirst[1].first + m_subs._Mypair._Myval2._Myfirst[2].second - m_subs._Mypair._Myval2._Myfirst[2].first + + m_subs._Mypair._Myval2._Mylast - m_subs._Mypair._Myval2._Myfirst - 2 + m_subs._Mypair._Myval2._Myfirst + 2 + + + + + + + + This item is empty. + m_subs._Mypair._Myval2._Mylast - m_subs._Mypair._Myval2._Myfirst - 3 + m_subs._Mypair._Myval2._Myfirst[2].first - m_subs._Mypair._Myval2._Myfirst[1].first + m_subs._Mypair._Myval2._Myfirst[2].second - m_subs._Mypair._Myval2._Myfirst[2].first + + m_subs._Mypair._Myval2._Mylast - m_subs._Mypair._Myval2._Myfirst - 2 + m_subs._Mypair._Myval2._Myfirst + 2 + + + + + + + + This item is empty. + m_subs._Mypair._Myval2._Mylast - m_subs._Mypair._Myval2._Myfirst - 3 + m_subs._Mypair._Myval2._Myfirst[2].first - m_subs._Mypair._Myval2._Myfirst[1].first + m_subs._Mypair._Myval2._Myfirst[2].second - m_subs._Mypair._Myval2._Myfirst[2].first + + m_subs._Mypair._Myval2._Mylast - m_subs._Mypair._Myval2._Myfirst - 2 + m_subs._Mypair._Myval2._Myfirst + 2 + + + + + + + + This item is empty. + m_subs._Mypair._Myval2._Mylast - m_subs._Mypair._Myval2._Myfirst - 3 + m_subs._Mypair._Myval2._Myfirst[2].first - m_subs._Mypair._Myval2._Myfirst[1].first + m_subs._Mypair._Myval2._Myfirst[2].second - m_subs._Mypair._Myval2._Myfirst[2].first + + m_subs._Mypair._Myval2._Mylast - m_subs._Mypair._Myval2._Myfirst - 2 + m_subs._Mypair._Myval2._Myfirst + 2 + + + + + + + + m_subs._Mypair._Myval2._Mylast - m_subs._Mypair._Myval2._Myfirst - 3 + m_subs._Mypair._Myval2._Myfirst[2].first._Ptr - m_subs._Mypair._Myval2._Myfirst[1].first._Ptr + m_subs._Mypair._Myval2._Myfirst[2].second._Ptr - m_subs._Mypair._Myval2._Myfirst[2].first._Ptr + + m_subs._Mypair._Myval2._Mylast - m_subs._Mypair._Myval2._Myfirst - 2 + m_subs._Mypair._Myval2._Myfirst + 2 + + + This item is empty + + + + + diff --git a/VS2022/Visualizers/boost_SmartPointers.natvis b/VS2022/Visualizers/boost_SmartPointers.natvis new file mode 100644 index 0000000..c954b4f --- /dev/null +++ b/VS2022/Visualizers/boost_SmartPointers.natvis @@ -0,0 +1,199 @@ + + + + px,na + empty + scoped_ptr {*px} + + px + + + + + px,na + empty + scoped_array {px} + + &px + + + + + default + + + + + + custom deleter + + del + + + + + custom deleter, custom allocator + + d_ + a_ + + + + + + + + px,na + empty + shared_ptr {*px} [{use_count()} strong ref] [{*pn.pi_}] + shared_ptr {*px} [{use_count()} strong ref, {weak_count() - 1} weak ref] [{*pn.pi_}] + shared_ptr {*px} [{use_count()} strong ref, {weak_count() - 1} weak refs] [{*pn.pi_}] + shared_ptr {*px} [{use_count()} strong refs] [{*pn.pi_}] + shared_ptr {*px} [{use_count()} strong refs, {weak_count() - 1} weak ref] [{*pn.pi_}] + shared_ptr {*px} [{use_count()} strong refs, {weak_count() - 1} weak refs] [{*pn.pi_}] + + px + *pn.pi_ + + + + + + + + px,na + empty + nullptr + {*px} + shared_ptr {*px} [{use_count()} strong ref] [{*pn.pi_}] + shared_ptr {*px} [{use_count()} strong ref, {weak_count() - 1} weak ref] [{*pn.pi_}] + shared_ptr {*px} [{use_count()} strong ref, {weak_count() - 1} weak refs] [{*pn.pi_}] + shared_ptr {*px} [{use_count()} strong refs] [{*pn.pi_}] + shared_ptr {*px} [{use_count()} strong refs, {weak_count() - 1} weak ref] [{*pn.pi_}] + shared_ptr {*px} [{use_count()} strong refs, {weak_count() - 1} weak refs] [{*pn.pi_}] + + px + *pn.pi_ + + + + + + + + px,na + empty + nullptr + {*px} + shared_ptr {*px} [{use_count()} strong ref] [{*pn.pi_}] + shared_ptr {*px} [{use_count()} strong ref, {weak_count() - 1} weak ref] [{*pn.pi_}] + shared_ptr {*px} [{use_count()} strong ref, {weak_count() - 1} weak refs] [{*pn.pi_}] + shared_ptr {*px} [{use_count()} strong refs] [{*pn.pi_}] + shared_ptr {*px} [{use_count()} strong refs, {weak_count() - 1} weak ref] [{*pn.pi_}] + shared_ptr {*px} [{use_count()} strong refs, {weak_count() - 1} weak refs] [{*pn.pi_}] + + px + *pn.pi_ + + + + + + + + empty + expired [{weak_count()} weak ref] [{*pn.pi_}] + expired [{weak_count()} weak refs] [{*pn.pi_}] + weak_ptr {*px} [{use_count()} strong ref, {weak_count() - 1} weak ref] [{*pn.pi_}] + weak_ptr {*px} [{use_count()} strong ref, {weak_count() - 1} weak refs] [{*pn.pi_}] + weak_ptr {*px} [{use_count()} strong refs, {weak_count() - 1} weak ref] [{*pn.pi_}] + weak_ptr {*px} [{use_count()} strong refs, {weak_count() - 1} weak refs] [{*pn.pi_}] + + px + *pn.pi_ + + + + + + + + empty + nullptr + {*px} + expired [{weak_count()} weak ref] [{*pn.pi_}] + expired [{weak_count()} weak refs] [{*pn.pi_}] + weak_ptr {*px} [{use_count()} strong ref, {weak_count() - 1} weak ref] [{*pn.pi_}] + weak_ptr {*px} [{use_count()} strong ref, {weak_count() - 1} weak refs] [{*pn.pi_}] + weak_ptr {*px} [{use_count()} strong refs, {weak_count() - 1} weak ref] [{*pn.pi_}] + weak_ptr {*px} [{use_count()} strong refs, {weak_count() - 1} weak refs] [{*pn.pi_}] + + px + *pn.pi_ + + + + + + + + empty + nullptr + {*px} + expired [{weak_count()} weak ref] [{*pn.pi_}] + expired [{weak_count()} weak refs] [{*pn.pi_}] + weak_ptr {*px} [{use_count()} strong ref, {weak_count() - 1} weak ref] [{*pn.pi_}] + weak_ptr {*px} [{use_count()} strong ref, {weak_count() - 1} weak refs] [{*pn.pi_}] + weak_ptr {*px} [{use_count()} strong refs, {weak_count() - 1} weak ref] [{*pn.pi_}] + weak_ptr {*px} [{use_count()} strong refs, {weak_count() - 1} weak refs] [{*pn.pi_}] + + px + *pn.pi_ + + + + + px,na + empty + intrusive_ptr {*px} + + px + + + + + + + + px,na + empty + shared_array {*px} [{use_count()} strong ref] [{*pn.pi_}] + shared_array {*px} [{use_count()} strong ref, {weak_count() - 1} weak ref] [{*pn.pi_}] + shared_array {*px} [{use_count()} strong ref, {weak_count() - 1} weak refs] [{*pn.pi_}] + shared_array {*px} [{use_count()} strong refs] [{*pn.pi_}] + shared_array {*px} [{use_count()} strong refs, {weak_count() - 1} weak ref] [{*pn.pi_}] + shared_array {*px} [{use_count()} strong refs, {weak_count() - 1} weak refs] [{*pn.pi_}] + + px + *pn.pi_ + + + + + + + + px,na + empty + shared_array {*px} [{use_count()} strong ref] [{*pn.pi_}] + shared_array {*px} [{use_count()} strong ref, {weak_count() - 1} weak ref] [{*pn.pi_}] + shared_array {*px} [{use_count()} strong ref, {weak_count() - 1} weak refs] [{*pn.pi_}] + shared_array {*px} [{use_count()} strong refs] [{*pn.pi_}] + shared_array {*px} [{use_count()} strong refs, {weak_count() - 1} weak ref] [{*pn.pi_}] + shared_array {*px} [{use_count()} strong refs, {weak_count() - 1} weak refs] [{*pn.pi_}] + + px + *pn.pi_ + + + diff --git a/VS2022/Visualizers/boost_Unordered.natvis b/VS2022/Visualizers/boost_Unordered.natvis new file mode 100644 index 0000000..3e4d114 --- /dev/null +++ b/VS2022/Visualizers/boost_Unordered.natvis @@ -0,0 +1,135 @@ + + + + + + {{ size={size_} }} + + + size_ + buckets_[bucket_count_].next_ + next_ + *((std::pair<$T2 const ,$T3>*)&((boost::unordered::detail::ptr_node<std::pair<$T2 const ,$T3> >*)this)->data_) + + + + + + + + {{ size={size_} }} + + + size_ + buckets_[bucket_count_].next_ + next_ + *((std::pair<$T2 const ,$T3>*)&((boost::unordered::detail::ptr_node<std::pair<$T2 const ,$T3> >*)this)->value_base_.data_) + + + + + + + + {{ size={size_} }} + + + size_ + buckets_[bucket_count_].next_ + next_ + *((std::pair<$T2 const ,$T3>*)&((boost::unordered::detail::ptr_node<std::pair<$T2 const ,$T3> >*)this)->value_base_.data_),view(MapHelper) + + + + + + + {{ size={size_} }} + + + size_ + buckets_[bucket_count_].next_ + next_ + *((std::pair<$T2 const ,$T3>*)&((boost::unordered::detail::grouped_ptr_node<std::pair<$T2 const ,$T3> >*)this)->data_) + + + + + + + {{ size={size_} }} + + + size_ + buckets_[bucket_count_].next_ + next_ + *((std::pair<$T2 const ,$T3>*)&((boost::unordered::detail::grouped_ptr_node<std::pair<$T2 const ,$T3> >*)this)->value_base_.data_) + + + + + + + {{ size={size_} }} + + + size_ + buckets_[bucket_count_].next_ + next_ + *(($T2*)&((boost::unordered::detail::ptr_node<$T2>*)this)->data_) + + + + + + + + {{ size={size_} }} + + + size_ + buckets_[bucket_count_].next_ + next_ + *(($T2*)&((boost::unordered::detail::ptr_node<$T2>*)this)->value_base_.data_) + + + + + + + {{ size={size_} }} + + + size_ + buckets_[bucket_count_].next_ + next_ + *(($T2*)&((boost::unordered::detail::grouped_ptr_node<$T2>*)this)->data_) + + + + + + + {{ size={size_} }} + + + size_ + buckets_[bucket_count_].next_ + next_ + *(($T2*)&((boost::unordered::detail::grouped_ptr_node<$T2>*)this)->value_base_.data_) + + + + + + + + + {table_} + + table_ + + + diff --git a/VS2022/Visualizers/boost_Variant.natvis b/VS2022/Visualizers/boost_Variant.natvis new file mode 100644 index 0000000..bde47f4 --- /dev/null +++ b/VS2022/Visualizers/boost_Variant.natvis @@ -0,0 +1,615 @@ + + + + + + + + + + + + + + + + which_ + storage_ + + + + + + which_ + storage_ + + + + + + + + {*($T1 *)&(storage_.data_.buf)} + + *($T1 *)&(storage_.data_.buf) + + + + + + + + {*($T1 *)&(storage_.data_.buf)} + {*($T2 *)&(storage_.data_.buf)} + + *($T1 *)&(storage_.data_.buf) + *($T2 *)&(storage_.data_.buf) + + + + + + + + {*($T1 *)&(storage_.data_.buf)} + {*($T2 *)&(storage_.data_.buf)} + {*($T3 *)&(storage_.data_.buf)} + + *($T1 *)&(storage_.data_.buf) + *($T2 *)&(storage_.data_.buf) + *($T3 *)&(storage_.data_.buf) + + + + + + + + {*($T1 *)&(storage_.data_.buf)} + {*($T2 *)&(storage_.data_.buf)} + {*($T3 *)&(storage_.data_.buf)} + {*($T4 *)&(storage_.data_.buf)} + + *($T1 *)&(storage_.data_.buf) + *($T2 *)&(storage_.data_.buf) + *($T3 *)&(storage_.data_.buf) + *($T4 *)&(storage_.data_.buf) + + + + + + + + {*($T1 *)&(storage_.data_.buf)} + {*($T2 *)&(storage_.data_.buf)} + {*($T3 *)&(storage_.data_.buf)} + {*($T4 *)&(storage_.data_.buf)} + {*($T5 *)&(storage_.data_.buf)} + + *($T1 *)&(storage_.data_.buf) + *($T2 *)&(storage_.data_.buf) + *($T3 *)&(storage_.data_.buf) + *($T4 *)&(storage_.data_.buf) + *($T5 *)&(storage_.data_.buf) + + + + + + + + {*($T1 *)&(storage_.data_.buf)} + {*($T2 *)&(storage_.data_.buf)} + {*($T3 *)&(storage_.data_.buf)} + {*($T4 *)&(storage_.data_.buf)} + {*($T5 *)&(storage_.data_.buf)} + {*($T6 *)&(storage_.data_.buf)} + + *($T1 *)&(storage_.data_.buf) + *($T2 *)&(storage_.data_.buf) + *($T3 *)&(storage_.data_.buf) + *($T4 *)&(storage_.data_.buf) + *($T5 *)&(storage_.data_.buf) + *($T6 *)&(storage_.data_.buf) + + + + + + + + {*($T1 *)&(storage_.data_.buf)} + {*($T2 *)&(storage_.data_.buf)} + {*($T3 *)&(storage_.data_.buf)} + {*($T4 *)&(storage_.data_.buf)} + {*($T5 *)&(storage_.data_.buf)} + {*($T6 *)&(storage_.data_.buf)} + {*($T7 *)&(storage_.data_.buf)} + + *($T1 *)&(storage_.data_.buf) + *($T2 *)&(storage_.data_.buf) + *($T3 *)&(storage_.data_.buf) + *($T4 *)&(storage_.data_.buf) + *($T5 *)&(storage_.data_.buf) + *($T6 *)&(storage_.data_.buf) + *($T7 *)&(storage_.data_.buf) + + + + + + + + {*($T1 *)&(storage_.data_.buf)} + {*($T2 *)&(storage_.data_.buf)} + {*($T3 *)&(storage_.data_.buf)} + {*($T4 *)&(storage_.data_.buf)} + {*($T5 *)&(storage_.data_.buf)} + {*($T6 *)&(storage_.data_.buf)} + {*($T7 *)&(storage_.data_.buf)} + {*($T8 *)&(storage_.data_.buf)} + + *($T1 *)&(storage_.data_.buf) + *($T2 *)&(storage_.data_.buf) + *($T3 *)&(storage_.data_.buf) + *($T4 *)&(storage_.data_.buf) + *($T5 *)&(storage_.data_.buf) + *($T6 *)&(storage_.data_.buf) + *($T7 *)&(storage_.data_.buf) + *($T8 *)&(storage_.data_.buf) + + + + + + + + {*($T1 *)&(storage_.data_.buf)} + {*($T2 *)&(storage_.data_.buf)} + {*($T3 *)&(storage_.data_.buf)} + {*($T4 *)&(storage_.data_.buf)} + {*($T5 *)&(storage_.data_.buf)} + {*($T6 *)&(storage_.data_.buf)} + {*($T7 *)&(storage_.data_.buf)} + {*($T8 *)&(storage_.data_.buf)} + {*($T9 *)&(storage_.data_.buf)} + + *($T1 *)&(storage_.data_.buf) + *($T2 *)&(storage_.data_.buf) + *($T3 *)&(storage_.data_.buf) + *($T4 *)&(storage_.data_.buf) + *($T5 *)&(storage_.data_.buf) + *($T6 *)&(storage_.data_.buf) + *($T7 *)&(storage_.data_.buf) + *($T8 *)&(storage_.data_.buf) + *($T9 *)&(storage_.data_.buf) + + + + + + + + {*($T1 *)&(storage_.data_.buf)} + {*($T2 *)&(storage_.data_.buf)} + {*($T3 *)&(storage_.data_.buf)} + {*($T4 *)&(storage_.data_.buf)} + {*($T5 *)&(storage_.data_.buf)} + {*($T6 *)&(storage_.data_.buf)} + {*($T7 *)&(storage_.data_.buf)} + {*($T8 *)&(storage_.data_.buf)} + {*($T9 *)&(storage_.data_.buf)} + {*($T10 *)&(storage_.data_.buf)} + + *($T1 *)&(storage_.data_.buf) + *($T2 *)&(storage_.data_.buf) + *($T3 *)&(storage_.data_.buf) + *($T4 *)&(storage_.data_.buf) + *($T5 *)&(storage_.data_.buf) + *($T6 *)&(storage_.data_.buf) + *($T7 *)&(storage_.data_.buf) + *($T8 *)&(storage_.data_.buf) + *($T9 *)&(storage_.data_.buf) + *($T10 *)&(storage_.data_.buf) + + + + + + + + {*($T1 *)&(storage_.data_.buf)} + {*($T2 *)&(storage_.data_.buf)} + {*($T3 *)&(storage_.data_.buf)} + {*($T4 *)&(storage_.data_.buf)} + {*($T5 *)&(storage_.data_.buf)} + {*($T6 *)&(storage_.data_.buf)} + {*($T7 *)&(storage_.data_.buf)} + {*($T8 *)&(storage_.data_.buf)} + {*($T9 *)&(storage_.data_.buf)} + {*($T10 *)&(storage_.data_.buf)} + {*($T11 *)&(storage_.data_.buf)} + + *($T1 *)&(storage_.data_.buf) + *($T2 *)&(storage_.data_.buf) + *($T3 *)&(storage_.data_.buf) + *($T4 *)&(storage_.data_.buf) + *($T5 *)&(storage_.data_.buf) + *($T6 *)&(storage_.data_.buf) + *($T7 *)&(storage_.data_.buf) + *($T8 *)&(storage_.data_.buf) + *($T9 *)&(storage_.data_.buf) + *($T10 *)&(storage_.data_.buf) + *($T11 *)&(storage_.data_.buf) + + + + + + + + {*($T1 *)&(storage_.data_.buf)} + {*($T2 *)&(storage_.data_.buf)} + {*($T3 *)&(storage_.data_.buf)} + {*($T4 *)&(storage_.data_.buf)} + {*($T5 *)&(storage_.data_.buf)} + {*($T6 *)&(storage_.data_.buf)} + {*($T7 *)&(storage_.data_.buf)} + {*($T8 *)&(storage_.data_.buf)} + {*($T9 *)&(storage_.data_.buf)} + {*($T10 *)&(storage_.data_.buf)} + {*($T11 *)&(storage_.data_.buf)} + {*($T12 *)&(storage_.data_.buf)} + + *($T1 *)&(storage_.data_.buf) + *($T2 *)&(storage_.data_.buf) + *($T3 *)&(storage_.data_.buf) + *($T4 *)&(storage_.data_.buf) + *($T5 *)&(storage_.data_.buf) + *($T6 *)&(storage_.data_.buf) + *($T7 *)&(storage_.data_.buf) + *($T8 *)&(storage_.data_.buf) + *($T9 *)&(storage_.data_.buf) + *($T10 *)&(storage_.data_.buf) + *($T11 *)&(storage_.data_.buf) + *($T12 *)&(storage_.data_.buf) + + + + + + + + {*($T1 *)&(storage_.data_.buf)} + {*($T2 *)&(storage_.data_.buf)} + {*($T3 *)&(storage_.data_.buf)} + {*($T4 *)&(storage_.data_.buf)} + {*($T5 *)&(storage_.data_.buf)} + {*($T6 *)&(storage_.data_.buf)} + {*($T7 *)&(storage_.data_.buf)} + {*($T8 *)&(storage_.data_.buf)} + {*($T9 *)&(storage_.data_.buf)} + {*($T10 *)&(storage_.data_.buf)} + {*($T11 *)&(storage_.data_.buf)} + {*($T12 *)&(storage_.data_.buf)} + {*($T13 *)&(storage_.data_.buf)} + + *($T1 *)&(storage_.data_.buf) + *($T2 *)&(storage_.data_.buf) + *($T3 *)&(storage_.data_.buf) + *($T4 *)&(storage_.data_.buf) + *($T5 *)&(storage_.data_.buf) + *($T6 *)&(storage_.data_.buf) + *($T7 *)&(storage_.data_.buf) + *($T8 *)&(storage_.data_.buf) + *($T9 *)&(storage_.data_.buf) + *($T10 *)&(storage_.data_.buf) + *($T11 *)&(storage_.data_.buf) + *($T12 *)&(storage_.data_.buf) + *($T13 *)&(storage_.data_.buf) + + + + + + + + {*($T1 *)&(storage_.data_.buf)} + {*($T2 *)&(storage_.data_.buf)} + {*($T3 *)&(storage_.data_.buf)} + {*($T4 *)&(storage_.data_.buf)} + {*($T5 *)&(storage_.data_.buf)} + {*($T6 *)&(storage_.data_.buf)} + {*($T7 *)&(storage_.data_.buf)} + {*($T8 *)&(storage_.data_.buf)} + {*($T9 *)&(storage_.data_.buf)} + {*($T10 *)&(storage_.data_.buf)} + {*($T11 *)&(storage_.data_.buf)} + {*($T12 *)&(storage_.data_.buf)} + {*($T13 *)&(storage_.data_.buf)} + {*($T14 *)&(storage_.data_.buf)} + + *($T1 *)&(storage_.data_.buf) + *($T2 *)&(storage_.data_.buf) + *($T3 *)&(storage_.data_.buf) + *($T4 *)&(storage_.data_.buf) + *($T5 *)&(storage_.data_.buf) + *($T6 *)&(storage_.data_.buf) + *($T7 *)&(storage_.data_.buf) + *($T8 *)&(storage_.data_.buf) + *($T9 *)&(storage_.data_.buf) + *($T10 *)&(storage_.data_.buf) + *($T11 *)&(storage_.data_.buf) + *($T12 *)&(storage_.data_.buf) + *($T13 *)&(storage_.data_.buf) + *($T14 *)&(storage_.data_.buf) + + + + + + + + {*($T1 *)&(storage_.data_.buf)} + {*($T2 *)&(storage_.data_.buf)} + {*($T3 *)&(storage_.data_.buf)} + {*($T4 *)&(storage_.data_.buf)} + {*($T5 *)&(storage_.data_.buf)} + {*($T6 *)&(storage_.data_.buf)} + {*($T7 *)&(storage_.data_.buf)} + {*($T8 *)&(storage_.data_.buf)} + {*($T9 *)&(storage_.data_.buf)} + {*($T10 *)&(storage_.data_.buf)} + {*($T11 *)&(storage_.data_.buf)} + {*($T12 *)&(storage_.data_.buf)} + {*($T13 *)&(storage_.data_.buf)} + {*($T14 *)&(storage_.data_.buf)} + {*($T15 *)&(storage_.data_.buf)} + + *($T1 *)&(storage_.data_.buf) + *($T2 *)&(storage_.data_.buf) + *($T3 *)&(storage_.data_.buf) + *($T4 *)&(storage_.data_.buf) + *($T5 *)&(storage_.data_.buf) + *($T6 *)&(storage_.data_.buf) + *($T7 *)&(storage_.data_.buf) + *($T8 *)&(storage_.data_.buf) + *($T9 *)&(storage_.data_.buf) + *($T10 *)&(storage_.data_.buf) + *($T11 *)&(storage_.data_.buf) + *($T12 *)&(storage_.data_.buf) + *($T13 *)&(storage_.data_.buf) + *($T14 *)&(storage_.data_.buf) + *($T15 *)&(storage_.data_.buf) + + + + + + + + {*($T1 *)&(storage_.data_.buf)} + {*($T2 *)&(storage_.data_.buf)} + {*($T3 *)&(storage_.data_.buf)} + {*($T4 *)&(storage_.data_.buf)} + {*($T5 *)&(storage_.data_.buf)} + {*($T6 *)&(storage_.data_.buf)} + {*($T7 *)&(storage_.data_.buf)} + {*($T8 *)&(storage_.data_.buf)} + {*($T9 *)&(storage_.data_.buf)} + {*($T10 *)&(storage_.data_.buf)} + {*($T11 *)&(storage_.data_.buf)} + {*($T12 *)&(storage_.data_.buf)} + {*($T13 *)&(storage_.data_.buf)} + {*($T14 *)&(storage_.data_.buf)} + {*($T15 *)&(storage_.data_.buf)} + {*($T16 *)&(storage_.data_.buf)} + + *($T1 *)&(storage_.data_.buf) + *($T2 *)&(storage_.data_.buf) + *($T3 *)&(storage_.data_.buf) + *($T4 *)&(storage_.data_.buf) + *($T5 *)&(storage_.data_.buf) + *($T6 *)&(storage_.data_.buf) + *($T7 *)&(storage_.data_.buf) + *($T8 *)&(storage_.data_.buf) + *($T9 *)&(storage_.data_.buf) + *($T10 *)&(storage_.data_.buf) + *($T11 *)&(storage_.data_.buf) + *($T12 *)&(storage_.data_.buf) + *($T13 *)&(storage_.data_.buf) + *($T14 *)&(storage_.data_.buf) + *($T15 *)&(storage_.data_.buf) + *($T16 *)&(storage_.data_.buf) + + + + + + + + {*($T1 *)&(storage_.data_.buf)} + {*($T2 *)&(storage_.data_.buf)} + {*($T3 *)&(storage_.data_.buf)} + {*($T4 *)&(storage_.data_.buf)} + {*($T5 *)&(storage_.data_.buf)} + {*($T6 *)&(storage_.data_.buf)} + {*($T7 *)&(storage_.data_.buf)} + {*($T8 *)&(storage_.data_.buf)} + {*($T9 *)&(storage_.data_.buf)} + {*($T10 *)&(storage_.data_.buf)} + {*($T11 *)&(storage_.data_.buf)} + {*($T12 *)&(storage_.data_.buf)} + {*($T13 *)&(storage_.data_.buf)} + {*($T14 *)&(storage_.data_.buf)} + {*($T15 *)&(storage_.data_.buf)} + {*($T16 *)&(storage_.data_.buf)} + {*($T17 *)&(storage_.data_.buf)} + + *($T1 *)&(storage_.data_.buf) + *($T2 *)&(storage_.data_.buf) + *($T3 *)&(storage_.data_.buf) + *($T4 *)&(storage_.data_.buf) + *($T5 *)&(storage_.data_.buf) + *($T6 *)&(storage_.data_.buf) + *($T7 *)&(storage_.data_.buf) + *($T8 *)&(storage_.data_.buf) + *($T9 *)&(storage_.data_.buf) + *($T10 *)&(storage_.data_.buf) + *($T11 *)&(storage_.data_.buf) + *($T12 *)&(storage_.data_.buf) + *($T13 *)&(storage_.data_.buf) + *($T14 *)&(storage_.data_.buf) + *($T15 *)&(storage_.data_.buf) + *($T16 *)&(storage_.data_.buf) + *($T17 *)&(storage_.data_.buf) + + + + + + + + {*($T1 *)&(storage_.data_.buf)} + {*($T2 *)&(storage_.data_.buf)} + {*($T3 *)&(storage_.data_.buf)} + {*($T4 *)&(storage_.data_.buf)} + {*($T5 *)&(storage_.data_.buf)} + {*($T6 *)&(storage_.data_.buf)} + {*($T7 *)&(storage_.data_.buf)} + {*($T8 *)&(storage_.data_.buf)} + {*($T9 *)&(storage_.data_.buf)} + {*($T10 *)&(storage_.data_.buf)} + {*($T11 *)&(storage_.data_.buf)} + {*($T12 *)&(storage_.data_.buf)} + {*($T13 *)&(storage_.data_.buf)} + {*($T14 *)&(storage_.data_.buf)} + {*($T15 *)&(storage_.data_.buf)} + {*($T16 *)&(storage_.data_.buf)} + {*($T17 *)&(storage_.data_.buf)} + {*($T18 *)&(storage_.data_.buf)} + + *($T1 *)&(storage_.data_.buf) + *($T2 *)&(storage_.data_.buf) + *($T3 *)&(storage_.data_.buf) + *($T4 *)&(storage_.data_.buf) + *($T5 *)&(storage_.data_.buf) + *($T6 *)&(storage_.data_.buf) + *($T7 *)&(storage_.data_.buf) + *($T8 *)&(storage_.data_.buf) + *($T9 *)&(storage_.data_.buf) + *($T10 *)&(storage_.data_.buf) + *($T11 *)&(storage_.data_.buf) + *($T12 *)&(storage_.data_.buf) + *($T13 *)&(storage_.data_.buf) + *($T14 *)&(storage_.data_.buf) + *($T15 *)&(storage_.data_.buf) + *($T16 *)&(storage_.data_.buf) + *($T17 *)&(storage_.data_.buf) + *($T18 *)&(storage_.data_.buf) + + + + + + + + {*($T1 *)&(storage_.data_.buf)} + {*($T2 *)&(storage_.data_.buf)} + {*($T3 *)&(storage_.data_.buf)} + {*($T4 *)&(storage_.data_.buf)} + {*($T5 *)&(storage_.data_.buf)} + {*($T6 *)&(storage_.data_.buf)} + {*($T7 *)&(storage_.data_.buf)} + {*($T8 *)&(storage_.data_.buf)} + {*($T9 *)&(storage_.data_.buf)} + {*($T10 *)&(storage_.data_.buf)} + {*($T11 *)&(storage_.data_.buf)} + {*($T12 *)&(storage_.data_.buf)} + {*($T13 *)&(storage_.data_.buf)} + {*($T14 *)&(storage_.data_.buf)} + {*($T15 *)&(storage_.data_.buf)} + {*($T16 *)&(storage_.data_.buf)} + {*($T17 *)&(storage_.data_.buf)} + {*($T18 *)&(storage_.data_.buf)} + {*($T19 *)&(storage_.data_.buf)} + + *($T1 *)&(storage_.data_.buf) + *($T2 *)&(storage_.data_.buf) + *($T3 *)&(storage_.data_.buf) + *($T4 *)&(storage_.data_.buf) + *($T5 *)&(storage_.data_.buf) + *($T6 *)&(storage_.data_.buf) + *($T7 *)&(storage_.data_.buf) + *($T8 *)&(storage_.data_.buf) + *($T9 *)&(storage_.data_.buf) + *($T10 *)&(storage_.data_.buf) + *($T11 *)&(storage_.data_.buf) + *($T12 *)&(storage_.data_.buf) + *($T13 *)&(storage_.data_.buf) + *($T14 *)&(storage_.data_.buf) + *($T15 *)&(storage_.data_.buf) + *($T16 *)&(storage_.data_.buf) + *($T17 *)&(storage_.data_.buf) + *($T18 *)&(storage_.data_.buf) + *($T19 *)&(storage_.data_.buf) + + + + + + + + {*($T1 *)&(storage_.data_.buf)} + {*($T2 *)&(storage_.data_.buf)} + {*($T3 *)&(storage_.data_.buf)} + {*($T4 *)&(storage_.data_.buf)} + {*($T5 *)&(storage_.data_.buf)} + {*($T6 *)&(storage_.data_.buf)} + {*($T7 *)&(storage_.data_.buf)} + {*($T8 *)&(storage_.data_.buf)} + {*($T9 *)&(storage_.data_.buf)} + {*($T10 *)&(storage_.data_.buf)} + {*($T11 *)&(storage_.data_.buf)} + {*($T12 *)&(storage_.data_.buf)} + {*($T13 *)&(storage_.data_.buf)} + {*($T14 *)&(storage_.data_.buf)} + {*($T15 *)&(storage_.data_.buf)} + {*($T16 *)&(storage_.data_.buf)} + {*($T17 *)&(storage_.data_.buf)} + {*($T18 *)&(storage_.data_.buf)} + {*($T19 *)&(storage_.data_.buf)} + {*($T20 *)&(storage_.data_.buf)} + + *($T1 *)&(storage_.data_.buf) + *($T2 *)&(storage_.data_.buf) + *($T3 *)&(storage_.data_.buf) + *($T4 *)&(storage_.data_.buf) + *($T5 *)&(storage_.data_.buf) + *($T6 *)&(storage_.data_.buf) + *($T7 *)&(storage_.data_.buf) + *($T8 *)&(storage_.data_.buf) + *($T9 *)&(storage_.data_.buf) + *($T10 *)&(storage_.data_.buf) + *($T11 *)&(storage_.data_.buf) + *($T12 *)&(storage_.data_.buf) + *($T13 *)&(storage_.data_.buf) + *($T14 *)&(storage_.data_.buf) + *($T15 *)&(storage_.data_.buf) + *($T16 *)&(storage_.data_.buf) + *($T17 *)&(storage_.data_.buf) + *($T18 *)&(storage_.data_.buf) + *($T19 *)&(storage_.data_.buf) + *($T20 *)&(storage_.data_.buf) + + + + + p_,na + {*p_} + + p_ + + + diff --git a/VS2022/Visualizers/boost_uBLAS.natvis b/VS2022/Visualizers/boost_uBLAS.natvis new file mode 100644 index 0000000..8e40c06 --- /dev/null +++ b/VS2022/Visualizers/boost_uBLAS.natvis @@ -0,0 +1,93 @@ + + + + + {{ size={size_} }} + + size_ + + size_ + data_ + + + + + + {data_} + + data_ + + + + + {{ size={size_} }} + + size_ + data_ + + + + + {{ size={size_} filled={filled_} }} + + size_ + capacity_ + filled_ + index_data_ + value_data_ + + + + + {{ size={size_} filled={filled_} }} + + size_ + capacity_ + sorted_ + filled_ + sorted_filled_ + index_data_ + value_data_ + + + + + {{ size={size1_}x{size2_} }} + + data_.size_ + + Forward + 2 + size1_ + size2_ + data_.data_ + + + + + + {{ size={size1_}x{size2_} }} + + size1_ + size2_ + + + + + {{ size={size1_}x{size2_} }} + + size1_ + size2_ + + + + + {{ size={size1_}x{size2_} }} + + size1_ + size2_ + value_ + + + + diff --git a/VS2022/Visualizers/directx.natvis b/VS2022/Visualizers/directx.natvis new file mode 100644 index 0000000..3dff32c --- /dev/null +++ b/VS2022/Visualizers/directx.natvis @@ -0,0 +1,622 @@ + + + + + 0x887A0006 + The application's device failed due to badly formed commands sent by the application. This is an design-time issue that should be investigated and fixed. + + + 0x887A0005 + The video card has been physically removed from the system, or a driver upgrade for the video card has occurred. The application should destroy and recreate the device. For help debugging the problem, call ID3D10Device::GetDeviceRemovedReason. + + + 0x887A0007 + The device failed due to a badly formed command. This is a run-time issue; The application should destroy and recreate the device. + + + 0x887A0020 + The driver encountered a problem and was put into the device removed state. + + + 0x887A000B + An event (for example, a power cycle) interrupted the gathering of presentation statistics. + + + 0x887A000C + The application attempted to acquire exclusive ownership of an output, but failed because some other application (or device within the application) already acquired ownership. + + + 0x887A0001 + The application provided invalid parameter data; this must be debugged and fixed before the application is released. + + + 0x887A0003 + The buffer supplied by the application is not big enough to hold the requested data. + + + 0x887A0021 + A global counter resource is in use, and the Direct3D device can't currently use the counter resource. + + + 0x887A0022 + The resource or request is not currently available, but it might become available later. + + + 0x887A0002 + When calling IDXGIObject::GetPrivateData, the GUID passed in is not recognized as one previously passed to IDXGIObject::SetPrivateData or IDXGIObject::SetPrivateDataInterface. When calling IDXGIFactory::EnumAdapters or IDXGIAdapter::EnumOutputs, the enumerated ordinal is out of range. + + + 0x887a0023 + Reserved + + + 0x887A0024 + Reserved + + + 0x887A000A + The GPU was busy at the moment when a call was made to perform an operation, and did not execute or schedule the operation. + + + 0x887A0004 + The requested functionality is not supported by the device or the driver. + + + 0x887A0026 + The desktop duplication interface is invalid. The desktop duplication interface typically becomes invalid when a different type of image is displayed on the desktop. + + + 0x887A0027 + The time-out interval elapsed before the next desktop frame was available. + + + 0x887A0028 + The Remote Desktop Services session is currently disconnected. + + + 0x887A0029 + The DXGI outuput (monitor) to which the swap chain content was restricted is now disconnected or changed. + + + 0x887A002A + DXGI can't provide content protection on the swap chain. This error is typically caused by an older driver, or when you use a swap chain that is incompatible with content protection. + + + 0x887A002B + You tried to use a resource to which you did not have the required access privileges. This error is most typically caused when you write to a shared resource with read-only access. + + + 0x887A002C + The supplied name of a resource in a call to IDXGIResource1::CreateSharedHandle is already associated with some other resource. + + + 0x087a0001 + The window content is not visible. When receiving this status, an application can stop rendering and use DXGI_PRESENT_TEST to determine when to resume rendering. + + + 0x087a0002 + The Present operation was partially invisible to the user. + + + 0x087a0004 + The driver is requesting that the DXGI runtime not use shared resources to communicate with the Desktop Window Manager. + + + 0x087a0005 + The Present operation was not visible because the Windows session has switched to another desktop (for example, ctrl-alt-del). + + + 0x087a0006 + The Present operation was not visible because the target monitor was being used for some other purpose. + + + 0x087a0007 + The desktop display mode has been changed, there might be color conversion/stretching. The application should call IDXGISwapChain::ResizeBuffers to match the new display mode. + + + 0x087a0008 + IDXGISwapChain::ResizeTarget and IDXGISwapChain::SetFullscreenState will return DXGI_STATUS_MODE_CHANGE_IN_PROGRESS if a fullscreen/windowed mode transition is occurring when either API is called. + + + + + 2289436696 + The pixel format of the texture surface is not valid. + + + 2289436697 + The device does not support a specified texture-blending operation for color values. + + + 2289436698 + The device does not support a specified texture-blending argument for color values. + + + 2289436699 + The device does not support a specified texture-blending operation for the alpha channel. + + + 2289436700 + The device does not support a specified texture-blending argument for the alpha channel. + + + 2289436701 + The application is requesting more texture-filtering operations than the device supports. + + + 2289436702 + The current texture filters cannot be used together. + + + 2289436703 + The device does not support the specified texture factor value. Not used; provided only to support older drivers. + + + 2289436705 + The currently set render states cannot be used together. + + + 2289436706 + The device does not support the specified texture filter. + + + 2289436710 + The current textures cannot be used simultaneously. + + + 2289436711 + Internal driver error. Applications should destroy and recreate the device when receiving this error. + + + 2289436774 + The requested item was not found. + + + 2289436775 + There is more data available than the specified buffer size can hold. + + + 2289436776 + The device has been lost but cannot be reset at this time. Therefore, rendering is not possible.A Direct 3D device object other than the one that returned this code caused the hardware adapter to be reset by the OS. Delete all video memory objects (surfaces, textures, state blocks) and call Reset() to return the device to a default state. If the application continues rendering without a reset, the rendering calls will succeed. + + + 2289436777 + The device has been lost but can be reset at this time. + + + 2289436778 + This device does not support the queried technique. + + + 2289435004 + Direct3D does not have enough display memory to perform the operation. The device is using more resources in a single scene than can fit simultaneously into video memory. Present, PresentEx, or CheckDeviceState can return this error. Recovery is similar to D3DERR_DEVICEHUNG, though the application may want to reduce its per-frame memory usage as well to avoid having the error recur. + + + 2289436779 + The requested device type is not valid. + + + 2289436780 + The method call is invalid. For example, a method's parameter may not be a valid pointer. + + + 2289436781 + Not used. + + + 2289435164 + The previous blit operation that is transferring information to or from this surface is incomplete. + + + 141953135 + This is a success code. However, the autogeneration of mipmaps is not supported for this format. This means that resource creation will succeed but the mipmap levels will not be automatically generated. + + + + 2289436784 + The hardware adapter has been removed. Application must destroy the device, do enumeration of adapters and create another Direct3D device. If application continues rendering without calling Reset, the rendering calls will succeed. Applies to Direct3D 9Ex only. + + + 141953141 + At least one allocation that comprises the resources is on disk. Direct3D 9Ex only. + + + 141953142 + No allocations that comprise the resources are on disk. However, at least one allocation is not in GPU-accessible memory. Direct3D 9Ex only. + + + 141953143 + The desktop display mode has been changed. The application can continue rendering, but there might be color conversion/stretching. Pick a back buffer format similar to the current display mode, and call Reset to recreate the swap chains. The device will leave this state after a Reset is called. Direct3D 9Ex only. + + + 141953144 + The presentation area is occluded. Occlusion means that the presentation window is minimized or another device entered the fullscreen mode on the same monitor as the presentation window and the presentation window is completely on that monitor. Occlusion will not occur if the client area is covered by another Window. Occluded applications can continue rendering and all calls will succeed, but the occluded presentation window will not be updated. Preferably the application should stop rendering to the presentation window using the device and keep calling CheckDeviceState until S_OK or S_PRESENT_MODE_CHANGED returns. Direct3D 9Ex only. + + + 2289436788 + The device that returned this code caused the hardware adapter to be reset by the OS. Most applications should destroy the device and quit. Applications that must continue should destroy all video memory objects (surfaces, textures, state blocks etc) and call Reset() to put the device in a default state. If the application then continues rendering in the same way, the device will return to this state. Applies to Direct3D 9Ex only. + + + 0x8876087b + The device does not support overlay for the specified size or display mode. Direct3D 9Ex under Windows 7 only. + + + 0x8876087c + The device does not support overlay for the specified surface format. Direct3D 9Ex under Windows 7 only. + + + 0x8876087d + The specified content cannot be protected. Direct3D 9Ex under Windows 7 only. + + + 0x8876087e + The specified cryptographic algorithm is not supported. Direct3D 9Ex under Windows 7 only. + + + 0x88760884 + The present statistics have no orderly sequence. Direct3D 9Ex under Windows 7 only. + + + + + 0x88790002 + The file was not found. + + + 0x88790001 + There are too many unique instances of a particular type of state object. + + + + + 0x887c0002 + The file was not found. + + + 0x887c0001 + There are too many unique instances of a particular type of state object. + + + 0x887c0003 + There are too many unique instances of a particular type of view object. + + + 0x887c0004 + The first call to ID3D11DeviceContext::Map after either ID3D11Device::CreateDeferredContext or ID3D11DeviceContext::FinishCommandList per Resource was not D3D11_MAP_WRITE_DISCARD. + + + + + 2289434629 + + + 2289434634 + + + 2289434644 + + + 2289434664 + + + 2289434679 + + + 2289434714 + + + 2289434719 + + + 2289434724 + + + 2289434734 + + + 2289434744 + + + 2289434754 + + + 2289434769 + + + 2289434774 + + + 2289434784 + + + 2289434794 + + + 2289434795 + + + 2289434796 + + + 2289434829 + + + 2289434834 + + + 2289434836 + + + 2289434839 + + + 2289434844 + + + 2289434846 + + + 2289434849 + + + 2289434854 + + + 2289434864 + + + 2289434874 + + + 2289434879 + + + 2289434884 + + + 2289434894 + + + 2289434904 + + + 2289434914 + + + 2289434934 + + + 2289434950 + + + 2289434951 + + + 2289434954 + + + 2289434964 + + + 2289434969 + + + 2289434974 + + + 2289434984 + + + 2289434994 + + + 2289435006 + + + 2289435008 + + + 2289435011 + + + 2289435024 + + + 2289435034 + + + 2289435044 + + + 2289435054 + + + 2289435059 + + + 2289435064 + + + 2289435074 + + + 2289435084 + + + 2289435094 + + + 2289435104 + + + 2289435114 + + + 2289435134 + + + 2289435144 + + + 2289435145 + + + 2289435161 + + + 2289435166 + + + 2289435184 + + + 2289435185 + + + 2289435186 + + + 2289435187 + + + 2289435188 + + + 2289435189 + + + 2289435190 + + + 2289435191 + + + 2289435192 + + + 2289435193 + + + 2289435194 + + + 2289435195 + + + 2289435196 + + + 2289435197 + + + 2289435198 + + + 2289435199 + + + 2289435200 + + + 2289435201 + + + 2289435202 + + + 2289435203 + + + 2289435204 + + + 2289435205 + + + 2289435206 + + + 2289435207 + + + 2289435208 + + + 2289435209 + + + 2289435210 + + + 2289435211 + + + 2289435212 + + + 2289435213 + + + 2289435214 + + + 2289435215 + + + 2289435216 + + + 2289435224 + + + 2289435225 + + + 2289435226 + + + 2289435227 + + + 2289435244 + + + 2289435254 + + + 2289435264 + + + 2289435284 + + + 2289435304 + + + 2289435314 + + + 2289435315 + + + 2289435316 + + + 2289435317 + + + 2289435318 + + + 2289435319 + + + 2289435320 + + + 2289435321 + + + 2289435323 + + diff --git a/VS2022/Visualizers/external.natjmc b/VS2022/Visualizers/external.natjmc new file mode 100644 index 0000000..1fad57f --- /dev/null +++ b/VS2022/Visualizers/external.natjmc @@ -0,0 +1,8 @@ + + + + + + + + diff --git a/VS2022/Visualizers/gsl.natvis b/VS2022/Visualizers/gsl.natvis new file mode 100644 index 0000000..e53d53b --- /dev/null +++ b/VS2022/Visualizers/gsl.natvis @@ -0,0 +1,60 @@ + + + + span_.storage_.data_ + {span_.storage_.data_,[span_.storage_.size_]} + span_.storage_.data_,[span_.storage_.size_] + + span_.storage_.size_ + + span_.storage_.size_ + span_.storage_.data_ + + + + + + span_.storage_.data_ + {span_.storage_.data_,[$T2]} + span_.storage_.data_,[$T2] + + $T2 + + $T2 + span_.storage_.data_ + + + + + + storage_.data_ + {{ size={storage_.size_} }} + + storage_.size_ + + storage_.size_ + storage_.data_ + + + + + + storage_.data_ + {{ size={$T2} }} + + $T2 + + $T2 + storage_.data_ + + + + + + ptr_ + not_null {*ptr_} + + ptr_ + + + diff --git a/VS2022/Visualizers/icu.natvis b/VS2022/Visualizers/icu.natvis new file mode 100644 index 0000000..a753670 --- /dev/null +++ b/VS2022/Visualizers/icu.natvis @@ -0,0 +1,44 @@ + + + + + + + + + + + + + + {fUnion.fStackFields.fBuffer,[fUnion.fFields.fLengthAndFlags >> kLengthShift]na} + + + + + {fUnion.fFields.fArray,[fUnion.fFields.fLengthAndFlags >> kLengthShift]na} + + + + + {fUnion.fFields.fArray,[fUnion.fFields.fLength]na} + + + + + + fUnion.fStackFields.fBuffer,[fUnion.fFields.fLengthAndFlags >> kLengthShift]na + + + + + fUnion.fFields.fArray,[fUnion.fFields.fLengthAndFlags >> kLengthShift]na + + + + + fUnion.fFields.fArray,[fUnion.fFields.fLength]na + + + + diff --git a/VS2022/Visualizers/wxWidgets.natvis b/VS2022/Visualizers/wxWidgets.natvis new file mode 100644 index 0000000..61494ba --- /dev/null +++ b/VS2022/Visualizers/wxWidgets.natvis @@ -0,0 +1,140 @@ + + + + + {x},{y} + + x + y + + + + + {x}*{y} + + x + y + + + + + {x},{y} {width}*{height} + + x + y + width + height + + + + + {m_time.m_ll}ms + + + + + {m_ll} + + + + + + + + {m_impl,su} + m_impl,su + + m_impl + + + + + + {m_pchData,su} + m_pchData,su + + m_pchData + (*((wxStringData**)m_pchData) - 1)->nDataLength + (*((wxStringData**)m_pchData) - 1)->nAllocLength + (*((wxStringData**)m_pchData) - 1)->nRefs + *((wxStringData**)m_pchData) - 1 + + + + + {{ size={m_nCount} }} + + m_nCount + m_nSize + m_autoSort + + m_nCount + m_pItems + + + + + + + + + + {{ size={m_nCount} }} + + m_nCount + m_nSize + + m_nCount + m_pItems + + + + + + {{ size={m_count} }} + + + m_count + m_nodeFirst + m_next + m_data + + + + + + {{ size={m_size} }} + + m_size + m_capacity + + m_size + m_objects + + + + + + empty + wxDir {*((wchar_t**)&m_data->m_dirname),su} + + m_data + + + + + Volume {*((wchar_t**)&m_volume),su}, Dirs {m_dirs}, Name {*((wchar_t**)&m_name),su}, Ext {*((wchar_t**)&m_ext),su} + + + diff --git a/VS2022/packages.config b/VS2022/packages.config new file mode 100644 index 0000000..ae6bf41 --- /dev/null +++ b/VS2022/packages.config @@ -0,0 +1,4 @@ + + + + \ No newline at end of file diff --git a/VS2022/readme.txt b/VS2022/readme.txt new file mode 100644 index 0000000..955b44a --- /dev/null +++ b/VS2022/readme.txt @@ -0,0 +1 @@ +VS2022 Tools > Options... > Debugging > Output Window > Natvis diagnostic messages = Verbose diff --git a/VS2022/source.extension.vsixmanifest b/VS2022/source.extension.vsixmanifest new file mode 100644 index 0000000..68979b8 --- /dev/null +++ b/VS2022/source.extension.vsixmanifest @@ -0,0 +1,53 @@ + + + + + C++ Debugger Visualizers for VS2022 + C++ Debugger Visualizers for Boost, wxWidgets, TinyXML, TinyXML2 + https://github.com/KindDragon/CPPDebuggerVisualizers + LICENSE.txt + Changelog.txt + cppVisualizerIcon.png + cppVisualizerScreenshot.png + C++, Debugger, Visualizer, Boost, wxWidgets, TinyXML2 + + + + amd64 + + + amd64 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file From be5298013ae8fc6e4454b4f69e4552feeaa65e3f Mon Sep 17 00:00:00 2001 From: Stewart Wonnacott Date: Mon, 8 Nov 2021 09:35:03 +0000 Subject: [PATCH 2/7] update version to 1.23 --- VS2022/source.extension.vsixmanifest | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/VS2022/source.extension.vsixmanifest b/VS2022/source.extension.vsixmanifest index 68979b8..9713c91 100644 --- a/VS2022/source.extension.vsixmanifest +++ b/VS2022/source.extension.vsixmanifest @@ -1,7 +1,7 @@  - + C++ Debugger Visualizers for VS2022 C++ Debugger Visualizers for Boost, wxWidgets, TinyXML, TinyXML2 https://github.com/KindDragon/CPPDebuggerVisualizers From aa080a7a9d2fc1d899f57c6af518648060d9683a Mon Sep 17 00:00:00 2001 From: Stewart Wonnacott Date: Mon, 7 Mar 2022 11:41:42 +0000 Subject: [PATCH 3/7] Removed CopyVsixExtensionFiles option --- VS2022/CPPDebuggerVisualizers.VS2022.csproj | 2 -- 1 file changed, 2 deletions(-) diff --git a/VS2022/CPPDebuggerVisualizers.VS2022.csproj b/VS2022/CPPDebuggerVisualizers.VS2022.csproj index e210d1d..473a671 100644 --- a/VS2022/CPPDebuggerVisualizers.VS2022.csproj +++ b/VS2022/CPPDebuggerVisualizers.VS2022.csproj @@ -62,8 +62,6 @@ TRACE prompt 4 - True - a:\ From 0d9915de1ff2e5da71d37af2a64c70e2c51e247a Mon Sep 17 00:00:00 2001 From: Stewart Wonnacott Date: Mon, 7 Mar 2022 13:04:38 +0000 Subject: [PATCH 4/7] Target correct versions for 2022 --- VS2022/source.extension.vsixmanifest | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/VS2022/source.extension.vsixmanifest b/VS2022/source.extension.vsixmanifest index 9713c91..2015197 100644 --- a/VS2022/source.extension.vsixmanifest +++ b/VS2022/source.extension.vsixmanifest @@ -12,10 +12,13 @@ C++, Debugger, Visualizer, Boost, wxWidgets, TinyXML2 - + amd64 - + + amd64 + + amd64 @@ -48,6 +51,6 @@ - + \ No newline at end of file From 403da5b5ffa26c1339bc8936a81d46eac375b209 Mon Sep 17 00:00:00 2001 From: Stewart Wonnacott Date: Fri, 6 May 2022 11:56:32 +0100 Subject: [PATCH 5/7] =?UTF-8?q?Added=20fix=20from=20scigor:=20Fixed=20uuid?= =?UTF-8?q?=20visualization=20by=20rewriting=20the=20the=20uuid=20visualiz?= =?UTF-8?q?ation=20part=E2=80=A6=20=E2=80=A6=20without=20the=20use=20of=20?= =?UTF-8?q?the=20custom=20dll?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- VS2022/Visualizers/boost.natvis | 43 ++++----------------------------- 1 file changed, 5 insertions(+), 38 deletions(-) diff --git a/VS2022/Visualizers/boost.natvis b/VS2022/Visualizers/boost.natvis index dc65d15..d372795 100644 --- a/VS2022/Visualizers/boost.natvis +++ b/VS2022/Visualizers/boost.natvis @@ -388,44 +388,11 @@ - - - - ncs - - - rfc 4122 - - - microsoft - - - future - - - time based - - - dce security - - - name based md5 - - - random number based - - - name based sha1 - - - 16 - data,x - - + {((((uint32_t)data[3] & 0xFF)) + (((uint32_t)data[2] & 0xFF) << 8) + (((uint32_t)data[1] & 0xFF) << 16) + (((uint32_t)data[0] & 0xFF) << 24)),xb} - {((((uint32_t)data[7] & 0xFF)) + (((uint32_t)data[6] & 0xFF) << 8) + (((uint32_t)data[5] & 0xFF) << 16) + (((uint32_t)data[4] & 0xFF) << 24)),xb} - {((((uint32_t)data[11] & 0xFF)) + (((uint32_t)data[10] & 0xFF) << 8) + (((uint32_t)data[9] & 0xFF) << 16) + (((uint32_t)data[8] & 0xFF) << 24)),xb} - {((((uint32_t)data[15] & 0xFF)) + (((uint32_t)data[14] & 0xFF) << 8) + (((uint32_t)data[13] & 0xFF) << 16) + (((uint32_t)data[12] & 0xFF) << 24)),xb} + + + + From 4b20c1accd47fe35d3265fd676b64158c409ae82 Mon Sep 17 00:00:00 2001 From: Stewart Wonnacott Date: Fri, 6 May 2022 11:56:53 +0100 Subject: [PATCH 6/7] Updated project settings --- VS2022/source.extension.vsixmanifest | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/VS2022/source.extension.vsixmanifest b/VS2022/source.extension.vsixmanifest index 9713c91..a05793b 100644 --- a/VS2022/source.extension.vsixmanifest +++ b/VS2022/source.extension.vsixmanifest @@ -1,7 +1,7 @@  - + C++ Debugger Visualizers for VS2022 C++ Debugger Visualizers for Boost, wxWidgets, TinyXML, TinyXML2 https://github.com/KindDragon/CPPDebuggerVisualizers @@ -12,10 +12,13 @@ C++, Debugger, Visualizer, Boost, wxWidgets, TinyXML2 - + amd64 - + + amd64 + + amd64 @@ -48,6 +51,6 @@ - + \ No newline at end of file From 67fea68e1ccfed9e3a8452a843a75ec30e91c41b Mon Sep 17 00:00:00 2001 From: Stewart Wonnacott Date: Fri, 6 May 2022 11:57:17 +0100 Subject: [PATCH 7/7] Added VSIX ;) --- .../Release/CPPDebuggerVisualizers.VS2022.vsix | Bin 0 -> 59260 bytes 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 VS2022/bin/Release/CPPDebuggerVisualizers.VS2022.vsix diff --git a/VS2022/bin/Release/CPPDebuggerVisualizers.VS2022.vsix b/VS2022/bin/Release/CPPDebuggerVisualizers.VS2022.vsix new file mode 100644 index 0000000000000000000000000000000000000000..e1e95739e43f7e8de760202bb65df72afa5fc9f7 GIT binary patch literal 59260 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 literal 0 HcmV?d00001