979 lines
24 KiB
Text
979 lines
24 KiB
Text
;------------------------------------------------------------------------------
|
|
; GEAR types visualizer
|
|
;------------------------------------------------------------------------------
|
|
; How to install :
|
|
; - Select and copy the text below.
|
|
; - Open autoexp.dat at location C:\Program Files\Microsoft Visual Studio 8\Common7\Packages\Debugger
|
|
; - Append the text under the [Visualizer] section to the VS file.
|
|
;
|
|
; You don't need to restart or stop Visual Studio when doing this as this file is always reloaded everytime
|
|
; the debugger start.
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
; Gear
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
; Some things to know that are not explained in the original autoexp.dat
|
|
;
|
|
; $c vs $e
|
|
; In the preview block:
|
|
; $c refers to the top level container of the current preview line in the debugger
|
|
; ex: If A previews B which previews C, $c in C's preview block will refer to A
|
|
; $e refers to the element of the actual rule
|
|
; In the children block:
|
|
; $c and $e both refers the element of the actual rule
|
|
; In a #tree or #array:
|
|
; $c and $e behaves the same way than in a preview block (see above), except:
|
|
; In a #tree specification, #tree(...) : $e refers to the dereference of node pointers
|
|
;
|
|
; In short, use $e everywhere unless you have a good reason to use $c
|
|
;
|
|
; #tree(
|
|
; head: pointer to the starting node
|
|
; left: pointer to the left node
|
|
; right: pointer to the right node
|
|
; skip: [optional] pointer value used as the end of a branch (so it won't be evaluated)
|
|
; size: [optional] limit the number of nodes to display as an array
|
|
;
|
|
; useful readings:
|
|
; http://www.virtualdub.org/blog/pivot/entry.php?id=120
|
|
; http://www.virtualdub.org/blog/pivot/entry.php?id=172
|
|
;
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
; Gear::GearBasicString
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
; Ansi version
|
|
Gear::GearBasicString<char,*> {
|
|
preview (
|
|
#(
|
|
"length=", [$e.m_string->size, u],
|
|
", capacity=", [$e.m_string->capacity, u],
|
|
", string=", [$e.m_string->data, s]
|
|
)
|
|
)
|
|
|
|
stringview ( [$e.m_string->data, sb] )
|
|
}
|
|
|
|
; All other are considered as unicode...
|
|
Gear::GearBasicString<*> {
|
|
preview (
|
|
#(
|
|
"length=", [$e.m_string->size, u],
|
|
", capacity=", [$e.m_string->capacity, u],
|
|
", string=", [$e.m_string->data, su]
|
|
)
|
|
)
|
|
|
|
stringview ( [$e.m_string->data, sub] )
|
|
}
|
|
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
; GEAR MATH TYPES
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;------------------------------------------------------------------------------
|
|
; Gear::Fixed32
|
|
;------------------------------------------------------------------------------
|
|
Gear::Fixed32{
|
|
preview
|
|
(
|
|
#( [$e.m_Fixed32 / 4096.0f,g] )
|
|
)
|
|
|
|
children
|
|
(
|
|
#( m_Fixed32: [$c.m_Fixed32,d] )
|
|
)
|
|
}
|
|
|
|
|
|
;------------------------------------------------------------------------------
|
|
; Gear::VectorGeneric<float>, Gear::VectorGeneric<double>, Gear::VectorGeneric<Gear::Fixed32>
|
|
;------------------------------------------------------------------------------
|
|
Gear::VectorGeneric<float,*>|Gear::VectorGeneric<double,*>{
|
|
children
|
|
(
|
|
#array
|
|
(
|
|
expr : [$e.v[$i],g],
|
|
size : $T1
|
|
)
|
|
)
|
|
|
|
preview
|
|
(
|
|
#(
|
|
"{",
|
|
#array
|
|
(
|
|
expr : [$e.v[$i],g],
|
|
size : $T1
|
|
),
|
|
"}"
|
|
)
|
|
)
|
|
}
|
|
|
|
Gear::VectorGeneric<Gear::Fixed32,*>{
|
|
children
|
|
(
|
|
#array
|
|
(
|
|
expr : $e.v[$i],
|
|
size : $T1
|
|
)
|
|
)
|
|
|
|
preview
|
|
(
|
|
#(
|
|
"{",
|
|
#array
|
|
(
|
|
expr : $e.v[$i],
|
|
size : $T1
|
|
),
|
|
"}"
|
|
)
|
|
)
|
|
}
|
|
|
|
|
|
;------------------------------------------------------------------------------
|
|
; __m128 - To reorder the fields in the preview
|
|
;------------------------------------------------------------------------------
|
|
__m128{
|
|
preview
|
|
(
|
|
#( "{",[$e.m128_f32[0],g],", ",[$e.m128_f32[1],g],", ",[$e.m128_f32[2],g],", ",[$e.m128_f32[3],g],"}")
|
|
)
|
|
}
|
|
|
|
;------------------------------------------------------------------------------
|
|
; Gear::Vector2, Gear::Vector3, Gear::Vector4
|
|
;------------------------------------------------------------------------------
|
|
|
|
Gear::Vector2<*>{
|
|
preview
|
|
(
|
|
#( "{",[(($T1*)&$c)[0]],", ",[(($T1*)&$c)[1]],"}" )
|
|
)
|
|
|
|
children
|
|
(
|
|
#(
|
|
#(x: [(($T1*)&$c)[0]]),
|
|
#(y: [(($T1*)&$c)[1]])
|
|
)
|
|
)
|
|
}
|
|
|
|
Gear::Vector3<*>{
|
|
preview
|
|
(
|
|
#( "{",[(($T1*)&$c)[0]],", ",[(($T1*)&$c)[1]],", ",[(($T1*)&$c)[2]],"}" )
|
|
)
|
|
|
|
children
|
|
(
|
|
#(
|
|
#(x: [(($T1*)&$c)[0]]),
|
|
#(y: [(($T1*)&$c)[1]]),
|
|
#(z: [(($T1*)&$c)[2]])
|
|
)
|
|
)
|
|
}
|
|
|
|
Gear::Vector4<*>{
|
|
preview
|
|
(
|
|
#( "{",[(($T1*)&$c)[0]],", ",[(($T1*)&$c)[1]],", ",[(($T1*)&$c)[2]],", ",[(($T1*)&$c)[3]],"}" )
|
|
)
|
|
|
|
children
|
|
(
|
|
#(
|
|
#(x: [(($T1*)&$c)[0]]),
|
|
#(y: [(($T1*)&$c)[1]]),
|
|
#(z: [(($T1*)&$c)[2]]),
|
|
#(w: [(($T1*)&$c)[3]])
|
|
)
|
|
)
|
|
}
|
|
|
|
;------------------------------------------------------------------------------
|
|
; Gear::Quaternion4
|
|
;------------------------------------------------------------------------------
|
|
Gear::Quaternion4<*>{
|
|
preview
|
|
(
|
|
#( $c.q.v )
|
|
)
|
|
}
|
|
|
|
|
|
;------------------------------------------------------------------------------
|
|
; Gear::Matrix22, Gear::Matrix33, Gear::Matrix34, Gear::Matrix44
|
|
;------------------------------------------------------------------------------
|
|
Gear::Matrix22<*>{
|
|
preview
|
|
(
|
|
#( $e.m[0], $e.m[1] )
|
|
)
|
|
|
|
children
|
|
(
|
|
#array
|
|
(
|
|
expr : $c.m[$i],
|
|
size : 2
|
|
)
|
|
)
|
|
}
|
|
|
|
Gear::Matrix33<*>{
|
|
preview
|
|
(
|
|
#( $e.m[0], $e.m[1], $e.m[2] )
|
|
)
|
|
|
|
children
|
|
(
|
|
#array
|
|
(
|
|
expr : $c.m[$i],
|
|
size : 3
|
|
)
|
|
)
|
|
}
|
|
|
|
Gear::Matrix34<*>|Gear::Matrix44<*>{
|
|
preview
|
|
(
|
|
#( $e.m[0], $e.m[1], $e.m[2], $e.m[3] )
|
|
)
|
|
|
|
children
|
|
(
|
|
#array
|
|
(
|
|
expr : $c.m[$i],
|
|
size : 4
|
|
)
|
|
)
|
|
}
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
; GEAR CONTAINERS
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;------------------------------------------------------------------------------
|
|
; Gear::GearVector, Gear::SacVector
|
|
;------------------------------------------------------------------------------
|
|
Gear::GearVector<*,*,*,*>|Gear::SacVector<*,*,*,*>{
|
|
|
|
preview
|
|
(
|
|
#(
|
|
"{size=" , $c.m_size,
|
|
" ...}"
|
|
)
|
|
)
|
|
|
|
children
|
|
(
|
|
#(
|
|
[original]: [$c,!],
|
|
size: $c.m_size,
|
|
#array
|
|
(
|
|
expr : (($T1*)$c.m_array)[$i],
|
|
size : $c.m_size
|
|
)
|
|
)
|
|
)
|
|
}
|
|
|
|
Gear::SacVector<*,*,*,*>::ConstIterator|Gear::SacVector<*,*,*,*>::Iterator|Gear::SacVector<*,*,*,*>::ConstReverseIterator|Gear::SacVector<*,*,*,*>::ReverseIterator{
|
|
preview
|
|
(
|
|
#(
|
|
"{value=" , *($c.m_iterator),
|
|
" ...}"
|
|
)
|
|
)
|
|
|
|
children
|
|
(
|
|
#(
|
|
[original]: [$c,!],
|
|
value : *($c.m_iterator)
|
|
)
|
|
)
|
|
|
|
}
|
|
|
|
;------------------------------------------------------------------------------
|
|
; Gear::GearMap, Gear::GearRBTree, Gear::SacRBTree
|
|
;------------------------------------------------------------------------------
|
|
|
|
; Because of a limitation of this parser, the template parameter that depends on a previous template parameter must partially be hardcoded, and thus $T5 == $T1
|
|
|
|
; IsLessThanFunctor specialisation
|
|
Gear::GearMap<*,*,*,*,Gear::IsLessThanFunctor<*> >|Gear::SacMap<*,*,*,*,Gear::IsLessThanFunctor<*> >{
|
|
preview
|
|
(
|
|
#(
|
|
"{count=" , $e.m_count,
|
|
"} root=", (*((Gear::SacRBTree<Gear::SacPair<$T1 const ,$T2>,$T1,$T3,$T4,Gear::IsLessThanFunctor<$T5>,Gear::Select1st<Gear::SacPair<$T1 const ,$T2> > >::TreeNode*)$e.m_tree.m_parent)),
|
|
" ...}"
|
|
)
|
|
)
|
|
|
|
children
|
|
(
|
|
#(
|
|
#tree
|
|
(
|
|
head : $e.m_tree.m_parent,
|
|
skip : 0,
|
|
size : $e.m_count,
|
|
left : m_left,
|
|
right : m_right
|
|
) : (*((Gear::SacRBTree<Gear::SacPair<$T1 const ,$T2>,$T1,$T3,$T4,Gear::IsLessThanFunctor<$T5>,Gear::Select1st<Gear::SacPair<$T1 const ,$T2> > >::TreeNode*)&$e)),
|
|
#(
|
|
root: (*((Gear::SacRBTree<Gear::SacPair<$T1 const ,$T2>,$T1,$T3,$T4,Gear::IsLessThanFunctor<$T5>,Gear::Select1st<Gear::SacPair<$T1 const ,$T2> > >::TreeNode*)$e.m_tree.m_parent)),
|
|
left most: (*((Gear::SacRBTree<Gear::SacPair<$T1 const ,$T2>,$T1,$T3,$T4,Gear::IsLessThanFunctor<$T5>,Gear::Select1st<Gear::SacPair<$T1 const ,$T2> > >::TreeNode*)$e.m_tree.m_left)),
|
|
right most: (*((Gear::SacRBTree<Gear::SacPair<$T1 const ,$T2>,$T1,$T3,$T4,Gear::IsLessThanFunctor<$T5>,Gear::Select1st<Gear::SacPair<$T1 const ,$T2> > >::TreeNode*)$e.m_tree.m_right)),
|
|
count: $e.m_count,
|
|
[original] : [$e,!]
|
|
)
|
|
)
|
|
)
|
|
}
|
|
|
|
Gear::GearRBTree<*,*,*,*,*,*>|Gear::SacRBTree<*,*,*,*,*,*>{
|
|
preview
|
|
(
|
|
#(
|
|
"{count=" , $e.m_count,
|
|
"} root=", (*((Gear::SacRBTree<$T1,$T2,$T3,$T4,$T5,$T6>::TreeNode*)$e.m_tree.m_parent)),
|
|
" ...}"
|
|
)
|
|
)
|
|
|
|
children
|
|
(
|
|
#(
|
|
#tree
|
|
(
|
|
head : $e.m_tree.m_parent,
|
|
skip : 0,
|
|
size : $e.m_count,
|
|
left : m_left,
|
|
right : m_right
|
|
) : (*((Gear::SacRBTree<$T1,$T2,$T3,$T4,$T5,$T6>::TreeNode*)&$e)),
|
|
#(
|
|
root: (*((Gear::SacRBTree<$T1,$T2,$T3,$T4,$T5,$T6>::TreeNode*)$e.m_tree.m_parent)),
|
|
left most: (*((Gear::SacRBTree<$T1,$T2,$T3,$T4,$T5,$T6>::TreeNode*)$e.m_tree.m_left)),
|
|
right most: (*((Gear::SacRBTree<$T1,$T2,$T3,$T4,$T5,$T6>::TreeNode*)$e.m_tree.m_right)),
|
|
count: $e.m_count,
|
|
[original] : [$e,!]
|
|
)
|
|
)
|
|
)
|
|
}
|
|
|
|
Gear::SacRBTree<*,*,*,*,*,*>::TreeNode{
|
|
|
|
preview
|
|
(
|
|
#(
|
|
"{element=" , $e.m_element,
|
|
" color=" , $e.m_color,
|
|
" ...}"
|
|
)
|
|
)
|
|
|
|
children
|
|
(
|
|
#(
|
|
[original]:[$e,!],
|
|
left:
|
|
#if ($e.m_left > 0)
|
|
(
|
|
(Gear::SacRBTree<$T1,$T2,$T3,$T4,$T5,$T6>::TreeNode *)$e.m_left
|
|
)
|
|
#else
|
|
(
|
|
(void *)$e.m_left
|
|
)
|
|
,
|
|
right:
|
|
#if ($e.m_right > 0)
|
|
(
|
|
(Gear::SacRBTree<$T1,$T2,$T3,$T4,$T5,$T6>::TreeNode *)$e.m_right
|
|
)
|
|
#else
|
|
(
|
|
(void *)$e.m_right
|
|
)
|
|
,
|
|
color:$e.m_color,
|
|
element:$e.m_element
|
|
)
|
|
)
|
|
}
|
|
|
|
Gear::SacRBTree<*,*,*,*,*,*>::ConstIterator|Gear::SacRBTree<*,*,*,*,*,*>::Iterator|Gear::SacRBTree<*,*,*,*,*,*>::ConstReverseIterator|Gear::SacRBTree<*,*,*,*,*,*>::ReverseIterator{
|
|
preview
|
|
(
|
|
#(
|
|
"{ ",
|
|
((Gear::SacRBTree<$T1,$T2,$T3,$T4,$T5,$T6>::TreeNode *)$e.m_node)->m_element,
|
|
" ...}"
|
|
)
|
|
)
|
|
|
|
children
|
|
(
|
|
#(
|
|
[original]: [$e,!],
|
|
value : ((Gear::SacRBTree<$T1,$T2,$T3,$T4,$T5,$T6>::TreeNode *)$e.m_node)->m_element
|
|
)
|
|
)
|
|
}
|
|
|
|
|
|
;------------------------------------------------------------------------------
|
|
; Gear::GearList, Gear::SacList
|
|
;------------------------------------------------------------------------------
|
|
Gear::GearList<*,*,*>|Gear::SacList<*,*,*>{
|
|
preview
|
|
(
|
|
#(
|
|
"{size=" , $c.m_size,
|
|
" ...}"
|
|
)
|
|
)
|
|
|
|
children
|
|
(
|
|
#(
|
|
#list
|
|
(
|
|
head: $c.m_node.m_next,
|
|
next: m_next,
|
|
size: $c.m_size
|
|
) : ((Gear::SacList<$T1,$T2,$T3>::ListNode *)&$e)->m_element
|
|
|
|
|
|
)
|
|
)
|
|
|
|
}
|
|
|
|
Gear::SacList<*,*,*>::ConstIterator|Gear::SacList<*,*,*>::Iterator|Gear::SacList<*,*,*>::ConstReverseIterator|Gear::SacList<*,*,*>::ReverseIterator{
|
|
preview
|
|
(
|
|
#(
|
|
"{ ",
|
|
((Gear::SacList<$T1,$T2,$T3>::ListNode *)$c.m_node)->m_element,
|
|
" ...}"
|
|
)
|
|
)
|
|
|
|
children
|
|
(
|
|
#(
|
|
[original]: [$c,!],
|
|
value : ((Gear::SacList<$T1,$T2,$T3>::ListNode *)$c.m_node)->m_element
|
|
)
|
|
)
|
|
|
|
}
|
|
|
|
|
|
|
|
;------------------------------------------------------------------------------
|
|
; Gear::GearQueue, Gear::SacQueue ; Gear::GearDeque, Gear::SacDeque
|
|
;------------------------------------------------------------------------------
|
|
Gear::GearQueue<*,*,*,*>|Gear::SacQueue<*,*,*,*>|Gear::GearDeque<*,*,*,*>|Gear::SacDeque<*,*,*,*>{
|
|
|
|
preview
|
|
(
|
|
#(
|
|
"{size=",
|
|
#if($c.m_begin <= $c.m_end)
|
|
(
|
|
[$c.m_end - $c.m_begin,i]
|
|
)
|
|
#else
|
|
(
|
|
[($c.m_capacity - $c.m_begin) + $c.m_end,i]
|
|
)
|
|
,
|
|
" ...}"
|
|
)
|
|
)
|
|
|
|
children
|
|
(
|
|
#(
|
|
[original]:[$c,!],
|
|
size:
|
|
#if($c.m_begin <= $c.m_end)
|
|
(
|
|
[$c.m_end - $c.m_begin,i]
|
|
)
|
|
#else
|
|
(
|
|
[($c.m_capacity - $c.m_begin) + $c.m_end,i]
|
|
)
|
|
,
|
|
front: $c.m_array[$c.m_begin % $c.m_capacity],
|
|
back:
|
|
#if ($c.m_end == 0)
|
|
(
|
|
$c.m_array[$c.m_capacity - 1]
|
|
)
|
|
#else
|
|
(
|
|
$c.m_array[$c.m_end - 1]
|
|
)
|
|
,
|
|
capacity : $c.m_capacity,
|
|
#array (
|
|
expr: $c.m_array[($c.m_begin + $i) % $c.m_capacity],
|
|
size:
|
|
#if($c.m_begin <= $c.m_end)
|
|
(
|
|
[$c.m_end - $c.m_begin,i]
|
|
)
|
|
#else
|
|
(
|
|
[($c.m_capacity - $c.m_begin) + $c.m_end,i]
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
}
|
|
|
|
Gear::SacQueue<*,*,*,*>::ConstIterator|Gear::SacQueue<*,*,*,*>::Iterator|Gear::SacQueue<*,*,*,*>::ConstReverseIterator|Gear::SacQueue<*,*,*,*>::ReverseIterator|Gear::SacDeque<*,*,*,*>::ConstIterator|Gear::SacDeque<*,*,*,*>::Iterator|Gear::SacDeque<*,*,*,*>::ConstReverseIterator|Gear::SacDeque<*,*,*,*>::ReverseIterator{
|
|
preview
|
|
(
|
|
#(
|
|
"{ ", $c.m_parent->m_array[$c.m_iterator % $c.m_parent->m_capacity] ,
|
|
" ...}"
|
|
)
|
|
)
|
|
|
|
children
|
|
(
|
|
#(
|
|
[original]: [$c,!],
|
|
value: $c.m_parent->m_array[$c.m_iterator % $c.m_parent->m_capacity]
|
|
)
|
|
)
|
|
|
|
}
|
|
|
|
;------------------------------------------------------------------------------
|
|
; Gear::GearPriorityQueue, Gear::SacPriorityQueue
|
|
;------------------------------------------------------------------------------
|
|
Gear::GearPriorityQueue<*,*,*,*,*>|Gear::SacPriorityQueue<*,*,*,*,*>{
|
|
|
|
preview
|
|
(
|
|
#(
|
|
"{size=" , $c.m_internalArray.m_size,
|
|
" ...}"
|
|
)
|
|
)
|
|
|
|
children
|
|
(
|
|
#(
|
|
[original]: [$c,!],
|
|
top:
|
|
#if ( $c.m_internalArray.m_size > 0 )
|
|
(
|
|
($c.m_internalArray.m_array)[0]
|
|
)
|
|
#else
|
|
(
|
|
0x00000000
|
|
)
|
|
,
|
|
size: $c.m_internalArray.m_size,
|
|
#if ( $c.m_internalArray.m_size > 0)
|
|
(
|
|
#array
|
|
(
|
|
expr : ($c.m_internalArray.m_array)[$i],
|
|
size : $c.m_internalArray.m_size
|
|
)
|
|
)
|
|
|
|
)
|
|
)
|
|
}
|
|
|
|
;------------------------------------------------------------------------------
|
|
; Gear::SacStaticVector, Gear::SacStaticVector
|
|
;------------------------------------------------------------------------------
|
|
Gear::GearStaticVector<*,*,*,*>|Gear::SacStaticVector<*,*,*,*>{
|
|
|
|
preview
|
|
(
|
|
#(
|
|
"{size=" , $c.m_size,
|
|
" ...}"
|
|
)
|
|
)
|
|
|
|
children
|
|
(
|
|
#(
|
|
[original]: [$c,!],
|
|
size: $c.m_size,
|
|
#array
|
|
(
|
|
expr : (($T1 *)&$c.m_staticArray)[$i],
|
|
size : $c.m_size
|
|
)
|
|
)
|
|
)
|
|
}
|
|
|
|
Gear::SacStaticVector<*,*,*,*>::ConstIterator|Gear::SacStaticVector<*,*,*,*>::Iterator|Gear::SacStaticVector<*,*,*,*>::ConstReverseIterator|Gear::SacStaticVector<*,*,*,*>::ReverseIterator{
|
|
preview
|
|
(
|
|
#(
|
|
"{ ", ($T1 *)$c.m_iterator,
|
|
" ...}"
|
|
)
|
|
)
|
|
|
|
children
|
|
(
|
|
#(
|
|
[original]: [$c,!],
|
|
value: (($T1 *)$c.m_iterator)
|
|
)
|
|
)
|
|
|
|
}
|
|
|
|
;------------------------------------------------------------------------------
|
|
; Gear::GearSparseVector, Gear::SacSparseVector
|
|
;------------------------------------------------------------------------------
|
|
Gear::GearSparseVector<*,*,*,*>|Gear::SacSparseVector<*,*,*,*>{
|
|
|
|
preview
|
|
(
|
|
#(
|
|
"{size=" , $c.m_size,
|
|
" ...}"
|
|
)
|
|
)
|
|
|
|
children
|
|
(
|
|
#(
|
|
[original]:[$c,!],
|
|
size: $c.m_size,
|
|
front: (($T1 *)$c.m_bucketList.m_array[$c.m_bucketList.m_begin / $c.m_bucketsize])[$c.m_bucketList.m_begin % $c.m_bucketsize],
|
|
back: (($T1 *)$c.m_bucketList.m_array[($c.m_bucketList.m_begin + $c.m_size - 1) / $c.m_bucketsize])[($c.m_bucketList.m_begin + $c.m_size - 1 ) % $c.m_bucketsize],
|
|
#array (
|
|
expr: (($T1 *)$c.m_bucketList.m_array[($c.m_bucketList.m_begin + $i) / $c.m_bucketsize])[($c.m_bucketList.m_begin + $i ) % $c.m_bucketsize],
|
|
size: $c.m_size
|
|
)
|
|
)
|
|
)
|
|
}
|
|
|
|
Gear::SacSparseVector<*,*,*,*>::ConstIterator|Gear::SacSparseVector<*,*,*,*>::Iterator|Gear::SacSparseVector<*,*,*,*>::ConstReverseIterator|Gear::SacSparseVector<*,*,*,*>::ReverseIterator{
|
|
preview
|
|
(
|
|
#(
|
|
"{ ", (($T1 *)$c.m_parent->m_bucketList.m_array[($c.m_parent->m_bucketList.m_begin + $c.m_iterator) / $c.m_parent->m_bucketsize])[($c.m_parent->m_bucketList.m_begin + $c.m_iterator ) % $c.m_parent->m_bucketsize],
|
|
" ...}"
|
|
)
|
|
)
|
|
|
|
children
|
|
(
|
|
#(
|
|
[original]: [$c,!],
|
|
value: (($T1 *)$c.m_parent->m_bucketList.m_array[($c.m_parent->m_bucketList.m_begin + $c.m_iterator) / $c.m_parent->m_bucketsize])[($c.m_parent->m_bucketList.m_begin + $c.m_iterator ) % $c.m_parent->m_bucketsize]
|
|
)
|
|
)
|
|
}
|
|
|
|
;------------------------------------------------------------------------------
|
|
; Gear::BitArray
|
|
;------------------------------------------------------------------------------
|
|
Gear::BitArray<*,*,*>{
|
|
preview
|
|
(
|
|
#(
|
|
"{size=" , $c.m_NbElement,
|
|
" ...}"
|
|
)
|
|
)
|
|
|
|
children
|
|
(
|
|
#(
|
|
[original]:[$c,!],
|
|
size : $c.m_NbElement,
|
|
#array (
|
|
expr: #if ($c.m_BitPerElement > (32 - (( $c.m_BitPerElement * $i ) - ( ( ($c.m_BitPerElement * $i) / 32 ) * 32 ))) )
|
|
(
|
|
((((&($c.m_pArray[(($c.m_BitPerElement * $i) / 32)]))[0] & ((0xFFFFFFFF >> (32 - $c.m_BitPerElement)) << (( $c.m_BitPerElement * $i ) - ( ( ($c.m_BitPerElement * $i) / 32 ) * 32 )))) >> (( $c.m_BitPerElement * $i ) - ( ( ($c.m_BitPerElement * $i) / 32 ) * 32 ))) | (((&($c.m_pArray[(($c.m_BitPerElement * $i) / 32)]))[1] & ((0xFFFFFFFF >> (32 - $c.m_BitPerElement)) >> (32 - (( $c.m_BitPerElement * $i ) - ( ( ($c.m_BitPerElement * $i) / 32 ) * 32 ))))) << (32 - (( $c.m_BitPerElement * $i ) - ( ( ($c.m_BitPerElement * $i) / 32 ) * 32 )))))
|
|
)
|
|
#else
|
|
(
|
|
(((&($c.m_pArray[(($c.m_BitPerElement * $i) / 32)]))[0] & ((0xFFFFFFFF >> (32 - $c.m_BitPerElement)) << (( $c.m_BitPerElement * $i ) - ( ( ($c.m_BitPerElement * $i) / 32 ) * 32 )))) >> (( $c.m_BitPerElement * $i ) - ( ( ($c.m_BitPerElement * $i) / 32 ) * 32 )))
|
|
)
|
|
,
|
|
size: $c.m_NbElement
|
|
)
|
|
|
|
|
|
)
|
|
)
|
|
}
|
|
|
|
;------------------------------------------------------------------------------
|
|
; Gear::GearStack, Gear::SacStack
|
|
;------------------------------------------------------------------------------
|
|
Gear::GearStack<*,*,*,*>|Gear::SacStack<*,*,*,*>{
|
|
|
|
preview
|
|
(
|
|
#(
|
|
"{size=" , $c.m_internalArray.m_size,
|
|
" ...}"
|
|
)
|
|
)
|
|
|
|
children
|
|
(
|
|
#(
|
|
[original]: [$c,!],
|
|
size: $c.m_internalArray.m_size,
|
|
top : ($c.m_internalArray.m_array)[$c.m_internalArray.m_size - 1],
|
|
#array
|
|
(
|
|
expr : ($c.m_internalArray.m_array)[$i],
|
|
size : $c.m_internalArray.m_size
|
|
)
|
|
)
|
|
)
|
|
}
|
|
|
|
;------------------------------------------------------------------------------
|
|
; Gear::BitVector, Gear::BitVector
|
|
;------------------------------------------------------------------------------
|
|
Gear::BitVector<*>{
|
|
|
|
preview
|
|
(
|
|
#(
|
|
"{size=" , $T1,
|
|
" ...}"
|
|
)
|
|
)
|
|
|
|
children
|
|
(
|
|
#(
|
|
[original]: [$c,!],
|
|
size: $T1,
|
|
value : ($c.m_pBits[((0) >> 5)]),
|
|
bitnumber : ((0) & 31),
|
|
#array
|
|
(
|
|
expr: (($c.m_pBits[(($i) >> 5)]) >> (($i) & 31)) & 1,
|
|
size : $T1
|
|
)
|
|
)
|
|
)
|
|
}
|
|
|
|
;------------------------------------------------------------------------------
|
|
; Gear::CircularBuffer
|
|
;------------------------------------------------------------------------------
|
|
Gear::CircularBuffer<*,*>{
|
|
|
|
preview
|
|
(
|
|
#(
|
|
"{size=" , $c.m_elementCount,
|
|
" ...}"
|
|
)
|
|
)
|
|
|
|
children
|
|
(
|
|
#(
|
|
[original]: [$c,!],
|
|
size: $c.m_elementCount,
|
|
read position : $c.m_elementReadPos,
|
|
write position : $c.m_elementWritePos,
|
|
avalaible : $c.m_availablelement,
|
|
#array
|
|
(
|
|
expr : $c.m_buffer[$i],
|
|
size : $c.m_elementCount
|
|
)
|
|
)
|
|
)
|
|
}
|
|
|
|
;------------------------------------------------------------------------------
|
|
; Gear::GearHashMap, Gear::SacHashMap
|
|
;------------------------------------------------------------------------------
|
|
Gear::GearHashMap<*,*,*,*,*,*>|Gear::SacHashMap<*,*,*,*,*,*>{
|
|
preview
|
|
(
|
|
#(
|
|
"{count=" , $c.m_uiCount,
|
|
" ...}"
|
|
)
|
|
)
|
|
|
|
children
|
|
(
|
|
#(
|
|
[original] : [$c,!],
|
|
count : $c.m_uiCount,
|
|
hash size : $c.m_uiHashSize,
|
|
#array
|
|
(
|
|
expr :($c.m_pHashTable)[$i],
|
|
size : $c.m_uiHashSize
|
|
)
|
|
)
|
|
)
|
|
|
|
}
|
|
|
|
Gear::SacHashMap<*,*,*,*,*,*>::HashMapItem{
|
|
preview
|
|
(
|
|
#(
|
|
"{key=" , $c.m_key,
|
|
" value=" , $c.m_val,
|
|
" ...}"
|
|
)
|
|
)
|
|
|
|
children
|
|
(
|
|
#(
|
|
[original] : [$c,!],
|
|
#if ( $c.m_pNext > 0)
|
|
(
|
|
#(
|
|
key : $c.m_key,
|
|
value : $c.m_val,
|
|
next : $c.m_pNext
|
|
)
|
|
)
|
|
#else
|
|
(
|
|
#(
|
|
key : $c.m_key,
|
|
value : $c.m_val
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
}
|
|
|
|
Gear::SacHashMap<*,*,*,*,*,*>::ConstIterator|Gear::SacHashMap<*,*,*,*,*,*>::Iterator|Gear::SacHashMap<*,*,*,*,*,*>::ConstReverseIterator|Gear::SacHashMap<*,*,*,*,*,*>::ReverseIterator{
|
|
preview
|
|
(
|
|
#(
|
|
"{key=" , ((Gear::SacHashMap<$T1,$T2,$T3,$T4,$T5,$T6>::HashMapItem*)$c.m_iterator)->m_key,
|
|
" value=" , ((Gear::SacHashMap<$T1,$T2,$T3,$T4,$T5,$T6>::HashMapItem*)$c.m_iterator)->m_val,
|
|
" ...}"
|
|
)
|
|
)
|
|
|
|
children
|
|
(
|
|
#(
|
|
key : ((Gear::SacHashMap<$T1,$T2,$T3,$T4,$T5,$T6>::HashMapItem*)$c.m_iterator)->m_key,
|
|
value : ((Gear::SacHashMap<$T1,$T2,$T3,$T4,$T5,$T6>::HashMapItem*)$c.m_iterator)->m_val
|
|
)
|
|
)
|
|
}
|
|
|
|
;------------------------------------------------------------------------------
|
|
; Shears types
|
|
;------------------------------------------------------------------------------
|
|
Gear::Shears::DataStream{
|
|
preview
|
|
(
|
|
#(
|
|
[$e.m_name,s]
|
|
)
|
|
)
|
|
}
|
|
|
|
Gear::Shears::Barrier{
|
|
preview
|
|
(
|
|
#(
|
|
[$e.m_name,s]
|
|
)
|
|
)
|
|
}
|
|
|
|
Gear::Shears::Condition{
|
|
preview
|
|
(
|
|
#(
|
|
[$e.m_name,s]
|
|
)
|
|
)
|
|
}
|
|
|
|
Gear::Shears::BaseTask{
|
|
preview
|
|
(
|
|
#(
|
|
[$e.m_name,s]
|
|
)
|
|
)
|
|
}
|
|
|
|
Gear::Shears::StoryboardTask{
|
|
preview
|
|
(
|
|
#(
|
|
$e.m_baseTask
|
|
)
|
|
)
|
|
}
|
|
|
|
Gear::Shears::WorkUnit{
|
|
preview
|
|
(
|
|
#(
|
|
$e.m_baseTask
|
|
)
|
|
)
|
|
}
|