?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'main/atys-live' into fixes
[ryzomcore.git] / tool / visual_studio_macros / autoexp_vc10.dat
blobc39287ebd0d5e03fa973eeeb9d1b32518cd51dcb
1 ; AutoExp.Dat - templates for automatically expanding data
2 ; Copyright(c) Microsoft Corporation. All Rights Reserved.
3 ;---------------------------------------------------------------
4 ;
5 ; Location: C:\Program Files (x86)\Microsoft Visual Studio 10.0\Common7\Packages\Debugger\autoexp.dat
6 ;
7 ; While debugging, Data Tips and items in the Watch and Variable
8 ; windows are automatically expanded to show their most important
9 ; elements. The expansion follows the format given by the rules
10 ; in this file. You can add rules for your types or change the
11 ; predefined rules.
12 ;
13 ; For good examples, read the rules in this file.
14 ;
15 ; To find what the debugger considers the type of a variable to
16 ; be, add it to the Watch window and look at the Type column.
17 ;
18 ; An AutoExpand rule is a line with the name of a type, an equals
19 ; sign, and text with replaceable parts in angle brackets. The
20 ; part in angle brackets names a member of the type and an
21 ; optional Watch format specifier.
22 ;
23 ; AutoExpand rules use the following syntax. The equals sign (=),
24 ; angle brackets (<>), and comma are taken literally. Square
25 ; brackets ([]) indicate optional items.
26 ;
27 ; type=[text]<member[,format]>...
28 ;
29 ; type Name of the type (may be followed by <*> for template
30 ; types such as the ATL types listed below).
31 ;
32 ; text Any text.Usually the name of the member to display,
33 ; or a shorthand name for the member.
34 ;
35 ; member Name of a member to display.
36 ;
37 ; format Watch format specifier. One of the following:
38 ;
39 ; Letter Description Sample Display
40 ; ------ -------------------------- ------------ -------------
41 ; d,i Signed decimal integer 0xF000F065,d -268373915
42 ; u Unsigned decimal integer 0x0065,u 101
43 ; o Unsigned octal integer 0xF065,o 0170145
44 ; x,X Hexadecimal integer 61541,X 0X0000F065
45 ; l,h long or short prefix for 00406042,hx 0x0c22
46 ; d, i, u, o, x, X
47 ; f Signed floating-point 3./2.,f 1.500000
48 ; e Signed scientific-notation 3./2.,e 1.500000e+000
49 ; g Shorter of e and f 3./2.,g 1.5
50 ; c Single character 0x0065,c 'e'
51 ; s Zero-terminated string pVar,s "Hello world"
52 ; su Unicode string pVar,su "Hello world"
53 ;
54 ; For details of other format specifiers see Help under:
55 ; "format specifiers/watch variable"
56 ;
57 ; The special format <,t> specifies the name of the most-derived
58 ; type of the object. This is especially useful with pointers or
59 ; references to a base class.
60 ;
61 ; If there is no rule for a class, the base classes are checked for
62 ; a matching rule.
63 ;
64 ; There are some special entries allowed in the AutoExpand section:
65 ; $BUILTIN is used to display more complex types that need to do more
66 ; than just show a member variable or two.
67 ; $ADDIN allows external DLLs to be added to display even more complex
68 ; types via the EE Add-in API. The first argument is the DLL name, the
69 ; second argument is the name of the export from the DLL to use. For
70 ; further information on this API see the sample called EEAddIn.
71 ;
72 ; WARNING: if hexadecimal mode is on in the watch window, all numbers here are
73 ; evaluated in hex, e.g. 42 becomes 0x42
74
75 [AutoExpand]
76
77 ; from windef.h
78 tagPOINT =x=<x> y=<y>
79 tagRECT =top=<top> bottom=<bottom> left=<left> right=<right>
80
81 ; from winuser.h
82 tagMSG =msg=<message,x> wp=<wParam,x> lp=<lParam,x>
83
84 ; intrinsics
85 __m64 =<m64_i64,x>
86 __m128=$BUILTIN(M128)
87 __m128i=$BUILTIN(M128I)
88 __m128d=$BUILTIN(M128D)
89
90 ; from afxwin.h
91 CDC =hDC=<m_hDC> attrib=<m_hAttribDC>
92 CPaintDC =<,t> hWnd=<m_hWnd>
93 CPoint =x=<x> y=<y>
94 CRect =top=<top> bottom=<bottom> left=<left> right=<right>
95 CSize =cx=<cx> cy=<cy>
96 CWnd =<,t> hWnd=<m_hWnd>
97 CWinApp =<,t> <m_pszAppName,s>
98 CWinThread =<,t> h=<m_hThread> proc=<m_pfnThreadProc>
99
100 ; from afxcoll.h
101 CPtrList =cnt=<m_nCount>
102
103 ; from afxstat_.h
104 CProcessLocalObject =<,t>
105 CThreadLocalObject =<,t>
106
107 ; from afx.h
108 CArchiveException =cause=<m_cause>
109 CFile =hFile=<m_hFile> name=<m_strFileName.m_pchData,s>
110 CFileException =cause=<m_cause> OS Error=m_lOsError
111 CMemFile =pos=<m_nPosition> size=<m_nFileSize>
112 CObject =<,t>
113 CRuntimeClass =<m_lpszClassName,s>
114 CStdioFile =FILE*=<m_pStream> name=<m_strFilename.m_pchData,s>
115 CTimeSpan =time=<m_time>
116 CTime =time=<m_time>
117
118 ; from afxcoll.h
119 CByteArray =count=<m_nCount>
120 CStringList =count=<m_nCount>
121 ; same for all CXXXArray classes
122 ; same for CXXXList
123 ; same for CMapXXToXX
124
125 ; various string classes from MFC & ATL
126
127 _com_error=<m_hresult,hr>
128 _bstr_t=<m_Data->m_wstr,su> (<m_Data->m_RefCount,u>)
129 _com_ptr_t<*>=<m_pInterface>
130 _LARGE_INTEGER=<QuadPart>
131 _ULARGE_INTEGER=<QuadPart>
132 ATL::CComPtr<*>=<p>
133
134 ATL::CComQIPtr<*>=<p>
135
136 tagVARIANT=$BUILTIN(VARIANT)
137 VARIANT=$BUILTIN(VARIANT)
138 _GUID=$BUILTIN(GUID)
139
140 ; see EEAddIn sample for how to use these
141 ;_SYSTEMTIME=$ADDIN(EEAddIn.dll,AddIn_SystemTime)
142 ;_FILETIME=$ADDIN(EEAddIn.dll,AddIn_FileTime)
143
144 ; Qt autoexpand
145 QByteArray=<d->data,s> size=<d->size,u>
146 QPoint =x=<xp> y=<yp>
147 QPointF =x=<xp> y=<yp>
148 QRect =x1=<x1> y1=<y1> x2=<x2> y2=<y2>
149 QRectF =x=<xp> y=<yp> w=<w> h=<h>
150 QSize =width=<wd> height=<ht>
151 QSizeF =width=<wd> height=<ht>
152 QHash<*> =size=<d->size>
153 QVarLengthArray<*> =size=<s> data=<ptr>
154
155 [Visualizer]
156 ; This section contains visualizers for STL and ATL containers
157 ; DO NOT MODIFY
158 ATL::CStringT<char,*>|CSimpleStringT<char,*>|ATL::CSimpleStringT<char,*>{
159 preview ([$e.m_pszData,s])
160 stringview ([$e.m_pszData,sb])
161 }
162 ATL::CStringT<wchar_t,*>|CSimpleStringT<wchar_t,*>|ATL::CSimpleStringT<wchar_t,*>|ATL::CStringT<unsigned short,*>|CSimpleStringT<unsigned short,*>|ATL::CSimpleStringT<unsigned short,*>{
163 preview ([$e.m_pszData,su])
164 stringview ([$e.m_pszData,sub])
165 }
166 ATL::CComBSTR{
167 preview ([$e.m_str,su])
168 stringview ([$e.m_str,sub])
169 }
170
171
172 ; Many visualizers use nested #()s.
173 ; Why not use #(foo, bar) instead of #(#(foo), #(bar))?
174 ; The former alphabetically sorts its fields, while the latter does not.
175
176 ;------------------------------------------------------------------------------
177 ; std::pair from <utility>
178 ;------------------------------------------------------------------------------
179 std::pair<*>{
180 ; pair is previewed with "(<first>, <second>)".
181 preview (
182 #(
183 "(",
184 $e.first,
185 ", ",
186 $e.second,
187 ")"
188 )
189 )
190
191 ; We gloss over the fact that first and second are actually stored in _Pair_base.
192 children (
193 #(
194 #(first : $e.first),
195 #(second : $e.second)
196 )
197 )
198 }
199
200 ;------------------------------------------------------------------------------
201 ; std::plus, etc. from <functional>
202 ;------------------------------------------------------------------------------
203 ; STL functors are previewed with their names.
204 ; They have no state, so they have no children.
205 std::plus<*>{
206 preview ( "plus" )
207 children ( #array(expr: 0, size: 0) )
208 }
209 std::minus<*>{
210 preview ( "minus" )
211 children ( #array(expr: 0, size: 0) )
212 }
213 std::multiplies<*>{
214 preview ( "multiplies" )
215 children ( #array(expr: 0, size: 0) )
216 }
217 std::divides<*>{
218 preview ( "divides" )
219 children ( #array(expr: 0, size: 0) )
220 }
221 std::modulus<*>{
222 preview ( "modulus" )
223 children ( #array(expr: 0, size: 0) )
224 }
225 std::negate<*>{
226 preview ( "negate" )
227 children ( #array(expr: 0, size: 0) )
228 }
229 std::equal_to<*>{
230 preview ( "equal_to" )
231 children ( #array(expr: 0, size: 0) )
232 }
233 std::not_equal_to<*>{
234 preview ( "not_equal_to" )
235 children ( #array(expr: 0, size: 0) )
236 }
237 std::greater<*>{
238 preview ( "greater" )
239 children ( #array(expr: 0, size: 0) )
240 }
241 std::less<*>{
242 preview ( "less" )
243 children ( #array(expr: 0, size: 0) )
244 }
245 std::greater_equal<*>{
246 preview ( "greater_equal" )
247 children ( #array(expr: 0, size: 0) )
248 }
249 std::less_equal<*>{
250 preview ( "less_equal" )
251 children ( #array(expr: 0, size: 0) )
252 }
253 std::logical_and<*>{
254 preview ( "logical_and" )
255 children ( #array(expr: 0, size: 0) )
256 }
257 std::logical_or<*>{
258 preview ( "logical_or" )
259 children ( #array(expr: 0, size: 0) )
260 }
261 std::logical_not<*>{
262 preview ( "logical_not" )
263 children ( #array(expr: 0, size: 0) )
264 }
265
266 ;------------------------------------------------------------------------------
267 ; std::not1() from <functional>
268 ; std::not2() from <functional>
269 ;------------------------------------------------------------------------------
270 ; STL negators are previewed with "not[12](<stored functor>)".
271 ; They have a child with the fake name of [pred], so that the
272 ; stored functor can be inspected.
273 std::unary_negate<*>{
274 preview (
275 #(
276 "not1(",
277 $e._Functor,
278 ")"
279 )
280 )
281
282 children (
283 #([pred] : $e._Functor)
284 )
285 }
286 std::binary_negate<*>{
287 preview (
288 #(
289 "not2(",
290 $e._Functor,
291 ")"
292 )
293 )
294
295 children (
296 #([pred] : $e._Functor)
297 )
298 }
299
300 ;------------------------------------------------------------------------------
301 ; std::bind1st() from <functional>
302 ; std::bind2nd() from <functional>
303 ;------------------------------------------------------------------------------
304 ; STL binders are previewed with "bind1st(<op>, <value>)" or "bind2nd(<op>, <value>)".
305 ; We gloss over the fact that they derive from unary_function.
306 std::binder1st<*>{
307 preview (
308 #(
309 "bind1st(",
310 $e.op,
311 ", ",
312 $e.value,
313 ")"
314 )
315 )
316
317 children (
318 #(
319 #(op : $e.op),
320 #(value : $e.value)
321 )
322 )
323 }
324 std::binder2nd<*>{
325 preview (
326 #(
327 "bind2nd(",
328 $e.op,
329 ", ",
330 $e.value,
331 ")"
332 )
333 )
334
335 children (
336 #(
337 #(op : $e.op),
338 #(value : $e.value)
339 )
340 )
341 }
342
343 ;------------------------------------------------------------------------------
344 ; std::ptr_fun() from <functional>
345 ;------------------------------------------------------------------------------
346 ; STL function pointer adaptors are previewed with "ptr_fun(<stored function pointer>)".
347 ; Function pointers have no children, so the adaptors have no children.
348 std::pointer_to_unary_function<*>|std::pointer_to_binary_function<*>{
349 preview (
350 #(
351 "ptr_fun(",
352 $e._Pfun,
353 ")"
354 )
355 )
356
357 children ( #array(expr: 0, size: 0) )
358 }
359
360 ;------------------------------------------------------------------------------
361 ; std::mem_fun() from <functional>
362 ; std::mem_fun_ref() from <functional>
363 ;------------------------------------------------------------------------------
364 ; See ptr_fun().
365 std::mem_fun_t<*>|std::mem_fun1_t<*>|std::const_mem_fun_t<*>|std::const_mem_fun1_t<*>{
366 preview (
367 #(
368 "mem_fun(",
369 $e._Pmemfun,
370 ")"
371 )
372 )
373
374 children ( #array(expr: 0, size: 0) )
375 }
376 std::mem_fun_ref_t<*>|std::mem_fun1_ref_t<*>|std::const_mem_fun_ref_t<*>|std::const_mem_fun1_ref_t<*>{
377 preview (
378 #(
379 "mem_fun_ref(",
380 $e._Pmemfun,
381 ")"
382 )
383 )
384
385 children ( #array(expr: 0, size: 0) )
386 }
387
388 ;------------------------------------------------------------------------------
389 ; std::auto_ptr from <memory>
390 ;------------------------------------------------------------------------------
391 std::auto_ptr<*>{
392 ; An empty auto_ptr is previewed with "empty".
393 ; Otherwise, it is previewed with "auto_ptr <object>".
394 preview (
395 #if ($e._Myptr == 0) (
396 "empty"
397 ) #else (
398 #(
399 "auto_ptr ",
400 *$e._Myptr
401 )
402 )
403 )
404
405 ; An empty auto_ptr has no children.
406 ; Otherwise, it has a single child, its stored pointer, with a fake name of [ptr].
407 children (
408 #if ($e._Myptr == 0) (
409 #array(expr: 0, size: 0)
410 ) #else (
411 #([ptr] : $e._Myptr)
412 )
413 )
414 }
415
416 ;------------------------------------------------------------------------------
417 ; std::basic_string from <string>
418 ;------------------------------------------------------------------------------
419 ; basic_string is previewed with its stored string.
420 ; It has [size] and [capacity] children, followed by [0], [1], [2], etc. children
421 ; displaying its stored characters.
422 ; The ($e._Myres) < ($e._BUF_SIZE) test determines whether the Small String Optimization
423 ; is in effect.
424 ; NOTE: The parentheses in ($e._Myres) < ($e._BUF_SIZE) are necessary.
425 std::basic_string<char,*>{
426 preview ( #if (($e._Myres) < ($e._BUF_SIZE)) ( [$e._Bx._Buf,s] ) #else ( [$e._Bx._Ptr,s] ))
427 stringview ( #if (($e._Myres) < ($e._BUF_SIZE)) ( [$e._Bx._Buf,sb] ) #else ( [$e._Bx._Ptr,sb] ))
428
429 children (
430 #(
431 #([size] : $e._Mysize),
432 #([capacity] : $e._Myres),
433 #if (($e._Myres) < ($e._BUF_SIZE)) (
434 #array(expr: $e._Bx._Buf[$i], size: $e._Mysize)
435 ) #else (
436 #array(expr: $e._Bx._Ptr[$i], size: $e._Mysize)
437 )
438 )
439 )
440 }
441 std::basic_string<unsigned short,*>|std::basic_string<wchar_t,*>{
442 preview ( #if (($e._Myres) < ($e._BUF_SIZE)) ( [$e._Bx._Buf,su] ) #else ( [$e._Bx._Ptr,su] ))
443 stringview ( #if (($e._Myres) < ($e._BUF_SIZE)) ( [$e._Bx._Buf,sub] ) #else ( [$e._Bx._Ptr,sub] ))
444
445 children (
446 #(
447 #([size] : $e._Mysize),
448 #([capacity] : $e._Myres),
449 #if (($e._Myres) < ($e._BUF_SIZE)) (
450 #array(expr: $e._Bx._Buf[$i], size: $e._Mysize)
451 ) #else (
452 #array(expr: $e._Bx._Ptr[$i], size: $e._Mysize)
453 )
454 )
455 )
456 }
457 std::_String_iterator<char,*>|std::_String_const_iterator<char,*>{
458 preview ( [$e._Ptr,s] )
459 stringview ( [$e._Ptr,sb] )
460 children ( #([ptr] : $e._Ptr) )
461 }
462 std::_String_iterator<unsigned short,*>|std::_String_const_iterator<unsigned short,*>|std::_String_iterator<wchar_t,*>|std::_String_const_iterator<wchar_t,*>{
463 preview ( [$e._Ptr,su] )
464 stringview ( [$e._Ptr,sub] )
465 children ( #([ptr] : $e._Ptr) )
466 }
467
468 ;------------------------------------------------------------------------------
469 ; std::vector<bool> from <vector>
470 ;------------------------------------------------------------------------------
471 ; Despite its packed representation, vector<bool> is visualized like vector<T>.
472 std::vector<bool,*>{
473 preview (
474 #(
475 "[",
476 $e._Mysize,
477 "](",
478 #array(
479 expr: (bool)(($e._Myvec._Myfirst[$i / _VBITS] >> ($i % _VBITS)) & 1),
480 size: $e._Mysize
481 ),
482 ")"
483 )
484 )
485
486 children (
487 #(
488 #([size] : $e._Mysize),
489 #([capacity] : ($e._Myvec._Myend - $e._Myvec._Myfirst) * _VBITS),
490 #array(
491 expr: (bool)(($e._Myvec._Myfirst[$i / _VBITS] >> ($i % _VBITS)) & 1),
492 size: $e._Mysize
493 )
494 )
495 )
496 }
497 std::_Vb_reference<*>|std::_Vb_iterator<*>|std::_Vb_const_iterator<*>{
498 preview (
499 (bool)((*$e._Myptr >> $e._Myoff) & 1)
500 )
501
502 children (
503 #(
504 #([ptr] : $e._Myptr),
505 #([offset] : $e._Myoff)
506 )
507 )
508 }
509
510 ;------------------------------------------------------------------------------
511 ; std::vector from <vector>
512 ;------------------------------------------------------------------------------
513 ; vector is previewed with "[<size>](<elements>)".
514 ; It has [size] and [capacity] children, followed by its elements.
515 ; The other containers follow its example.
516 std::vector<*>{
517 preview (
518 #(
519 "[",
520 $e._Mylast - $e._Myfirst,
521 "](",
522 #array(
523 expr: $e._Myfirst[$i],
524 size: $e._Mylast - $e._Myfirst
525 ),
526 ")"
527 )
528 )
529
530 children (
531 #(
532 #([size] : $e._Mylast - $e._Myfirst),
533 #([capacity] : $e._Myend - $e._Myfirst),
534 #array(
535 expr: $e._Myfirst[$i],
536 size: $e._Mylast - $e._Myfirst
537 )
538 )
539 )
540 }
541 std::_Vector_iterator<*>|std::_Vector_const_iterator<*>{
542 preview (
543 *$e._Ptr
544 )
545
546 children (
547 #([ptr] : $e._Ptr)
548 )
549 }
550
551 ;------------------------------------------------------------------------------
552 ; std::deque from <deque>
553 ;------------------------------------------------------------------------------
554 std::deque<*>{
555 preview (
556 #(
557 "[",
558 $e._Mysize,
559 "](",
560 #array(
561 expr: $e._Map[(($i + $e._Myoff) / $e._EEN_DS) % $e._Mapsize][($i + $e._Myoff) % $e._EEN_DS],
562 size: $e._Mysize
563 ),
564 ")"
565 )
566 )
567
568 children (
569 #(
570 #array(
571 expr: $e._Map[(($i + $e._Myoff) / $e._EEN_DS) % $e._Mapsize][($i + $e._Myoff) % $e._EEN_DS],
572 size: $e._Mysize
573 )
574 )
575 )
576 }
577 std::_Deque_iterator<*,*>|std::_Deque_const_iterator<*,*>{
578 preview (
579 #if ($e._Myoff >= ((std::deque<$T1,$T2> *)$e._Myproxy->_Mycont)->_Myoff + ((std::deque<$T1,$T2> *)$e._Myproxy->_Mycont)->_Mysize) (
580 "end"
581 ) #else (
582 ((std::deque<$T1,$T2> *)$e._Myproxy->_Mycont)->_Map[($e._Myoff / ((std::deque<$T1,$T2> *)$e._Myproxy->_Mycont)->_EEN_DS) % ((std::deque<$T1,$T2> *)$e._Myproxy->_Mycont)->_Mapsize][$e._Myoff % ((std::deque<$T1,$T2> *)$e._Myproxy->_Mycont)->_EEN_DS]
583 )
584 )
585
586 children (
587 #if ($e._Myoff >= ((std::deque<$T1,$T2> *)$e._Myproxy->_Mycont)->_Myoff + ((std::deque<$T1,$T2> *)$e._Myproxy->_Mycont)->_Mysize) (
588 #array(expr: 0, size: 0)
589 ) #else (
590 #(
591 #([index] : $e._Myoff - ((std::deque<$T1,$T2> *)$e._Myproxy->_Mycont)->_Myoff),
592 #([ptr] : &((std::deque<$T1,$T2> *)$e._Myproxy->_Mycont)->_Map[($e._Myoff / ((std::deque<$T1,$T2> *)$e._Myproxy->_Mycont)->_EEN_DS) % ((std::deque<$T1,$T2> *)$e._Myproxy->_Mycont)->_Mapsize][$e._Myoff % ((std::deque<$T1,$T2> *)$e._Myproxy->_Mycont)->_EEN_DS] )
593 )
594 )
595 )
596 }
597
598 ;------------------------------------------------------------------------------
599 ; std::list from <list>
600 ;------------------------------------------------------------------------------
601 std::list<*>{
602 preview (
603 #(
604 "[",
605 $e._Mysize,
606 "](",
607 #list(
608 head: $e._Myhead->_Next,
609 size: $e._Mysize,
610 next: _Next
611 ) : $e._Myval,
612 ")"
613 )
614 )
615
616 children (
617 #list(
618 head: $e._Myhead->_Next,
619 size: $e._Mysize,
620 next: _Next
621 ) : $e._Myval
622 )
623 }
624 std::_List_iterator<*>|std::_List_const_iterator<*>{
625 preview ( $e._Ptr->_Myval )
626 children ( #([ptr] : &$e._Ptr->_Myval) )
627 }
628
629 ;------------------------------------------------------------------------------
630 ; std::queue from <queue>
631 ; std::stack from <stack>
632 ;------------------------------------------------------------------------------
633 std::queue<*>|std::stack<*>{
634 preview ( $e.c )
635 children ( #(c : $e.c) )
636 }
637
638 ;------------------------------------------------------------------------------
639 ; std::priority_queue from <queue>
640 ;------------------------------------------------------------------------------
641 std::priority_queue<*>{
642 preview ( $e.c )
643
644 children (
645 #(
646 #(c [heap]: $e.c),
647 #(comp : $e.comp)
648 )
649 )
650 }
651
652 ;------------------------------------------------------------------------------
653 ; std::map from <map>
654 ; std::multimap from <map>
655 ; std::set from <set>
656 ; std::multiset from <set>
657 ;------------------------------------------------------------------------------
658 std::map<*>|std::multimap<*>|std::set<*>|std::multiset<*>{
659 preview (
660 #(
661 "[",
662 $e._Mysize,
663 "](",
664 #tree(
665 head: $e._Myhead->_Parent,
666 skip: $e._Myhead,
667 left: _Left,
668 right: _Right,
669 size: $e._Mysize
670 ) : $e._Myval,
671 ")"
672 )
673 )
674
675 children (
676 #(
677 #([comp] : $e.comp),
678 #tree(
679 head: $e._Myhead->_Parent,
680 skip: $e._Myhead,
681 left: _Left,
682 right: _Right,
683 size: $e._Mysize
684 ) : $e._Myval
685 )
686 )
687 }
688 std::_Tree_iterator<*>|std::_Tree_const_iterator<*>{
689 preview ( $e._Ptr->_Myval )
690 children ( #([ptr] : &$e._Ptr->_Myval) )
691 }
692
693 ;------------------------------------------------------------------------------
694 ; std::bitset from <bitset>
695 ;------------------------------------------------------------------------------
696 std::bitset<*>{
697 preview (
698 #(
699 "[",
700 $e._EEN_BITS,
701 "](",
702 #array(
703 expr: [($e._Array[$i / $e._Bitsperword] >> ($i % $e._Bitsperword)) & 1,d],
704 size: $e._EEN_BITS
705 ),
706 ")"
707 )
708 )
709
710 children (
711 #array(
712 expr: [($e._Array[$i / $e._Bitsperword] >> ($i % $e._Bitsperword)) & 1,d],
713 size: $e._EEN_BITS
714 )
715 )
716 }
717 std::bitset<*>::reference{
718 preview (
719 [($e._Pbitset->_Array[$i / $e._Pbitset->_Bitsperword] >> ($e._Mypos % $e._Pbitset->_Bitsperword)) & 1,d]
720 )
721
722 children (
723 #(
724 #([bitset] : $e._Pbitset),
725 #([pos] : $e._Mypos)
726 )
727 )
728 }
729
730 ;------------------------------------------------------------------------------
731 ; std::reverse_iterator from <iterator>
732 ;------------------------------------------------------------------------------
733 std::reverse_iterator<std::_String_iterator<*> >|std::reverse_iterator<std::_String_const_iterator<*> >{
734 preview (
735 #(
736 "reverse_iterator to ",
737 $e.current._Ptr[-1]
738 )
739 )
740
741 children (
742 #(
743 #([to] : $e.current._Ptr - 1),
744 #(current : $e.current)
745 )
746 )
747 }
748 std::reverse_iterator<std::_Vb_iterator<*> >|std::reverse_iterator<std::_Vb_const_iterator<*> >{
749 preview (
750 #(
751 "reverse_iterator to ",
752 #if ($e.current._Myoff != 0) (
753 (bool)((*$e.current._Myptr >> ($e.current._Myoff - 1)) & 1)
754 ) #else (
755 (bool)(($e.current._Myptr[-1] >> (_VBITS - 1)) & 1)
756 )
757 )
758 )
759
760 children (
761 #if ($e.current._Myoff != 0) (
762 #(
763 #([to ptr] : $e.current._Myptr),
764 #([to offset] : $e.current._Myoff - 1),
765 #(current : $e.current)
766 )
767 ) #else (
768 #(
769 #([to ptr] : $e.current._Myptr - 1),
770 #([to offset] : _VBITS - 1),
771 #(current : $e.current)
772 )
773 )
774 )
775 }
776 std::reverse_iterator<std::_Vector_iterator<*> >|std::reverse_iterator<std::_Vector_const_iterator<*> >{
777 preview (
778 #(
779 "reverse_iterator to ",
780 $e.current._Ptr[-1]
781 )
782 )
783
784 children (
785 #(
786 #([to] : $e.current._Ptr - 1),
787 #(current : $e.current)
788 )
789 )
790 }
791 std::reverse_iterator<std::_Deque_iterator<*,*> >|std::reverse_iterator<std::_Deque_const_iterator<*,*> >{
792 preview (
793 #(
794 "reverse_iterator to ",
795 #if ($e.current._Myoff == ((std::deque<$T1,$T2> *)$e.current._Myproxy->_Mycont)->_Myoff) (
796 "end"
797 ) #else (
798 ((std::deque<$T1,$T2> *)$e.current._Myproxy->_Mycont)->_Map[(($e.current._Myoff - 1) / ((std::deque<$T1,$T2> *)$e.current._Myproxy->_Mycont)->_EEN_DS) % ((std::deque<$T1,$T2> *)$e.current._Myproxy->_Mycont)->_Mapsize][($e.current._Myoff - 1) % ((std::deque<$T1,$T2> *)$e.current._Myproxy->_Mycont)->_EEN_DS]
799 )
800 )
801 )
802
803 children (
804 #if ($e.current._Myoff == ((std::deque<$T1,$T2> *)$e.current._Myproxy->_Mycont)->_Myoff) (
805 #(current : $e.current)
806 ) #else (
807 #(
808 #([to index] : ($e.current._Myoff - 1) - ((std::deque<$T1,$T2> *)$e.current._Myproxy->_Mycont)->_Myoff),
809 #([to ptr] : &((std::deque<$T1,$T2> *)$e.current._Myproxy->_Mycont)->_Map[(($e.current._Myoff - 1) / ((std::deque<$T1,$T2> *)$e.current._Myproxy->_Mycont)->_EEN_DS) % ((std::deque<$T1,$T2> *)$e.current._Myproxy->_Mycont)->_Mapsize][($e.current._Myoff - 1) % ((std::deque<$T1,$T2> *)$e.current._Myproxy->_Mycont)->_EEN_DS] ),
810 #(current : $e.current)
811 )
812 )
813 )
814 }
815 std::reverse_iterator<std::_List_iterator<*> >|std::reverse_iterator<std::_List_const_iterator<*> >{
816 preview (
817 #(
818 "reverse_iterator to ",
819 $e.current._Ptr->_Prev->_Myval
820 )
821 )
822
823 children (
824 #(
825 #([to] : &$e.current._Ptr->_Prev->_Myval),
826 #(current : $e.current)
827 )
828 )
829 }
830 std::reverse_iterator<std::_Array_iterator<*> >|std::reverse_iterator<std::_Array_const_iterator<*> >{
831 preview (
832 #(
833 "reverse_iterator to ",
834 #if ($e.current._EEN_IDL == 0) (
835 $e.current._Ptr[-1]
836 ) #else (
837 #if ($e.current._Idx == 0) (
838 "end"
839 ) #else (
840 $e.current._Ptr[$e.current._Idx - 1]
841 )
842 )
843 )
844 )
845
846 children (
847 #if ($e.current._EEN_IDL == 0) (
848 #(
849 #([to] : $e.current._Ptr - 1),
850 #(current : $e.current)
851 )
852 ) #else (
853 #if ($e.current._Idx == 0) (
854 #(current : $e.current)
855 ) #else (
856 #(
857 #([to] : $e.current._Ptr + $e.current._Idx - 1),
858 #(current : $e.current)
859 )
860 )
861 )
862 )
863 }
864 std::reverse_iterator<*>{
865 preview (
866 #(
867 "reverse_iterator current ",
868 $e.current
869 )
870 )
871
872 children (
873 #(current : $e.current)
874 )
875 }
876
877 ;------------------------------------------------------------------------------
878 ; std::complex from <complex>
879 ;------------------------------------------------------------------------------
880 std::complex<*>{
881 preview (
882 #if ($e._Val[1] == 0) (
883 ; Purely real.
884 $e._Val[0]
885 ) #else (
886 #if ($e._Val[0] == 0) (
887 ; Purely imaginary.
888 #if ($e._Val[1] < 0) (
889 #("-i*", -$e._Val[1])
890 ) #else (
891 #("i*", $e._Val[1])
892 )
893 ) #else (
894 ; Mixed.
895 #if ($e._Val[1] < 0) (
896 #($e._Val[0], "-i*", -$e._Val[1])
897 ) #else (
898 #($e._Val[0], "+i*", $e._Val[1])
899 )
900 )
901 )
902 )
903
904 children (
905 #(
906 #(real : $e._Val[0]),
907 #(imag : $e._Val[1])
908 )
909 )
910 }
911
912 ;------------------------------------------------------------------------------
913 ; std::valarray from <valarray>
914 ;------------------------------------------------------------------------------
915 std::valarray<*>{
916 preview (
917 #(
918 "[",
919 $e._Mysize,
920 "](",
921 #array(
922 expr: $e._Myptr[$i],
923 size: $e._Mysize
924 ),
925 ")"
926 )
927 )
928
929 children (
930 #array(
931 expr: $e._Myptr[$i],
932 size: $e._Mysize
933 )
934 )
935 }
936
937 ;------------------------------------------------------------------------------
938 ; std::tr1::reference_wrapper from <functional>
939 ;------------------------------------------------------------------------------
940 std::tr1::reference_wrapper<*>{
941 preview (
942 #if ($e._Callee._EEN_INDIRECT == 1) (
943 ; For ordinary T, reference_wrapper<T> stores a T * _Callee._Ptr
944 ; which is non-null. Actual references are previewed with what they
945 ; refer to, so reference_wrapper<T> is previewed with dereferencing its
946 ; stored pointer.
947 *$e._Callee._Ptr
948 ) #else (
949 ; When T is a pointer to data member type, reference_wrapper<T>
950 ; stores a T _Callee._Object directly.
951 $e._Callee._Object
952 )
953 )
954
955 children (
956 #if ($e._Callee._EEN_INDIRECT == 1) (
957 ; Actual references have the same children as what they refer to.
958 ; Unfortunately, there appears to be no way to imitate this exactly.
959 ; Therefore, we make reference_wrapper<T> appear to have a single
960 ; child, its stored pointer, with a fake name of [ptr].
961 #([ptr] : $e._Callee._Ptr)
962 ) #else (
963 ; When T is a pointer to data member type, T has no children,
964 ; so we make reference_wrapper<T> appear to have no children.
965 #array(expr: 0, size: 0)
966 )
967 )
968 }
969
970 ;------------------------------------------------------------------------------
971 ; std::tr1::shared_ptr from <memory>
972 ;------------------------------------------------------------------------------
973 std::tr1::_Ref_count<*>{
974 preview ( "default" )
975 children ( #array(expr: 0, size: 0) )
976 }
977 std::tr1::_Ref_count_del<*>{
978 preview ( "custom deleter" )
979 children ( #([deleter] : $e._Dtor) )
980 }
981 std::tr1::_Ref_count_del_alloc<*>{
982 preview ( "custom deleter, custom allocator" )
983 children (
984 #(
985 #([deleter] : $e._Dtor),
986 #([allocator] : $e._Myal)
987 )
988 )
989 }
990 std::tr1::_Ref_count_obj<*>{
991 preview ( "make_shared" )
992 children ( #array(expr: 0, size: 0) )
993 }
994 std::tr1::_Ref_count_obj_alloc<*>{
995 preview ( "allocate_shared" )
996 children ( #([allocator] : $e._Myal) )
997 }
998 std::tr1::shared_ptr<*>{
999 preview (
1000 ; shared_ptr<T> stores a T * _Ptr .
1001 #if ($e._Ptr == 0) (
1002 ; A default-constructed shared_ptr has a null _Ptr and a null _Rep,
1003 ; and is formally said to be empty.
1004 ; A shared_ptr constructed from a null pointer has a null _Ptr
1005 ; and a NON-null _Rep . It is formally said to own the null pointer.
1006 ; We preview both with "empty".
1007 "empty"
1008 ) #else (
1009 ; Raw pointers are previewed with "<pointer value> <object>".
1010 ; auto_ptr is previewed with "auto_ptr <object>".
1011 ; Following these examples, shared_ptr is previewed with
1012 ; "shared_ptr <object> [N strong refs, M weak refs]".
1013 #(
1014 "shared_ptr ",
1015 *$e._Ptr,
1016 " [",
1017 $e._Rep->_Uses,
1018 #if ($e._Rep->_Uses == 1) (" strong ref") #else (" strong refs"),
1019 #if ($e._Rep->_Weaks - 1 > 0) (
1020 #(
1021 ", ",
1022 $e._Rep->_Weaks - 1,
1023 #if ($e._Rep->_Weaks - 1 == 1) (" weak ref") #else (" weak refs")
1024 )
1025 ),
1026 "] [",
1027 *$e._Rep,
1028 "]"
1029 )
1030 ; Note: _Rep->_Uses counts how many shared_ptrs share ownership of the object,
1031 ; so we directly display it as the strong reference count.
1032 ; _Rep->_Weaks counts how many shared_ptrs and weak_ptrs share ownership of
1033 ; the "representation object" (or "control block"). All of the shared_ptrs are
1034 ; counted as a single owner. That is, _Weaks is initialized to 1, and when
1035 ; _Uses falls to 0, _Weaks is decremented. This avoids incrementing and decrementing
1036 ; _Weaks every time that a shared_ptr gains or loses ownership. Therefore,
1037 ; _Weaks - 1 is the weak reference count, the number of weak_ptrs that are observing
1038 ; the shared object.
1039 )
1040 )
1041
1042 children (
1043 #if ($e._Ptr == 0) (
1044 ; We make empty shared_ptrs (and shared_ptrs that own
1045 ; the null pointer) appear to have no children.
1046 #array(expr: 0, size: 0)
1047 ) #else (
1048 #(
1049 ; We make shared_ptr appear to have two children:
1050
1051 ; Its stored pointer, with a fake name of [ptr].
1052 #([ptr] : $e._Ptr),
1053
1054 ; Its deleter and allocator, which may be default or custom.
1055 #([deleter and allocator] : *$e._Rep)
1056 )
1057 )
1058 )
1059 }
1060
1061 ;------------------------------------------------------------------------------
1062 ; std::tr1::weak_ptr from <memory>
1063 ;------------------------------------------------------------------------------
1064 std::tr1::weak_ptr<*>{
1065 preview (
1066 #if ($e._Ptr == 0) (
1067 "empty"
1068 ) #elif ($e._Rep->_Uses == 0) (
1069 ; weak_ptr is just like shared_ptr, except that a weak_ptr can be expired.
1070 #(
1071 "expired [",
1072 *$e._Rep,
1073 "]"
1074 )
1075 ) #else (
1076 #(
1077 "weak_ptr ",
1078 *$e._Ptr,
1079 " [",
1080 $e._Rep->_Uses,
1081 #if ($e._Rep->_Uses == 1) (" strong ref") #else (" strong refs"),
1082 #if ($e._Rep->_Weaks - 1 > 0) (
1083 #(
1084 ", ",
1085 $e._Rep->_Weaks - 1,
1086 #if ($e._Rep->_Weaks - 1 == 1) (" weak ref") #else (" weak refs")
1087 )
1088 ),
1089 "] [",
1090 *$e._Rep,
1091 "]"
1092 )
1093 )
1094 )
1095
1096 children (
1097 #if ($e._Ptr == 0) (
1098 #array(expr: 0, size: 0)
1099 ) #elif ($e._Rep->_Uses == 0) (
1100 ; When a weak_ptr is expired, we show its deleter and allocator.
1101 ; The deleter has already been used, but the control block has not yet been deallocated.
1102 #([deleter and allocator] : *$e._Rep)
1103 ) #else (
1104 #(
1105 #([ptr] : $e._Ptr),
1106 #([deleter and allocator] : *$e._Rep)
1107 )
1108 )
1109 )
1110 }
1111
1112 ;------------------------------------------------------------------------------
1113 ; std::tr1::mem_fn() from <functional>
1114 ;------------------------------------------------------------------------------
1115 ; Note that when mem_fn() is given a data member pointer, it returns a _Call_wrapper<_Callable_pmd<*> > .
1116 ; Data member pointers themselves don't have useful previews, so we don't attempt to visualize this.
1117 ; When mem_fn() is given a member function pointer, it returns a _Mem_fn[N], which we can visualize.
1118 std::tr1::_Mem_fn1<*>|std::tr1::_Mem_fn2<*>|std::tr1::_Mem_fn3<*>|std::tr1::_Mem_fn4<*>|std::tr1::_Mem_fn5<*>|std::tr1::_Mem_fn6<*>|std::tr1::_Mem_fn7<*>|std::tr1::_Mem_fn8<*>|std::tr1::_Mem_fn9<*>|std::tr1::_Mem_fn10<*>{
1119 preview (
1120 ; We preview the functor returned by mem_fn() with "mem_fn(<stored member function pointer>)".
1121 #(
1122 "mem_fn(",
1123 $e._Callee._Object,
1124 ")"
1125 )
1126 )
1127
1128 children (
1129 ; Member function pointers have no children.
1130 #array(expr: 0, size: 0)
1131 )
1132 }
1133
1134 ;------------------------------------------------------------------------------
1135 ; std::tr1::bind() from <functional>
1136 ;------------------------------------------------------------------------------
1137 ; bind() placeholders are previewed with their names.
1138 ; They have no state, so they have no children.
1139 std::tr1::_Ph<1>{
1140 preview ( "_1" )
1141 children ( #array(expr: 0, size: 0) )
1142 }
1143 std::tr1::_Ph<2>{
1144 preview ( "_2" )
1145 children ( #array(expr: 0, size: 0) )
1146 }
1147 std::tr1::_Ph<3>{
1148 preview ( "_3" )
1149 children ( #array(expr: 0, size: 0) )
1150 }
1151 std::tr1::_Ph<4>{
1152 preview ( "_4" )
1153 children ( #array(expr: 0, size: 0) )
1154 }
1155 std::tr1::_Ph<5>{
1156 preview ( "_5" )
1157 children ( #array(expr: 0, size: 0) )
1158 }
1159 std::tr1::_Ph<6>{
1160 preview ( "_6" )
1161 children ( #array(expr: 0, size: 0) )
1162 }
1163 std::tr1::_Ph<7>{
1164 preview ( "_7" )
1165 children ( #array(expr: 0, size: 0) )
1166 }
1167 std::tr1::_Ph<8>{
1168 preview ( "_8" )
1169 children ( #array(expr: 0, size: 0) )
1170 }
1171 std::tr1::_Ph<9>{
1172 preview ( "_9" )
1173 children ( #array(expr: 0, size: 0) )
1174 }
1175 std::tr1::_Ph<10>{
1176 preview ( "_10" )
1177 children ( #array(expr: 0, size: 0) )
1178 }
1179
1180 ; The functor returned by bind(f, t1, t2) is previewed with "bind(f, t1, t2)".
1181 ; It has children with the fake names of [f], [t1], [t2], etc.
1182 std::tr1::_Bind<*,*,std::tr1::_Bind0<*> >|std::tr1::_Bind_fty<*,*,std::tr1::_Bind0<*> >{
1183 preview (
1184 #(
1185 "bind(", $e._Bx._Callee._Object,
1186 ")"
1187 )
1188 )
1189
1190 children (
1191 #(
1192 #([f] : $e._Bx._Callee._Object)
1193 )
1194 )
1195 }
1196 std::tr1::_Bind<*,*,std::tr1::_Bind1<*> >|std::tr1::_Bind_fty<*,*,std::tr1::_Bind1<*> >{
1197 preview (
1198 #(
1199 "bind(", $e._Bx._Callee._Object,
1200 ", ", $e._Bx._Vx0,
1201 ")"
1202 )
1203 )
1204
1205 children (
1206 #(
1207 #([f] : $e._Bx._Callee._Object),
1208 #([t1] : $e._Bx._Vx0)
1209 )
1210 )
1211 }
1212 std::tr1::_Bind<*,*,std::tr1::_Bind2<*> >|std::tr1::_Bind_fty<*,*,std::tr1::_Bind2<*> >{
1213 preview (
1214 #(
1215 "bind(", $e._Bx._Callee._Object,
1216 ", ", $e._Bx._Vx0,
1217 ", ", $e._Bx._Vx1,
1218 ")"
1219 )
1220 )
1221
1222 children (
1223 #(
1224 #([f] : $e._Bx._Callee._Object),
1225 #([t1] : $e._Bx._Vx0),
1226 #([t2] : $e._Bx._Vx1)
1227 )
1228 )
1229 }
1230 std::tr1::_Bind<*,*,std::tr1::_Bind3<*> >|std::tr1::_Bind_fty<*,*,std::tr1::_Bind3<*> >{
1231 preview (
1232 #(
1233 "bind(", $e._Bx._Callee._Object,
1234 ", ", $e._Bx._Vx0,
1235 ", ", $e._Bx._Vx1,
1236 ", ", $e._Bx._Vx2,
1237 ")"
1238 )
1239 )
1240
1241 children (
1242 #(
1243 #([f] : $e._Bx._Callee._Object),
1244 #([t1] : $e._Bx._Vx0),
1245 #([t2] : $e._Bx._Vx1),
1246 #([t3] : $e._Bx._Vx2)
1247 )
1248 )
1249 }
1250 std::tr1::_Bind<*,*,std::tr1::_Bind4<*> >|std::tr1::_Bind_fty<*,*,std::tr1::_Bind4<*> >{
1251 preview (
1252 #(
1253 "bind(", $e._Bx._Callee._Object,
1254 ", ", $e._Bx._Vx0,
1255 ", ", $e._Bx._Vx1,
1256 ", ", $e._Bx._Vx2,
1257 ", ", $e._Bx._Vx3,
1258 ")"
1259 )
1260 )
1261
1262 children (
1263 #(
1264 #([f] : $e._Bx._Callee._Object),
1265 #([t1] : $e._Bx._Vx0),
1266 #([t2] : $e._Bx._Vx1),
1267 #([t3] : $e._Bx._Vx2),
1268 #([t4] : $e._Bx._Vx3)
1269 )
1270 )
1271 }
1272 std::tr1::_Bind<*,*,std::tr1::_Bind5<*> >|std::tr1::_Bind_fty<*,*,std::tr1::_Bind5<*> >{
1273 preview (
1274 #(
1275 "bind(", $e._Bx._Callee._Object,
1276 ", ", $e._Bx._Vx0,
1277 ", ", $e._Bx._Vx1,
1278 ", ", $e._Bx._Vx2,
1279 ", ", $e._Bx._Vx3,
1280 ", ", $e._Bx._Vx4,
1281 ")"
1282 )
1283 )
1284
1285 children (
1286 #(
1287 #([f] : $e._Bx._Callee._Object),
1288 #([t1] : $e._Bx._Vx0),
1289 #([t2] : $e._Bx._Vx1),
1290 #([t3] : $e._Bx._Vx2),
1291 #([t4] : $e._Bx._Vx3),
1292 #([t5] : $e._Bx._Vx4)
1293 )
1294 )
1295 }
1296 std::tr1::_Bind<*,*,std::tr1::_Bind6<*> >|std::tr1::_Bind_fty<*,*,std::tr1::_Bind6<*> >{
1297 preview (
1298 #(
1299 "bind(", $e._Bx._Callee._Object,
1300 ", ", $e._Bx._Vx0,
1301 ", ", $e._Bx._Vx1,
1302 ", ", $e._Bx._Vx2,
1303 ", ", $e._Bx._Vx3,
1304 ", ", $e._Bx._Vx4,
1305 ", ", $e._Bx._Vx5,
1306 ")"
1307 )
1308 )
1309
1310 children (
1311 #(
1312 #([f] : $e._Bx._Callee._Object),
1313 #([t1] : $e._Bx._Vx0),
1314 #([t2] : $e._Bx._Vx1),
1315 #([t3] : $e._Bx._Vx2),
1316 #([t4] : $e._Bx._Vx3),
1317 #([t5] : $e._Bx._Vx4),
1318 #([t6] : $e._Bx._Vx5)
1319 )
1320 )
1321 }
1322 std::tr1::_Bind<*,*,std::tr1::_Bind7<*> >|std::tr1::_Bind_fty<*,*,std::tr1::_Bind7<*> >{
1323 preview (
1324 #(
1325 "bind(", $e._Bx._Callee._Object,
1326 ", ", $e._Bx._Vx0,
1327 ", ", $e._Bx._Vx1,
1328 ", ", $e._Bx._Vx2,
1329 ", ", $e._Bx._Vx3,
1330 ", ", $e._Bx._Vx4,
1331 ", ", $e._Bx._Vx5,
1332 ", ", $e._Bx._Vx6,
1333 ")"
1334 )
1335 )
1336
1337 children (
1338 #(
1339 #([f] : $e._Bx._Callee._Object),
1340 #([t1] : $e._Bx._Vx0),
1341 #([t2] : $e._Bx._Vx1),
1342 #([t3] : $e._Bx._Vx2),
1343 #([t4] : $e._Bx._Vx3),
1344 #([t5] : $e._Bx._Vx4),
1345 #([t6] : $e._Bx._Vx5),
1346 #([t7] : $e._Bx._Vx6)
1347 )
1348 )
1349 }
1350 std::tr1::_Bind<*,*,std::tr1::_Bind8<*> >|std::tr1::_Bind_fty<*,*,std::tr1::_Bind8<*> >{
1351 preview (
1352 #(
1353 "bind(", $e._Bx._Callee._Object,
1354 ", ", $e._Bx._Vx0,
1355 ", ", $e._Bx._Vx1,
1356 ", ", $e._Bx._Vx2,
1357 ", ", $e._Bx._Vx3,
1358 ", ", $e._Bx._Vx4,
1359 ", ", $e._Bx._Vx5,
1360 ", ", $e._Bx._Vx6,
1361 ", ", $e._Bx._Vx7,
1362 ")"
1363 )
1364 )
1365
1366 children (
1367 #(
1368 #([f] : $e._Bx._Callee._Object),
1369 #([t1] : $e._Bx._Vx0),
1370 #([t2] : $e._Bx._Vx1),
1371 #([t3] : $e._Bx._Vx2),
1372 #([t4] : $e._Bx._Vx3),
1373 #([t5] : $e._Bx._Vx4),
1374 #([t6] : $e._Bx._Vx5),
1375 #([t7] : $e._Bx._Vx6),
1376 #([t8] : $e._Bx._Vx7)
1377 )
1378 )
1379 }
1380 std::tr1::_Bind<*,*,std::tr1::_Bind9<*> >|std::tr1::_Bind_fty<*,*,std::tr1::_Bind9<*> >{
1381 preview (
1382 #(
1383 "bind(", $e._Bx._Callee._Object,
1384 ", ", $e._Bx._Vx0,
1385 ", ", $e._Bx._Vx1,
1386 ", ", $e._Bx._Vx2,
1387 ", ", $e._Bx._Vx3,
1388 ", ", $e._Bx._Vx4,
1389 ", ", $e._Bx._Vx5,
1390 ", ", $e._Bx._Vx6,
1391 ", ", $e._Bx._Vx7,
1392 ", ", $e._Bx._Vx8,
1393 ")"
1394 )
1395 )
1396
1397 children (
1398 #(
1399 #([f] : $e._Bx._Callee._Object),
1400 #([t1] : $e._Bx._Vx0),
1401 #([t2] : $e._Bx._Vx1),
1402 #([t3] : $e._Bx._Vx2),
1403 #([t4] : $e._Bx._Vx3),
1404 #([t5] : $e._Bx._Vx4),
1405 #([t6] : $e._Bx._Vx5),
1406 #([t7] : $e._Bx._Vx6),
1407 #([t8] : $e._Bx._Vx7),
1408 #([t9] : $e._Bx._Vx8)
1409 )
1410 )
1411 }
1412 std::tr1::_Bind<*,*,std::tr1::_Bind10<*> >|std::tr1::_Bind_fty<*,*,std::tr1::_Bind10<*> >{
1413 preview (
1414 #(
1415 "bind(", $e._Bx._Callee._Object,
1416 ", ", $e._Bx._Vx0,
1417 ", ", $e._Bx._Vx1,
1418 ", ", $e._Bx._Vx2,
1419 ", ", $e._Bx._Vx3,
1420 ", ", $e._Bx._Vx4,
1421 ", ", $e._Bx._Vx5,
1422 ", ", $e._Bx._Vx6,
1423 ", ", $e._Bx._Vx7,
1424 ", ", $e._Bx._Vx8,
1425 ", ", $e._Bx._Vx9,
1426 ")"
1427 )
1428 )
1429
1430 children (
1431 #(
1432 #([f] : $e._Bx._Callee._Object),
1433 #([t1] : $e._Bx._Vx0),
1434 #([t2] : $e._Bx._Vx1),
1435 #([t3] : $e._Bx._Vx2),
1436 #([t4] : $e._Bx._Vx3),
1437 #([t5] : $e._Bx._Vx4),
1438 #([t6] : $e._Bx._Vx5),
1439 #([t7] : $e._Bx._Vx6),
1440 #([t8] : $e._Bx._Vx7),
1441 #([t9] : $e._Bx._Vx8),
1442 #([t10] : $e._Bx._Vx9)
1443 )
1444 )
1445 }
1446
1447 ;------------------------------------------------------------------------------
1448 ; std::tr1::function from <functional>
1449 ;------------------------------------------------------------------------------
1450 std::tr1::_Impl_no_alloc0<*>|std::tr1::_Impl_no_alloc1<*>|std::tr1::_Impl_no_alloc2<*>|std::tr1::_Impl_no_alloc3<*>|std::tr1::_Impl_no_alloc4<*>|std::tr1::_Impl_no_alloc5<*>|std::tr1::_Impl_no_alloc6<*>|std::tr1::_Impl_no_alloc7<*>|std::tr1::_Impl_no_alloc8<*>|std::tr1::_Impl_no_alloc9<*>|std::tr1::_Impl_no_alloc10<*>{
1451 preview ( $e._Callee._Object )
1452 children ( #([functor] : $e._Callee._Object) )
1453 }
1454 std::tr1::_Impl0<*>|std::tr1::_Impl1<*>|std::tr1::_Impl2<*>|std::tr1::_Impl3<*>|std::tr1::_Impl4<*>|std::tr1::_Impl5<*>|std::tr1::_Impl6<*>|std::tr1::_Impl7<*>|std::tr1::_Impl8<*>|std::tr1::_Impl9<*>|std::tr1::_Impl10<*>{
1455 preview ( $e._Callee._Object )
1456 children (
1457 #(
1458 #([functor] : $e._Callee._Object),
1459 #([allocator] : $e._Myal)
1460 )
1461 )
1462 }
1463 std::tr1::function<*>{
1464 preview (
1465 #if ($e._Impl == 0) (
1466 ; Detecting empty functions is trivial.
1467 "empty"
1468 ) #else (
1469 *$e._Impl
1470 )
1471 )
1472
1473 children (
1474 #if ($e._Impl == 0) (
1475 ; We make empty functions appear to have no children.
1476 #array(expr: 0, size: 0)
1477 ) #else (
1478 #([functor and allocator] : *$e._Impl)
1479 )
1480 )
1481 }
1482
1483 ;------------------------------------------------------------------------------
1484 ; std::tr1::tuple from <tuple>
1485 ;------------------------------------------------------------------------------
1486 ; tuple is visualized like pair, except that we have to give fake names to tuple's children.
1487 std::tr1::tuple<std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil>{
1488 preview (
1489 "()"
1490 )
1491
1492 children (
1493 #array(expr: 0, size: 0)
1494 )
1495 }
1496 std::tr1::tuple<*,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil>{
1497 preview (
1498 #(
1499 "(", $e._Impl._Value,
1500 ")"
1501 )
1502 )
1503
1504 children (
1505 #(
1506 [0] : $e._Impl._Value
1507 )
1508 )
1509 }
1510 std::tr1::tuple<*,*,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil>{
1511 preview (
1512 #(
1513 "(", $e._Impl._Value,
1514 ", ", $e._Impl._Tail._Value,
1515 ")"
1516 )
1517 )
1518
1519 children (
1520 #(
1521 [0] : $e._Impl._Value,
1522 [1] : $e._Impl._Tail._Value
1523 )
1524 )
1525 }
1526 std::tr1::tuple<*,*,*,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil>{
1527 preview (
1528 #(
1529 "(", $e._Impl._Value,
1530 ", ", $e._Impl._Tail._Value,
1531 ", ", $e._Impl._Tail._Tail._Value,
1532 ")"
1533 )
1534 )
1535
1536 children (
1537 #(
1538 [0] : $e._Impl._Value,
1539 [1] : $e._Impl._Tail._Value,
1540 [2] : $e._Impl._Tail._Tail._Value
1541 )
1542 )
1543 }
1544 std::tr1::tuple<*,*,*,*,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil>{
1545 preview (
1546 #(
1547 "(", $e._Impl._Value,
1548 ", ", $e._Impl._Tail._Value,
1549 ", ", $e._Impl._Tail._Tail._Value,
1550 ", ", $e._Impl._Tail._Tail._Tail._Value,
1551 ")"
1552 )
1553 )
1554
1555 children (
1556 #(
1557 [0] : $e._Impl._Value,
1558 [1] : $e._Impl._Tail._Value,
1559 [2] : $e._Impl._Tail._Tail._Value,
1560 [3] : $e._Impl._Tail._Tail._Tail._Value
1561 )
1562 )
1563 }
1564 std::tr1::tuple<*,*,*,*,*,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil>{
1565 preview (
1566 #(
1567 "(", $e._Impl._Value,
1568 ", ", $e._Impl._Tail._Value,
1569 ", ", $e._Impl._Tail._Tail._Value,
1570 ", ", $e._Impl._Tail._Tail._Tail._Value,
1571 ", ", $e._Impl._Tail._Tail._Tail._Tail._Value,
1572 ")"
1573 )
1574 )
1575
1576 children (
1577 #(
1578 [0] : $e._Impl._Value,
1579 [1] : $e._Impl._Tail._Value,
1580 [2] : $e._Impl._Tail._Tail._Value,
1581 [3] : $e._Impl._Tail._Tail._Tail._Value,
1582 [4] : $e._Impl._Tail._Tail._Tail._Tail._Value
1583 )
1584 )
1585 }
1586 std::tr1::tuple<*,*,*,*,*,*,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil>{
1587 preview (
1588 #(
1589 "(", $e._Impl._Value,
1590 ", ", $e._Impl._Tail._Value,
1591 ", ", $e._Impl._Tail._Tail._Value,
1592 ", ", $e._Impl._Tail._Tail._Tail._Value,
1593 ", ", $e._Impl._Tail._Tail._Tail._Tail._Value,
1594 ", ", $e._Impl._Tail._Tail._Tail._Tail._Tail._Value,
1595 ")"
1596 )
1597 )
1598
1599 children (
1600 #(
1601 [0] : $e._Impl._Value,
1602 [1] : $e._Impl._Tail._Value,
1603 [2] : $e._Impl._Tail._Tail._Value,
1604 [3] : $e._Impl._Tail._Tail._Tail._Value,
1605 [4] : $e._Impl._Tail._Tail._Tail._Tail._Value,
1606 [5] : $e._Impl._Tail._Tail._Tail._Tail._Tail._Value
1607 )
1608 )
1609 }
1610 std::tr1::tuple<*,*,*,*,*,*,*,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil>{
1611 preview (
1612 #(
1613 "(", $e._Impl._Value,
1614 ", ", $e._Impl._Tail._Value,
1615 ", ", $e._Impl._Tail._Tail._Value,
1616 ", ", $e._Impl._Tail._Tail._Tail._Value,
1617 ", ", $e._Impl._Tail._Tail._Tail._Tail._Value,
1618 ", ", $e._Impl._Tail._Tail._Tail._Tail._Tail._Value,
1619 ", ", $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Value,
1620 ")"
1621 )
1622 )
1623
1624 children (
1625 #(
1626 [0] : $e._Impl._Value,
1627 [1] : $e._Impl._Tail._Value,
1628 [2] : $e._Impl._Tail._Tail._Value,
1629 [3] : $e._Impl._Tail._Tail._Tail._Value,
1630 [4] : $e._Impl._Tail._Tail._Tail._Tail._Value,
1631 [5] : $e._Impl._Tail._Tail._Tail._Tail._Tail._Value,
1632 [6] : $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Value
1633 )
1634 )
1635 }
1636 std::tr1::tuple<*,*,*,*,*,*,*,*,std::tr1::_Nil,std::tr1::_Nil>{
1637 preview (
1638 #(
1639 "(", $e._Impl._Value,
1640 ", ", $e._Impl._Tail._Value,
1641 ", ", $e._Impl._Tail._Tail._Value,
1642 ", ", $e._Impl._Tail._Tail._Tail._Value,
1643 ", ", $e._Impl._Tail._Tail._Tail._Tail._Value,
1644 ", ", $e._Impl._Tail._Tail._Tail._Tail._Tail._Value,
1645 ", ", $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Value,
1646 ", ", $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Value,
1647 ")"
1648 )
1649 )
1650
1651 children (
1652 #(
1653 [0] : $e._Impl._Value,
1654 [1] : $e._Impl._Tail._Value,
1655 [2] : $e._Impl._Tail._Tail._Value,
1656 [3] : $e._Impl._Tail._Tail._Tail._Value,
1657 [4] : $e._Impl._Tail._Tail._Tail._Tail._Value,
1658 [5] : $e._Impl._Tail._Tail._Tail._Tail._Tail._Value,
1659 [6] : $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Value,
1660 [7] : $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Value
1661 )
1662 )
1663 }
1664 std::tr1::tuple<*,*,*,*,*,*,*,*,*,std::tr1::_Nil>{
1665 preview (
1666 #(
1667 "(", $e._Impl._Value,
1668 ", ", $e._Impl._Tail._Value,
1669 ", ", $e._Impl._Tail._Tail._Value,
1670 ", ", $e._Impl._Tail._Tail._Tail._Value,
1671 ", ", $e._Impl._Tail._Tail._Tail._Tail._Value,
1672 ", ", $e._Impl._Tail._Tail._Tail._Tail._Tail._Value,
1673 ", ", $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Value,
1674 ", ", $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Value,
1675 ", ", $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Value,
1676 ")"
1677 )
1678 )
1679
1680 children (
1681 #(
1682 [0] : $e._Impl._Value,
1683 [1] : $e._Impl._Tail._Value,
1684 [2] : $e._Impl._Tail._Tail._Value,
1685 [3] : $e._Impl._Tail._Tail._Tail._Value,
1686 [4] : $e._Impl._Tail._Tail._Tail._Tail._Value,
1687 [5] : $e._Impl._Tail._Tail._Tail._Tail._Tail._Value,
1688 [6] : $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Value,
1689 [7] : $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Value,
1690 [8] : $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Value
1691 )
1692 )
1693 }
1694 std::tr1::tuple<*,*,*,*,*,*,*,*,*,*>{
1695 preview (
1696 #(
1697 "(", $e._Impl._Value,
1698 ", ", $e._Impl._Tail._Value,
1699 ", ", $e._Impl._Tail._Tail._Value,
1700 ", ", $e._Impl._Tail._Tail._Tail._Value,
1701 ", ", $e._Impl._Tail._Tail._Tail._Tail._Value,
1702 ", ", $e._Impl._Tail._Tail._Tail._Tail._Tail._Value,
1703 ", ", $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Value,
1704 ", ", $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Value,
1705 ", ", $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Value,
1706 ", ", $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Value,
1707 ")"
1708 )
1709 )
1710
1711 children (
1712 #(
1713 [0] : $e._Impl._Value,
1714 [1] : $e._Impl._Tail._Value,
1715 [2] : $e._Impl._Tail._Tail._Value,
1716 [3] : $e._Impl._Tail._Tail._Tail._Value,
1717 [4] : $e._Impl._Tail._Tail._Tail._Tail._Value,
1718 [5] : $e._Impl._Tail._Tail._Tail._Tail._Tail._Value,
1719 [6] : $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Value,
1720 [7] : $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Value,
1721 [8] : $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Value,
1722 [9] : $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Value
1723 )
1724 )
1725 }
1726
1727 ;------------------------------------------------------------------------------
1728 ; std::tr1::array from <array>
1729 ;------------------------------------------------------------------------------
1730 std::tr1::array<*>{
1731 preview (
1732 ; An actual array is previewed with its address.
1733 ; array<T, N> is previewed like vector<T>.
1734 #(
1735 "[",
1736 $e._EEN_SIZE,
1737 "](",
1738 #array(expr: $e._Elems[$i], size: $e._EEN_SIZE),
1739 ")"
1740 )
1741 )
1742
1743 children (
1744 ; Just like an actual array.
1745 #array(expr: $e._Elems[$i], size: $e._EEN_SIZE)
1746 )
1747 }
1748 std::_Array_iterator<*>|std::_Array_const_iterator<*>{
1749 preview (
1750 #if ($e._EEN_IDL == 0) (
1751 *$e._Ptr
1752 ) #else (
1753 #if ($e._Idx == $e._EEN_SIZE) (
1754 ; array iterators are represented by _Ptr + _Idx,
1755 ; and they know how large their parent arrays are. Therefore, detecting
1756 ; end iterators is trivial.
1757 "end"
1758 ) #else (
1759 ; Like vector iterators, array iterators are previewed with what they point to.
1760 $e._Ptr[$e._Idx]
1761 )
1762 )
1763 )
1764
1765 children (
1766 #if ($e._EEN_IDL == 0) (
1767 #([ptr] : $e._Ptr)
1768 ) #else (
1769 #if ($e._Idx == $e._EEN_SIZE) (
1770 ; We make end iterators appear to have no children.
1771 #array(expr: 0, size: 0)
1772 ) #else (
1773 ; An array iterator is conceptually a pointer, so we make it appear to store one.
1774 #([ptr] : $e._Ptr + $e._Idx)
1775 )
1776 )
1777 )
1778 }
1779
1780 ;------------------------------------------------------------------------------
1781 ; stdext::hash_map from <hash_map>
1782 ; stdext::hash_multimap from <hash_map>
1783 ; stdext::hash_set from <hash_set>
1784 ; stdext::hash_multiset from <hash_set>
1785 ;------------------------------------------------------------------------------
1786 stdext::hash_map<*>|stdext::hash_multimap<*>|stdext::hash_set<*>|stdext::hash_multiset<*>{
1787 preview (
1788 #(
1789 "[",
1790 $e._List._Mysize,
1791 "](",
1792 #list(
1793 head: $e._List._Myhead->_Next,
1794 size: $e._List._Mysize,
1795 next: _Next
1796 ) : $e._Myval,
1797 ")"
1798 )
1799 )
1800
1801 children (
1802 #list(
1803 head: $e._List._Myhead->_Next,
1804 size: $e._List._Mysize,
1805 next: _Next
1806 ) : $e._Myval
1807 )
1808 }
1809
1810 ;------------------------------------------------------------------------------
1811 ; std::tr1::unordered_map from <unordered_map>
1812 ; std::tr1::unordered_multimap from <unordered_map>
1813 ; std::tr1::unordered_set from <unordered_set>
1814 ; std::tr1::unordered_multiset from <unordered_set>
1815 ;------------------------------------------------------------------------------
1816 std::hash<*>{
1817 preview ( "hash" )
1818 children ( #array(expr: 0, size: 0) )
1819 }
1820 std::tr1::unordered_map<*>|std::tr1::unordered_multimap<*>|std::tr1::unordered_set<*>|std::tr1::unordered_multiset<*>{
1821 preview (
1822 #(
1823 "[",
1824 $e._List._Mysize,
1825 "](",
1826 #list(
1827 head: $e._List._Myhead->_Next,
1828 size: $e._List._Mysize,
1829 next: _Next
1830 ) : $e._Myval,
1831 ")"
1832 )
1833 )
1834
1835 children (
1836 #(
1837 #([hash] : $e.comp._Hashobj),
1838 #([equal] : $e.comp._Keyeqobj),
1839 #list(
1840 head: $e._List._Myhead->_Next,
1841 size: $e._List._Mysize,
1842 next: _Next
1843 ) : $e._Myval
1844 )
1845 )
1846 }
1847
1848 ;------------------------------------------------------------------------------
1849 ; std::tr1::basic_regex from <regex>
1850 ;------------------------------------------------------------------------------
1851 std::tr1::basic_regex<*>{
1852 preview (
1853 #if ($e._Rep == 0) (
1854 ; Default construction creates an empty basic_regex.
1855 "empty"
1856 ) #elif ($e._EEN_VIS == 1) (
1857 ; By default, _ENHANCED_REGEX_VISUALIZER is defined to be 1 in debug and 0 in ship.
1858 ; When it is 1, basic_regex stores the string from which it was constructed.
1859 ; When it is 0, basic_regex stores only the resulting finite state machine.
1860 $e._Visualization
1861 ) #else (
1862 ; basic_regex contains many static const flags, which would be shown in the preview by default.
1863 ; Its actual members are _Rep and _Traits. _Rep holds the finite state machine, so we
1864 ; use it to preview basic_regex. (It does contain some human-readable information.)
1865 *$e._Rep
1866 )
1867 )
1868
1869 children (
1870 #if ($e._Rep == 0) (
1871 ; We make empty basic_regexes appear to have no children.
1872 #array(expr: 0, size: 0)
1873 ) #elif ($e._EEN_VIS == 1) (
1874 ; We want to hide those static const flags.
1875 ; We also want to give _Visualization a fake name.
1876 #(
1877 #([str] : $e._Visualization),
1878 #(_Rep : $e._Rep),
1879 #(_Traits : $e._Traits)
1880 )
1881 ) #else (
1882 ; We want to hide those static const flags.
1883 #(
1884 _Rep : $e._Rep,
1885 _Traits : $e._Traits
1886 )
1887 )
1888 )
1889 }
1890
1891 ;------------------------------------------------------------------------------
1892 ; std::tr1::sub_match from <regex>
1893 ;------------------------------------------------------------------------------
1894 std::tr1::sub_match<char const *>|std::tr1::sub_match<wchar_t const *>|std::tr1::sub_match<unsigned short const *>|std::tr1::sub_match<char *>|std::tr1::sub_match<wchar_t *>|std::tr1::sub_match<unsigned short *>{
1895 preview (
1896 ; It would be nice if we could preview sub_match with its str().
1897 ; However, visualizers cannot handle strings represented by pointer pairs.
1898 ; Therefore, our preview contains more limited information.
1899 #if ($e.matched) (
1900 ; If this sub_match participated in a match,
1901 ; we preview it with its length().
1902 $e.second - $e.first
1903 ) #else (
1904 ; Otherwise, we preview it with its matched bool (i.e. "false").
1905 ; (Why not length() (i.e. "0")? It's meaningful to have
1906 ; matched == true and length() == 0.
1907 "false"
1908 )
1909 )
1910
1911 children (
1912 #(
1913 ; sub_match's three data members are public, but we list them here
1914 ; (a) to display matched before first and second, and
1915 ; (b) to gloss over the fact that sub_match derives from std::pair.
1916 #(matched : $e.matched),
1917 #(first : $e.first),
1918 #(second : $e.second)
1919 )
1920 )
1921 }
1922 std::tr1::sub_match<std::_String_const_iterator<*> >|std::tr1::sub_match<std::_String_iterator<*> >{
1923 preview (
1924 #if ($e.matched) (
1925 ; We visualize ssub_match and wssub_match just like csub_match and wcsub_match,
1926 ; except that when determining the length(), we can't subtract iterators.
1927 ; We have to subtract their stored pointers.
1928 $e.second._Ptr - $e.first._Ptr
1929 ) #else (
1930 "false"
1931 )
1932 )
1933
1934 children (
1935 #(
1936 #(matched : $e.matched),
1937 #(first : $e.first),
1938 #(second : $e.second)
1939 )
1940 )
1941 }
1942
1943 ;------------------------------------------------------------------------------
1944 ; std::tr1::match_results from <regex>
1945 ;------------------------------------------------------------------------------
1946 std::tr1::match_results<*>{
1947 preview (
1948 ; A match_results object is empty iff its vector _Matches is empty.
1949 #if ($e._Matches._Myfirst == $e._Matches._Mylast) (
1950 "empty"
1951 ) #else (
1952 ; We preview a non-empty match_results object with its vector.
1953 $e._Matches
1954 )
1955 )
1956
1957 children (
1958 #if ($e._Matches._Myfirst == $e._Matches._Mylast) (
1959 ; We make empty match_results appear to have no children.
1960 #array(expr: 0, size: 0)
1961 ) #else (
1962 ; As match_results has operator[](), prefix(), and suffix() member functions,
1963 ; we make it appear to directly contain [0], [1], [2], etc. elements,
1964 ; as well as [prefix] and [suffix] elements.
1965 #(
1966 #array(expr: $e._Matches._Myfirst[$i], size: $e._Matches._Mylast - $e._Matches._Myfirst),
1967 #([prefix] : $e._Prefix),
1968 #([suffix] : $e._Suffix)
1969 )
1970 )
1971 )
1972 }
1973
1974 ;------------------------------------------------------------------------------
1975 ; std::tr1::regex_iterator from <regex>
1976 ;------------------------------------------------------------------------------
1977 std::tr1::regex_iterator<*>{
1978 preview (
1979 #if ($e._MyRe == 0) (
1980 ; We represent end-of-sequence regex_iterators with null regex pointers.
1981 "end"
1982 ) #else (
1983 ; Dereferenceable regex_iterators return match_results when dereferenced,
1984 ; so we'll preview them with that.
1985 $e._MyVal
1986 )
1987 )
1988
1989 children (
1990 #if ($e._MyRe == 0) (
1991 ; We make end-of-sequence regex_iterators appear to have no children.
1992 #array(expr: 0, size: 0)
1993 ) #else (
1994 ; For ease of understanding, we make dereferenceable regex_iterators
1995 ; appear to have data members with the "for exposition only" names from TR1.
1996 #(
1997 #([begin] : $e._Begin),
1998 #([end] : $e._End),
1999 #([pregex] : $e._MyRe),
2000 #([flags] : $e._Flags),
2001 #([match] : $e._MyVal)
2002 )
2003 )
2004 )
2005 }
2006
2007 ;------------------------------------------------------------------------------
2008 ; std::tr1::regex_token_iterator from <regex>
2009 ;------------------------------------------------------------------------------
2010 std::tr1::regex_token_iterator<*>{
2011 preview (
2012 #if ($e._Res == 0) (
2013 ; We represent end-of-sequence regex_token_iterators with null result pointers.
2014 "end"
2015 ) #else (
2016 ; Dereferenceable regex_token_iterators return *result when dereferenced,
2017 ; so we'll preview them with that.
2018 *$e._Res
2019 )
2020 )
2021
2022 children (
2023 #if ($e._Res == 0) (
2024 ; We make end-of-sequence regex_token_iterators appear to have no children.
2025 #array(expr: 0, size: 0)
2026 ) #else (
2027 ; For ease of understanding, we make dereferenceable regex_token_iterators
2028 ; appear to have data members with the "for exposition only" names from TR1.
2029 #(
2030 #([position] : $e._Pos),
2031 #([result] : $e._Res),
2032 #([suffix] : $e._Suffix),
2033 #([N] : $e._Cur),
2034 #([subs] : $e._Subs)
2035 )
2036 )
2037 )
2038 }
2039
2040 ;------------------------------------------------------------------------------
2041 ; std::identity, etc. from <functional>
2042 ;------------------------------------------------------------------------------
2043 std::identity<*>{
2044 preview ( "identity" )
2045 children ( #array(expr: 0, size: 0) )
2046 }
2047 std::bit_and<*>{
2048 preview ( "bit_and" )
2049 children ( #array(expr: 0, size: 0) )
2050 }
2051 std::bit_or<*>{
2052 preview ( "bit_or" )
2053 children ( #array(expr: 0, size: 0) )
2054 }
2055 std::bit_xor<*>{
2056 preview ( "bit_xor" )
2057 children ( #array(expr: 0, size: 0) )
2058 }
2059
2060 ;------------------------------------------------------------------------------
2061 ; std::unique_ptr from <memory>
2062 ;------------------------------------------------------------------------------
2063 std::unique_ptr<*>{
2064 preview (
2065 #if ($e._Myptr == 0) (
2066 "empty"
2067 ) #else (
2068 #(
2069 "unique_ptr ",
2070 *$e._Myptr
2071 )
2072 )
2073 )
2074
2075 children (
2076 #if ($e._Myptr == 0) (
2077 #array(expr: 0, size: 0)
2078 ) #else (
2079 #([ptr] : $e._Myptr)
2080 )
2081 )
2082 }
2083
2084 ;------------------------------------------------------------------------------
2085 ; std::forward_list from <forward_list>
2086 ;------------------------------------------------------------------------------
2087 std::forward_list<*>{
2088 preview (
2089 #(
2090 "(",
2091 #list(
2092 head: $e._Myhead,
2093 next: _Next
2094 ) : $e._Myval,
2095 ")"
2096 )
2097 )
2098
2099 children (
2100 #list(
2101 head: $e._Myhead,
2102 next: _Next
2103 ) : $e._Myval
2104 )
2105 }
2106 std::_Flist_iterator<*>|std::_Flist_const_iterator<*>{
2107 preview (
2108 #if ($e._Ptr == 0) (
2109 "end"
2110 ) #else (
2111 $e._Ptr->_Myval
2112 )
2113 )
2114
2115 children (
2116 #if ($e._Ptr == 0) (
2117 #array(expr: 0, size: 0)
2118 ) #else (
2119 #([ptr] : &$e._Ptr->_Myval)
2120 )
2121 )
2122 }
2123
2124
2125 ;------------------------------------------------------------------------------
2126 ; PROPVARIANT
2127 ;------------------------------------------------------------------------------
2128 ; Visualizers for VT_VECTOR C arrays
2129 tagCAC|tagCAUB|tagCAI|tagCAUI|tagCAL|tagCAUL|tagCAFLT|tagCADBL|tagCACY|tagCADATE|tagCABSTR|tagCABSTRBLOB|tagCABOOL|tagCASCODE|tagCAPROPVARIANT|tagCAH|tagCAUH|tagCALPSTR|tagCALPWSTR|tagCAFILETIME|tagCACLIPDATA|tagCACLSID{
2130 preview(
2131 #(
2132 "[", $e.cElems , "](",
2133 #array
2134 (
2135 expr : ($e.pElems)[$i],
2136 size : $e.cElems
2137 ),
2138 ")"
2139 )
2140 )
2141 children
2142 (
2143 #array
2144 (
2145 expr : ($e.pElems)[$i],
2146 size : $e.cElems
2147 )
2148 )
2149 }
2150 ; Visualizers for SAFE ARRAY
2151 tagSAFEARRAY|SAFEARRAY{
2152 preview(
2153 #if ($e.fFeatures & 0x0080) ; FADF_HAVEVARTYPE
2154 (
2155 ; Switch on the variant type field - which is stored 4 bytes
2156 ; before the beginning of the SAFEARRAY type
2157 #switch( ((unsigned *)&($e))[-1] )
2158 #case 0x2 ; VT_I2 | VT_ARRAY
2159 (
2160 #(
2161 "safearray of I2 = [",
2162 ; output the rank array
2163 #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
2164 "](",
2165 ; output the data elements
2166 #array(
2167 expr: ((signed short *)$e.pvData)[$i],
2168 size: $e.rgsabound[$r].cElements,
2169 rank: $e.cDims,
2170 base: $e.rgsabound[$r].lLbound
2171 ),
2172 ")"
2173 )
2174 )
2175 #case 0x3 ; VT_I4 | VT_ARRAY
2176 (
2177 #(
2178 "safearray of I4 = [",
2179 ; output the rank array
2180 #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
2181 "](",
2182 ; output the data elements
2183 #array(
2184 expr: ((signed int *)$e.pvData)[$i],
2185 size: $e.rgsabound[$r].cElements,
2186 rank: $e.cDims,
2187 base: $e.rgsabound[$r].lLbound
2188 ),
2189 ")"
2190 )
2191 )
2192 #case 0x4 ; VT_R4 | VT_ARRAY
2193 (
2194 #(
2195 "safearray of R4 = [",
2196 ; output the rank array
2197 #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
2198 "](",
2199 ; output the data elements
2200 #array(
2201 expr: ((float *)$e.pvData)[$i],
2202 size: $e.rgsabound[$r].cElements,
2203 rank: $e.cDims,
2204 base: $e.rgsabound[$r].lLbound
2205 ),
2206 ")"
2207 )
2208 )
2209 #case 0x5 ; VT_R8 | VT_ARRAY
2210 (
2211 #(
2212 "safearray of R8 = [",
2213 ; output the rank array
2214 #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
2215 "](",
2216 ; output the data elements
2217 #array(
2218 expr: ((double *)$e.pvData)[$i],
2219 size: $e.rgsabound[$r].cElements,
2220 rank: $e.cDims,
2221 base: $e.rgsabound[$r].lLbound
2222 ),
2223 ")"
2224 )
2225 )
2226 #case 0x6 ; VT_CY | VT_ARRAY
2227 (
2228 #(
2229 "safearray of CY = [",
2230 ; output the rank array
2231 #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
2232 "](",
2233 ; output the data elements
2234 #array(
2235 expr: ((CY *)$e.pvData)[$i],
2236 size: $e.rgsabound[$r].cElements,
2237 rank: $e.cDims,
2238 base: $e.rgsabound[$r].lLbound
2239 ),
2240 ")"
2241 )
2242 )
2243 #case 0x7 ; VT_DATE | VT_ARRAY
2244 (
2245 #(
2246 "safearray of DATE = [",
2247 ; output the rank array
2248 #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
2249 "](",
2250 ; output the data elements
2251 #array(
2252 expr: ((DATE *)$e.pvData)[$i],
2253 size: $e.rgsabound[$r].cElements,
2254 rank: $e.cDims,
2255 base: $e.rgsabound[$r].lLbound
2256 ),
2257 ")"
2258 )
2259 )
2260 #case 0x8 ; VT_BSTR | VT_ARRAY
2261 (
2262 #(
2263 "safearray of BSTR = [",
2264 ; output the rank array
2265 #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
2266 "](",
2267 ; output the data elements
2268 #array(
2269 expr: ((wchar_t **)$e.pvData)[$i],
2270 size: $e.rgsabound[$r].cElements,
2271 rank: $e.cDims,
2272 base: $e.rgsabound[$r].lLbound
2273 ),
2274 ")"
2275 )
2276 )
2277 #case 0xa ; VT_ERROR | VT_ARRAY
2278 (
2279 #(
2280 "safearray of ERROR = [",
2281 ; output the rank array
2282 #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
2283 "](",
2284 ; output the data elements
2285 #array(
2286 expr: ((long *)$e.pvData)[$i],
2287 size: $e.rgsabound[$r].cElements,
2288 rank: $e.cDims,
2289 base: $e.rgsabound[$r].lLbound
2290 ),
2291 ")"
2292 )
2293 )
2294 #case 0xb ; VT_BOOL | VT_ARRAY
2295 (
2296 #(
2297 "safearray of BOOL = [",
2298 ; output the rank array
2299 #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
2300 "](",
2301 ; output the data elements
2302 #array(
2303 expr: ((short *)$e.pvData)[$i],
2304 size: $e.rgsabound[$r].cElements,
2305 rank: $e.cDims,
2306 base: $e.rgsabound[$r].lLbound
2307 ),
2308 ")"
2309 )
2310 )
2311 #case 0xc ; VT_VARIANT | VT_ARRAY
2312 (
2313 #(
2314 "safearray of VARIANT = [",
2315 ; output the rank array
2316 #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
2317 "](",
2318 ; output the data elements
2319 #array(
2320 expr: ((tagVARIANT *)$e.pvData)[$i],
2321 size: $e.rgsabound[$r].cElements,
2322 rank: $e.cDims,
2323 base: $e.rgsabound[$r].lLbound
2324 ),
2325 ")"
2326 )
2327 )
2328 #case 0x10 ; VT_I1 | VT_ARRAY
2329 (
2330 #(
2331 "safearray of I1 = [",
2332 ; output the rank array
2333 #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
2334 "](",
2335 ; output the data elements
2336 #array(
2337 expr: ((signed char *)$e.pvData)[$i],
2338 size: $e.rgsabound[$r].cElements,
2339 rank: $e.cDims,
2340 base: $e.rgsabound[$r].lLbound
2341 ),
2342 ")"
2343 )
2344 )
2345 #case 0x11 ; VT_UI1 | VT_ARRAY
2346 (
2347 #(
2348 "safearray of UI1 = [",
2349 ; output the rank array
2350 #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
2351 "](",
2352 ; output the data elements
2353 #array(
2354 expr: ((unsigned char *)$e.pvData)[$i],
2355 size: $e.rgsabound[$r].cElements,
2356 rank: $e.cDims,
2357 base: $e.rgsabound[$r].lLbound
2358 ),
2359 ")"
2360 )
2361 )
2362 #case 0x12 ; VT_UI2 | VT_ARRAY
2363 (
2364 #(
2365 "safearray of UI2 = [",
2366 ; output the rank array
2367 #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
2368 "](",
2369 ; output the data elements
2370 #array(
2371 expr: ((unsigned short *)$e.pvData)[$i],
2372 size: $e.rgsabound[$r].cElements,
2373 rank: $e.cDims,
2374 base: $e.rgsabound[$r].lLbound
2375 ),
2376 ")"
2377 )
2378 )
2379 #case 0x13 ; VT_UI4 | VT_ARRAY
2380 (
2381 #(
2382 "safearray of UI4 = [",
2383 ; output the rank array
2384 #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
2385 "](",
2386 ; output the data elements
2387 #array(
2388 expr: ((unsigned int *)$e.pvData)[$i],
2389 size: $e.rgsabound[$r].cElements,
2390 rank: $e.cDims,
2391 base: $e.rgsabound[$r].lLbound
2392 ),
2393 ")"
2394 )
2395 )
2396 #case 0x14 ; VT_I8 | VT_ARRAY
2397 (
2398 #(
2399 "safearray of I8 = [",
2400 ; output the rank array
2401 #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
2402 "](",
2403 ; output the data elements
2404 #array(
2405 expr: ((signed __int64 *)$e.pvData)[$i],
2406 size: $e.rgsabound[$r].cElements,
2407 rank: $e.cDims,
2408 base: $e.rgsabound[$r].lLbound
2409 ),
2410 ")"
2411 )
2412 )
2413 #case 0x15 ; VT_UI8 | VT_ARRAY
2414 (
2415 #(
2416 "safearray of UI8 = [",
2417 ; output the rank array
2418 #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
2419 "](",
2420 ; output the data elements
2421 #array(
2422 expr: ((unsigned __int64 *)$e.pvData)[$i],
2423 size: $e.rgsabound[$r].cElements,
2424 rank: $e.cDims,
2425 base: $e.rgsabound[$r].lLbound
2426 ),
2427 ")"
2428 )
2429 )
2430 #case 0x16 ; VT_INT | VT_ARRAY
2431 (
2432 #(
2433 "safearray of INT = [",
2434 ; output the rank array
2435 #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
2436 "](",
2437 ; output the data elements
2438 #array(
2439 expr: ((int *)$e.pvData)[$i],
2440 size: $e.rgsabound[$r].cElements,
2441 rank: $e.cDims,
2442 base: $e.rgsabound[$r].lLbound
2443 ),
2444 ")"
2445 )
2446 )
2447 #case 0x17 ; VT_UINT | VT_ARRAY
2448 (
2449 #(
2450 "safearray of UINT = [",
2451 ; output the rank array
2452 #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
2453 "](",
2454 ; output the data elements
2455 #array(
2456 expr: ((unsigned *)$e.pvData)[$i],
2457 size: $e.rgsabound[$r].cElements,
2458 rank: $e.cDims,
2459 base: $e.rgsabound[$r].lLbound
2460 ),
2461 ")"
2462 )
2463 )
2464 #case 0x1e ; VT_LPSTR | VT_ARRAY
2465 (
2466 #(
2467 "safearray of LPSTR = [",
2468 ; output the rank array
2469 #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
2470 "](",
2471 ; output the data elements
2472 #array(
2473 expr: ((char **)$e.pvData)[$i],
2474 size: $e.rgsabound[$r].cElements,
2475 rank: $e.cDims,
2476 base: $e.rgsabound[$r].lLbound
2477 ),
2478 ")"
2479 )
2480 )
2481 #case 0x1f ; VT_LPWSTR | VT_ARRAY
2482 (
2483 #(
2484 "safearray of LPWSTR = [",
2485 ; output the rank array
2486 #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
2487 "](",
2488 ; output the data elements
2489 #array(
2490 expr: ((wchar_t **)$e.pvData)[$i],
2491 size: $e.rgsabound[$r].cElements,
2492 rank: $e.cDims,
2493 base: $e.rgsabound[$r].lLbound
2494 ),
2495 ")"
2496 )
2497 )
2498 #case 0x40 ; VT_FILETIME | VT_ARRAY
2499 (
2500 #(
2501 "safearray of FILETIME = [",
2502 ; output the rank array
2503 #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
2504 "](",
2505 ; output the data elements
2506 #array(
2507 expr: ((FILETIME *)$e.pvData)[$i],
2508 size: $e.rgsabound[$r].cElements,
2509 rank: $e.cDims,
2510 base: $e.rgsabound[$r].lLbound
2511 ),
2512 ")"
2513 )
2514 )
2515 #case 0x47 ; VT_CLIPDATA | VT_ARRAY
2516 (
2517 #(
2518 "safearray of CLIPDATA = [",
2519 ; output the rank array
2520 #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
2521 "](",
2522 ; output the data elements
2523 #array(
2524 expr: ((CLIPDATA *)$e.pvData)[$i],
2525 size: $e.rgsabound[$r].cElements,
2526 rank: $e.cDims,
2527 base: $e.rgsabound[$r].lLbound
2528 ),
2529 ")"
2530 )
2531 )
2532 #case 0x48 ; VT_CLSID | VT_ARRAY
2533 (
2534 #(
2535 "safearray of CLSID = [",
2536 ; output the rank array
2537 #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
2538 "](",
2539 ; output the data elements
2540 #array(
2541 expr: ((CLSID *)$e.pvData)[$i],
2542 size: $e.rgsabound[$r].cElements,
2543 rank: $e.cDims,
2544 base: $e.rgsabound[$r].lLbound
2545 ),
2546 ")"
2547 )
2548 )
2549 )
2550 #elif ($e.fFeatures & 0x0100) ; FADF_BSTR
2551 (
2552 #("safearray of BSTR = ",#array(expr: $e.rgsabound[$i].cElements, size: $e.cDims) : #("[",$e,"]"), "(", #array(expr: ((wchar_t * *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound ), ")")
2553 )
2554 #elif ($e.fFeatures & 0x0200) ; FADF_UNKNOWN
2555 (
2556 #("safearray of IUnknown* = [",#array(expr: $e.rgsabound[$i].cElements, size: $e.cDims), "](", #array(expr: ((IUnknown * *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound ), ")")
2557 )
2558 #elif ($e.fFeatures & 0x0400) ; FADF_DISPATCH
2559 (
2560 #("safearray of IDispatch* = [",#array(expr: $e.rgsabound[$i].cElements, size: $e.cDims), "](", #array(expr: ((IDispatch * *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound ), ")")
2561 )
2562 #elif ($e.fFeatures & 0x0800) ; FADF_VARIANT
2563 (
2564 #("safearray of VARIANT = ",#array(expr: $e.rgsabound[$i].cElements, size: $e.cDims) : #("[",$e,"]"), "(", #array(expr: ((tagVARIANT *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound ), ")")
2565 )
2566 )
2567 children
2568 (
2569 #( ;[actual members]: [$e,!],
2570 #if ($e.fFeatures & 0x0080) ; FADF_HAVEVARTYPE
2571 (
2572 #switch( ((unsigned *)&($e))[-1] ) ; for some reason the VT field is before the SAFEARRAY struct
2573 #case 2 ; VT_I2|VT_ARRAY
2574 (
2575 #array(
2576 expr: ((signed short *)$e.pvData)[$i],
2577 size: $e.rgsabound[$r].cElements,
2578 rank: $e.cDims,
2579 base: $e.rgsabound[$r].lLbound
2580 )
2581 )
2582 #case 3 ; VT_I4|VT_ARRAY
2583 (
2584 #array(
2585 expr: ((signed int *)$e.pvData)[$i],
2586 size: $e.rgsabound[$r].cElements,
2587 rank: $e.cDims,
2588 base: $e.rgsabound[$r].lLbound
2589 )
2590 )
2591 #case 4 ; VT_R4|VT_ARRAY
2592 (
2593 #array(
2594 expr: ((float *)$e.pvData)[$i],
2595 size: $e.rgsabound[$r].cElements,
2596 rank: $e.cDims,
2597 base: $e.rgsabound[$r].lLbound
2598 )
2599 )
2600 #case 5 ; VT_R8|VT_ARRAY
2601 (
2602 #array(
2603 expr: ((double *)$e.pvData)[$i],
2604 size: $e.rgsabound[$r].cElements,
2605 rank: $e.cDims,
2606 base: $e.rgsabound[$r].lLbound
2607 )
2608 )
2609 #case 0x10 ; VT_I1|VT_ARRAY
2610 (
2611 #array(
2612 expr: ((signed char *)$e.pvData)[$i],
2613 size: $e.rgsabound[$r].cElements,
2614 rank: $e.cDims,
2615 base: $e.rgsabound[$r].lLbound
2616 )
2617 )
2618 #case 0x11 ; VT_UI1|VT_ARRAY
2619 (
2620 #array(
2621 expr: ((unsigned char *)$e.pvData)[$i],
2622 size: $e.rgsabound[$r].cElements,
2623 rank: $e.cDims,
2624 base: $e.rgsabound[$r].lLbound
2625 )
2626 )
2627 #case 0x12 ; VT_UI2|VT_ARRAY
2628 (
2629 #array(
2630 expr: ((unsigned short *)$e.pvData)[$i],
2631 size: $e.rgsabound[$r].cElements,
2632 rank: $e.cDims,
2633 base: $e.rgsabound[$r].lLbound
2634 )
2635 )
2636 #case 0x13 ; VT_UI4|VT_ARRAY
2637 (
2638 #array(
2639 expr: ((unsigned int *)$e.pvData)[$i],
2640 size: $e.rgsabound[$r].cElements,
2641 rank: $e.cDims,
2642 base: $e.rgsabound[$r].lLbound
2643 )
2644 )
2645 #case 0x14 ; VT_I8|VT_ARRAY
2646 (
2647 #array(
2648 expr: ((signed __int64 *)$e.pvData)[$i],
2649 size: $e.rgsabound[$r].cElements,
2650 rank: $e.cDims,
2651 base: $e.rgsabound[$r].lLbound
2652 )
2653 )
2654 #case 0x15 ; VT_UI8|VT_ARRAY
2655 (
2656 #array(
2657 expr: ((unsigned __int64 *)$e.pvData)[$i],
2658 size: $e.rgsabound[$r].cElements,
2659 rank: $e.cDims,
2660 base: $e.rgsabound[$r].lLbound
2661 )
2662 )
2663 #case 0x1e ; VT_LPSTR|VT_ARRAY
2664 (
2665 #array(
2666 expr: ((char * *)$e.pvData)[$i],
2667 size: $e.rgsabound[$r].cElements,
2668 rank: $e.cDims,
2669 base: $e.rgsabound[$r].lLbound
2670 )
2671 )
2672 #case 0x1f ; VT_LPWSTR|VT_ARRAY
2673 (
2674 #array(
2675 expr: ((wchar_t **)$e.pvData)[$i],
2676 size: $e.rgsabound[$r].cElements,
2677 rank: $e.cDims,
2678 base: $e.rgsabound[$r].lLbound
2679 )
2680 )
2681 #case 0xc ; VT_VARIANT|VT_ARRAY
2682 (
2683 #array(
2684 expr: ((tagVARIANT *)$e.pvData)[$i],
2685 size: $e.rgsabound[$r].cElements,
2686 rank: $e.cDims,
2687 base: $e.rgsabound[$r].lLbound
2688 )
2689 )
2690 #case 0xb ; VT_BOOL|VT_ARRAY
2691 (
2692 #array(
2693 expr: ((short *)$e.pvData)[$i],
2694 size: $e.rgsabound[$r].cElements,
2695 rank: $e.cDims,
2696 base: $e.rgsabound[$r].lLbound
2697 )
2698 )
2699 #case 0xa ; VT_ERROR|VT_ARRAY
2700 (
2701 #array(
2702 expr: ((long *)$e.pvData)[$i],
2703 size: $e.rgsabound[$r].cElements,
2704 rank: $e.cDims,
2705 base: $e.rgsabound[$r].lLbound
2706 )
2707 )
2708 #case 6 ; VT_CY|VT_ARRAY
2709 (
2710 #array(
2711 expr: ((CY *)$e.pvData)[$i],
2712 size: $e.rgsabound[$r].cElements,
2713 rank: $e.cDims,
2714 base: $e.rgsabound[$r].lLbound
2715 )
2716 )
2717 #case 7 ; VT_DATE|VT_ARRAY
2718 (
2719 #array(
2720 expr: ((DATE *)$e.pvData)[$i],
2721 size: $e.rgsabound[$r].cElements,
2722 rank: $e.cDims,
2723 base: $e.rgsabound[$r].lLbound
2724 )
2725 )
2726 #case 0x40 ; VT_FILETIME|VT_ARRAY
2727 (
2728 #array(
2729 expr: ((FILETIME *)$e.pvData)[$i],
2730 size: $e.rgsabound[$r].cElements,
2731 rank: $e.cDims,
2732 base: $e.rgsabound[$r].lLbound
2733 )
2734 )
2735 #case 0x48 ; VT_CLSID|VT_ARRAY
2736 (
2737 #array(
2738 expr: ((CLSID *)$e.pvData)[$i],
2739 size: $e.rgsabound[$r].cElements,
2740 rank: $e.cDims,
2741 base: $e.rgsabound[$r].lLbound
2742 )
2743 )
2744 #case 0x47 ; VT_CF|VT_ARRAY
2745 (
2746 #array(
2747 expr: ((CLIPDATA *)$e.pvData)[$i],
2748 size: $e.rgsabound[$r].cElements,
2749 rank: $e.cDims,
2750 base: $e.rgsabound[$r].lLbound
2751 )
2752 )
2753 #case 8 ; VT_BSTR|VT_ARRAY
2754 (
2755 #array(
2756 expr: ((wchar_t * *)$e.pvData)[$i],
2757 size: $e.rgsabound[$r].cElements,
2758 rank: $e.cDims,
2759 base: $e.rgsabound[$r].lLbound
2760 )
2761 )
2762 #case 0x16 ; VT_INT|VT_ARRAY
2763 (
2764 #array(
2765 expr: ((int *)$e.pvData)[$i],
2766 size: $e.rgsabound[$r].cElements,
2767 rank: $e.cDims,
2768 base: $e.rgsabound[$r].lLbound
2769 )
2770 )
2771 #case 0x17 ; VT_UINT|VT_ARRAY
2772 (
2773 #array(
2774 expr: ((unsigned int*)$e.pvData)[$i],
2775 size: $e.rgsabound[$r].cElements,
2776 rank: $e.cDims,
2777 base: $e.rgsabound[$r].lLbound
2778 )
2779 )
2780 #default
2781 (
2782 #([actual members]: [$e,!])
2783 )
2784 #except
2785 (
2786 #([actual members]: [$e,!])
2787 )
2788 )
2789 #elif ($e.fFeatures & 0x0100) ; FADF_BSTR
2790 (
2791 #array(expr: ((wchar_t * *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound )
2792 )
2793 #elif ($e.fFeatures & 0x0200) ; FADF_UNKNOWN
2794 (
2795 #array(expr: ((IUnknown * *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound )
2796 )
2797 #elif ($e.fFeatures & 0x0400) ; FADF_DISPATCH
2798 (
2799 #array(expr: ((IDispatch * *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound )
2800 )
2801 #elif ($e.fFeatures & 0x0800) ; FADF_VARIANT
2802 (
2803 #array(expr: ((tagVARIANT *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound )
2804 )
2805 )
2806 )
2807 }
2808 tagPROPVARIANT|tagVARIANT|PROPVARIANT|VARIANT{
2809 preview(
2810 #switch ($e.vt)
2811 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2812 ;; Base Types ;;
2813 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2814 #case 0 ( #("Empty") ) ; VT_EMPTY
2815 #case 1 ( #("NULL") ) ; VT_NULL
2816 #case 2 ( #("I2 = ", $e.iVal) ) ; VT_I2
2817 #case 3 ( #("I4 = ", $e.lVal) ) ; VT_I4
2818 #case 4 ( #("R4 = ", $e.fltVal) ) ; VT_R4
2819 #case 5 ( #("R8 = ", $e.dblVal) ) ; VT_R8
2820 #case 6 ( #("CY = ", $e.cyVal) ) ; VT_CY
2821 #case 7 ( #("DATE = ", $e.date) ) ; VT_DATE
2822 #case 8 ( #("BSTR = ", $e.bstrVal) ) ; VT_BSTR
2823 #case 9 ( #("DISPATCH = ", $e.pdispVal) ) ; VT_DISPATCH
2824 #case 10 ( #("ERROR = ", $e.scode) ) ; VT_ERROR
2825 #case 0xB ( #("BOOL = ", $e.boolVal) ) ; VT_BOOL
2826 #case 0xC ( #("VARIANT ") ) ; VT_VARIANT
2827 #case 0xD ( #("UNKNOWN = ", $e.punkVal) ) ; VT_UNKOWN
2828 #case 0xE ( #("DECIMAL = ", $e.decVal) ) ; VT_DECIMAL
2829 #case 0x10 ( #("I1 = ", $e.cVal) ) ; VT_I1
2830 #case 0x11 ( #("UI1 = ", $e.bVal) ) ; VT_UI1
2831 #case 0x12 ( #("UI2 = ", $e.uiVal) ) ; VT_UI2
2832 #case 0x13 ( #("UI4 = ", $e.ulVal) ) ; VT_UI4
2833 #case 0x14 ( #("I8 = ", *(__int64*)&$e.dblVal) ) ; VT_I8
2834 #case 0x15 ( #("UI8 = ", *(unsigned __int64*)&$e.dblVal) ) ; VT_UI8
2835 #case 0x16 ( #("INT = ", $e.intVal) ) ; VT_INT
2836 #case 0x17 ( #("UINT = ", $e.uintVal) ) ; VT_UINT
2837 #case 0x18 ( #("VOID ") ) ; VT_VOID
2838 #case 0x19 ( #("HRESULT ") ) ; VT_HRESULT
2839 #case 0x1A ( #("PTR ") ) ; VT_PTR
2840 #case 0x1B ( #("SAFEARRAY ") ) ; VT_SAFEARRAY
2841 #case 0x1C ( #("CARRAY ") ) ; VT_CARRAY
2842 #case 0x1D ( #("USERDEFINED ") ) ; VT_USERDEFINED
2843 #case 0x1E ( #("LPSTR = ", $e.pszVal) ) ; VT_LPSTR
2844 #case 0x1F ( #("LPWSTR = ", $e.pwszVal) ) ; VT_LPWSTR
2845 #case 0x24 ( #("RECORD ") ) ; VT_RECORD
2846 #case 0x26 ( #("UINT_PTR ") ) ; VT_UINT_PTR
2847 #case 0x40 ( #("FILETIME = ", $e.filetime) ) ; VT_FILETIME
2848 #case 0x42 ( #("STREAM = ", $e.pStream) ) ; VT_STREAM
2849 #case 0x43 ( #("STORAGE = ", $e.pStorage) ) ; VT_STORAGE
2850 #case 0x44 ( #("STREAMED_OBJECT = ", $e.pStream) ) ; VT_STREAMED_OBJECT
2851 #case 0x45 ( #("STORED_OBJECT = ", $e.pStorage) ) ; VT_STORED_OBJECT
2852 #case 0x46 ( #("BLOB_OBJECT = ", $e.blob ) ) ; VT_BLOB_OBJECT
2853 #case 0x47 ( #("CF = ", $e.pclipdata) ) ; VT_CF
2854 #case 0x48 ( #("CLSID = ", $e.puuid) ) ; VT_CLSID
2855 #case 0x49 ( #("VERSIONED_STREAM = ", $e.pVersionedStream) ) ; VT_VERSIONED_STREAM
2856 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2857 ;; Vector types ;;
2858 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2859 #case 0x1002 ( #("vector of I2 = ", $e.cai) ) ; VT_I2|VT_VECTOR
2860 #case 0x1003 ( #("vector of I4 = ", $e.cal) ) ; VT_I4|VT_VECTOR
2861 #case 0x1004 ( #("vector of R4 = ", $e.caflt) ) ; VT_R4|VT_VECTOR
2862 #case 0x1005 ( #("vector of R8 = ", $e.cadbl) ) ; VT_R8|VT_VECTOR
2863 #case 0x1010 ( #("vector of I1 = ", $e.cac) ) ; VT_I1|VT_VECTOR
2864 #case 0x1011 ( #("vector of UI1 = ", $e.caub) ) ; VT_UI1|VT_VECTOR
2865 #case 0x1012 ( #("vector of UI2 = ", $e.caui) ) ; VT_UI2|VT_VECTOR
2866 #case 0x1013 ( #("vector of UI4 = ", $e.caul) ) ; VT_UI4|VT_VECTOR
2867 #case 0x1014 ( #("vector of I8 = ", $e.cah) ) ; VT_I8|VT_VECTOR
2868 #case 0x1015 ( #("vector of UI8 = ", $e.cauh) ) ; VT_UI8|VT_VECTOR
2869 #case 0x101E ( #("vector of LPSTR = ", $e.calpstr) ) ; VT_LPSTR|VT_VECTOR
2870 #case 0x101F ( #("vector of LPWSTR = ", $e.calpwstr) ) ; VT_LPWSTR|VT_VECTOR
2871 #case 0x100C ( #("vector of VARIANT ", $e.capropvar) ) ; VT_VARIANT|VT_VECTOR
2872 #case 0x100B ( #("vector of BOOL = ", $e.cabool) ) ; VT_BOOL|VT_VECTOR
2873 #case 0x100A ( #("vector of ERROR = ", $e.cascode) ) ; VT_ERROR|VT_VECTOR
2874 #case 0x1006 ( #("vector of CY = ", $e.cacy) ) ; VT_CY|VT_VECTOR
2875 #case 0x1007 ( #("vector of DATE = ", $e.cadate) ) ; VT_DATE|VT_VECTOR
2876 #case 0x1040 ( #("vector of FILETIME = ", $e.cafiletime) ) ; VT_FILETIME|VT_VECTOR
2877 #case 0x1048 ( #("vector of CLSID = ", $e.cauuid) ) ; VT_CLSID|VT_VECTOR
2878 #case 0x1047 ( #("vector of CF = ", $e.caclipdata) ) ; VT_CF|VT_VECTOR
2879 #case 0x1008 ( #("vector of BSTR = ", $e.cabstr) ) ; VT_BSTR|VT_VECTOR
2880 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2881 ;; Byref Types ;;
2882 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2883 #case 0x4016 ( #("byref of INT = ", $e.pintVal) ) ; VT_INT|VT_BYREF
2884 #case 0x4017 ( #("byref of UINT = ", $e.puintVal) ) ; VT_UINT|VT_BYREF
2885 #case 0x4002 ( #("byref of I2 = ", $e.piVal) ) ; VT_I2|VT_BYREF
2886 #case 0x4003 ( #("byref of I4 = ", $e.plVal) ) ; VT_I4|VT_BYREF
2887 #case 0x4004 ( #("byref of R4 = ", $e.pfltVal) ) ; VT_R4|VT_BYREF
2888 #case 0x4005 ( #("byref of R8 = ", $e.pdblVal) ) ; VT_R8|VT_BYREF
2889 #case 0x4010 ( #("byref of I1 = ", $e.pcVal) ) ; VT_I1|VT_BYREF
2890 #case 0x4011 ( #("byref of UI1 = ", $e.pbVal) ) ; VT_UI1|VT_BYREF
2891 #case 0x4012 ( #("byref of UI2 = ", $e.puiVal) ) ; VT_UI2|VT_BYREF
2892 #case 0x4013 ( #("byref of UI4 = ", $e.pulVal) ) ; VT_UI4|VT_BYREF
2893 #case 0x4014 ( #("byref of I8 = ", (__int64*)$e.pdblVal) ) ; VT_I8|VT_BYREF
2894 #case 0x4015 ( #("byref of UI8 = ", (unsigned __int64*)$e.pudblVal) ) ; VT_UI8|VT_BYREF
2895 #case 0x400C ( #("byref of VARIANT ", $e.pvarVal) ) ; VT_VARIANT|VT_BYREF
2896 #case 0x400B ( #("byref of BOOL = ", $e.pboolVal) ) ; VT_BOOL|VT_BYREF
2897 #case 0x400A ( #("byref of ERROR = ", $e.pscode) ) ; VT_ERROR|VT_BYREF
2898 #case 0x4006 ( #("byref of CY = ", $e.pcyVal) ) ; VT_CY|VT_BYREF
2899 #case 0x4007 ( #("byref of DATE = ", $e.pdate) ) ; VT_DATE|VT_BYREF
2900 #case 0x4008 ( #("byref of BSTR = ", $e.pbstrVal) ) ; VT_BSTR|VT_BYREF
2901 #case 0x400E ( #("byref of DECIMAL = ", $e.pdecVal) ) ; VT_DECIMAL|VT_BYREF
2902 #case 0x400D ( #("byref of UNKNOWN = ", $e.ppunkVal) ) ; VT_UNKOWN|VT_BYREF
2903 #case 0x4009 ( #("byref of DISPATCH = ", $e.ppdispVal) ) ; VT_DISPATCH|VT_BYREF
2904 #case 0x6000 ( #("byref of ARRAY = ", $e.pparray) ) ; VT_ARRAY|VT_BYREF
2905 #default
2906 (
2907 #if ($e.vt & 0x2000) ( $e.parray)
2908 #else ( #("Unknown vt type = ", $e.vt))
2909 )
2910 )
2911 children(
2912 #(
2913 vt: $e.vt,
2914 #switch ($e.vt)
2915 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2916 ;; Base Types ;;
2917 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2918 #case 0x2 ( #(I2 : $e.iVal) ) ; VT_I2
2919 #case 0x3 ( #(I4 : $e.lVal) ) ; VT_I4
2920 #case 0x4 ( #(R4 : $e.fltVal) ) ; VT_R4
2921 #case 0x5 ( #(R8 : $e.dblVal) ) ; VT_R8
2922 #case 0x6 ( #(CY : $e.cyVal) ) ; VT_CY
2923 #case 0x7 ( #(DATE : $e.date) ) ; VT_DATE
2924 #case 0x8 ( #(BSTR : $e.bstrVal) ) ; VT_BSTR
2925 #case 0x9 ( #(DISPATCH : $e.pdispVal) ) ; VT_DISPATCH
2926 #case 0xA ( #(ERROR : $e.scode) ) ; VT_ERROR
2927 #case 0xB ( #(BOOL : $e.boolVal) ) ; VT_BOOL
2928 #case 0xD ( #(UNKNOWN : $e.punkVal) ) ; VT_UNKOWN
2929 #case 0xE ( #(DECIMAL : $e.decVal) ) ; VT_DECIMAL
2930 #case 0x10 ( #(I1 : $e.cVal) ) ; VT_I1
2931 #case 0x11 ( #(UI1 : $e.bVal) ) ; VT_UI1
2932 #case 0x12 ( #(UI2 : $e.uiVal) ) ; VT_UI2
2933 #case 0x13 ( #(UI4 : $e.ulVal) ) ; VT_UI4
2934 #case 0x14 ( #(I8 : *(__int64*)&$e.dblVal) ) ; VT_I8
2935 #case 0x15 ( #(UI8 : *(unsigned __int64*)&$e.dblVal) ) ; VT_UI8
2936 #case 0x16 ( #(INT : $e.intVal) ) ; VT_INT
2937 #case 0x17 ( #(UINT : $e.uintVal) ) ; VT_UINT
2938 #case 0x1E ( #(LPSTR : $e.pszVal) ) ; VT_LPSTR
2939 #case 0x1F ( #(LPWSTR : $e.pwszVal) ) ; VT_LPWSTR
2940 #case 0x40 ( #(FILETIME : $e.filetime) ) ; VT_FILETIME
2941 #case 0x42 ( #(STREAM : $e.pStream) ) ; VT_STREAM
2942 #case 0x43 ( #(STORAGE : $e.pStorage) ) ; VT_STORAGE
2943 #case 0x44 ( #(STREAMED_OBJECT : $e.pStream) ) ; VT_STREAMED_OBJECT
2944 #case 0x45 ( #(STORED_OBJECT : $e.pStorage) ) ; VT_STORED_OBJECT
2945 #case 0x46 ( #(BLOB_OBJECT : $e.blob ) ) ; VT_BLOB_OBJECT
2946 #case 0x47 ( #(CF : $e.pclipdata) ) ; VT_CF
2947 #case 0x48 ( #(CLSID : $e.puuid) ) ; VT_CLSID
2948 #case 0x49 ( #(VERSIONED_STREAM : $e.pVersionedStream) ) ; VT_VERSIONED_STREAM
2949 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2950 ;; Vector types ;;
2951 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2952 #case 0x1002 ( #(vector of I2 : $e.cai) ) ; VT_I2|VT_VECTOR
2953 #case 0x1003 ( #(vector of I4 : $e.cal) ) ; VT_I4|VT_VECTOR
2954 #case 0x1004 ( #(vector of R4 : $e.caflt) ) ; VT_R4|VT_VECTOR
2955 #case 0x1005 ( #(vector of R8 : $e.cadbl) ) ; VT_R8|VT_VECTOR
2956 #case 0x1010 ( #(vector of I1 : $e.cac) ) ; VT_I1|VT_VECTOR
2957 #case 0x1011 ( #(vector of UI1 : $e.caub) ) ; VT_UI1|VT_VECTOR
2958 #case 0x1012 ( #(vector of UI2 : $e.caui) ) ; VT_UI2|VT_VECTOR
2959 #case 0x1013 ( #(vector of UI4 : $e.caul) ) ; VT_UI4|VT_VECTOR
2960 #case 0x1014 ( #(vector of I8 : $e.cah) ) ; VT_I8|VT_VECTOR
2961 #case 0x1015 ( #(vector of UI8 : $e.cauh) ) ; VT_UI8|VT_VECTOR
2962 #case 0x101E ( #(vector of LPSTR : $e.calpstr) ) ; VT_LPSTR|VT_VECTOR
2963 #case 0x101F ( #(vector of LPWSTR : $e.calpwstr) ) ; VT_LPWSTR|VT_VECTOR
2964 #case 0x100C ( #(vector of VARIANT : $e.capropvar) ) ; VT_VARIANT|VT_VECTOR
2965 #case 0x100B ( #(vector of BOOL : $e.cabool) ) ; VT_BOOL|VT_VECTOR
2966 #case 0x100A ( #(vector of ERROR : $e.cascode) ) ; VT_ERROR|VT_VECTOR
2967 #case 0x1006 ( #(vector of CY : $e.cacy) ) ; VT_CY|VT_VECTOR
2968 #case 0x1007 ( #(vector of DATE : $e.cadate) ) ; VT_DATE|VT_VECTOR
2969 #case 0x1040 ( #(vector of FILETIME : $e.cafiletime) ) ; VT_FILETIME|VT_VECTOR
2970 #case 0x1048 ( #(vector of CLSID : $e.cauuid) ) ; VT_CLSID|VT_VECTOR
2971 #case 0x1047 ( #(vector of CF : $e.caclipdata) ) ; VT_CF|VT_VECTOR
2972 #case 0x1008 ( #(vector of BSTR : $e.cabstr) ) ; VT_BSTR|VT_VECTOR
2973 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2974 ;; Byref Types ;;
2975 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2976 #case 0x4016 ( #(byref of INT : $e.pintVal) ) ; VT_INT|VT_BYREF
2977 #case 0x4017 ( #(byref of UINT : $e.puintVal) ) ; VT_UINT|VT_BYREF
2978 #case 0x4002 ( #(byref of I2 : $e.piVal) ) ; VT_I2|VT_BYREF
2979 #case 0x4003 ( #(byref of I4 : $e.plVal) ) ; VT_I4|VT_BYREF
2980 #case 0x4004 ( #(byref of R4 : $e.pfltVal) ) ; VT_R4|VT_BYREF
2981 #case 0x4005 ( #(byref of R8 : $e.pdblVal) ) ; VT_R8|VT_BYREF
2982 #case 0x4010 ( #(byref of I1 : $e.pcVal) ) ; VT_I1|VT_BYREF
2983 #case 0x4011 ( #(byref of UI1 : $e.pbVal) ) ; VT_UI1|VT_BYREF
2984 #case 0x4012 ( #(byref of UI2 : $e.puiVal) ) ; VT_UI2|VT_BYREF
2985 #case 0x4013 ( #(byref of UI4 : $e.pulVal) ) ; VT_UI4|VT_BYREF
2986 #case 0x4014 ( #(byref of I8 : (__int64*)$e.pdblVal) ) ; VT_I8|VT_BYREF
2987 #case 0x4015 ( #(byref of UI8 : (unsigned __int64*)$e.pdblVal) ) ; VT_UI8|VT_BYREF
2988 #case 0x400C ( #(byref of VARIANT : $e.pvarVal) ) ; VT_VARIANT|VT_BYREF
2989 #case 0x400B ( #(byref of BOOL : $e.pboolVal) ) ; VT_BOOL|VT_BYREF
2990 #case 0x400A ( #(byref of ERROR : $e.pscode) ) ; VT_ERROR|VT_BYREF
2991 #case 0x4006 ( #(byref of CY : $e.pcyVal) ) ; VT_CY|VT_BYREF
2992 #case 0x4007 ( #(byref of DATE : $e.pdate) ) ; VT_DATE|VT_BYREF
2993 #case 0x4008 ( #(byref of BSTR : $e.pbstrVal) ) ; VT_BSTR|VT_BYREF
2994 #case 0x400E ( #(byref of DECIMAL : $e.pdecVal) ) ; VT_DECIMAL|VT_BYREF
2995 #case 0x400D ( #(byref of UNKNOWN : $e.ppunkVal) ) ; VT_UNKOWN|VT_BYREF
2996 #case 0x4009 ( #(byref of DISPATCH : $e.ppdispVal) ) ; VT_DISPATCH|VT_BYREF
2997 #case 0x6000 ( #(byref of ARRAY : $e.pparray) ) ; VT_ARRAY|VT_BYREF
2998
2999 ; the following are either empty or invalid vt values for a variant
3000 ; #case 0 ( #(Empty :) ) ; VT_EMPTY
3001 ; #case 0x1 ( #(NULL :) ) ; VT_NULL
3002 ; #case 0xC ( #(VARIANT :) ) ; VT_VARIANT
3003 ; #case 0x18 ( #(VOID :) ) ; VT_VOID
3004 ; #case 0x19 ( #(HRESULT :) ) ; VT_HRESULT
3005 ; #case 0x1A ( #(PTR :) ) ; VT_PTR
3006 ; #case 0x1B ( #(SAFEARRAY :) ) ; VT_SAFEARRAY
3007 ; #case 0x1C ( #(CARRAY :) ) ; VT_CARRAY
3008 ; #case 0x1D ( #(USERDEFINED :) ) ; VT_USERDEFINED
3009 ; #case 0x24 ( #(RECORD :) ) ; VT_RECORD
3010 ; #case 0x26 ( #(UINT_PTR :) ) ; VT_UINT_PTR
3011 #default
3012 (
3013 #if ($e.vt & 0x2000 )
3014 ( #(safearray: $e.parray))
3015 #else
3016 (
3017 #(
3018 [raw members]: [$e,!] ; unformatted data members
3019 )
3020 )
3021 )
3022 #except
3023 (
3024 #(
3025 [raw members]: [$e,!] ; unformatted data members
3026 )
3027 )
3028 )
3029 )
3030 }
3031
3032 ; Visualizers for data structures in namespace Concurrency
3033 ;------------------------------------------------------------------------------
3034 ; Concurrency::message from <agents.h>
3035 ;------------------------------------------------------------------------------
3036 Concurrency::message<*>{
3037 preview (
3038 #(
3039 $e.payload
3040 )
3041 )
3042
3043 children (
3044 #(
3045 #(payload: $e.payload),
3046 #([msg_id]: $e._M_id)
3047 )
3048 )
3049 }
3050
3051 ;------------------------------------------------------------------------------
3052 ; Concurrency::multi_link_registry from <agents.h>
3053 ;------------------------------------------------------------------------------
3054 Concurrency::multi_link_registry<*>{
3055 preview (
3056 #(
3057 "[",
3058 $e._M_vector._M_index,
3059 "](",
3060 #array(
3061 expr: *($e._M_vector._M_array[$i]),
3062 size: $e._M_vector._M_index
3063 ),
3064 ")"
3065 )
3066 )
3067
3068 children (
3069 #(
3070 #([size]: $e._M_vector._M_index),
3071 #array(
3072 expr: *($e._M_vector._M_array[$i]),
3073 size: $e._M_vector._M_index
3074 )
3075 )
3076 )
3077 }
3078
3079 ;------------------------------------------------------------------------------
3080 ; Concurrency::details::_Queue from <agents.h>
3081 ;------------------------------------------------------------------------------
3082 Concurrency::details::_Queue<*>{
3083 preview (
3084 #(
3085 "[",
3086 $e._M_count,
3087 "](",
3088 #list(
3089 head: $e._M_pHead,
3090 next: _M_pNext,
3091 size: _M_count
3092 ),
3093 ")"
3094 )
3095 )
3096
3097 children (
3098 #(
3099 #([size]: $e._M_count),
3100 #list(
3101 head: $e._M_pHead,
3102 next: _M_pNext,
3103 size: _M_count
3104 )
3105 )
3106 )
3107 }
3108
3109 ;------------------------------------------------------------------------------
3110 ; Concurrency::unbounded_buffer from <agents.h>
3111 ;------------------------------------------------------------------------------
3112 Concurrency::unbounded_buffer<*>{
3113 preview (
3114 #(
3115 $e._M_messageBuffer
3116 )
3117 )
3118
3119 children (
3120 #(
3121 #(unprocessed_messages: $e._M_messageProcessor._M_queuedMessages._M_queue),
3122 #(messages: $e._M_messageBuffer),
3123 #(message_filter: *($e._M_pFilter)),
3124 #(linked_sources: $e._M_connectedSources._M_links),
3125 #(linked_targets: $e._M_connectedTargets),
3126 #(reserving_target: *($e._M_pReservedFor)),
3127 #(Scheduler: *($e._M_messageProcessor._M_pScheduler)),
3128 #(ScheduleGroup: *($e._M_messageProcessor._M_pScheduleGroup))
3129 )
3130 )
3131 }
3132
3133 ;------------------------------------------------------------------------------
3134 ; Concurrency::overwrite_buffer from <agents.h>
3135 ;------------------------------------------------------------------------------
3136 Concurrency::overwrite_buffer<*>{
3137 preview (
3138 #(
3139 $e._M_pMessage
3140 )
3141 )
3142
3143 children (
3144 #(
3145 #(value: *($e._M_pMessage)),
3146 #(unprocessed_messages: $e._M_messageProcessor._M_queuedMessages._M_queue),
3147 #(message_filter: *($e._M_pFilter)),
3148 #(linked_sources: $e._M_connectedSources._M_links),
3149 #(linked_targets: $e._M_connectedTargets),
3150 #(reserving_target: *($e._M_pReservedFor)),
3151 #(reserved_message: *($e._M_pReservedMessage)),
3152 #(Scheduler: *($e._M_messageProcessor._M_pScheduler)),
3153 #(ScheduleGroup: *($e._M_messageProcessor._M_pScheduleGroup))
3154 )
3155 )
3156 }
3157
3158 ;------------------------------------------------------------------------------
3159 ; Concurrency::single_assignment from <agents.h>
3160 ;------------------------------------------------------------------------------
3161 Concurrency::single_assignment<*>{
3162 preview (
3163 #(
3164 $e._M_pMessage
3165 )
3166 )
3167
3168 children (
3169 #(
3170 #(value: *($e._M_pMessage)),
3171 #(unprocessed_messages: $e._M_messageProcessor._M_queuedMessages._M_queue),
3172 #(message_filter: *($e._M_pFilter)),
3173 #(linked_sources: $e._M_connectedSources._M_links),
3174 #(linked_targets: $e._M_connectedTargets),
3175 #(reserving_target: *($e._M_pReservedFor)),
3176 #(Scheduler: *($e._M_messageProcessor._M_pScheduler)),
3177 #(ScheduleGroup: *($e._M_messageProcessor._M_pScheduleGroup))
3178 )
3179 )
3180 }
3181
3182 ;------------------------------------------------------------------------------
3183 ; Concurrency::call from <agents.h>
3184 ;------------------------------------------------------------------------------
3185 Concurrency::call<*>{
3186 preview (
3187 #(
3188 $e._M_pFunc
3189 )
3190 )
3191
3192 children (
3193 #(
3194 #(call_method: $e._M_pFunc),
3195 #(unprocessed_messages: $e._M_messageProcessor._M_queuedMessages._M_queue),
3196 #(message_filter: *($e._M_pFilter)),
3197 #(linked_sources: $e._M_connectedSources._M_links),
3198 #(Scheduler: *($e._M_messageProcessor._M_pScheduler)),
3199 #(ScheduleGroup: *($e._M_messageProcessor._M_pScheduleGroup))
3200 )
3201 )
3202 }
3203
3204 ;------------------------------------------------------------------------------
3205 ; Concurrency::transformer from <agents.h>
3206 ;------------------------------------------------------------------------------
3207 Concurrency::transformer<*>{
3208 preview (
3209 #(
3210 $e._M_pFunc
3211 )
3212 )
3213
3214 children (
3215 #(
3216 #(transform_method: $e._M_pFunc),
3217 #(unprocessed_messages: $e._M_messageProcessor._M_queuedMessages._M_queue),
3218 #(messages: $e._M_messageBuffer),
3219 #(message_filter: *($e._M_pFilter)),
3220 #(linked_sources: $e._M_connectedSources._M_links),
3221 #(linked_target: *($e._M_connectedTargets._M_connectedLink)),
3222 #(reserving_target: *($e._M_pReservedFor)),
3223 #(Scheduler: *($e._M_messageProcessor._M_pScheduler)),
3224 #(ScheduleGroup: *($e._M_messageProcessor._M_pScheduleGroup))
3225 )
3226 )
3227 }
3228
3229 ;------------------------------------------------------------------------------
3230 ; Concurrency::choice from <agents.h>
3231 ;------------------------------------------------------------------------------
3232 Concurrency::choice<*>{
3233 preview (
3234 #(
3235 "[",
3236 #if ($e._M_pSingleAssignment->_M_fIsInitialized) ("initialized")
3237 #else ("not_initialized"),
3238 "] ",
3239 $e._M_sourceTuple
3240 )
3241 )
3242
3243 children (
3244 #(
3245 #([input_count]: $e._M_pSingleAssignment->_M_connectedSources._M_links._M_vector._M_index),
3246 #(index: $e._M_pSingleAssignment->_M_pMessage->payload),
3247 #(source_tuple: $e._M_sourceTuple),
3248 #(linked_sources: $e._M_pSingleAssignment->_M_connectedSources._M_links),
3249 #(linked_targets: $e._M_pSingleAssignment->_M_connectedTargets),
3250 #(reserving_target: *($e._M_pSingleAssignment->_M_pReservedFor)),
3251 #(Scheduler: *($e._M_pScheduler)),
3252 #(ScheduleGroup: *($e._M_pScheduleGroup)),
3253 #([raw _M_pSourceChoices] : $e._M_pSourceChoices)
3254 )
3255 )
3256 }
3257
3258 ;------------------------------------------------------------------------------
3259 ; Concurrency::join<*,*>::_MessageArray from <agents.h>
3260 ;------------------------------------------------------------------------------
3261 Concurrency::join<*,*>::_MessageArray{
3262 preview (
3263 #(
3264 "[",
3265 $e._M_count,
3266 "](",
3267 #array(
3268 expr: *(((Concurrency::message<$T1>**)$e._M_messages)[$i]),
3269 size: $e._M_count
3270 ),
3271 ")"
3272 )
3273 )
3274
3275 children (
3276 #(
3277 #([size]: $e._M_count),
3278 #array(
3279 expr: *(((Concurrency::message<$T1>**)$e._M_messages)[$i]),
3280 size: $e._M_count
3281 )
3282 )
3283 )
3284 }
3285
3286 ;------------------------------------------------------------------------------
3287 ; Concurrency::join<*,*>::_SavedMessageIdArray from <agents.h>
3288 ;------------------------------------------------------------------------------
3289 Concurrency::join<*,*>::_SavedMessageIdArray{
3290 preview (
3291 #(
3292 "[",
3293 $e._M_count,
3294 "](",
3295 #array(
3296 expr: ((int*)$e._M_savedIds)[$i],
3297 size: $e._M_count
3298 ),
3299 ")"
3300 )
3301 )
3302
3303 children (
3304 #(
3305 #([size]: $e._M_count),
3306 #array(
3307 expr: ((int*)$e._M_savedIds)[$i],
3308 size: $e._M_count
3309 )
3310 )
3311 )
3312 }
3313
3314 ;------------------------------------------------------------------------------
3315 ; Concurrency::join from <agents.h>
3316 ;------------------------------------------------------------------------------
3317 Concurrency::join<*,*>{
3318 preview (
3319 #(
3320 "[",
3321 $e._M_messageArray._M_count - $e._M_messagesRemaining,
3322 "/",
3323 $e._M_messageArray._M_count,
3324 "](",
3325 #array(
3326 expr: *($e._M_connectedSources._M_links._M_vector._M_array[$i]),
3327 size: $e._M_connectedSources._M_links._M_vector._M_index
3328 ),
3329 ")"
3330 )
3331 )
3332
3333 children (
3334 #(
3335 #([join_type]: (Concurrency::join_type)$T2),
3336 #([offer_count]: $e._M_messageArray._M_count - $e._M_messagesRemaining),
3337 #(offer_IDs: $e._M_savedMessageIdArray),
3338 #([input_count]: $e._M_messageArray._M_count),
3339 #(input_values: $e._M_messageArray),
3340 #(messages: $e._M_messageBuffer),
3341 #(message_filter: *($e._M_pFilter)),
3342 #(linked_sources: $e._M_connectedSources._M_links),
3343 #(linked_target: $e._M_connectedTargets._M_connectedLink),
3344 #(reserving_target: *($e._M_pReservedFor)),
3345 #(Scheduler: *($e._M_messageProcessor._M_pScheduler)),
3346 #(ScheduleGroup: *($e._M_messageProcessor._M_pScheduleGroup))
3347 )
3348 )
3349 }
3350
3351 ;------------------------------------------------------------------------------
3352 ; Concurrency::multitype_join from <agents.h>
3353 ;------------------------------------------------------------------------------
3354 Concurrency::multitype_join<*,*>{
3355 preview (
3356 #(
3357 "[",
3358 $e._M_pJoinNode->_M_connectedSources._M_links._M_vector._M_index - $e._M_pJoinNode->_M_counter,
3359 "/",
3360 $e._M_pJoinNode->_M_connectedSources._M_links._M_vector._M_index,
3361 "]",
3362 $e._M_sourceTuple
3363 )
3364 )
3365
3366 children (
3367 #(
3368 #([join_type]: (Concurrency::join_type)$T2),
3369 #([offer_count]: $e._M_pJoinNode->_M_connectedSources._M_links._M_vector._M_index - $e._M_pJoinNode->_M_counter),
3370 #([input_count]: $e._M_pJoinNode->_M_connectedSources._M_links._M_vector._M_index),
3371 #(source_tuple: $e._M_sourceTuple),
3372 #(messages: $e._M_pJoinNode->_M_messageBuffer),
3373 #(linked_sources: $e._M_pJoinNode->_M_connectedSources._M_links),
3374 #(linked_target: $e._M_pJoinNode->_M_connectedTargets._M_connectedLink),
3375 #(reserving_target: *($e._M_pJoinNode->_M_pReservedFor)),
3376 #(Scheduler: *($e._M_pJoinNode->_M_messageProcessor._M_pScheduler)),
3377 #(ScheduleGroup: *($e._M_pJoinNode->_M_messageProcessor._M_pScheduleGroup)),
3378 #([raw _M_pSourceJoins] : $e._M_pSourceJoins)
3379 )
3380 )
3381 }
3382
3383 ;------------------------------------------------------------------------------
3384 ; Concurrency::timer from <agents.h>
3385 ;------------------------------------------------------------------------------
3386 Concurrency::timer<*>{
3387 preview (
3388 #(
3389 $e._M_state
3390 )
3391 )
3392
3393 children (
3394 #(
3395 #(state: $e._M_state),
3396 #(value: $e._M_value),
3397 #(repeating: $e._M_fRepeating),
3398 #(interval_ms: $e._M_ms),
3399 #(linked_target: *($e._M_connectedTargets._M_connectedLink)),
3400 #(reserving_target: *($e._M_pReservedFor)),
3401 #(Scheduler: *($e._M_messageProcessor._M_pScheduler)),
3402 #(ScheduleGroup: *($e._M_messageProcessor._M_pScheduleGroup))
3403 )
3404 )
3405 }
3406
3407 ;------------------------------------------------------------------------------
3408 ; Concurrency::details::SchedulerBase from <SchedulerBase.h>
3409 ; Concurrency::details::ThreadScheduler from <ThreadScheduler.h>
3410 ; Concurrency::details::UMSThreadScheduler from <UMSThreadScheduler.h>
3411 ;------------------------------------------------------------------------------
3412 Concurrency::details::SchedulerBase|Concurrency::details::ThreadScheduler|Concurrency::details::UMSThreadScheduler{
3413 preview (
3414 #(
3415 "[",
3416 $e.m_id,
3417 "] ",
3418 #if ($e.m_schedulerKind == 0) ("ThreadScheduler")
3419 #else ("UmsScheduler"),
3420 #if ($e.m_id == $e.s_pDefaultScheduler->m_id) (", default")
3421 #else ("")
3422 )
3423 )
3424
3425 children (
3426 #(
3427 #(ID: $e.m_id),
3428 #(SchedulerPolicy: $e.m_policy),
3429 #(VirtualProcessorCount: $e.m_virtualProcessorCount),
3430 #(ReferenceCount: $e.m_refCount),
3431 #([isDefaultScheduler]: $e.m_id == $e.s_pDefaultScheduler->m_id)
3432 )
3433 )
3434 }
3435
3436 ;------------------------------------------------------------------------------
3437 ; Concurrency::details::ScheduleGroupBase from <ScheduleGroupBase.h>
3438 ; Concurrency::details::CacheLocalScheduleGroup from <CacheLocalScheduleGroup.h>
3439 ; Concurrency::details::FairScheduleGroup from <FairScheduleGroup.h>
3440 ;------------------------------------------------------------------------------
3441 Concurrency::details::ScheduleGroupBase|Concurrency::details::CacheLocalScheduleGroup|Concurrency::details::FairScheduleGroup{
3442 preview (
3443 #(
3444 "[",
3445 $e.m_id,
3446 "]",
3447 #if ($e.m_kind & 4) (" AnonymousScheduleGroup")
3448 #else ("")
3449 )
3450 )
3451
3452 children (
3453 #(
3454 #(ID: $e.m_id),
3455 #(Scheduler: *($e.m_pScheduler))
3456 )
3457 )
3458 }
3459
3460 ;------------------------------------------------------------------------------
3461 ; Concurrency::details::ContextBase from <ContextBase.h>
3462 ; Concurrency::details::InternalContextBase from <InternalContextBase.h>
3463 ; Concurrency::details::ThreadInternalContext from <ThreadInternalContext.h>
3464 ; Concurrency::details::UMSThreadInternalContext from <UMSThreadInternalContext.h>
3465 ;------------------------------------------------------------------------------
3466 Concurrency::details::ContextBase|Concurrency::details::InternalContextBase|Concurrency::details::ThreadInternalContext|Concurrency::details::UMSThreadInternalContext{
3467 preview (
3468 #(
3469 "[",
3470 $e.m_threadId,
3471 "] ",
3472 #if ($e.m_blockedState == 0) ("not_concrt_blocked")
3473 #elif ($e.m_blockedState == 1) ("concrt_blocked")
3474 #elif ($e.m_blockedState == 2) ("ums_sync_blocked")
3475 #elif ($e.m_blockedState == 4) ("ums_async_blocked")
3476 #else ("")
3477 )
3478 )
3479
3480 children (
3481 #(
3482 #(ID: $e.m_id),
3483 #(ThreadID: $e.m_threadId),
3484 #(Scheduler: *($e.m_pScheduler)),
3485 #(ScheduleGroup: *($e.m_pGroup))
3486 )
3487 )
3488 }
3489
3490 ;------------------------------------------------------------------------------
3491 ; Concurrency::details::ExternalContextBase from <ExternalContextBase.h>
3492 ;------------------------------------------------------------------------------
3493 Concurrency::details::ExternalContextBase{
3494 preview (
3495 #(
3496 "[",
3497 $e.m_threadId,
3498 "] ",
3499 #if ($e.m_contextSwitchingFence == 1) ("concrt_blocked")
3500 #else ("not_concrt_blocked")
3501 )
3502 )
3503
3504 children (
3505 #(
3506 #(ID: $e.m_id),
3507 #(ThreadID: $e.m_threadId),
3508 #(Scheduler: *($e.m_pScheduler)),
3509 #(ScheduleGroup: *($e.m_pGroup))
3510 )
3511 )
3512 }
3513
3514 ;------------------------------------------------------------------------------
3515 ; Concurrency::SchedulerPolicy from <concrt.h>
3516 ;------------------------------------------------------------------------------
3517 Concurrency::SchedulerPolicy{
3518 preview (
3519 #(
3520 $e._M_pPolicyBag->_M_values._M_specificValues._M_schedulerKind,
3521 ", Min=",
3522 $e._M_pPolicyBag->_M_values._M_specificValues._M_minConcurrency,
3523 ", Max=",
3524 $e._M_pPolicyBag->_M_values._M_specificValues._M_maxConcurrency
3525 )
3526 )
3527
3528 children (
3529 #(
3530 #(SchedulerKind: $e._M_pPolicyBag->_M_values._M_specificValues._M_schedulerKind),
3531 #(MinConcurrency: $e._M_pPolicyBag->_M_values._M_specificValues._M_minConcurrency),
3532 #(MaxConcurrency: $e._M_pPolicyBag->_M_values._M_specificValues._M_maxConcurrency),
3533 #(TargetOversubscriptionFactor: $e._M_pPolicyBag->_M_values._M_specificValues._M_targetOversubscriptionFactor),
3534 #(LocalContextCacheSize: $e._M_pPolicyBag->_M_values._M_specificValues._M_localContextCacheSize),
3535 #(ContextStackSize: $e._M_pPolicyBag->_M_values._M_specificValues._M_contextStackSize),
3536 #(ContextPriority: $e._M_pPolicyBag->_M_values._M_specificValues._M_contextPriority),
3537 #(SchedulingProtocol: $e._M_pPolicyBag->_M_values._M_specificValues._M_schedulingProtocol),
3538 #(DynamicProgressFeedback: $e._M_pPolicyBag->_M_values._M_specificValues._M_dynamicProgressFeedback)
3539 )
3540 )
3541 }
3542
3543 ;------------------------------------------------------------------------------
3544 ; Concurrency::event from <concrt.h>
3545 ;------------------------------------------------------------------------------
3546 Concurrency::event{
3547 preview (
3548 #(
3549 #if ($e._M_pWaitChain == 1) ("set")
3550 #else ("not_set")
3551 )
3552 )
3553
3554 children (
3555 #(
3556 #([is_set]: ($e._M_pWaitChain == 1)),
3557 #([has_waiters]: (($e._M_pWaitChain != 0) && ($e._M_pWaitChain != 1)))
3558 )
3559 )
3560 }
3561
3562 ;------------------------------------------------------------------------------
3563 ; Concurrency::critical_section from <concrt.h>
3564 ;------------------------------------------------------------------------------
3565 Concurrency::critical_section{
3566 preview (
3567 #(
3568 #if ($e._M_pHead != 0) ("locked")
3569 #else ("not_locked")
3570 )
3571 )
3572
3573 children (
3574 #(
3575 #([is_locked]: ($e._M_pHead != 0)),
3576 #(OwningContext: *((Concurrency::Context*)($e._M_activeNode[0])))
3577 )
3578 )
3579 }
3580
3581 ;------------------------------------------------------------------------------
3582 ; Concurrency::critical_section::scoped_lock from <concrt.h>
3583 ;------------------------------------------------------------------------------
3584 Concurrency::critical_section::scoped_lock{
3585 preview (
3586 #(
3587 $e._M_critical_section
3588 )
3589 )
3590
3591 children (
3592 #(
3593 CriticalSection: $e._M_critical_section
3594 )
3595 )
3596 }
3597
3598 ;------------------------------------------------------------------------------
3599 ; Concurrency::reader_writer_lock from <concrt.h>
3600 ;------------------------------------------------------------------------------
3601 Concurrency::reader_writer_lock{
3602 preview (
3603 #(
3604 #if (($e._M_lockState < 8) && ($e._M_lockState & 2)) ("held_by_writer")
3605 #elif ($e._M_lockState >= 8) (
3606 #(
3607 "held_by_reader(s) [",
3608 ($e._M_lockState / 8),
3609 "]"
3610 )
3611 )
3612 #else ("not_held")
3613 )
3614 )
3615
3616 children (
3617 #(
3618 #([is_reader_lock_held]: ($e._M_lockState >= 8)),
3619 #([num_reader_lock_holders]: ($e._M_lockState / 8)),
3620 #([is_writer_lock_held]: ($e._M_lockState < 8) && ($e._M_lockState & 2)),
3621 #(OwningWriterContext: *((Concurrency::Context*)($e._M_activeWriter[0])))
3622 )
3623 )
3624 }
3625
3626 ;------------------------------------------------------------------------------
3627 ; Concurrency::reader_writer_lock::scoped_lock from <concrt.h>
3628 ; Concurrency::reader_writer_lock::scoped_lock_read from <concrt.h>
3629 ;------------------------------------------------------------------------------
3630 Concurrency::reader_writer_lock::scoped_lock|Concurrency::reader_writer_lock::scoped_lock_read{
3631 preview (
3632 #(
3633 $e._M_reader_writer_lock
3634 )
3635 )
3636
3637 children (
3638 #(
3639 ReaderWriterLock: $e._M_reader_writer_lock
3640 )
3641 )
3642 }
3643
3644 ;------------------------------------------------------------------------------
3645 ; Concurrency::details::_TaskCollectionBase from <concrt.h>
3646 ;------------------------------------------------------------------------------
3647 Concurrency::details::_TaskCollectionBase{
3648 preview (
3649 #(
3650 #if ((((int)$e._M_pException & ~0x3) != 0) && (((int)$e._M_pException & ~0x3) != 0xC)) ("exception")
3651 #else ("no_exception")
3652 )
3653 )
3654
3655 children (
3656 #(
3657 #([has_exception]: (((int)$e._M_pException & ~0x3) != 0) && (((int)$e._M_pException & ~0x3) != 0xC)),
3658 #(CreatingContext: *((Concurrency::Context*)$e._M_pOwningContext))
3659 )
3660 )
3661 }
3662
3663 ;------------------------------------------------------------------------------
3664 ; Concurrency::task_group from <ppl.h>
3665 ; Concurrency::structured_task_group from <ppl.h>
3666 ;------------------------------------------------------------------------------
3667 Concurrency::task_group|Concurrency::structured_task_group{
3668 preview (
3669 #(
3670 #if ((((int)$e._M_task_collection._M_pException & ~0x3) != 0) && (((int)$e._M_task_collection._M_pException & ~0x3) != 0xC)) ("exception")
3671 #else ("no_exception")
3672 )
3673 )
3674
3675 children (
3676 #(
3677 #([has_exception]: (((int)$e._M_task_collection._M_pException & ~0x3) != 0) && (((int)$e._M_task_collection._M_pException & ~0x3) != 0xC)),
3678 #(CreatingContext: *((Concurrency::Context*)$e._M_task_collection._M_pOwningContext))
3679 )
3680 )
3681 }
3682
3683 ;------------------------------------------------------------------------------
3684 ; Concurrency::task_handle from <ppl.h>
3685 ;------------------------------------------------------------------------------
3686 Concurrency::task_handle<*>{
3687 preview (
3688 #(
3689 $e._M_function
3690 )
3691 )
3692
3693 children (
3694 #(
3695 #(Function: $e._M_function),
3696 #(RuntimeOwnsLifetime: $e._M_fRuntimeOwnsLifetime),
3697 #(TaskCollection: *($e._M_pTaskCollection))
3698 )
3699 )
3700 }
3701
3702 ;------------------------------------------------------------------------------
3703 ; Concurrency::combinable from <ppl.h>
3704 ;------------------------------------------------------------------------------
3705 Concurrency::combinable<*>{
3706 preview(
3707 #(
3708 "(",
3709 #array(
3710 expr: *($e._M_buckets[$i]),
3711 size: $e._M_size
3712 ) : #list(
3713 head: $e,
3714 next: _M_chain
3715 ) : $e._M_value,
3716 ")"
3717 )
3718 )
3719 children(
3720 #(
3721 #array(
3722 expr: *($e._M_buckets[$i]),
3723 size: $e._M_size
3724 ) : #list(
3725 head: $e,
3726 next: _M_chain
3727 ) : $e._M_value,
3728 #(InitFunction : $e._M_fnInitialize)
3729 )
3730 )
3731 }
3732
3733 ;------------------------------------------------------------------------------
3734 ; Concurrency::concurrent_vector from <concurrent_vector.h>
3735 ;------------------------------------------------------------------------------
3736 Concurrency::concurrent_vector<*,*>{
3737 preview(
3738 #(
3739 "[",
3740 $e._My_early_size._M_value,
3741 "](",
3742 #array (
3743 expr: #(
3744 #if (($i >> 1) == 0) ((($T1*)$e._My_segment._M_value[0]._My_array)[$i])
3745 #else ((($T1*)$e._My_segment._M_value[__log2($i)]._My_array)[$i - (0x1 << __log2($i))])
3746 ),
3747 size: $e._My_early_size._M_value
3748 ),
3749 ")"
3750 )
3751 )
3752 children(
3753 #(
3754 [size] : $e._My_early_size._M_value,
3755 #array (
3756 expr: #(
3757 #if (($i >> 1) == 0) ((($T1*)$e._My_segment._M_value[0]._My_array)[$i])
3758 #else ((($T1*)$e._My_segment._M_value[__log2($i)]._My_array)[$i - (0x1 << __log2($i))])
3759 ),
3760 size: $e._My_early_size._M_value
3761 )
3762 )
3763 )
3764 }
3765
3766 ;------------------------------------------------------------------------------
3767 ; Concurrency::details::_Vector_iterator from <concurrent_vector.h>
3768 ;------------------------------------------------------------------------------
3769 Concurrency::details::_Vector_iterator<Concurrency::concurrent_vector<*,*>,*>{
3770 preview(
3771 #(
3772 #if (($e._My_index >> 1) == 0) ((($T1*)$e._My_vector->_My_segment._M_value[0]._My_array)[$e._My_index])
3773 #else ((($T1*)$e._My_vector->_My_segment._M_value[__log2($e._My_index)]._My_array)[$e._My_index - (0x1 << __log2($e._My_index))])
3774 )
3775 )
3776 children(
3777 #(
3778 [ptr]: #if (($e._My_index >> 1) == 0) (&((($T1*)$e._My_vector->_My_segment._M_value[0]._My_array)[$e._My_index]))
3779 #else (&((($T1*)$e._My_vector->_My_segment._M_value[__log2($e._My_index)]._My_array)[$e._My_index - (0x1 << __log2($e._My_index))]))
3780
3781 )
3782 )
3783 }
3784
3785 ;------------------------------------------------------------------------------
3786 ; Concurrency::concurrent_queue from <concurrent_queue.h>
3787 ;------------------------------------------------------------------------------
3788 Concurrency::concurrent_queue<*,*>{
3789 preview
3790 (
3791 #(
3792 "[",
3793 $e._My_rep->_Tail_counter._M_value - $e._My_rep->_Head_counter._M_value,
3794 "](",
3795 #array
3796 (
3797 expr : #if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 0) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1])
3798 #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 1) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1])
3799 #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 2) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1])
3800 #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 3) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1])
3801 #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 4) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1])
3802 #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 5) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1])
3803 #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 6) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1])
3804 #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 7) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1])
3805 #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 8) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1])
3806 #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 9) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1])
3807 #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 10) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1])
3808 #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 11) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1])
3809 #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 12) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1])
3810 #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 13) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1])
3811 #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 14) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1])
3812 #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 15) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1])
3813 #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 16) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1])
3814 #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 17) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1])
3815 #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 18) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1])
3816 #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 19) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1])
3817 #else ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1])))))))))))))))))))),
3818 size : #if ($e._My_rep->_Tail_counter._M_value-$e._My_rep->_Head_counter._M_value < 20*8*$e._Items_per_page) ($e._My_rep->_Tail_counter._M_value-$e._My_rep->_Head_counter._M_value)
3819 #else (20*8*$e._Items_per_page)
3820 ),
3821 ")"
3822 )
3823 )
3824 children
3825 (
3826 #(
3827 #([unsafe_size]: $e._My_rep->_Tail_counter._M_value-$e._My_rep->_Head_counter._M_value),
3828 #array
3829 (
3830 expr : #if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 0) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1])
3831 #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 1) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1])
3832 #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 2) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1])
3833 #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 3) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1])
3834 #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 4) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1])
3835 #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 5) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1])
3836 #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 6) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1])
3837 #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 7) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1])
3838 #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 8) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1])
3839 #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 9) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1])
3840 #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 10) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1])
3841 #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 11) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1])
3842 #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 12) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1])
3843 #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 13) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1])
3844 #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 14) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1])
3845 #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 15) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1])
3846 #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 16) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1])
3847 #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 17) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1])
3848 #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 18) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1])
3849 #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 19) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1])
3850 #else ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1])))))))))))))))))))),
3851 size : #if ($e._My_rep->_Tail_counter._M_value-$e._My_rep->_Head_counter._M_value < 20*8*$e._Items_per_page) ($e._My_rep->_Tail_counter._M_value-$e._My_rep->_Head_counter._M_value)
3852 #else (20*8*$e._Items_per_page)
3853 )
3854 )
3855 )
3856 }
3857
3858 ;------------------------------------------------------------------------------
3859 ; Concurrency::details::_Concurrent_queue_iterator from <concurrent_queue.h>
3860 ;------------------------------------------------------------------------------
3861 Concurrency::details::_Concurrent_queue_iterator<Concurrency::concurrent_queue<*,*>,*>{
3862 preview(
3863 #(
3864 *(($T1*)$e._My_item)
3865 )
3866 )
3867 children(
3868 #(
3869 [ptr]: (($T1*)$e._My_item)
3870
3871 )
3872 )
3873 }
3874
3875 ; Qt visualizers
3876 ; Nokia Qt 4.x visualizers -----------------------------------------[ start ]--
3877 ;------------------------------------------------------------------------------
3878 ; Feel free to modify these visualizers to suit yours needs! But please let us
3879 ; know about the changes you make, so we continuously improve the visualizers.
3880
3881 QString|*::QString{
3882 preview ([$e.d->data,su])
3883 stringview ([$e.d->data,sub])
3884 children
3885 (
3886 #(
3887 d: $c.d,
3888 [size]: $c.d->size,
3889 [referenced]: $c.d->ref._q_value
3890 )
3891 )
3892 }
3893
3894 QByteArray|*::QByteArray{
3895 preview ([$e.d->data,s])
3896 stringview ([$e.d->data,sb])
3897 children
3898 (
3899 #(
3900 d: $c.d,
3901 [size]: $c.d->size,
3902 [referenced]: $c.d->ref._q_value
3903 )
3904 )
3905 }
3906
3907 QFileInfo|*::QFileInfo{
3908 preview
3909 (
3910 #(
3911 "private=", $c.d_ptr
3912 )
3913 )
3914 }
3915
3916 QUrl|*::QUrl{
3917 preview
3918 (
3919 #if ($e.d.stateFlags == 0) (
3920 $e.d
3921 ) #else (
3922 #( $e.d->scheme, $e.d->host, $e.d->path )
3923 )
3924 )
3925 children
3926 (
3927 #(
3928 scheme: $c.d->scheme,
3929 host: $c.d->host,
3930 path: $c.d->path,
3931 username: $c.d->userName,
3932 password: $c.d->password,
3933 encodedOriginal: $c.d->encodedOriginal,
3934 query: $c.d->query,
3935 fragment: $c.d->fragment
3936 )
3937 )
3938 }
3939
3940 QTime|*::QTime{
3941 preview
3942 (
3943 #(
3944 "hour=", [$e.mds / 3600000, d],
3945 ", minute=", [($e.mds % 3600000) / 60000, d],
3946 ", second=", [($e.mds / 1000) % 60, d],
3947 ", millisecond=", [$e.mds % 1000, d]
3948 )
3949 )
3950 children
3951 (
3952 #(
3953 [hour]: [$e.mds / 3600000, d],
3954 [minute]: [($e.mds % 3600000) / 60000, d],
3955 [second]: [($e.mds / 1000) % 60, d],
3956 [millisecond]: [$e.mds % 1000, d]
3957 )
3958 )
3959 }
3960
3961 QVariant{
3962 preview
3963 (
3964 #if ($e.d.type == 1) (
3965 #("bool = ", [$e.d.data.b])
3966 ) #elif ($e.d.type == 2) (
3967 #("int = ", [$e.d.data.i])
3968 ) #elif ($e.d.type == 3) (
3969 #("usigned int = ", [$e.d.data.u])
3970 ) #elif ($e.d.type == 4) (
3971 #("long long = ", [$e.d.data.ll])
3972 ) #elif ($e.d.type == 5) (
3973 #("unsigned long long = ", [$e.d.data.ull])
3974 ) #elif ($e.d.type == 6) (
3975 #("double = ", [$e.d.data.d])
3976 ) #elif ($e.d.type == 7) (
3977 #("char = ", [$e.d.data.c])
3978 ) #elif ($e.d.type == 8) (
3979 #("QMap = ", [(QMap) $e.d.data.ptr])
3980 ) #elif ($e.d.type == 10) (
3981 #("QString = ", [(QString) $e.d.data.ptr])
3982 ) #elif ($e.d.type == 11) (
3983 #("QStringList = ", [(QStringList) $e.d.data.ptr])
3984 ) #elif ($e.d.type == 17) (
3985 #("QUrl = ", [(QUrl) $e.d.data.ptr])
3986 ) #else (
3987 #("type = ", [$e.d.type])
3988 )
3989 )
3990 children
3991 (
3992 #if ($e.d.type == 1) (
3993 $c.d.data.b
3994 ) #elif ($e.d.type == 2) (
3995 $c.d.data.i
3996 ) #elif ($e.d.type == 3) (
3997 $c.d.data.u
3998 ) #elif ($e.d.type == 4) (
3999 $c.d.data.ll
4000 ) #elif ($e.d.type == 5) (
4001 $c.d.data.ull
4002 ) #elif ($e.d.type == 6) (
4003 $c.d.data.d
4004 ) #elif ($e.d.type == 7) (
4005 $c.d.data.c
4006 ) #elif ($e.d.type == 8) (
4007 ) #elif ($e.d.type == 10) (
4008 #(
4009 [size]: ((QString) $c.d.data.ptr).d->size
4010 )
4011 ) #elif ($e.d.type == 11) (
4012 #if ((((QStringList) $e.d.data.ptr).d->end - ((QStringList) $e.d.data.ptr).d->begin) <= 10) (
4013 #array
4014 (
4015 expr: (QString)((((QStringList) $e.d.data.ptr).d->array + ((QStringList) $e.d.data.ptr).d->begin)[$i]),
4016 size: ((QStringList) $e.d.data.ptr).d->end-((QStringList) $e.d.data.ptr).d->begin
4017 )
4018 ) #else (
4019 #array
4020 (
4021 expr: (QString)((((QStringList) $e.d.data.ptr).d->array + ((QStringList) $e.d.data.ptr).d->begin)[$i]),
4022 size: 10
4023 )
4024 )
4025 ) #elif ($e.d.type == 17) (
4026 #(
4027 scheme: ((QUrl) $e.d.data.ptr).d->scheme,
4028 host: ((QUrl) $e.d.data.ptr).d->host,
4029 path: ((QUrl) $e.d.data.ptr).d->path,
4030 username: ((QUrl) $e.d.data.ptr).d->userName,
4031 password: ((QUrl) $e.d.data.ptr).d->password,
4032 encodedOriginal: ((QUrl) $e.d.data.ptr).d->encodedOriginal,
4033 query: ((QUrl) $e.d.data.ptr).d->query,
4034 fragment: ((QUrl) $e.d.data.ptr).d->fragment
4035 )
4036 ) #else (
4037 #("type = ", [$e.d.type])
4038 )
4039 )
4040 }
4041
4042 *::QVariant{
4043 preview
4044 (
4045 #if ($e.d.type == 1) (
4046 #("bool = ", [$e.d.data.b])
4047 ) #elif ($e.d.type == 2) (
4048 #("int = ", [$e.d.data.i])
4049 ) #elif ($e.d.type == 3) (
4050 #("usigned int = ", [$e.d.data.u])
4051 ) #elif ($e.d.type == 4) (
4052 #("long long = ", [$e.d.data.ll])
4053 ) #elif ($e.d.type == 5) (
4054 #("unsigned long long = ", [$e.d.data.ull])
4055 ) #elif ($e.d.type == 6) (
4056 #("double = ", [$e.d.data.d])
4057 ) #elif ($e.d.type == 7) (
4058 #("char = ", [$e.d.data.c])
4059 ) #elif ($e.d.type == 8) (
4060 #("QMap = ", [($T1::QMap) $e.d.data.ptr])
4061 ) #elif ($e.d.type == 10) (
4062 #("QString = ", [($T1::QString) $e.d.data.ptr])
4063 ) #elif ($e.d.type == 11) (
4064 #("QStringList = ", [($T1::QStringList) $e.d.data.ptr])
4065 ) #elif ($e.d.type == 17) (
4066 #("QUrl = ", [($T1::QUrl) $e.d.data.ptr])
4067 ) #else (
4068 #("type = ", [$e.d.type])
4069 )
4070 )
4071 children
4072 (
4073 #if ($e.d.type == 1) (
4074 $c.d.data.b
4075 ) #elif ($e.d.type == 2) (
4076 $c.d.data.i
4077 ) #elif ($e.d.type == 3) (
4078 $c.d.data.u
4079 ) #elif ($e.d.type == 4) (
4080 $c.d.data.ll
4081 ) #elif ($e.d.type == 5) (
4082 $c.d.data.ull
4083 ) #elif ($e.d.type == 6) (
4084 $c.d.data.d
4085 ) #elif ($e.d.type == 7) (
4086 $c.d.data.c
4087 ) #elif ($e.d.type == 8) (
4088 ) #elif ($e.d.type == 10) (
4089 #(
4090 [size]: (($T1::QString) $c.d.data.ptr).d->size
4091 )
4092 ) #elif ($e.d.type == 11) (
4093 #if (((($T1::QStringList) $e.d.data.ptr).d->end - (($T1::QStringList) $e.d.data.ptr).d->begin) <= 10) (
4094 #array
4095 (
4096 expr: ($T1::QString)(((($T1::QStringList) $e.d.data.ptr).d->array + (($T1::QStringList) $e.d.data.ptr).d->begin)[$i]),
4097 size: (($T1::QStringList) $e.d.data.ptr).d->end-(($T1::QStringList) $e.d.data.ptr).d->begin
4098 )
4099 ) #else (
4100 #array
4101 (
4102 expr: ($T1::QString)(((($T1::QStringList) $e.d.data.ptr).d->array + (($T1::QStringList) $e.d.data.ptr).d->begin)[$i]),
4103 size: 10
4104 )
4105 )
4106 ) #elif ($e.d.type == 17) (
4107 #(
4108 scheme: (($T1::QUrl) $e.d.data.ptr).d->scheme,
4109 host: (($T1::QUrl) $e.d.data.ptr).d->host,
4110 path: (($T1::QUrl) $e.d.data.ptr).d->path,
4111 username: (($T1::QUrl) $e.d.data.ptr).d->userName,
4112 password: (($T1::QUrl) $e.d.data.ptr).d->password,
4113 encodedOriginal: (($T1::QUrl) $e.d.data.ptr).d->encodedOriginal,
4114 query: (($T1::QUrl) $e.d.data.ptr).d->query,
4115 fragment: (($T1::QUrl) $e.d.data.ptr).d->fragment
4116 )
4117 ) #else (
4118 #("type = ", [$e.d.type])
4119 )
4120 )
4121 }
4122
4123 ;------------------------------------------------------------------------------
4124 ; QStringList
4125 ;------------------------------------------------------------------------------
4126 QStringList{
4127 preview
4128 (
4129 #if (($c.d->end - $c.d->begin) <= 10) (
4130 #(
4131 "[", $c.d->end - $c.d->begin, "](",
4132 #array
4133 (
4134 expr: (QString)(($c.d->array + $c.d->begin)[$i]),
4135 size: $c.d->end-$c.d->begin
4136 ), ")"
4137 )
4138 ) #else (
4139 #(
4140 "[", $c.d->end - $c.d->begin, "](",
4141 #array
4142 (
4143 expr: (QString)(($c.d->array + $c.d->begin)[$i]),
4144 size: 10
4145 ), ", ...)"
4146 )
4147 )
4148 )
4149 }
4150
4151 *::QStringList{
4152 preview
4153 (
4154 #if (($c.d->end - $c.d->begin) <= 10) (
4155 #(
4156 "[", $c.d->end - $c.d->begin, "](",
4157 #array
4158 (
4159 expr: ($T1::QString)(($c.d->array + $c.d->begin)[$i]),
4160 size: $c.d->end-$c.d->begin
4161 ), ")"
4162 )
4163 ) #else (
4164 #(
4165 "[", $c.d->end - $c.d->begin, "](",
4166 #array
4167 (
4168 expr: ($T1::QString)(($c.d->array + $c.d->begin)[$i]),
4169 size: 10
4170 ), ", ...)"
4171 )
4172 )
4173 )
4174 }
4175
4176 ;------------------------------------------------------------------------------
4177 ; QList, QQueue
4178 ;------------------------------------------------------------------------------
4179 QList<*>|QQueue<*>{
4180 preview
4181 (
4182 #if (int(sizeof($T1)) <= int(sizeof(void*))) (
4183 #if (($c.d->end - $c.d->begin) <= 10) (
4184 #(
4185 "[", $c.d->end - $c.d->begin, "](",
4186 #array
4187 (
4188 expr: ($T1)(($c.d->array + $c.d->begin)[$i]),
4189 size: $c.d->end-$c.d->begin
4190 ), ")"
4191 )
4192 ) #else (
4193 #(
4194 "[", $c.d->end - $c.d->begin, "](",
4195 #array
4196 (
4197 expr: ($T1)(($c.d->array + $c.d->begin)[$i]),
4198 size: 10
4199 ), ", ...)"
4200 )
4201 )
4202 ) #else (
4203 #if (($c.d->end - $c.d->begin) <= 10) (
4204 #(
4205 "[", $c.d->end - $c.d->begin, "](",
4206 #array
4207 (
4208 expr: *($T1*)(($c.d->array + $c.d->begin)[$i]),
4209 size: $c.d->end-$c.d->begin
4210 ), ")"
4211 )
4212 ) #else (
4213 #(
4214 "[", $c.d->end - $c.d->begin, "](",
4215 #array
4216 (
4217 expr: *($T1*)(($c.d->array + $c.d->begin)[$i]),
4218 size: 10
4219 ), ", ...)"
4220 )
4221 )
4222 )
4223 )
4224 children
4225 (
4226 #if (int(sizeof($T1)) <= int(sizeof(void*))) (
4227 #array (
4228 expr: ($T1)(($c.d->array + $c.d->begin)[$i]),
4229 size: $c.d->end - $c.d->begin
4230 )
4231 ) #else (
4232 #array (
4233 expr: *($T1*)(($c.d->array + $c.d->begin)[$i]),
4234 size: $c.d->end - $c.d->begin
4235 )
4236 )
4237 )
4238 }
4239
4240 *::QList<*>|*::QQueue<*>{
4241 preview
4242 (
4243 #if (int(sizeof($T2)) <= int(sizeof(void*))) (
4244 #if (($c.d->end - $c.d->begin) <= 10) (
4245 #(
4246 "[", $c.d->end - $c.d->begin, "](",
4247 #array
4248 (
4249 expr: ($T2)(($c.d->array + $c.d->begin)[$i]),
4250 size: $c.d->end-$c.d->begin
4251 ), ")"
4252 )
4253 ) #else (
4254 #(
4255 "[", $c.d->end - $c.d->begin, "](",
4256 #array
4257 (
4258 expr: ($T2)(($c.d->array + $c.d->begin)[$i]),
4259 size: 10
4260 ), ", ...)"
4261 )
4262 )
4263 ) #else (
4264 #if (($c.d->end - $c.d->begin) <= 10) (
4265 #(
4266 "[", $c.d->end - $c.d->begin, "](",
4267 #array
4268 (
4269 expr: *($T2*)(($c.d->array + $c.d->begin)[$i]),
4270 size: $c.d->end-$c.d->begin
4271 ), ")"
4272 )
4273 ) #else (
4274 #(
4275 "[", $c.d->end - $c.d->begin, "](",
4276 #array
4277 (
4278 expr: *($T2*)(($c.d->array + $c.d->begin)[$i]),
4279 size: 10
4280 ), ", ...)"
4281 )
4282 )
4283 )
4284 )
4285 children
4286 (
4287 #if (int(sizeof($T2)) <= int(sizeof(void*))) (
4288 #array (
4289 expr: ($T2)(($c.d->array + $c.d->begin)[$i]),
4290 size: $c.d->end - $c.d->begin
4291 )
4292 ) #else (
4293 #array (
4294 expr: *($T2*)(($c.d->array + $c.d->begin)[$i]),
4295 size: $c.d->end - $c.d->begin
4296 )
4297 )
4298 )
4299 }
4300
4301 ;------------------------------------------------------------------------------
4302 ; QList::iterator, QQueue::iterator
4303 ;------------------------------------------------------------------------------
4304 QList<*>::iterator|QList<*>::const_iterator|QQueue<*>::iterator|QQueue<*>::const_iterator{
4305 preview
4306 (
4307 #(
4308 ($T1*)$c.ptr
4309 )
4310 )
4311 children
4312 (
4313 #(
4314 ptr: ($T1)$c.ptr
4315 )
4316 )
4317 }
4318
4319 *::QList<*>::iterator|*::QList<*>::const_iterator|*::QQueue<*>::iterator|*::QQueue<*>::const_iterator{
4320 preview
4321 (
4322 #(
4323 ($T2)$c.i->v
4324 )
4325 )
4326 children
4327 (
4328 #(
4329 ptr: ($T2)$c.i->v
4330 )
4331 )
4332 }
4333
4334 ;------------------------------------------------------------------------------
4335 ; QListIterator
4336 ;------------------------------------------------------------------------------
4337 QListIterator<*>|QMutableListIterator<*>{
4338 preview
4339 (
4340 #(
4341 *($T1*)($c.i.i->v)
4342 )
4343 )
4344 children
4345 (
4346 #(
4347 Value: *($T1*)($c.i.i->v)
4348 )
4349 )
4350 }
4351
4352 *::QListIterator<*>|*::QMutableListIterator<*>{
4353 preview
4354 (
4355 #(
4356 *($T2*)($c.i.i->v)
4357 )
4358 )
4359 children
4360 (
4361 #(
4362 Value: *($T2*)($c.i.i->v)
4363 )
4364 )
4365 }
4366
4367 ;------------------------------------------------------------------------------
4368 ; QLinkedList
4369 ;------------------------------------------------------------------------------
4370 QLinkedList<*>{
4371 preview
4372 (
4373 #if ($e.d->size >= 10) (
4374 #(
4375 "[", $e.d->size, "](",
4376 #list
4377 (
4378 head: $c.d->n,
4379 size: 10,
4380 next: n
4381 ) : ( (*(QLinkedListNode<$T1>*)&$e).t ), ", ...)"
4382 )
4383 ) #else (
4384 #(
4385 "[", $e.d->size, "](",
4386 #list
4387 (
4388 head: $c.d->n,
4389 size: $c.d->size,
4390 next: n
4391 ) : ( (*(QLinkedListNode<$T1>*)&$e).t ), ")"
4392 )
4393 )
4394 )
4395 children
4396 (
4397 #(
4398 #list
4399 (
4400 head: $c.d->n,
4401 size: $c.d->size,
4402 next: n
4403 ) : (*(QLinkedListNode<$T1>*)&$e).t
4404 )
4405 )
4406 }
4407
4408 *::QLinkedList<*>{
4409 preview
4410 (
4411 #if ($e.d->size >= 10) (
4412 #(
4413 "[", $e.d->size, "](",
4414 #list
4415 (
4416 head: $c.d->n,
4417 size: 10,
4418 next: n
4419 ) : ( (*($T1::QLinkedListNode<$T2>*)&$e).t ), ", ...)"
4420 )
4421 ) #else (
4422 #(
4423 "[", $e.d->size, "](",
4424 #list
4425 (
4426 head: $c.d->n,
4427 size: $c.d->size,
4428 next: n
4429 ) : ( (*($T1::QLinkedListNode<$T2>*)&$e).t ), ")"
4430 )
4431 )
4432 )
4433 children
4434 (
4435 #(
4436 #list
4437 (
4438 head: $c.d->n,
4439 size: $c.d->size,
4440 next: n
4441 ) : (*($T1::QLinkedListNode<$T2>*)&$e).t
4442 )
4443 )
4444 }
4445
4446 ;------------------------------------------------------------------------------
4447 ; QLinkedList::iterator
4448 ;------------------------------------------------------------------------------
4449 QLinkedList<*>::iterator|*::QLinkedList<*>::iterator|QLinkedList<*>::const_iterator|*::QLinkedList<*>::const_iterator{
4450 preview
4451 (
4452 #(
4453 $e.i->t
4454 )
4455 )
4456 children
4457 (
4458 #(
4459 ptr: $e.i->t
4460 )
4461 )
4462 }
4463
4464 QLinkedListIterator<*>|*::QLinkedListIterator<*>{
4465 preview
4466 (
4467 #(
4468 $c.i
4469 )
4470 )
4471 children
4472 (
4473 #(
4474 value: $c.i
4475 )
4476 )
4477 }
4478
4479 ;------------------------------------------------------------------------------
4480 ; QVector, QStack
4481 ;
4482 ; By default, this visualizer supports only Qt 4.6.x. If you're going to use
4483 ; Qt 4.5.x code, then you may want to replace all expr lines with this:
4484 ; expr: (((size_t)($c.d) + (size_t)(sizeof(QVectorData)) ))[$i],
4485 ;
4486 ; This will allow this visualizer to display Qt 4.5.x and Qt 4.6.x QVector
4487 ; objects. But be aware of some limitations. For example enum types can't be
4488 ; displayed properly this way.
4489 ;
4490 ; Qt 4.5.x:
4491 ; QVector::d is QVectorTypedData<T>
4492 ; QVector::p is QVectorData
4493 ; expr: $c.d->array[$i]
4494 ;
4495 ; Qt 4.6.x:
4496 ; QVector::d is QVectorData
4497 ; QVector::p is QVectorTypedData<T>
4498 ; expr: $c.p->array[$i]
4499 ;
4500 ;------------------------------------------------------------------------------
4501 QVector<*>|*::QVector<*>|QStack<*>|*::QStack<*>{
4502 preview
4503 (
4504 #if ($c.d->size <= 10) (
4505 #(
4506 "[", $c.d->size, "](",
4507 #array
4508 (
4509 expr: $c.p->array[$i],
4510 size: $c.d->size
4511 ), ")"
4512 )
4513 ) #else (
4514 #(
4515 "[", $c.d->size, "](",
4516 #array
4517 (
4518 expr: $c.p->array[$i],
4519 size: 10
4520 ), ", ...)"
4521 )
4522 )
4523 )
4524 children
4525 (
4526 #array
4527 (
4528 expr: $c.p->array[$i],
4529 size: $c.d->size
4530 )
4531 )
4532 }
4533
4534 ;------------------------------------------------------------------------------
4535 ; QMap
4536 ;------------------------------------------------------------------------------
4537 QMapNode<*,*>{
4538 preview
4539 (
4540 #(
4541 "(",
4542 $e.key,
4543 "; ",
4544 $e.value,
4545 ")"
4546 )
4547 )
4548
4549 children
4550 (
4551 #(
4552 key: $e.key,
4553 value: $e.value
4554 )
4555 )
4556 }
4557
4558 QMap<*>{
4559 children
4560 (
4561 #(
4562 raw data: [$c,!],
4563 #tree
4564 (
4565 head : $c.d->forward[0],
4566 skip : $c.d,
4567 size : $c.d->size,
4568 left : backward,
4569 right : forward
4570 ) : ( (QMapNode<$T1>*)((char*)&$e - (sizeof(QMapPayloadNode<$T1>) - sizeof(QMapData::Node*))) )
4571 )
4572 )
4573
4574 preview
4575 (
4576 #(
4577 "[",
4578 $e.d->size,
4579 "](",
4580 #tree
4581 (
4582 head : $c.d->forward[0],
4583 size : $c.d->size,
4584 left : backward,
4585 right : forward
4586 ) : $e,
4587 ")"
4588 )
4589 )
4590 }
4591
4592 ;------------------------------------------------------------------------------
4593 ; QHash
4594 ;------------------------------------------------------------------------------
4595 QHash<*>{
4596 preview
4597 (
4598 #(
4599 "[", $e.d->size, "] (...)"
4600 )
4601 )
4602 children
4603 (
4604 #(
4605 #array (
4606 expr: (QHashNode<$T1>*)$c.d->buckets[$i],
4607 size: $c.d->numBuckets
4608 ) : #list (
4609 head: $e,
4610 next: next
4611 ) : #switch ($e.next != 0) #case 1 (
4612 $e
4613 )
4614 )
4615 )
4616 }
4617
4618 *::QHash<*>{
4619 preview
4620 (
4621 #(
4622 "[", $e.d->size, "] (...)"
4623 )
4624 )
4625 children
4626 (
4627 #(
4628 #array (
4629 expr: ($T1::QHashNode<$T2> *)$c.d->buckets[$i],
4630 size: $c.d->numBuckets
4631 ) : #list (
4632 head: $e,
4633 next: next
4634 ) : #switch ($e.next != 0) #case 1 (
4635 $e
4636 )
4637 )
4638 )
4639 }
4640
4641 ;------------------------------------------------------------------------------
4642 ; QMultiHash
4643 ;------------------------------------------------------------------------------
4644 QMultiHash<*>{
4645 preview
4646 (
4647 (*(QHash<$T1>*)(&$c))
4648 )
4649 }
4650
4651 *::QMultiHash<*>{
4652 preview
4653 (
4654 (*($T1::QHash<$T2>*)(&$c))
4655 )
4656 }
4657
4658 ;------------------------------------------------------------------------------
4659 ; QHash::iterator
4660 ;------------------------------------------------------------------------------
4661 QHash<*>::iterator{
4662 preview
4663 (
4664 #(
4665 "(", ((QHashNode<$T1>*)($c.i))->key, ", ", ((QHashNode<$T1>*)($c.i))->value, ")"
4666 )
4667 )
4668 children
4669 (
4670 #(
4671 key: ((QHashNode<$T1>*)($c.i))->key,
4672 value: ((QHashNode<$T1>*)($c.i))->value
4673 )
4674 )
4675 }
4676
4677 *::QHash<*>::iterator{
4678 preview
4679 (
4680 #(
4681 "(", (($T1::QHashNode<$T2>*)($c.i))->key, ", ", (($T1::QHashNode<$T2>*)($c.i))->key, ")"
4682 )
4683 )
4684 children
4685 (
4686 #(
4687 key: (($T1::QHashNode<$T2>*)($c.i))->key,
4688 value: (($T1::QHashNode<$T2>*)($c.i))->value
4689 )
4690 )
4691 }
4692
4693 ;------------------------------------------------------------------------------
4694 ; QHashIterator
4695 ;------------------------------------------------------------------------------
4696 QHashIterator<*>{
4697 preview
4698 (
4699 #(
4700 "(", ((QHashNode<$T1>*)((($c).i).i))->key, ", ", ((QHashNode<$T1>*)((($c).i).i))->key, ")"
4701 )
4702 )
4703 children
4704 (
4705 #(
4706 key: ((QHashNode<$T1>*)((($c).i).i))->key,
4707 value: ((QHashNode<$T1>*)((($c).i).i))->value
4708 )
4709 )
4710 }
4711
4712 *::QHashIterator<*>{
4713 preview
4714 (
4715 #(
4716 "(", (($T1::QHashNode<$T2>*)((($c).i).i))->key, ", ", (($T1::QHashNode<$T2>*)((($c).i).i))->key, ")"
4717 )
4718 )
4719 children
4720 (
4721 #(
4722 key: (($T1::QHashNode<$T2>*)((($c).i).i))->key,
4723 value: (($T1::QHashNode<$T2>*)((($c).i).i))->value
4724 )
4725 )
4726 }
4727
4728 ;------------------------------------------------------------------------------
4729 ; QHashNode
4730 ;------------------------------------------------------------------------------
4731 QHashNode<*>|*::QHashNode<*>{
4732 preview
4733 (
4734 #(
4735 "(key = ", $c.key,"; value = ", $c.value, ")"
4736 )
4737 )
4738 children
4739 (
4740 #(
4741 key: $c.key,
4742 value: $c.value
4743 )
4744 )
4745 }
4746
4747 ;------------------------------------------------------------------------------
4748 ; QSet
4749 ;------------------------------------------------------------------------------
4750 QSet<*>{
4751 preview
4752 (
4753 #(
4754 "[", $e.q_hash.d->size, "] (...)"
4755 )
4756 )
4757 children
4758 (
4759 #(
4760 #array (
4761 expr: (QHashNode<$T1,QHashDummyValue> *)$c.q_hash.d->buckets[$i],
4762 size: $c.q_hash.d->numBuckets
4763 ) : #list (
4764 head: $e,
4765 next: next
4766 ) : #switch ($e.next != 0) #case 1 (
4767 $e.key
4768 )
4769 )
4770 )
4771 }
4772
4773 *::QSet<*>{
4774 preview
4775 (
4776 #(
4777 "[", $e.q_hash.d->size, "] (...)"
4778 )
4779 )
4780 children
4781 (
4782 #(
4783 #array (
4784 expr: ($T1::QHashNode<$T2,QHashDummyValue> *)$c.q_hash.d->buckets[$i],
4785 size: $c.q_hash.d->numBuckets
4786 ) : #list (
4787 head: $e,
4788 next: next
4789 ) : #switch ($e.next != 0) #case 1 (
4790 $e.key
4791 )
4792 )
4793 )
4794 }
4795
4796 ;------------------------------------------------------------------------------
4797 ; QPalette
4798 ;------------------------------------------------------------------------------
4799 QPalette{
4800 children
4801 (
4802 #(
4803 WindowText_active:
4804 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+ 0)->d,
4805 Button_active:
4806 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+ 1)->d,
4807 Light_active:
4808 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+ 2)->d,
4809 Midlight_active:
4810 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+ 3)->d,
4811 Dark_active:
4812 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+ 4)->d,
4813 Mid_active:
4814 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+ 5)->d,
4815 Text_active:
4816 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+ 6)->d,
4817 BrightText_active:
4818 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+ 7)->d,
4819 ButtonText_active:
4820 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+ 8)->d,
4821 Base_active:
4822 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+ 9)->d,
4823 Window_active:
4824 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+10)->d,
4825 Shadow_active:
4826 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+11)->d,
4827 Highlight_active:
4828 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+12)->d,
4829 HighlightedText_active:
4830 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+13)->d,
4831 Link_active:
4832 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+14)->d,
4833 LinkVisited_active:
4834 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+15)->d,
4835 AlternateBase_active:
4836 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+16)->d,
4837 NoRole_active:
4838 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+17)->d,
4839 ToolTipBase_active:
4840 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+18)->d,
4841 ToolTipText_active:
4842 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+19)->d,
4843
4844 WindowText_disabled:
4845 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+ 0)->d,
4846 Button_disabled:
4847 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+ 1)->d,
4848 Light_disabled:
4849 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+ 2)->d,
4850 Midlight_disabled:
4851 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+ 3)->d,
4852 Dark_disabled:
4853 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+ 4)->d,
4854 Mid_disabled:
4855 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+ 5)->d,
4856 Text_disabled:
4857 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+ 6)->d,
4858 BrightText_disabled:
4859 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+ 7)->d,
4860 ButtonText_disabled:
4861 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+ 8)->d,
4862 Base_disabled:
4863 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+ 9)->d,
4864 Window_disabled:
4865 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+10)->d,
4866 Shadow_disabled:
4867 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+11)->d,
4868 Highlight_disabled:
4869 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+12)->d,
4870 HighlightedText_disabled:
4871 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+13)->d,
4872 Link_disabled:
4873 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+14)->d,
4874 LinkVisited_disabled:
4875 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+15)->d,
4876 AlternateBase_disabled:
4877 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+16)->d,
4878 NoRole_disabled:
4879 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+17)->d,
4880 ToolTipBase_disabled:
4881 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+18)->d,
4882 ToolTipText_disabled:
4883 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+19)->d,
4884
4885 WindowText_inactive:
4886 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+ 0)->d,
4887 Button_inactive:
4888 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+ 1)->d,
4889 Light_inactive:
4890 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+ 2)->d,
4891 Midlight_inactive:
4892 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+ 3)->d,
4893 Dark_inactive:
4894 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+ 4)->d,
4895 Mid_inactive:
4896 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+ 5)->d,
4897 Text_inactive:
4898 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+ 6)->d,
4899 BrightText_inactive:
4900 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+ 7)->d,
4901 ButtonText_inactive:
4902 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+ 8)->d,
4903 Base_inactive:
4904 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+ 9)->d,
4905 Window_inactive:
4906 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+10)->d,
4907 Shadow_inactive:
4908 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+11)->d,
4909 Highlight_inactive:
4910 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+12)->d,
4911 HighlightedText_inactive:
4912 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+13)->d,
4913 Link_inactive:
4914 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+14)->d,
4915 LinkVisited_inactive:
4916 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+15)->d,
4917 AlternateBase_inactive:
4918 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+16)->d,
4919 NoRole_inactive:
4920 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+17)->d,
4921 ToolTipBase_inactive:
4922 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+18)->d,
4923 ToolTipText_inactive:
4924 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+19)->d
4925 )
4926 )
4927 }
4928
4929 *::QPalette{
4930 children
4931 (
4932 #(
4933 WindowText_active:
4934 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+ 0)->d,
4935 Button_active:
4936 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+ 1)->d,
4937 Light_active:
4938 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+ 2)->d,
4939 Midlight_active:
4940 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+ 3)->d,
4941 Dark_active:
4942 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+ 4)->d,
4943 Mid_active:
4944 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+ 5)->d,
4945 Text_active:
4946 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+ 6)->d,
4947 BrightText_active:
4948 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+ 7)->d,
4949 ButtonText_active:
4950 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+ 8)->d,
4951 Base_active:
4952 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+ 9)->d,
4953 Window_active:
4954 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+10)->d,
4955 Shadow_active:
4956 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+11)->d,
4957 Highlight_active:
4958 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+12)->d,
4959 HighlightedText_active:
4960 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+13)->d,
4961 Link_active:
4962 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+14)->d,
4963 LinkVisited_active:
4964 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+15)->d,
4965 AlternateBase_active:
4966 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+16)->d,
4967 NoRole_active:
4968 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+17)->d,
4969 ToolTipBase_active:
4970 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+18)->d,
4971 ToolTipText_active:
4972 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+19)->d,
4973
4974 WindowText_disabled:
4975 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+ 0)->d,
4976 Button_disabled:
4977 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+ 1)->d,
4978 Light_disabled:
4979 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+ 2)->d,
4980 Midlight_disabled:
4981 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+ 3)->d,
4982 Dark_disabled:
4983 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+ 4)->d,
4984 Mid_disabled:
4985 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+ 5)->d,
4986 Text_disabled:
4987 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+ 6)->d,
4988 BrightText_disabled:
4989 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+ 7)->d,
4990 ButtonText_disabled:
4991 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+ 8)->d,
4992 Base_disabled:
4993 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+ 9)->d,
4994 Window_disabled:
4995 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+10)->d,
4996 Shadow_disabled:
4997 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+11)->d,
4998 Highlight_disabled:
4999 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+12)->d,
5000 HighlightedText_disabled:
5001 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+13)->d,
5002 Link_disabled:
5003 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+14)->d,
5004 LinkVisited_disabled:
5005 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+15)->d,
5006 AlternateBase_disabled:
5007 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+16)->d,
5008 NoRole_disabled:
5009 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+17)->d,
5010 ToolTipBase_disabled:
5011 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+18)->d,
5012 ToolTipText_disabled:
5013 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+19)->d,
5014
5015 WindowText_inactive:
5016 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+ 0)->d,
5017 Button_inactive:
5018 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+ 1)->d,
5019 Light_inactive:
5020 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+ 2)->d,
5021 Midlight_inactive:
5022 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+ 3)->d,
5023 Dark_inactive:
5024 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+ 4)->d,
5025 Mid_inactive:
5026 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+ 5)->d,
5027 Text_inactive:
5028 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+ 6)->d,
5029 BrightText_inactive:
5030 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+ 7)->d,
5031 ButtonText_inactive:
5032 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+ 8)->d,
5033 Base_inactive:
5034 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+ 9)->d,
5035 Window_inactive:
5036 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+10)->d,
5037 Shadow_inactive:
5038 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+11)->d,
5039 Highlight_inactive:
5040 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+12)->d,
5041 HighlightedText_inactive:
5042 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+13)->d,
5043 Link_inactive:
5044 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+14)->d,
5045 LinkVisited_inactive:
5046 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+15)->d,
5047 AlternateBase_inactive:
5048 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+16)->d,
5049 NoRole_inactive:
5050 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+17)->d,
5051 ToolTipBase_inactive:
5052 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+18)->d,
5053 ToolTipText_inactive:
5054 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+19)->d
5055 )
5056 )
5057 }
5058
5059 ;------------------------------------------------------------------------------
5060 ; QBrush
5061 ;------------------------------------------------------------------------------
5062 QBrush|*::QBrush{
5063 preview
5064 (
5065 #(
5066 "[", $c.d->style, "] (...)"
5067 )
5068 )
5069 children
5070 (
5071 #(
5072 style: $c.d->style,
5073 color: $c.d->color,
5074 transform: $c.d->transform
5075 )
5076 )
5077 }
5078
5079 QBrushData|*::QBrushData{
5080 preview
5081 (
5082 #(
5083 "[", $c.style, "] (...)"
5084 )
5085 )
5086 children
5087 (
5088 #(
5089 style: $c.style,
5090 color: $c.color,
5091 transform: $c.transform
5092 )
5093 )
5094 }
5095
5096 ;------------------------------------------------------------------------------
5097 ; QColor
5098 ;------------------------------------------------------------------------------
5099 QColor|*::QColor{
5100 preview
5101 (
5102 #(
5103 #if ($c.cspec == 1) (
5104 #(
5105 "[", $c.cspec, "] [", "r = ", [$c.ct.argb.red,x],
5106 ", g = ", [$c.ct.argb.green,x],
5107 ", b = ", [$c.ct.argb.blue,x], "] (...)"
5108 )
5109 ) #elif ($c.cspec == 2) (
5110 #(
5111 "[", $c.cspec, "] [", "h = ", [$c.ct.ahsv.hue,x],
5112 ", s = ", [$c.ct.ahsv.saturation,x],
5113 ", v = ", [$c.ct.ahsv.value,x], "] (...)"
5114 )
5115 ) #elif ($c.cspec == 3) (
5116 #(
5117 "[", $c.cspec, "] [", "c = ", [$c.ct.acmyk.cyan,x],
5118 ", m = ", [$c.ct.acmyk.magenta,x],
5119 ", y = ", [$c.ct.acmyk.yellow,x],
5120 ", k = ", [$c.ct.acmyk.black,x], "] (...)"
5121 )
5122 ) #else (
5123 #(
5124 "[Invalid]"
5125 )
5126 )
5127 )
5128 )
5129 children
5130 (
5131 #(
5132 #if ($c.cspec == 1) (
5133 #(
5134 red: [$c.ct.argb.red,x],
5135 green: [$c.ct.argb.green,x],
5136 blue: [$c.ct.argb.blue,x],
5137 alpha: [$c.ct.argb.alpha,x],
5138 pad: [$c.ct.argb.pad,x]
5139 )
5140 ) #elif ($c.cspec == 2) (
5141 #(
5142 hue: [$c.ct.ahsv.hue,x],
5143 saturation: [$c.ct.ahsv.saturation,x],
5144 value: [$c.ct.ahsv.value,x],
5145 alpha: [$c.ct.ahsv.alpha,x],
5146 pad: [$c.ct.ahsv.pad,x]
5147 )
5148 ) #elif ($c.cspec == 3) (
5149 #(
5150 cyan: [$c.ct.acmyk.cyan,x],
5151 magenta: [$c.ct.acmyk.magenta,x],
5152 yellow: [$c.ct.acmyk.yellow,x],
5153 black: [$c.ct.acmyk.black,x],
5154 alpha: [$c.ct.acmyk.alpha,x]
5155 )
5156 )
5157 )
5158 )
5159 }
5160
5161 ;------------------------------------------------------------------------------
5162 ; QTransform
5163 ;------------------------------------------------------------------------------
5164 QTransform|*::QTransform{
5165 preview
5166 (
5167 #(
5168 "[",[$c.affine._m11,g]," ",[$c.affine._m12,g]," ",[$c.m_13,g],"]",
5169 "[",[$c.affine._m21,g]," ",[$c.affine._m22,g]," ",[$c.m_23,g],"]",
5170 "[",[$c.affine._dx,g]," ",[$c.affine._dy,g]," ",[$c.m_33,g],"]"
5171 )
5172 )
5173 children
5174 (
5175 #(
5176 translation_horizontal_m31_dx: [$c.affine._dx,g],
5177 translation_vertical_m32_dy: [$c.affine._dy,g],
5178 scaling_horizontal_m11: [$c.affine._m11,g],
5179 scaling_vertical_m22: [$c.affine._m22,g],
5180 projection_factor_m33: [$c.m_33,g],
5181 projection_horizontal_m13: [$c.m_13,g],
5182 projection_vertical_m23: [$c.m_23,g],
5183 shearing_horizontal_m21: [$c.affine._m21,g],
5184 shearing_vertical_m12: [$c.affine._m12,g],
5185 type: $c.m_type,
5186 dirty: (bool)$c.m_dirty
5187 )
5188 )
5189 }
5190
5191 ;------------------------------------------------------------------------------
5192 ; QMatrix
5193 ;------------------------------------------------------------------------------
5194 QMatrix|*::QMatrix{
5195 preview
5196 (
5197 #(
5198 "[",[$c._m11,g]," ",[$c._m12,g],"]",
5199 "[",[$c._m21,g]," ",[$c._m22,g],"]",
5200 "[",[$c._dx,g]," ",[$c._dy,g],"]"
5201 )
5202 )
5203 children
5204 (
5205 #(
5206 translation_horizontal_dx: [$c._dx,g],
5207 translation_vertical_dy: [$c._dy,g],
5208 scaling_horizontal_m11: [$c._m11,g],
5209 scaling_vertical_m22: [$c._m22,g],
5210 shearing_horizontal_m21: [$c._m21,g],
5211 shearing_vertical_m12: [$c._m12,g]
5212 )
5213 )
5214 }
5215
5216 ;------------------------------------------------------------------------------
5217 ; QPolygon
5218 ;------------------------------------------------------------------------------
5219 QPolygon{
5220 preview
5221 (
5222 #(
5223 "[", ((QVector<QPoint>*)(&$c))->d->size, "] (...)"
5224 )
5225 )
5226 children
5227 (
5228 #(
5229 #array
5230 (
5231 expr: ((QVector<QPoint>*)(&$c))->d->array[$i],
5232 size: ((QVector<QPoint>*)(&$c))->d->size
5233 )
5234 )
5235 )
5236 }
5237
5238 *::QPolygon{
5239 preview
5240 (
5241 #(
5242 "[", (($T1::QVector<$T1::QPoint>*)(&$c))->d->size, "] (...)"
5243 )
5244 )
5245 children
5246 (
5247 #(
5248 #array
5249 (
5250 expr: (($T1::QVector<$T1::QPoint>*)(&$c))->d->array[$i],
5251 size: (($T1::QVector<$T1::QPoint>*)(&$c))->d->size
5252 )
5253 )
5254 )
5255 }
5256
5257 ;------------------------------------------------------------------------------
5258 ; QPolygonF
5259 ;------------------------------------------------------------------------------
5260 QPolygonF{
5261 preview
5262 (
5263 #(
5264 "[", ((QVector<QPointF>*)(&$c))->d->size, "] (...)"
5265 )
5266 )
5267 children
5268 (
5269 #(
5270 #array
5271 (
5272 expr: ((QVector<QPointF>*)(&$c))->d->array[$i],
5273 size: ((QVector<QPointF>*)(&$c))->d->size
5274 )
5275 )
5276 )
5277 }
5278
5279 *::QPolygonF{
5280 preview
5281 (
5282 #(
5283 "[", (($T1::QVector<$T1::QPointF>*)(&$c))->d->size, "] (...)"
5284 )
5285 )
5286 children
5287 (
5288 #(
5289 #array
5290 (
5291 expr: (($T1::QVector<$T1::QPointF>*)(&$c))->d->array[$i],
5292 size: (($T1::QVector<$T1::QPointF>*)(&$c))->d->size
5293 )
5294 )
5295 )
5296 }
5297
5298 ;------------------------------------------------------------------------------
5299 ; Nokia Qt 4.x visualizers -------------------------------------------[ end ]--
5300
5301 ; STLport visualizers
5302 ;------------------------------------------------------------------------------
5303 ; stlport::basic_string
5304 ;------------------------------------------------------------------------------
5305 stlp_std::basic_string<char,*>|stlpx_std::basic_string<char,*>|stlpmtx_std::basic_string<char,*>|stlpxmtx_std::basic_string<char,*>|stlpd_std::priv::_NonDbg_str<char,*>|stlpdx_std::priv::_NonDbg_str<char,*>|stlpdmtx_std::priv::_NonDbg_str<char,*>|stlpdxmtx_std::priv::_NonDbg_str<char,*>{
5306 preview
5307 (
5308 [$c._M_start_of_storage._M_data, s]
5309 )
5310
5311 stringview
5312 (
5313 [$c._M_start_of_storage._M_data, s]
5314 )
5315
5316 children
5317 (
5318 #(
5319 [raw view]: [$c,!],
5320 buffer: [(unsigned int)$c._M_start_of_storage._M_data, x],
5321 length: $c._M_finish - $c._M_start_of_storage._M_data,
5322 capacity: #if($c._M_start_of_storage._M_data == $c._M_buffers._M_static_buf)
5323 (
5324 $c._DEFAULT_SIZE
5325 )
5326 #else
5327 (
5328 $c._M_buffers._M_end_of_storage - $c._M_start_of_storage._M_data
5329 ),
5330 #array
5331 (
5332 expr: $c._M_start_of_storage._M_data[$i],
5333 size: $c._M_finish - $c._M_start_of_storage._M_data
5334 )
5335 )
5336 )
5337 }
5338
5339 stlp_std::basic_string<unsigned short,*>|stlp_std::basic_string<wchar_t,*>|stlpx_std::basic_string<unsigned short,*>|stlpx_std::basic_string<wchar_t,*>|stlpmtx_std::basic_string<unsigned short,*>|stlpmtx_std::basic_string<wchar_t,*>|stlpxmtx_std::basic_string<unsigned short,*>|stlpxmtx_std::basic_string<wchar_t,*>|stlpd_std::priv::_NonDbg_str<unsigned short,*>|stlpd_std::priv::_NonDbg_str<wchar_t,*>|stlpdx_std::priv::_NonDbg_str<unsigned short,*>|stlpdx_std::priv::_NonDbg_str<wchar_t,*>|stlpdmtx_std::priv::_NonDbg_str<unsigned short,*>|stlpdmtx_std::priv::_NonDbg_str<wchar_t,*>|stlpdxmtx_std::priv::_NonDbg_str<unsigned short,*>|stlpdxmtx_std::priv::_NonDbg_str<wchar_t,*>{
5340 preview
5341 (
5342 [$c._M_start_of_storage._M_data, su]
5343 )
5344
5345 stringview
5346 (
5347 [$c._M_start_of_storage._M_data, su]
5348 )
5349
5350 children
5351 (
5352 #(
5353 [raw view]: [$c,!],
5354 buffer: [(unsigned int)$c._M_start_of_storage._M_data, x],
5355 length: $c._M_finish - $c._M_start_of_storage._M_data,
5356 capacity: #if($c._M_start_of_storage._M_data == $c._M_buffers._M_static_buf)
5357 (
5358 $c._DEFAULT_SIZE
5359 )
5360 #else
5361 (
5362 $c._M_buffers._M_end_of_storage - $c._M_start_of_storage._M_data
5363 ),
5364 #array
5365 (
5366 expr: $c._M_start_of_storage._M_data[$i],
5367 size: $c._M_finish - $c._M_start_of_storage._M_data
5368 )
5369 )
5370 )
5371 }
5372
5373 stlpd_std::basic_string<*>|stlpdx_std::basic_string<*>|stlpdmtx_std::basic_string<*>|stlpdxmtx_std::basic_string<*>{
5374 preview
5375 (
5376 $c._M_non_dbg_impl
5377 )
5378
5379 stringview
5380 (
5381 $c._M_non_dbg_impl
5382 )
5383
5384 children
5385 (
5386 #(
5387 [raw view]: [$c,!],
5388 string: $c._M_non_dbg_impl
5389 )
5390 )
5391 }
5392
5393 ;------------------------------------------------------------------------------
5394 ; stlport::vector
5395 ;------------------------------------------------------------------------------
5396 stlp_std::vector<bool,*>|stlpx_std::vector<bool,*>|stlpmtx_std::vector<bool,*>|stlpxmtx_std::vector<bool,*>|stlpd_std::priv::_NonDbg_vector<bool,*>|stlpdx_std::priv::_NonDbg_vector<bool,*>|stlpdmtx_std::priv::_NonDbg_vector<bool,*>|stlpdxmtx_std::priv::_NonDbg_vector<bool,*>{
5397 preview
5398 (
5399 #(
5400 "[",
5401 ($c._M_finish._M_p - $c._M_start._M_p) * sizeof(unsigned int) * 8 + $c._M_finish._M_offset,
5402 "](",
5403 #array
5404 (
5405 expr : ($c._M_start._M_p[$i / (sizeof(unsigned int) * 8)] >> ($i % (sizeof(unsigned int) * 8))),
5406 size : (($c._M_finish._M_p - $c._M_start._M_p) * sizeof(unsigned int) * 8 + $c._M_finish._M_offset)
5407 ) : (bool)($e & 1),
5408 ")"
5409 )
5410 )
5411 children
5412 (
5413 #(
5414 [raw view]: [$c,!],
5415 buffer : [(unsigned int)$c._M_start._M_p, x],
5416 size : (($c._M_finish._M_p - $c._M_start._M_p) * sizeof(unsigned int) * 8 + $c._M_finish._M_offset),
5417 #array
5418 (
5419 expr : ($c._M_start._M_p[$i / (sizeof(unsigned int) * 8)] >> ($i % (sizeof(unsigned int) * 8))),
5420 size : (($c._M_finish._M_p - $c._M_start._M_p) * sizeof(unsigned int) * 8 + $c._M_finish._M_offset)
5421 ) : (bool)($e & 1)
5422 )
5423 )
5424 }
5425
5426 stlp_std::priv::_Bit_iter<*>|stlpx_std::priv::_Bit_iter<*>|stlpmtx_std::priv::_Bit_iter<*>|stlpxmtx_std::priv::_Bit_iter<*>|stlpd_std::priv::_Bit_iter<*>|stlpdx_std::priv::_Bit_iter<*>|stlpdmtx_std::priv::::_Bit_iter<*>|stlpdxmtx_std::priv::_Bit_iter<*>{
5427 preview
5428 (
5429 #(
5430 (bool) (((*$c._M_p) >> $c._M_offset) & 1)
5431 )
5432 )
5433 children
5434 (
5435 #(
5436 [raw view]: [$c,!],
5437 value : (bool) (((*$c._M_p) >> $c._M_offset) & 1)
5438 )
5439 )
5440 }
5441
5442 stlp_std::vector<*>|stlpx_std::vector<*>|stlpmtx_std::vector<*>|stlpxmtx_std::vector<*>|stlpd_std::priv::_NonDbg_vector<*>|stlpdx_std::priv::_NonDbg_vector<*>|stlpdmtx_std::priv::_NonDbg_vector<*>|stlpdxmtx_std::priv::_NonDbg_vector<*>{
5443 preview
5444 (
5445 #(
5446 "[",
5447 $c._M_finish - $c._M_start,
5448 "/",
5449 $c._M_end_of_storage._M_data - $c._M_start,
5450 "](",
5451 #array
5452 (
5453 expr : ($c._M_start)[$i],
5454 size : $c._M_finish - $c._M_start
5455 ),
5456 ")"
5457 )
5458 )
5459 children
5460 (
5461 #(
5462 [raw view]: [$c,!],
5463 size : $c._M_finish - $c._M_start,
5464 capacity : $c._M_end_of_storage._M_data - $c._M_start,
5465 #array
5466 (
5467 expr : ($c._M_start)[$i],
5468 size : $c._M_finish - $c._M_start
5469 )
5470 )
5471 )
5472 }
5473
5474 stlpd_std::vector<*>|stlpdx_std::vector<*>|stlpdmtx_std::vector<*>|stlpdxmtx_std::vector<*>{
5475 preview
5476 (
5477 $c._M_non_dbg_impl
5478 )
5479 children
5480 (
5481 #(
5482 [raw view] : [$c,!],
5483 vector : $c._M_non_dbg_impl
5484 )
5485 )
5486 }
5487
5488 ;------------------------------------------------------------------------------
5489 ; stlport::deque
5490 ;------------------------------------------------------------------------------
5491 stlp_std::deque<*,*>|stlpx_std::deque<*,*>|stlpmtx_std::deque<*,*>|stlpxmtx_std::deque<*,*>|stlpd_std::priv::_NonDbg_deque<*,*>|stlpdx_std::priv::_NonDbg_deque<*,*>|stlpdmtx_std::priv::_NonDbg_deque<*,*>|stlpdxmtx_std::priv::_NonDbg_deque<*,*>{
5492 preview
5493 (
5494 #if (((unsigned int)($c._M_start._M_cur + 1) - ((unsigned int)$c._M_start._M_cur)) < _MAX_BYTES)
5495 (
5496 #(
5497 "[",
5498 (($c._M_finish._M_node - $c._M_start._M_node + 1) * (_MAX_BYTES / sizeof($T1))) - ($c._M_start._M_cur - $c._M_start._M_first) - ($c._M_finish._M_last - $c._M_finish._M_cur),
5499 "/",
5500 ($c._M_finish._M_node - $c._M_start._M_node + 1) * (_MAX_BYTES / sizeof($T1)) - 1,
5501 "](",
5502 #array
5503 (
5504 expr : *(*($c._M_start._M_node + (($i + ($c._M_start._M_cur - $c._M_start._M_first)) / (_MAX_BYTES / sizeof($T1)))) + (($i + ($c._M_start._M_cur - $c._M_start._M_first)) % (_MAX_BYTES / sizeof($T1)))),
5505 size : (($c._M_finish._M_node - $c._M_start._M_node + 1) * (_MAX_BYTES / sizeof($T1))) - ($c._M_start._M_cur - $c._M_start._M_first) - ($c._M_finish._M_last - $c._M_finish._M_cur)
5506 ),
5507 ")"
5508 )
5509 )
5510 #else
5511 (
5512 #(
5513 "[",
5514 $c._M_finish._M_node - $c._M_start._M_node,
5515 "/",
5516 $c._M_finish._M_node - $c._M_start._M_node,
5517 "](",
5518 #array
5519 (
5520 expr : **($c._M_start._M_node + $i),
5521 size : $c._M_finish._M_node - $c._M_start._M_node
5522 ),
5523 ")"
5524 )
5525 )
5526 )
5527 children
5528 (
5529 #if (((unsigned int)($c._M_start._M_cur + 1) - ((unsigned int)$c._M_start._M_cur)) < _MAX_BYTES)
5530 (
5531 #(
5532 [raw view]: [$c,!],
5533 size : (($c._M_finish._M_node - $c._M_start._M_node + 1) * (_MAX_BYTES / sizeof($T1))) - ($c._M_start._M_cur - $c._M_start._M_first) - ($c._M_finish._M_last - $c._M_finish._M_cur),
5534 capacity : ($c._M_finish._M_node - $c._M_start._M_node + 1) * (_MAX_BYTES / sizeof($T1)) - 1,
5535 front free space : $c._M_start._M_cur - $c._M_start._M_first,
5536 back free space : $c._M_finish._M_last - $c._M_finish._M_cur - 1,
5537 #array
5538 (
5539 expr : *(*($c._M_start._M_node + (($i + ($c._M_start._M_cur - $c._M_start._M_first)) / (_MAX_BYTES / sizeof($T1)))) + (($i + ($c._M_start._M_cur - $c._M_start._M_first)) % (_MAX_BYTES / sizeof($T1)))),
5540 size : (($c._M_finish._M_node - $c._M_start._M_node + 1) * (_MAX_BYTES / sizeof($T1))) - ($c._M_start._M_cur - $c._M_start._M_first) - ($c._M_finish._M_last - $c._M_finish._M_cur)
5541 )
5542 )
5543 )
5544 #else
5545 (
5546 #(
5547 [raw view] : [$c,!],
5548 size : $c._M_finish._M_node - $c._M_start._M_node,
5549 capacity : $c._M_finish._M_node - $c._M_start._M_node,
5550 front free space : $c._M_start._M_cur - $c._M_start._M_first,
5551 back free space : $c._M_finish._M_last - $c._M_finish._M_cur - 1,
5552 #array
5553 (
5554 expr : **($c._M_start._M_node + $i),
5555 size : $c._M_finish._M_node - $c._M_start._M_node
5556 )
5557 )
5558 )
5559 )
5560 }
5561
5562 stlp_std::priv::_Deque_iterator<*>|stlpx_std::priv::_Deque_iterator<*>|stlpmtx_std::priv::_Deque_iterator<*>|stlpxmtx_std::priv::_Deque_iterator<*>|stlpd_std::priv::_Deque_iterator<*>|stlpdx_std::priv::_Deque_iterator<*>|stlpdmtx_std::priv::_Deque_iterator<*>|stlpdxmtx_std::priv::_Deque_iterator<*>{
5563 preview
5564 (
5565 *($c._M_cur)
5566 )
5567 children
5568 (
5569 #(
5570 [raw view] : [$c, !],
5571 ptr : [(unsigned int)($c._M_cur), x],
5572 value : *($c._M_cur)
5573 )
5574 )
5575 }
5576
5577 stlpd_std::deque<*>|stlpdx_std::deque<*>|stlpdmtx_std::deque<*>|stlpdxmtx_std::deque<*>{
5578 preview
5579 (
5580 $c._M_non_dbg_impl
5581 )
5582 children
5583 (
5584 #(
5585 [raw view] : [$c,!],
5586 deque : $c._M_non_dbg_impl
5587 )
5588 )
5589 }
5590
5591 ;------------------------------------------------------------------------------
5592 ; stlport::list
5593 ;------------------------------------------------------------------------------
5594 stlp_std::list<*,*>|stlpx_std::list<*,*>|stlpmtx_std::list<*,*>|stlpxmtx_std::list<*,*>|stlpd_std::priv::_NonDbg_list<*,*>|stlpdx_std::priv::_NonDbg_list<*,*>|stlpdmtx_std::priv::_NonDbg_list<*,*>|stlpdxmtx_std::priv::_NonDbg_list<*,*>{
5595 preview
5596 (
5597 #(
5598 "(",
5599 #list
5600 (
5601 head : $c._M_node._M_data._M_next,
5602 skip : &($c._M_node._M_data),
5603 next : _M_next,
5604 ): #( *($T1*)(&($e) + 1)),
5605 ")"
5606 )
5607 )
5608 children
5609 (
5610 #(
5611 [raw view]: [$c,!],
5612 #list
5613 (
5614 head : $c._M_node._M_data._M_next,
5615 skip : &($c._M_node._M_data),
5616 next : _M_next,
5617 ): #( *($T1*)(&($e) + 1))
5618 )
5619 )
5620 }
5621
5622 stlp_std::priv::_List_iterator<*,*>|stlpx_std::priv::_List_iterator<*,*>|stlpmtx_std::priv::_List_iterator<*,*>|stlpxmtx_std::priv::_List_iterator<*,*>|stlpd_std::priv::_List_iterator<*,*>|stlpdx_std::priv::_List_iterator<*,*>|stlpdmtx_std::priv::_List_iterator<*,*>|stlpdxmtx_std::priv::_List_iterator<*,*>{
5623 preview
5624 (
5625 #(*($T1 *)($c._M_node + 1))
5626 )
5627 children
5628 (
5629 #(
5630 [raw view] : [$c, !],
5631 ptr : [(unsigned int)($c._M_node + 1), x],
5632 value : *($T1 *)($c._M_node + 1)
5633 )
5634 )
5635 }
5636
5637 stlpd_std::list<*,*>|stlpdx_std::list<*,*>|stlpdmtx_std::list<*,*>|stlpdxmtx_std::list<*,*>{
5638 preview
5639 (
5640 $c._M_non_dbg_impl
5641 )
5642 children
5643 (
5644 #(
5645 [raw view] : [$c,!],
5646 list : $c._M_non_dbg_impl
5647 )
5648 )
5649 }
5650
5651 ;------------------------------------------------------------------------------
5652 ; stlport::slist
5653 ;------------------------------------------------------------------------------
5654 stlp_std::slist<*,*>|stlpx_std::slist<*,*>|stlpmtx_std::slist<*,*>|stlpxmtx_std::slist<*,*>|stlpd_std::priv::_NonDbg_slist<*,*>|stlpdx_std::priv::_NonDbg_slist<*,*>|stlpdmtx_std::priv::_NonDbg_slist<*,*>|stlpdxmtx_std::priv::_NonDbg_slist<*,*>{
5655 preview
5656 (
5657 #(
5658 "(",
5659 #list
5660 (
5661 head : $c._M_head._M_data._M_next,
5662 skip : &($c._M_head._M_data),
5663 next : _M_next,
5664 ): #( *($T1*)(&($e) + 1)),
5665 ")"
5666 )
5667 )
5668 children
5669 (
5670 #(
5671 [raw view]: [$c,!],
5672 #list
5673 (
5674 head : $c._M_head._M_data._M_next,
5675 skip : &($c._M_head._M_data),
5676 next : _M_next,
5677 ): #( *($T1*)(&($e) + 1))
5678 )
5679 )
5680 }
5681
5682 stlp_std::priv::_Slist_iterator<*,*>|stlpx_std::priv::_Slist_iterator<*,*>|stlpmtx_std::priv::_Slist_iterator<*,*>|stlpxmtx_std::priv::_Slist_iterator<*,*>|stlpd_std::priv::_Slist_iterator<*,*>|stlpdx_std::priv::_Slist_iterator<*,*>|stlpdmtx_std::priv::_Slist_iterator<*,*>|stlpdxmtx_std::priv::_Slist_iterator<*,*>{
5683 preview
5684 (
5685 #(*($T1 *)($c._M_node + 1))
5686 )
5687 children
5688 (
5689 #(
5690 [raw view] : [$c,!],
5691 ptr : [(unsigned int)($c._M_node + 1), x],
5692 value : *($T1 *)($c._M_node + 1)
5693 )
5694 )
5695 }
5696
5697 stlpd_std::slist<*,*>|stlpdx_std::slist<*,*>|stlpdmtx_std::slist<*,*>|stlpdxmtx_std::slist<*,*>{
5698 preview
5699 (
5700 $c._M_non_dbg_impl
5701 )
5702 children
5703 (
5704 #(
5705 [raw view] : [$c,!],
5706 [slist] : $c._M_non_dbg_impl
5707 )
5708 )
5709 }
5710
5711 ;------------------------------------------------------------------------------
5712 ; stlport::pair
5713 ;------------------------------------------------------------------------------
5714 stlp_std::pair<*,*>|stlpx_std::pair<*,*>|stlpmtx_std::pair<*,*>|stlpxmtx_std::pair<*,*>|stlpd_std::pair<*,*>|stlpdx_std::pair<*,*>|stlpdmtx_std::pair<*,*>|stlpdxmtx_std::pair<*,*>{
5715 preview
5716 (
5717 #(
5718 "(",
5719 $c.first,
5720 ", ",
5721 $c.second,
5722 ")"
5723 )
5724 )
5725 }
5726
5727 ;------------------------------------------------------------------------------
5728 ; stlport::map, stlport::multimap, stlport::set, stlport::multiset
5729 ;------------------------------------------------------------------------------
5730 stlp_std::map<*>|stlpx_std::map<*>|stlpmtx_std::map<*>|stlpxmtx_std::map<*>|stlp_std::multimap<*>|stlpx_std::multimap<*>|stlpmtx_std::multimap<*>|stlpxmtx_std::multimap<*>|stlp_std::set<*>|stlpx_std::set<*>|stlpmtx_std::set<*>|stlpxmtx_std::set<*>|stlp_std::multiset<*>|stlpx_std::multiset<*>|stlpmtx_std::multiset<*>|stlpxmtx_std::multiset<*>{
5731 preview
5732 (
5733 #(
5734 "[",
5735 $c._M_t._M_node_count,
5736 "](",
5737 $c._M_t,
5738 ")"
5739 )
5740 )
5741 children
5742 (
5743 #(
5744 [raw view]: [$c,!],
5745 size: [$c._M_t._M_node_count],
5746 tree: $c._M_t
5747 )
5748 )
5749 }
5750
5751 stlpd_std::map<*>|stlpdx_std::map<*>|stlpdmtx_std::map<*>|stlpdxmtx_std::map<*>|stlpd_std::multimap<*>|stlpdx_std::multimap<*>|stlpdmtx_std::multimap<*>|stlpdxmtx_std::multimap<*>|stlpd_std::set<*>|stlpdx_std::set<*>|stlpdmtx_std::set<*>|stlpdxmtx_std::set<*>|stlpd_std::multiset<*>|stlpdx_std::multiset<*>|stlpdmtx_std::multiset<*>|stlpdxmtx_std::multiset<*>{
5752 preview
5753 (
5754 #(
5755 "[",
5756 $c._M_t._M_non_dbg_impl._M_node_count,
5757 "](",
5758 $c._M_t._M_non_dbg_impl,
5759 ")"
5760 )
5761 )
5762 children
5763 (
5764 #(
5765 [raw view]: [$c,!],
5766 size: $c._M_t._M_non_dbg_impl._M_node_count,
5767 tree: $c._M_t._M_non_dbg_impl
5768 )
5769 )
5770 }
5771
5772 stlp_std::priv::_Rb_tree<*,*,*,*,*>|stlpx_std::priv::_Rb_tree<*,*,*,*,*>|stlpmtx_std::priv::_Rb_tree<*,*,*,*,*>|stlpxmtx_std::priv::_Rb_tree<*,*,*,*,*>|stlpd_std::priv::_NonDbg_Rb_tree<*,*,*,*,*>|stlpdx_std::priv::_NonDbg_Rb_tree<*,*,*,*,*>|stlpdmtx_std::priv::_NonDbg_Rb_tree<*,*,*,*,*>|stlpdxmtx_std::priv::_NonDbg_Rb_tree<*,*,*,*,*>{
5773 preview
5774 (
5775 #tree
5776 (
5777 head : $c._M_header._M_data._M_parent,
5778 skip : &($c._M_header._M_data),
5779 size : $c._M_node_count,
5780 left : _M_left,
5781 right : _M_right
5782 ): #(*($T3 *)(&($e) + 1))
5783 )
5784 children
5785 (
5786 #(
5787 [raw view]: [$c,!],
5788 #tree
5789 (
5790 head : $c._M_header._M_data._M_parent,
5791 skip : &($c._M_header._M_data),
5792 size : $c._M_node_count,
5793 left : _M_left,
5794 right : _M_right
5795 ) : #(*($T3 *)(&($e) + 1))
5796 )
5797 )
5798 }
5799
5800 stlp_std::priv::_Rb_tree_iterator<*,*>|stlpx_std::priv::_Rb_tree_iterator<*,*>|stlpmtx_std::priv::_Rb_tree_iterator<*,*>|stlpxmtx_std::priv::_Rb_tree_iterator<*,*>|stlpd_std::priv::_Rb_tree_iterator<*,*>|stlpdx_std::priv::_Rb_tree_iterator<*,*>|stlpdmtx_std::priv::_Rb_tree_iterator<*,*>|stlpdxmtx_std::priv::_Rb_tree_iterator<*,*>{
5801 preview
5802 (
5803 [*($T1*)($c._M_node + 1)]
5804 )
5805 children
5806 (
5807 #(
5808 [raw view]: [$c,!],
5809 value: [*($T1*)($c._M_node + 1)],
5810 ptr: [(unsigned int)($c._M_node + 1), x]
5811 )
5812 )
5813 }
5814
5815 ;------------------------------------------------------------------------------
5816 ; stlport::hash_map, stlport::hash_multimap, stlport::hash_set, stlport::hash_multiset
5817 ; stlport::unordered_map, stlport::unordered_multimap, stlport::unordered_set, stlport::unordered_multiset
5818 ;------------------------------------------------------------------------------
5819 stlp_std::hash_map<*>|stlpx_std::hash_map<*>|stlpmtx_std::hash_map<*>|stlpxmtx_std::hash_map<*>|stlp_std::hash_multimap<*>|stlpx_std::hash_multimap<*>|stlpmtx_std::hash_multimap<*>|stlpxmtx_std::hash_multimap<*>|stlp_std::hash_set<*>|stlpx_std::hash_set<*>|stlpmtx_std::hash_set<*>|stlpxmtx_std::hash_set<*>|stlp_std::hash_multiset<*>|stlpx_std::hash_multiset<*>|stlpmtx_std::hash_multiset<*>|stlpxmtx_std::hash_multiset<*>|stlp_std::tr1::unordered_map<*>|stlpx_std::tr1::unordered_map<*>|stlpmtx_std::tr1::unordered_map<*>|stlpxmtx_std::tr1::unordered_map<*>|stlp_std::tr1::unordered_multimap<*>|stlpx_std::tr1::unordered_multimap<*>|stlpmtx_std::tr1::unordered_multimap<*>|stlpxmtx_std::tr1::unordered_multimap<*>|stlp_std::tr1::unordered_set<*>|stlpx_std::tr1::unordered_set<*>|stlpmtx_std::tr1::unordered_set<*>|stlpxmtx_std::tr1::unordered_set<*>|stlp_std::tr1::unordered_multiset<*>|stlpx_std::tr1::unordered_multiset<*>|stlpmtx_std::tr1::unordered_multiset<*>|stlpxmtx_std::tr1::unordered_multiset<*>{
5820 preview
5821 (
5822 #(
5823 "[",
5824 $c._M_ht._M_num_elements,
5825 "]",
5826 $c._M_ht
5827 )
5828 )
5829 children
5830 (
5831 #(
5832 [raw view]: [$c,!],
5833 hashtable: $c._M_ht
5834 )
5835 )
5836 }
5837
5838 stlpd_std::hash_map<*>|stlpdx_std::hash_map<*>|stlpdmtx_std::hash_map<*>|stlpdxmtx_std::hash_map<*>|stlpd_std::hash_multimap<*>|stlpdx_std::hash_multimap<*>|stlpdmtx_std::hash_multimap<*>|stlpdxmtx_std::hash_multimap<*>|stlpd_std::hash_set<*>|stlpdx_std::hash_set<*>|stlpdmtx_std::hash_set<*>|stlpdxmtx_std::hash_set<*>|stlpd_std::hash_multiset<*>|stlpdx_std::hash_multiset<*>|stlpdmtx_std::hash_multiset<*>|stlpdxmtx_std::hash_multiset<*>|stlpd_std::tr1::unordered_map<*>|stlpdx_std::tr1::unordered_map<*>|stlpdmtx_std::tr1::unordered_map<*>|stlpdxmtx_std::tr1::unordered_map<*>|stlpd_std::tr1::unordered_multimap<*>|stlpdx_std::tr1::unordered_multimap<*>|stlpdmtx_std::tr1::unordered_multimap<*>|stlpdxmtx_std::tr1::unordered_multimap<*>|stlpd_std::tr1::unordered_set<*>|stlpdx_std::tr1::unordered_set<*>|stlpdmtx_std::tr1::unordered_set<*>|stlpdxmtx_std::tr1::unordered_set<*>|stlpd_std::tr1::unordered_multiset<*>|stlpdx_std::tr1::unordered_multiset<*>|stlpdmtx_std::tr1::unordered_multiset<*>|stlpdxmtx_std::tr1::unordered_multiset<*>{
5839 preview
5840 (
5841 #(
5842 "[",
5843 $c._M_ht._M_non_dbg_impl._M_num_elements,
5844 "]",
5845 $c._M_ht._M_non_dbg_impl
5846 )
5847 )
5848 children
5849 (
5850 #(
5851 [raw view]: [$c,!],
5852 hashtable: $c._M_ht._M_non_dbg_impl
5853 )
5854 )
5855 }
5856
5857 stlp_std::hashtable<*,*>|stlpx_std::hashtable<*,*>|stlpmtx_std::hashtable<*,*>|stlpxmtx_std::hashtable<*,*>|stlpd_std::priv::_NonDbg_hashtable<*,*>|stlpdx_std::priv::_NonDbg_hashtable<*,*>|stlpdmtx_std::priv::_NonDbg_hashtable<*,*>|stlpdxmtx_std::priv::_NonDbg_hashtable<*,*>{
5858 preview
5859 (
5860 $c._M_elems
5861 )
5862 children
5863 (
5864 #(
5865 [raw view]: [$c,!],
5866 size : $c._M_num_elements,
5867 load factor : (float)$c._M_num_elements / ($c._M_buckets._M_finish - $c._M_buckets._M_start),
5868 max load factor: $c._M_max_load_factor,
5869 buckets : $c._M_buckets,
5870 elements : $c._M_elems
5871 )
5872 )
5873 }
5874
5875 ;------------------------------------------------------------------------------
5876 ; stlport::queue, stlport::priority_queue, stlport::stack
5877 ;------------------------------------------------------------------------------
5878 stlp_std::queue<*>|stlpx_std::queue<*>|stlpmtx_std::queue<*>|stlpxmtx_std::queue<*>|stlpd_std::queue<*>|stlpdx_std::queue<*>|stlpdmtx_std::queue<*>|stlpdxmtx_std::queue<*>|stlp_std::priority_queue<*>|stlpx_std::priority_queue<*>|stlpmtx_std::priority_queue<*>|stlpxmtx_std::priority_queue<*>|stlpd_std::priority_queue<*>|stlpdx_std::priority_queue<*>|stlpdmtx_std::priority_queue<*>|stlpdxmtx_std::priority_queue<*>|stlp_std::stack<*>|stlpx_std::stack<*>|stlpmtx_std::stack<*>|stlpxmtx_std::stack<*>|stlpd_std::stack<*>|stlpdx_std::stack<*>|stlpdmtx_std::stack<*>|stlpdxmtx_std::stack<*>{
5879 preview
5880 (
5881 $c.c
5882 )
5883 children
5884 (
5885 #(
5886 [raw view] : [$c,!],
5887 container : $c.c
5888 )
5889 )
5890 }
5891
5892 ;------------------------------------------------------------------------------
5893 ; stlport debug iterator
5894 ;------------------------------------------------------------------------------
5895 stlp_std::priv::_DBG_iter<*>|stlpx_std::priv::_DBG_iter<*>|stlpmtx_std::priv::_DBG_iter<*>|stlpxmtx_std::priv::_DBG_iter<*>|stlpd_std::priv::_DBG_iter<*>|stlpdx_std::priv::_DBG_iter<*>|stlpdmtx_std::priv::_DBG_iter<*>|stlpdxmtx_std::priv::_DBG_iter<*>{
5896 preview
5897 (
5898 #if($c._M_owner != 0)
5899 (
5900 $c._M_iterator
5901 )
5902 #else
5903 (
5904 "undefined"
5905 )
5906 )
5907 children
5908 (
5909 #(
5910 #if($c._M_owner != 0)
5911 (
5912 #(
5913 [raw view] : [$c,!],
5914 [iterator] : $c._M_iterator,
5915 [valid] : [true]
5916 )
5917 )
5918 #else
5919 (
5920 #(
5921 [raw view] : [$c,!],
5922 [valid] : [false]
5923 )
5924 )
5925 )
5926 )
5927 }
5928
5929 ;------------------------------------------------------------------------------
5930 ; stlport::bitset
5931 ; TODO: Fix it, it doesn't work as expected even when adding an enum to the bitset
5932 ; class to get access to the bitset static size rather than using $T1.
5933 ;------------------------------------------------------------------------------
5934 stdp_std::bitset<*,*>|stdpx_std::bitset<*,*>|stdpmtx_std::bitset<*,*>|stdpxmtx_std::bitset<*,*>|stdpd_std::bitset<*>|stdpdx_std::bitset<*>|stdpdmtx_std::bitset<*>|stdpdxmtx_std::bitset<*>{
5935 preview
5936 (
5937 #(
5938 "[",
5939 $T1,
5940 "](",
5941 #array
5942 (
5943 expr : ($c._M_w[$i / (sizeof(unsigned long) * 8)] >> ($i % (sizeof(unsigned long) * 8))),
5944 size : $T1
5945 ) : [($e & 1),d],
5946 ")"
5947 )
5948 )
5949 children
5950 (
5951 #array
5952 (
5953 expr : ($c._M_w[$i / (sizeof(unsigned long) * 8)] >> ($i % (sizeof(unsigned long) * 8))),
5954 size : $T1
5955 ) : (bool)($e & 1)
5956 )
5957 }
5958
5959 stdp_std::bitset<*>::reference|stdpx_std::bitset<*>::reference|stdpmtx_std::bitset<*>::reference|stdpxmtx_std::bitset<*>::reference|stdpd_std::bitset<*>::reference|stdpdx_std::bitset<*>::reference|stdpdmtx_std::bitset<*>::reference|stdpdxmtx_std::bitset<*>{
5960 preview
5961 (
5962 #(
5963 "bitset[", $c._M_bpos, "] = ",
5964 (bool)(*($c._M_wp) >> $c._M_bpos) & 1)
5965 )
5966 )
5967 }
5968
5969 ;------------------------------------------------------------------------------
5970 ; stlport::auto_ptr
5971 ;------------------------------------------------------------------------------
5972 stlp_std::auto_ptr<*>|stlpx_std::auto_ptr<*>|stlpmtx_std::auto_ptr<*>|stlpxmtx_std::auto_ptr<*>|stlpd_std::auto_ptr<*>|stlpdx_std::auto_ptr<*>|stlpdmtx_std::auto_ptr<*>|stlpdxmtx_std::auto_ptr<*>{
5973 preview
5974 (
5975 #if(($c._M_p) != 0)
5976 (
5977 [*($T1 *)$c._M_p]
5978 )
5979 #else
5980 (
5981 "null"
5982 )
5983 )
5984 children
5985 (
5986 #if(($c._M_p) != 0)
5987 (
5988 #(
5989 [raw view]: [$c,!],
5990 ptr: [(unsigned int)$c._M_p, x],
5991 value: [*($T1 *)$c._M_p]
5992 )
5993 )
5994 #else
5995 (
5996 #(
5997 [raw view]: [$c,!]
5998 )
5999 )
6000 )
6001 }
6002
6003 ;------------------------------------------------------------------------------
6004 ; stlport::complex
6005 ;------------------------------------------------------------------------------
6006 stlp_std::complex<*>|stlpx_std::complex<*>|stlpmtx_std::complex<*>|stlpxmtx_std::complex<*>|stlpd_std::complex<*>|stlpdx_std::complex<*>|stlpdmtx_std::complex<*>|stlpdxmtx_std::complex<*>{
6007 children
6008 (
6009 #(
6010 real: $e._M_re,
6011 imaginary: $e._M_im
6012 )
6013 )
6014 preview
6015 (
6016 #if($e._M_im != 0)
6017 (
6018 #if ($e._M_re != 0)
6019 ( ; Real and Imaginary components
6020 #if ($e._M_im >= 0)
6021 (
6022 #($e._M_re,"+i*", $e._M_im)
6023 )
6024 #else
6025 (
6026 #($e._M_re,"-i*", -$e._M_im)
6027 )
6028 )
6029 #else
6030 ( ; Purely imaginary
6031 #if ($e._M_im >= 0.0)
6032 (
6033 #("i*", $e._M_im)
6034 )
6035 #else
6036 (
6037 #("-i*", -$e._M_im)
6038 )
6039 )
6040 )
6041 #else
6042 ( ; Purely real
6043 $e._M_re
6044 )
6045 )
6046 }
6047
6048 ;------------------------------------------------------------------------------
6049 ; stlport::valarray
6050 ;------------------------------------------------------------------------------
6051
6052 stlp_std::valarray<*>|stlpx_std::valarray<*>|stlpmtx_std::valarray<*>|stlpxmtx_std::valarray<*>|stlpd_std::valarray<*>|stlpdx_std::valarray<*>|stlpdmtx_std::valarray<*>|stlpdxmtx_std::valarray<*>{
6053 preview
6054 (
6055 #(
6056 "[",
6057 $c._M_size ,
6058 "](",
6059 #array
6060 (
6061 expr : ($c._M_first)[$i],
6062 size : $c._M_size
6063 ),
6064 ")"
6065 )
6066 )
6067
6068 children
6069 (
6070 #array
6071 (
6072 expr : ($c._M_first)[$i],
6073 size : $c._M_size
6074 )
6075 )
6076 }
6077
6078 stlp_std::slice|stlpx_std::slice|stlpmtx_std::slice|stlpxmtx_std::slice|stlpd_std::slice|stlpdx_std::slice|stlpdmtx_std::slice|stlpdxmtx_std::slice{
6079 preview
6080 (
6081 #(
6082 "start = ",
6083 $c._M_start,
6084 ", size = ",
6085 $c._M_length,
6086 ", stride = ",
6087 $c._M_stride
6088 )
6089 )
6090 children
6091 (
6092 #(
6093 [raw view] : [$c,!],
6094 start : $c._M_start,
6095 size : $c._M_length,
6096 stride : $c._M_stride
6097 )
6098 )
6099 }
6100
6101 stlp_std::gslice|stlpx_std::gslice|stlpmtx_std::gslice|stlpxmtx_std::gslice|stlpd_std::gslice|stlpdx_std::gslice|stlpdmtx_std::gslice|stlpdxmtx_std::gslice{
6102 preview
6103 (
6104 #(
6105 "start = ",
6106 $c._M_start,
6107 ", sizes = ",
6108 $c._M_lengths,
6109 ", strides = ",
6110 $c._M_strides
6111 )
6112 )
6113 children
6114 (
6115 #(
6116 [raw view] : [$c,!],
6117 start : $c._M_start,
6118 sizes : $c._M_lengths,
6119 strides : $c._M_strides
6120 )
6121 )
6122 }
6123
6124 ; This section lets you define your own errors for the HRESULT display.
6125 ; You need to list the error code in unsigned decimal, followed by the message.
6126 ; Changes will take effect the next time you redisplay the variable.
6127
6128 [hresult]
6129 ;1234=my custom error code
6130