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/VS2017/Visualizers/boost.natvis b/VS2017/Visualizers/boost.natvis index dc65d15..ee2b9d7 100644 --- a/VS2017/Visualizers/boost.natvis +++ b/VS2017/Visualizers/boost.natvis @@ -388,44 +388,7 @@ - - - - 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} diff --git a/VS2017/Visualizers/boost_MultiIndex.natvis b/VS2017/Visualizers/boost_MultiIndex.natvis index 23517c3..0092596 100644 --- a/VS2017/Visualizers/boost_MultiIndex.natvis +++ b/VS2017/Visualizers/boost_MultiIndex.natvis @@ -54,17 +54,17 @@ - - {{ size={(($T3*)this)->node_count} }} + + {{ size={(($T2*)this)->node_count} }} - (($T3*)this)->buckets.spc.n_ - 1 - (($T3*)this)->max_load - (($T3*)this)->mlf - (($T3*)this)->eq_ - (($T3*)this)->hash_ + (($T2*)this)->buckets.spc.n_ - 1 + (($T2*)this)->max_load + (($T2*)this)->mlf + (($T2*)this)->eq_ + (($T2*)this)->hash_ - + @@ -73,12 +73,11 @@ - NodePtr = (boost::multi_index::detail::hashed_index_node_trampoline<$T1>*)((((($T3*)this)->buckets.spc.data_ + BucketIndex))->prior_) + NodePtr = (boost::multi_index::detail::hashed_index_node_trampoline<$T1>*)((((($T2*)this)->buckets.spc.data_ + BucketIndex))->prior_) - *reinterpret_cast<$T3::value_type*>(&(((boost::multi_index::detail::hashed_index_node<$T1,$T2>*)NodePtr))->space) - + *reinterpret_cast<$T2::value_type*>(&(((boost::multi_index::detail::hashed_index_node<$T1>*)NodePtr))->space) NodePtr = (boost::multi_index::detail::hashed_index_node_trampoline<$T1>*)(NodePtr->next_) diff --git a/VS2017/Visualizers/boost_Unordered.natvis b/VS2017/Visualizers/boost_Unordered.natvis index 3e4d114..9ee4cef 100644 --- a/VS2017/Visualizers/boost_Unordered.natvis +++ b/VS2017/Visualizers/boost_Unordered.natvis @@ -44,6 +44,68 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + {{ size={size_} }} + + + + + + + + + + + + gb_inc_n=countr_zero(pbg->bitmask & reset_first_bits_(pbg_p - pbg->buckets + 1)) + + pbg_p = pbg->buckets + gb_inc_n + + + pbg = pbg->next + pbg_p = pbg->buckets + countr_zero(pbg->bitmask) + + node_p = pbg_p->next + + + *((std::pair<$T2 const ,$T3>*)node_p->buf.data_.buf),view(MapHelper) + node_p = node_p->next + + + + {{ size={size_} }} diff --git a/VS2019/Visualizers/boost.natvis b/VS2019/Visualizers/boost.natvis index dc65d15..ee2b9d7 100644 --- a/VS2019/Visualizers/boost.natvis +++ b/VS2019/Visualizers/boost.natvis @@ -388,44 +388,7 @@ - - - - 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} diff --git a/VS2019/Visualizers/boost_Containers.natvis b/VS2019/Visualizers/boost_Containers.natvis index ce613b8..0fab2e6 100644 --- a/VS2019/Visualizers/boost_Containers.natvis +++ b/VS2019/Visualizers/boost_Containers.natvis @@ -525,4 +525,33 @@ + + + {data_,s} + data_,s + + (int)size_ + (int)$T1 + + size_ + data_ + + + + + + + + {data_,su} + data_,su + + (int)size_ + (int)$T1 + + size_ + data_ + + + + diff --git a/VS2019/Visualizers/boost_MultiIndex.natvis b/VS2019/Visualizers/boost_MultiIndex.natvis index 23517c3..0092596 100644 --- a/VS2019/Visualizers/boost_MultiIndex.natvis +++ b/VS2019/Visualizers/boost_MultiIndex.natvis @@ -54,17 +54,17 @@ - - {{ size={(($T3*)this)->node_count} }} + + {{ size={(($T2*)this)->node_count} }} - (($T3*)this)->buckets.spc.n_ - 1 - (($T3*)this)->max_load - (($T3*)this)->mlf - (($T3*)this)->eq_ - (($T3*)this)->hash_ + (($T2*)this)->buckets.spc.n_ - 1 + (($T2*)this)->max_load + (($T2*)this)->mlf + (($T2*)this)->eq_ + (($T2*)this)->hash_ - + @@ -73,12 +73,11 @@ - NodePtr = (boost::multi_index::detail::hashed_index_node_trampoline<$T1>*)((((($T3*)this)->buckets.spc.data_ + BucketIndex))->prior_) + NodePtr = (boost::multi_index::detail::hashed_index_node_trampoline<$T1>*)((((($T2*)this)->buckets.spc.data_ + BucketIndex))->prior_) - *reinterpret_cast<$T3::value_type*>(&(((boost::multi_index::detail::hashed_index_node<$T1,$T2>*)NodePtr))->space) - + *reinterpret_cast<$T2::value_type*>(&(((boost::multi_index::detail::hashed_index_node<$T1>*)NodePtr))->space) NodePtr = (boost::multi_index::detail::hashed_index_node_trampoline<$T1>*)(NodePtr->next_) diff --git a/VS2019/Visualizers/boost_Unordered.natvis b/VS2019/Visualizers/boost_Unordered.natvis index 3e4d114..9ee4cef 100644 --- a/VS2019/Visualizers/boost_Unordered.natvis +++ b/VS2019/Visualizers/boost_Unordered.natvis @@ -44,6 +44,68 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + {{ size={size_} }} + + + + + + + + + + + + gb_inc_n=countr_zero(pbg->bitmask & reset_first_bits_(pbg_p - pbg->buckets + 1)) + + pbg_p = pbg->buckets + gb_inc_n + + + pbg = pbg->next + pbg_p = pbg->buckets + countr_zero(pbg->bitmask) + + node_p = pbg_p->next + + + *((std::pair<$T2 const ,$T3>*)node_p->buf.data_.buf),view(MapHelper) + node_p = node_p->next + + + + {{ size={size_} }} diff --git a/VS2022/CPPDebuggerVisualizers.VS2022.csproj b/VS2022/CPPDebuggerVisualizers.VS2022.csproj new file mode 100644 index 0000000..ff86bca --- /dev/null +++ b/VS2022/CPPDebuggerVisualizers.VS2022.csproj @@ -0,0 +1,198 @@ + + + + + 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.8 + false + false + false + false + false + false + + + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + + + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + + + + 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..ee2b9d7 --- /dev/null +++ b/VS2022/Visualizers/boost.natvis @@ -0,0 +1,407 @@ + + + + + + {{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 + + + + + {((((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} + + + + {*(($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..0fab2e6 --- /dev/null +++ b/VS2022/Visualizers/boost_Containers.natvis @@ -0,0 +1,557 @@ + + + + + {{ 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) + + + + + + {data_,s} + data_,s + + (int)size_ + (int)$T1 + + size_ + data_ + + + + + + + + {data_,su} + data_,su + + (int)size_ + (int)$T1 + + size_ + 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..0092596 --- /dev/null +++ b/VS2022/Visualizers/boost_MultiIndex.natvis @@ -0,0 +1,93 @@ + + + + + + + + {{ 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={(($T2*)this)->node_count} }} + + + (($T2*)this)->buckets.spc.n_ - 1 + (($T2*)this)->max_load + (($T2*)this)->mlf + (($T2*)this)->eq_ + (($T2*)this)->hash_ + + + + + + + + + + + NodePtr = (boost::multi_index::detail::hashed_index_node_trampoline<$T1>*)((((($T2*)this)->buckets.spc.data_ + BucketIndex))->prior_) + + + + *reinterpret_cast<$T2::value_type*>(&(((boost::multi_index::detail::hashed_index_node<$T1>*)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..9ee4cef --- /dev/null +++ b/VS2022/Visualizers/boost_Unordered.natvis @@ -0,0 +1,197 @@ + + + + + + {{ 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_} }} + + + + + + + + + + + + gb_inc_n=countr_zero(pbg->bitmask & reset_first_bits_(pbg_p - pbg->buckets + 1)) + + pbg_p = pbg->buckets + gb_inc_n + + + pbg = pbg->next + pbg_p = pbg->buckets + countr_zero(pbg->bitmask) + + node_p = pbg_p->next + + + *((std::pair<$T2 const ,$T3>*)node_p->buf.data_.buf),view(MapHelper) + node_p = node_p->next + + + + + + + {{ 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..6d12547 --- /dev/null +++ b/VS2022/source.extension.vsixmanifest @@ -0,0 +1,56 @@ + + + + + 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 + + + amd64 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file