Merge pull request #1668 from Dmitry-Me/assignmentOpReturningUnsuitableType
[platform/upstream/coreclr.git] / src / AUTOEXP.DAT
1 ;---------------------------------------------------------------
2 ; This comment block added by the CLR dev team.
3 ;
4 ; This is a custom autoexp.dat that causes VS2005 to nicely
5 ; pretty-print common CLR data types (MethodDesc, EEClass, etc.)
6 ; in the debugger watch window. For example, instead of
7 ; seeing
8 ;
9 ;     pString     {...}         
10 ;
11 ; you will see the more useful
12 ;
13 ;     pString     {0x<addr> "Hello" }
14 ;
15 ;
16 ;
17 ;
18 ; To use this file, replace the autoexp.dat file in your VS
19 ; installation with this one. This file is normally found under
20 ; this path:
21 ;
22 ;    C:\Program Files\Microsoft Visual Studio 8\Common7\Packages\Debugger
23 ;
24 ; If you have your own custom rules that you don't want messed
25 ; up or you're just healthily paranoid, you can cut and paste
26 ; the CLR-specific section only. The section begins with
27 ;
28 ;   ;---- [BEGIN] CLR-specific autoexps ---------------------------
29 ;
30 ; and ends with
31 ;
32 ;   ;---- [END] CLR-specific autoexps ---------------------------
33 ;
34 ; Note that this *must* go into the [AutoExpand] section of the file.
35 ; Don't just append to the end of the file or the debugger won't
36 ; see it.
37 ;
38
39 ;
40 ;---------------------------------------------------------------
41
42
43
44
45
46
47
48
49 ;---------------------------------------------------------------
50 ; AutoExp.Dat - templates for automatically expanding data
51 ; Licensed to the .NET Foundation under one or more agreements.
52 ; The .NET Foundation licenses this file to you under the MIT license.
53 ; See the LICENSE file in the project root for more information.
54 ;---------------------------------------------------------------
55 ;
56 ; While debugging, Data Tips and items in the Watch and Variable
57 ; windows are automatically expanded to show their most important
58 ; elements. The expansion follows the format given by the rules
59 ; in this file. You can add rules for your types or change the
60 ; predefined rules.
61 ;
62 ; For good examples, read the rules in this file.
63 ;
64 ; To find what the debugger considers the type of a variable to
65 ; be, add it to the Watch window and look at the Type column.
66 ;
67 ; An AutoExpand rule is a line with the name of a type, an equals 
68 ; sign, and text with replaceable parts in angle brackets. The 
69 ; part in angle brackets names a member of the type and an 
70 ; optional Watch format specifier.
71 ;
72 ; AutoExpand rules use the following syntax. The equals sign (=), 
73 ; angle brackets (<>), and comma are taken literally. Square
74 ; brackets ([]) indicate optional items.
75 ;
76 ; type=[text]<member[,format]>...
77 ;
78 ; type      Name of the type (may be followed by <*> for template
79 ;           types such as the ATL types listed below).
80 ;
81 ; text      Any text.Usually the name of the member to display, 
82 ;           or a shorthand name for the member.
83 ;
84 ; member    Name of a member to display.
85 ;
86 ; format    Watch format specifier. One of the following:
87 ;
88 ;   Letter  Description                 Sample         Display
89 ;   ------  --------------------------  ------------   -------------
90 ;   d,i     Signed decimal integer      0xF000F065,d   -268373915
91 ;   u       Unsigned decimal integer    0x0065,u       101
92 ;   o       Unsigned octal integer      0xF065,o       0170145
93 ;   x,X     Hexadecimal integer         61541,X        0X0000F065
94 ;   l,h     long or short prefix for    00406042,hx    0x0c22
95 ;             d, i, u, o, x, X
96 ;   f       Signed floating-point       3./2.,f        1.500000
97 ;   e       Signed scientific-notation  3./2.,e        1.500000e+000
98 ;   g       Shorter of e and f          3./2.,g        1.5
99 ;   c       Single character            0x0065,c       'e'
100 ;   s       Zero-terminated string      pVar,s         "Hello world"
101 ;   su      Unicode string              pVar,su        "Hello world"
102 ;
103 ; For details of other format specifiers see Help under:
104 ; "format specifiers/watch variable"
105 ;
106 ; The special format <,t> specifies the name of the most-derived 
107 ; type of the object. This is especially useful with pointers or
108 ; references to a base class.
109 ;
110 ; If there is no rule for a class, the base classes are checked for
111 ; a matching rule.
112 ;
113 ; There are some special entries allowed in the AutoExpand section:
114 ; $BUILTIN is used to display more complex types that need to do more
115 ; than just show a member variable or two.
116 ; $ADDIN allows external DLLs to be added to display even more complex
117 ; types via the EE Add-in API. The first argument is the DLL name, the
118 ; second argument is the name of the export from the DLL to use. For 
119 ; further information on this API see the sample called EEAddIn.
120 ;
121 ; WARNING: if hexadecimal mode is on in the watch window, all numbers here are
122 ; evaluated in hex, e.g. 42 becomes 0x42
123
124 [AutoExpand]
125
126 ;---- [BEGIN] CLR-specific autoexps ---------------------------
127
128
129
130 PEFile=<m_pDebugName,su>
131 Module=<m_file->m_pDebugName, su>
132 Assembly=<m_pManifestFile->m_pDebugName,su>
133 ClassLoader=<m_pAssembly->m_pManifestFile->m_pDebugName,su>
134 AssemblySpec=<m_pAssemblyName,s> v<m_context.usMajorVersion,d>.<m_context.usMinorVersion,d>.<m_context.usBuildNumber,d>.<m_context.usRevisionNumber,d> <m_CodeInfo.m_pszCodeBase,su>
135
136 TypeHandle=<m_asMT->m_pEEClass->m_szDebugClassName,s>
137 ParamTypeDesc=<m_TemplateMT->m_pEEClass->m_szDebugClassName, s>
138
139
140 EEClass=<m_szDebugClassName,s>
141 MethodTable=<m_pEEClass->m_szDebugClassName,s>
142 MethodDesc=<m_pszDebugClassName,s>::<m_pszDebugMethodName,s> 
143 ReflectMethod=<pMethod->m_pszDebugClassName,s>::<pMethod->m_pszDebugMethodName,s> 
144 FieldDesc=<m_pMTOfEnclosingClass->m_pEEClass->m_szDebugClassName,s>::<m_debugName,s>
145
146 Thread=<m_ThreadId,x>
147
148 BaseObject=<m_pMethTab->m_pEEClass->m_szDebugClassName,s>
149 Object=<m_pMethTab->m_pEEClass->m_szDebugClassName,s>
150 StringObject=<m_Characters>
151 OBJECTREF= <m_asObj->m_pMethTab->m_pEEClass->m_szDebugClassName,s>
152 REF<StringObject>=<m_asString->m_Characters>
153 REF<*>= <m_asObj->m_pMethTab->m_pEEClass->m_szDebugClassName,s>
154
155 ; SStrings are annoying because their internal buffer can be in either
156 ; unicode or ansi depending on the code path. Thus, this rule attempts
157 ; to print it both ways. We will do the ascii attempt first as it's
158 ; less likely to produce verbose garbage (usually, it'll print just the
159 ; first character.)
160 ;
161 ; So the typical output you'll see is...
162 ;
163 ;   {"A"/"ABCD"}              ; sbuffer is using unicode representation
164 ;   {"ABCD"/"<square boxes>"} ; sbuffer was using ansi representation
165 ;
166 ; The rule below also kicks in as desired for StackSString and InlineSString.
167
168 SString =<m_buffer, s>|<m_buffer, su>
169
170
171 HolderBase<*>=<m_value>
172
173 NATIVE_BINDER_SPACE::IEntry=<_tag,su>
174 HolderBase<NATIVE_BINDER_SPACE::IEntry *>=<m_value> <m_value->_tag,su>
175 HolderBase<NATIVE_BINDER_SPACE::CILEntry *>=<m_value> <m_value->_tag,su>
176 HolderBase<NATIVE_BINDER_SPACE::CNgenEntry *>=<m_value> <m_value->_tag,su>
177
178 NATIVE_BINDER_SPACE::CILEntryBind=<_pILEntry->_tag,su>
179 HolderBase<NATIVE_BINDER_SPACE::CILEntryBind *>=<m_value> <m_value->_pILEntry->_tag,su>
180
181 NATIVE_BINDER_SPACE::CNgenEntryBind=<_pNgenEntry->_tag,su>
182 HolderBase<NATIVE_BINDER_SPACE::CNgenEntryBind *>=<m_value> <m_value->_pNgenEntry->_tag,su>
183
184 NATIVE_BINDER_SPACE::CDependencyEntry=<_pEntry->_tag,su>
185 HolderBase<NATIVE_BINDER_SPACE::CDependencyEntry *>=<m_value> <m_value->_pEntry->_tag,su>
186
187 CAssemblyName=<_rProp._rProp[3].asStr>
188 HolderBase<CAssemblyName *>=<m_value->_rProp._rProp[3].asStr>
189 HolderBase<IAssemblyName *>=<m_pAutoExpVisibleValue->_asCAssemblyName->_rProp._rProp[3].asStr>
190
191 BindResult=<m_tag,su>
192 HolderBase<BindResult *>=<m_value->m_tag,su>
193 HolderBase<IBindResult *>=<m_pAutoExpVisibleValue->_asBindResult->m_tag,su>
194
195 AssemblyLocation=<m_pwzAssemblyPath>
196 HolderBase<AssemblyLocation *>=<m_value->m_pwzAssemblyPath>
197 HolderBase<IAssemblyLocation *>=<m_pAutoExpVisibleValue->_asAssemblyLocation->m_pwzAssemblyPath>
198
199
200 ;---- [END] CLR-specific autoexps ---------------------------
201
202
203
204
205
206
207 ; from windef.h
208 tagPOINT =x=<x> y=<y>
209 tagRECT =top=<top> bottom=<bottom> left=<left> right=<right>
210
211 ; from winuser.h
212 tagMSG =msg=<message,x> wp=<wParam,x> lp=<lParam,x>
213
214 ; intrinsics
215 __m64 =<m64_i64,x>
216 __m128=$BUILTIN(M128)
217 __m128i=$BUILTIN(M128I)
218 __m128d=$BUILTIN(M128D)
219
220 ; from afxwin.h
221 CDC =hDC=<m_hDC> attrib=<m_hAttribDC>
222 CPaintDC =<,t> hWnd=<m_hWnd>
223 CPoint =x=<x> y=<y>
224 CRect =top=<top> bottom=<bottom> left=<left> right=<right>
225 CSize =cx=<cx> cy=<cy>
226 CWnd =<,t> hWnd=<m_hWnd>
227 CWinApp =<,t> <m_pszAppName,s>
228 CWinThread =<,t> h=<m_hThread> proc=<m_pfnThreadProc>
229
230 ; from afxcoll.h
231 CPtrList =cnt=<m_nCount>
232
233 ; from afxstat_.h
234 CProcessLocalObject =<,t>
235 CThreadLocalObject =<,t>
236
237 ; from afx.h
238 CArchiveException =cause=<m_cause>
239 CFile =hFile=<m_hFile> name=<m_strFileName.m_pchData,s>
240 CFileException =cause=<m_cause> OS Error=m_lOsError
241 CMemFile =pos=<m_nPosition> size=<m_nFileSize>
242 CObject =<,t>
243 CRuntimeClass =<m_lpszClassName,s>
244 CStdioFile =FILE*=<m_pStream> name=<m_strFilename.m_pchData,s>
245 CTimeSpan =time=<m_time>
246 CTime =time=<m_time>
247
248 ; from afxcoll.h
249 CByteArray =count=<m_nCount>
250 CStringList =count=<m_nCount>
251 ; same for all CXXXArray classes
252 ; same for CXXXList
253 ; same for CMapXXToXX
254
255 ; various string classes from MFC & ATL
256
257 _com_error=<m_hresult,hr>
258 _bstr_t=<m_Data->m_wstr,su> (<m_Data->m_RefCount,u>)
259 _com_ptr_t<*>=<m_pInterface>
260 _LARGE_INTEGER=<QuadPart>
261 _ULARGE_INTEGER=<QuadPart>
262 ATL::CComPtr<*>=<p>
263
264 ATL::CComQIPtr<*>=<p>
265
266 tagVARIANT=$BUILTIN(VARIANT)
267 VARIANT=$BUILTIN(VARIANT)
268 _GUID=$BUILTIN(GUID)
269
270 ; see EEAddIn sample for how to use these
271 ;_SYSTEMTIME=$ADDIN(EEAddIn.dll,AddIn_SystemTime)
272 ;_FILETIME=$ADDIN(EEAddIn.dll,AddIn_FileTime)
273
274 std::binder1st<*>= op=<op> value=<value>
275 std::binder2nd<*>= op=<op> value=<value>
276 std::less<*>=lessthan
277 std::greater<*>=greaterthan
278
279 [Visualizer]
280 ; This section contains visualizers for STL and ATL containers
281 ; DO NOT MODIFY
282
283
284
285 ATL::CStringT<char,*>|CSimpleStringT<char,*>|ATL::CSimpleStringT<char,*>{
286         preview([$c.m_pszData,s])
287         stringview([$c.m_pszData,sb])
288 }
289
290 ATL::CStringT<wchar_t,*>|CSimpleStringT<wchar_t,*>|ATL::CSimpleStringT<wchar_t,*>|ATL::CStringT<unsigned short,*>|CSimpleStringT<unsigned short,*>|ATL::CSimpleStringT<unsigned short,*>{
291         preview([$c.m_pszData,su])
292         stringview([$c.m_pszData,sub])
293 }
294
295 ATL::CComBSTR{
296         preview([$c.m_str,su])
297         stringview([$c.m_str,sub])
298 }
299
300
301 ;------------------------------------------------------------------------------
302 ;  std::vector<bool,*> specialization
303 ;------------------------------------------------------------------------------
304
305 std::vector<bool,*>{
306         children
307         (
308                 #array
309                 (
310                         expr : ($c._Myvec._Myfirst[$i / _VBITS] >> ($i % _VBITS)), 
311                         size : ($c._Mysize)
312                 )  : (bool)($e & 1)
313         )
314                 
315     preview
316     ( 
317             #( 
318                                 "[", 
319                                 $e._Mysize , 
320                                 "](", 
321                                 #array
322                                 (
323                                         expr : ($c._Myvec._Myfirst[$i / _VBITS] >> ($i % _VBITS)), 
324                                         size : ($c._Mysize)
325                                 )  : (bool)($e & 1), ")")
326         )               
327 }
328
329 std::vector<bool,*>::iterator|std::vector<bool,*>::const_iterator|std::_Vb_iterator<*>|std::_Vb_const_iterator<*>{
330         preview
331         (
332                 #( 
333                         (bool) (((*$e._Myptr) >> $e._Myoff) & 1)   
334                 )
335         )
336         
337         children
338         (
339                 #( 
340                         ptr: (bool) (((*$e._Myptr) >> $e._Myoff) & 1)   
341                 )
342         )
343
344         
345 }
346
347
348 ;------------------------------------------------------------------------------
349 ;  std::vector
350 ;------------------------------------------------------------------------------
351 std::vector<*>{
352         children
353         (
354             #array
355             (
356                         expr :  ($c._Myfirst)[$i],  
357                         size :  $c._Mylast-$c._Myfirst
358                 )
359         )
360         
361     preview
362     ( 
363         #( 
364                         "[", 
365             $e._Mylast - $e._Myfirst , 
366             "](", 
367             
368             #array
369             (
370                                 expr :  ($c._Myfirst)[$i],  
371                                 size :  $c._Mylast-$c._Myfirst
372                         ), 
373                         ")"
374                 )
375         )
376         
377
378 }
379
380 std::_Vector_iterator<*>|std::_Vector_const_iterator<*>{
381         preview 
382         (
383                 #(*$e._Myptr)
384         )
385         
386         children
387         (
388                 #(ptr: *$e._Myptr)
389         )
390 }
391
392
393
394 ;------------------------------------------------------------------------------
395 ;  std::string/basic_string
396 ;------------------------------------------------------------------------------
397
398 std::basic_string<char,*>{
399         preview
400         ( 
401                 #if(($e._Myres) < ($e._BUF_SIZE))
402                 (
403                         [$e._Bx._Buf,s]
404                 )
405                 #else
406                 (
407                         [$e._Bx._Ptr,s]
408                 )
409         )
410         
411         stringview
412         (
413                 #if(($e._Myres) < ($e._BUF_SIZE))
414                 (
415                         [$e._Bx._Buf,sb]
416                 )
417                 #else
418                 (
419                         [$e._Bx._Ptr,sb]
420                 )
421         )
422         
423         children
424         (
425                 #if(($e._Myres) < ($e._BUF_SIZE))
426                 (
427                         #([actual members]: [$e,!] , #array( expr: $e._Bx._Buf[$i], size: $e._Mysize))
428                 )
429                 #else
430                 (
431                         #([actual members]: [$e,!],  #array( expr: $e._Bx._Ptr[$i], size: $e._Mysize))
432                 )       
433         )       
434
435 }
436
437 std::basic_string<unsigned short,*>|std::basic_string<wchar_t,*>{
438         preview
439         ( 
440                 #if(($e._Myres) < ($e._BUF_SIZE)) ( [$e._Bx._Buf,su] )
441                 #else ( [$e._Bx._Ptr,su] )
442         )
443         
444         stringview
445         ( 
446                 #if(($e._Myres) < ($e._BUF_SIZE)) ( [$e._Bx._Buf,sub] )
447                 #else ( [$e._Bx._Ptr,sub] )
448         )
449         
450         children
451         (
452                 #if(($e._Myres) < ($e._BUF_SIZE))
453                 (
454                         #([actual members]: [$e,!] , #array( expr: $e._Bx._Buf[$i], size: $e._Mysize))
455                 )
456                 #else
457                 (
458                         #([actual members]: [$e,!],  #array( expr: $e._Bx._Ptr[$i], size: $e._Mysize))
459                 )       
460         )       
461 }
462
463 std::basic_string<*>::iterator|std::basic_string<*>::const_iterator|std::_String_iterator<*>|std::_String_const_iterator<*>{
464         preview
465         ( 
466                 #( $e._Myptr ) 
467         )
468
469         children
470         ( 
471                 #( ptr: $e._Myptr ) 
472         )
473 }
474
475 std::pair<*>{
476         preview
477         (
478                 #( 
479                         "(", 
480                         $e.first, 
481                         ",", 
482                         $e.second , 
483                         ")"
484                 )
485         )
486 }
487
488 ;------------------------------------------------------------------------------
489 ;  std::auto_ptr
490 ;------------------------------------------------------------------------------
491
492 std::auto_ptr<*>{
493         preview
494         ( 
495                 #(      "auto_ptr ",
496                         (*(($T1 *)$c._Myptr))
497                  )
498         )
499         children
500         ( 
501                 #( 
502                         ptr: (*(($T1 *)$c._Myptr)) 
503                 )
504         )
505 }
506
507 ;------------------------------------------------------------------------------
508 ;  std::map
509 ;------------------------------------------------------------------------------
510
511 std::map<*>{
512         children
513         (
514                 #tree
515                 (
516                         head : $c._Myhead->_Parent, 
517                     skip : $c._Myhead, 
518                     size : $c._Mysize, 
519                     left : _Left, 
520                     right : _Right
521                 ) : $e._Myval
522         )
523                      
524         preview
525         (
526                 #(
527                         "[", 
528                         $e._Mysize, 
529                         "](", 
530
531                         #tree
532                         (
533                                 head : $c._Myhead->_Parent, 
534                                 skip : $c._Myhead, 
535                                 size : $c._Mysize, 
536                                 left : _Left, 
537                                 right : _Right
538                         ) : $e._Myval,
539                         
540                         ")"
541                 )
542         )                    
543 }
544
545 ;------------------------------------------------------------------------------
546 ;  std::multi_map
547 ;------------------------------------------------------------------------------
548
549 std::multimap<*>{
550         children
551         (
552                 #tree
553                 (
554                         head : $c._Myhead->_Parent, 
555                     skip : $c._Myhead, 
556                     size : $c._Mysize, 
557                     left : _Left, 
558                     right : _Right
559                 ) : $e._Myval
560         )
561                      
562         preview
563         (
564                 #(
565                         "[", 
566                         $e._Mysize, 
567                         "](", 
568                         
569                         #tree
570                         (       
571                                 head : $c._Myhead->_Parent, 
572                                 skip : $c._Myhead, 
573                                 size : $c._Mysize, 
574                                 left : _Left, 
575                                 right : _Right
576                         ) : $e._Myval,
577                         
578                         ")"
579                 )
580         )                    
581 }
582
583
584 ;------------------------------------------------------------------------------
585 ;  std::list
586 ;------------------------------------------------------------------------------
587
588 std::list<*>{
589
590         children
591         (
592                 #list
593                 (
594                         head : $c._Myhead->_Next, 
595                     size : $c._Mysize, 
596                     next : _Next
597                 ) : $e._Myval
598         )
599                           
600         preview
601         (
602                 #(
603                         "[", 
604                         $e._Mysize, 
605                         "](", 
606                   
607                         #list
608                         (
609                                 head : $c._Myhead->_Next, 
610                                 size : $c._Mysize, 
611                                 next : _Next
612                         ) : $e._Myval,
613                  
614                         ")"
615                 )
616         )                             
617 }
618
619 std::list<*>::iterator|std::list<*>::const_iterator|std::list<*>::_Iterator<1>|std::list<*>::_Const_iterator<1>{
620         preview
621         (
622                 #($e._Ptr->_Myval)
623         )
624         
625         children
626         (
627                 #(ptr: $e._Ptr->_Myval)
628         )
629
630 }
631
632
633 ;------------------------------------------------------------------------------
634 ;  std::bitset  <bitset>
635 ;------------------------------------------------------------------------------
636
637 std::bitset<*>{       
638         preview
639         (
640                 #(
641                 "[",
642                         $c.digits,
643                 "](",
644                 #array
645                 (       
646                         expr :  ($c._Array[$i / $c._Bitsperword] >> ($i % $c._Bitsperword)),  
647                         size :  $c.digits
648                 ) : [($e & 1),d],
649                 ")"
650                 )
651         )
652         children
653         (
654                 #array
655                 (       
656                         expr :  ($c._Array[$i / $c._Bitsperword] >> ($i % $c._Bitsperword)),  
657                         size :  $c.digits
658                 ) : (bool)($e & 1))
659 }
660
661 std::bitset<*>::reference{
662     preview
663     (
664                 #(
665                         "bitset[", $e._Mypos, "] = ", 
666                         (bool)(($e._Pbitset->_Array[$i / _Bitsperword] >> ($e._Mypos % _Bitsperword)) & 1) 
667                 )
668     )
669 }
670
671 ;------------------------------------------------------------------------------
672 ;  std::deque
673 ;------------------------------------------------------------------------------
674
675 std::deque<*>{
676         children
677         (
678                 #array
679                 (
680                         expr : $c._Map[ (($i + $c._Myoff) / $c._EEN_DS) % $c._Mapsize][($i + $c._Myoff) % $c._EEN_DS],  
681                         size : $c._Mysize
682                 )
683         )
684
685         preview
686         (
687                 #(
688                         "[", 
689                         $e._Mysize, 
690                         "](", 
691                   
692                         #array
693                         (
694                                 expr : $c._Map[ (($i + $c._Myoff) / $c._EEN_DS) % $c._Mapsize][($i + $c._Myoff) % $c._EEN_DS],  
695                                 size : $c._Mysize
696                         ),
697                  
698                         ")"
699                 )
700         )                      
701 }
702
703 std::deque<*,*>::iterator|std::_Deque_iterator<*,*,*>|std::_Deque_const_iterator<*,*,*>{
704    preview
705    (
706            #if( $e._Myoff >= ((std::deque<$T1,$T2 > *)$c._Mycont)->_Myoff + ((std::deque<$T1,$T2 > *)$c._Mycont)->_Mysize)
707            (
708                         #("<end>")
709            )
710            #else(
711                         #(
712                                 "deque[", 
713                                 $e._Myoff - ((std::deque<$T1,$T2 > *)$c._Mycont)->_Myoff, 
714                                 "] = ",
715                                 ((std::deque<$T1,$T2 > *)$c._Mycont)->_Map[ (($c._Myoff) / ((std::deque<$T1,$T2 > *)$c._Mycont)->_EEN_DS) % ((std::deque<$T1,$T2 > *)$c._Mycont)->_Mapsize][$c._Myoff % ((std::deque<$T1,$T2 > *)$c._Mycont)->_EEN_DS] 
716                         )
717                 )
718         )
719         children
720         (
721            #if( ((std::deque<$T1,$T2 > *)$c._Mycont)->_Myoff + ((std::deque<$T1,$T2 > *)$c._Mycont)->_Mysize > $e._Myoff) 
722            (
723                         #(
724                                 ptr: ((std::deque<$T1,$T2 > *)$c._Mycont)->_Map[ ($c._Myoff / ((std::deque<$T1,$T2 > *)$c._Mycont)->_EEN_DS) % ((std::deque<$T1,$T2 > *)$c._Mycont)->_Mapsize][$c._Myoff % ((std::deque<$T1,$T2 > *)$c._Mycont)->_EEN_DS] 
725                         )
726                 )
727         )
728 }
729
730 ;------------------------------------------------------------------------------
731 ;  std::queue
732 ;------------------------------------------------------------------------------
733
734 std::queue<*>{
735         children
736         (
737                 #array
738                 (
739                         expr : $c.c._Map[ (($i + $c.c._Myoff) / $c.c._EEN_DS) % $c.c._Mapsize][($i + $c.c._Myoff) % $c.c._EEN_DS],  
740                         size : $c.c._Mysize
741                 )
742         )
743                    
744  preview
745         (
746                 #(
747                         "[", 
748                         $e.c._Mysize, 
749                         "](", 
750                   
751                         #array
752                         (
753                                 expr : $c.c._Map[ (($i + $c.c._Myoff) / $c.c._EEN_DS) % $c.c._Mapsize][($i + $c.c._Myoff) % $c.c._EEN_DS],  
754                                 size : $c.c._Mysize
755                         ),
756                  
757                         ")"
758                 )
759         )                          
760 }
761
762
763 ;------------------------------------------------------------------------------
764 ;  std::priority_queue
765 ;------------------------------------------------------------------------------
766
767 std::priority_queue<*>{
768         preview
769         ( 
770                 $e.c 
771         )
772 }
773
774 ;------------------------------------------------------------------------------
775 ;  std::set
776 ;------------------------------------------------------------------------------
777
778 std::set<*>{
779     preview
780     ( 
781                 #( 
782                         "[", 
783             $e._Mysize , 
784             "](", 
785             
786             #tree
787             (
788                                 head : $c._Myhead->_Parent, 
789                                 skip : $c._Myhead, 
790                                 left : _Left, 
791                                 right : _Right,
792                                 size  : $c._Mysize
793                         ) : $e._Myval, 
794                         
795                         ")"
796                 )
797         )
798                            
799         children
800         (
801                 #tree
802                 (
803                         head : $c._Myhead->_Parent, 
804                         skip : $c._Myhead, 
805                         left : _Left, 
806                         right : _Right,
807                         size  : $c._Mysize
808                 ) : $e._Myval
809         )
810 }
811
812 ;------------------------------------------------------------------------------
813 ;  std::multi_set
814 ;------------------------------------------------------------------------------
815
816 std::multiset<*>{
817     preview
818     (
819                 #( 
820                         "[", 
821             $e._Mysize , 
822             "](", 
823             
824             #tree
825             (
826                                 head : $c._Myhead->_Parent, 
827                                 skip : $c._Myhead, 
828                                 left : _Left, 
829                                 right : _Right,
830                                 size  : $c._Mysize
831                         ) : $e._Myval, 
832                         
833                         ")"
834                 )
835         )
836                            
837         children
838         (
839                 #tree
840                 (
841                         head : $c._Myhead->_Parent, 
842                         skip : $c._Myhead, 
843                         left : _Left, 
844                         right : _Right,
845                         size  : $c._Mysize
846                 ) : $e._Myval
847         )
848 }
849
850
851 ;------------------------------------------------------------------------------
852 ;  std::_Tree (shared my map/multimap/set/multiset)
853 ;------------------------------------------------------------------------------
854
855 std::_Tree<*>::iterator|std::_Tree<*>::const_iterator{
856         preview
857         (
858                 #($e._Ptr->_Myval)
859         )
860         
861         children
862         (
863                 #(ptr: $e._Ptr->_Myval)
864         )
865
866         
867 }
868
869
870 ;------------------------------------------------------------------------------
871 ;  std::stack
872 ;------------------------------------------------------------------------------
873
874 std::stack<*>{
875         children
876         (
877                 #array
878                 (
879                         expr : $c.c._Map[ (($i + $c.c._Myoff) / $c.c._EEN_DS) % $c.c._Mapsize][($i + $c.c._Myoff) % $c.c._EEN_DS],  
880                         size : $c.c._Mysize
881                 )
882         )
883            
884     preview
885     (
886                 #( 
887                         "[", 
888             $e.c._Mysize , 
889             "](", 
890             
891             #array
892             (
893                                 expr : $c.c._Map[ (($i + $c.c._Myoff) / $c.c._EEN_DS) % $c.c._Mapsize][($i + $c.c._Myoff) % $c.c._EEN_DS],  
894                                 size : $c.c._Mysize
895                         ), 
896                         
897                         ")"
898                 )
899         )           
900 }
901
902 ;------------------------------------------------------------------------------
903 ;  stdext::hash_map
904 ;  stdext::hash_multimap
905 ;  stdext::hash_set
906 ;  stdext::hash_multiset
907 ;------------------------------------------------------------------------------
908
909 stdext::hash_map<*>|stdext::hash_multimap<*>|stdext::hash_set<*>|stdext::hash_multiset<*>{
910         
911         preview
912         (
913                 #(
914                         "[", 
915                         $e._List._Mysize, 
916                         "](", 
917                  
918                         #list
919                         (
920                                 head : $c._List._Myhead->_Next, 
921                     size : $c._List._Mysize,
922                                 next : _Next
923                         ) : $e._Myval,
924                         
925                         ")"
926                 )
927         )       
928
929         children
930         (
931     
932                 #list
933                 (
934                         head : $c._List._Myhead->_Next, 
935                         size : $c._List._Mysize, 
936                         next : _Next
937                 ) : $e._Myval
938         )
939 }
940
941 ;------------------------------------------------------------------------------
942 ;  std::complex
943 ;------------------------------------------------------------------------------
944
945 std::complex<*>{
946         children
947         (
948                 #(
949                         real: $e._Val[0],
950                         imaginary: $e._Val[1]
951                 )
952         )
953         preview
954         (
955                 #if($e._Val[1] != 0)
956                 (                                                                               
957                         #if ($e._Val[0] != 0)                           
958                         (                                                                       ; Real and Imaginary components 
959                                 #if ($e._Val[1] >= 0)
960                                 (
961                                         #($e._Val[0],"+i*", $e._Val[1])
962                                 )
963                                 #else
964                                 (
965                                         #($e._Val[0],"-i*", -$e._Val[1])                                                          
966                                 )
967                         )
968                         #else
969                         (                                                                       ; Purely imaginary
970                                 #if ($e._Val[1] >= 0.0)
971                                 (
972                                         #("i*", $e._Val[1])
973                                 )
974                                 #else
975                                 (
976                                         #("-i*", -$e._Val[1])                                           
977                                 )
978                         )
979                 )
980                 #else
981                 (                                                                               ; Purely real
982                         $e._Val[0]              
983                 )
984         )
985 }
986
987 ;------------------------------------------------------------------------------
988 ;  std::valarray
989 ;------------------------------------------------------------------------------
990
991 std::valarray<*>{
992     preview
993     ( 
994                 #( 
995                         "[", 
996             $e._Mysize , 
997             "](", 
998             
999             #array
1000             (
1001                                 expr :  ($c._Myptr)[$i],  
1002                                 size :  $c._Mysize
1003                         ), 
1004                         
1005                         ")"
1006                 )
1007         )
1008         
1009         children
1010         (
1011                 #array
1012                 (
1013                         expr :  ($c._Myptr)[$i],  
1014                         size :  $c._Mysize
1015                 )
1016         )
1017 }
1018
1019 ;------------------------------------------------------------------------------
1020 ;  PROPVARIANT
1021 ;------------------------------------------------------------------------------
1022
1023 ; Visualizers for VT_VECTOR C arrays
1024 tagCAC|tagCAUB|tagCAI|tagCAUI|tagCAL|tagCAUL|tagCAFLT|tagCADBL|tagCACY|tagCADATE|tagCABSTR|tagCABSTRBLOB|tagCABOOL|tagCASCODE|tagCAPROPVARIANT|tagCAH|tagCAUH|tagCALPSTR|tagCALPWSTR|tagCAFILETIME|tagCACLIPDATA|tagCACLSID{
1025         preview(
1026                 #( 
1027                         "[", 
1028             $e.cElems , 
1029             "](", 
1030             
1031             #array
1032             (
1033                                 expr :  ($c.pElems)[$i],  
1034                                 size :  $c.cElems
1035                         ),                      
1036                         ")"
1037                 )
1038         )
1039
1040         children
1041         (
1042                 #array
1043                 (
1044                         expr :  ($c.pElems)[$i],  
1045                         size :  $c.cElems
1046                 )
1047         )       
1048         
1049 }
1050
1051 ; Visualizers for SAFE ARRAY
1052 tagSAFEARRAY|SAFEARRAY{
1053         preview(                
1054                         #if ($c.fFeatures & 0x0080)             ; FADF_HAVEVARTYPE 
1055                         (
1056                                 ;
1057                                 ;       Switch on the variant type field - which is stored 4 bytes
1058                                 ;       before the beginning of the SAFEARRAY type
1059                                 ;
1060                                 #switch( ((unsigned *)&($c))[-1] )                                              
1061                                         #case 0x2                                                       ; VT_I2 | VT_ARRAY
1062                                         (
1063                                                 #(
1064                                                         "safearray of I2 = [",  
1065                                                                                                                                 
1066                                                         ; output the rank array
1067                                                         #array( expr: $c.rgsabound[$i].cElements, size: $c.cDims),              
1068                                                         
1069                                                         "](", 
1070                                                         
1071                                                         ; output the data elements
1072                                                         #array( 
1073                                                                         expr: ((signed short *)$c.pvData)[$i], 
1074                                                                         size: $c.rgsabound[$r].cElements, 
1075                                                                         rank: $c.cDims, 
1076                                                                         base: $c.rgsabound[$r].lLbound 
1077                                                                   ), 
1078                                                         ")"
1079                                                 )
1080                                         )       
1081                                         
1082                                         #case 0x3                                                       ; VT_I4 | VT_ARRAY
1083                                         (
1084                                                 #(
1085                                                         "safearray of I4 = [",  
1086                                                                                                                                 
1087                                                         ; output the rank array
1088                                                         #array( expr: $c.rgsabound[$i].cElements, size: $c.cDims),              
1089                                                         
1090                                                         "](", 
1091                                                         
1092                                                         ; output the data elements
1093                                                         #array( 
1094                                                                         expr: ((signed int *)$c.pvData)[$i], 
1095                                                                         size: $c.rgsabound[$r].cElements, 
1096                                                                         rank: $c.cDims, 
1097                                                                         base: $c.rgsabound[$r].lLbound 
1098                                                                   ), 
1099                                                         ")"
1100                                                 )
1101                                         )       
1102                                         
1103                                         #case 0x4                                                       ; VT_R4 | VT_ARRAY
1104                                         (
1105                                                 #(
1106                                                         "safearray of R4 = [",  
1107                                                                                                                                 
1108                                                         ; output the rank array
1109                                                         #array( expr: $c.rgsabound[$i].cElements, size: $c.cDims),              
1110                                                         
1111                                                         "](", 
1112                                                         
1113                                                         ; output the data elements
1114                                                         #array( 
1115                                                                         expr: ((float *)$c.pvData)[$i], 
1116                                                                         size: $c.rgsabound[$r].cElements, 
1117                                                                         rank: $c.cDims, 
1118                                                                         base: $c.rgsabound[$r].lLbound 
1119                                                                   ), 
1120                                                         ")"
1121                                                 )
1122                                         )       
1123                                         
1124                                         #case 0x5                                                       ; VT_R8 | VT_ARRAY
1125                                         (
1126                                                 #(
1127                                                         "safearray of R8 = [",  
1128                                                                                                                                 
1129                                                         ; output the rank array
1130                                                         #array( expr: $c.rgsabound[$i].cElements, size: $c.cDims),              
1131                                                         
1132                                                         "](", 
1133                                                         
1134                                                         ; output the data elements
1135                                                         #array( 
1136                                                                         expr: ((double *)$c.pvData)[$i], 
1137                                                                         size: $c.rgsabound[$r].cElements, 
1138                                                                         rank: $c.cDims, 
1139                                                                         base: $c.rgsabound[$r].lLbound 
1140                                                                   ), 
1141                                                         ")"
1142                                                 )
1143                                         )       
1144                                         
1145                                         #case 0x6                                                       ; VT_CY | VT_ARRAY
1146                                         (
1147                                                 #(
1148                                                         "safearray of CY = [",  
1149                                                                                                                                 
1150                                                         ; output the rank array
1151                                                         #array( expr: $c.rgsabound[$i].cElements, size: $c.cDims),              
1152                                                         
1153                                                         "](", 
1154                                                         
1155                                                         ; output the data elements
1156                                                         #array( 
1157                                                                         expr: ((CY *)$c.pvData)[$i], 
1158                                                                         size: $c.rgsabound[$r].cElements, 
1159                                                                         rank: $c.cDims, 
1160                                                                         base: $c.rgsabound[$r].lLbound 
1161                                                                   ), 
1162                                                         ")"
1163                                                 )
1164                                         )
1165                                         
1166                                         #case 0x7                                                       ; VT_DATE | VT_ARRAY
1167                                         (
1168                                                 #(
1169                                                         "safearray of DATE = [",        
1170                                                                                                                                 
1171                                                         ; output the rank array
1172                                                         #array( expr: $c.rgsabound[$i].cElements, size: $c.cDims),              
1173                                                         
1174                                                         "](", 
1175                                                         
1176                                                         ; output the data elements
1177                                                         #array( 
1178                                                                         expr: ((DATE *)$c.pvData)[$i], 
1179                                                                         size: $c.rgsabound[$r].cElements, 
1180                                                                         rank: $c.cDims, 
1181                                                                         base: $c.rgsabound[$r].lLbound 
1182                                                                   ), 
1183                                                         ")"
1184                                                 )
1185                                         )               
1186                                         
1187                                         #case 0x8                                                       ; VT_BSTR | VT_ARRAY
1188                                         (
1189                                                 #(
1190                                                         "safearray of BSTR = [",        
1191                                                                                                                                 
1192                                                         ; output the rank array
1193                                                         #array( expr: $c.rgsabound[$i].cElements, size: $c.cDims),              
1194                                                         
1195                                                         "](", 
1196                                                         
1197                                                         ; output the data elements
1198                                                         #array( 
1199                                                                         expr: ((wchar_t **)$c.pvData)[$i], 
1200                                                                         size: $c.rgsabound[$r].cElements, 
1201                                                                         rank: $c.cDims, 
1202                                                                         base: $c.rgsabound[$r].lLbound 
1203                                                                   ), 
1204                                                         ")"
1205                                                 )
1206                                         )       
1207
1208                                         #case 0xa                                                       ; VT_ERROR | VT_ARRAY
1209                                         (
1210                                                 #(
1211                                                         "safearray of ERROR = [",       
1212                                                                                                                                 
1213                                                         ; output the rank array
1214                                                         #array( expr: $c.rgsabound[$i].cElements, size: $c.cDims),              
1215                                                         
1216                                                         "](", 
1217                                                         
1218                                                         ; output the data elements
1219                                                         #array( 
1220                                                                         expr: ((long *)$c.pvData)[$i], 
1221                                                                         size: $c.rgsabound[$r].cElements, 
1222                                                                         rank: $c.cDims, 
1223                                                                         base: $c.rgsabound[$r].lLbound 
1224                                                                   ), 
1225                                                         ")"
1226                                                 )
1227                                         )
1228                                         
1229                                         #case 0xb                                                       ; VT_BOOL | VT_ARRAY
1230                                         (
1231                                                 #(
1232                                                         "safearray of BOOL = [",        
1233                                                                                                                                 
1234                                                         ; output the rank array
1235                                                         #array( expr: $c.rgsabound[$i].cElements, size: $c.cDims),              
1236                                                         
1237                                                         "](", 
1238                                                         
1239                                                         ; output the data elements
1240                                                         #array( 
1241                                                                         expr: ((short *)$c.pvData)[$i], 
1242                                                                         size: $c.rgsabound[$r].cElements, 
1243                                                                         rank: $c.cDims, 
1244                                                                         base: $c.rgsabound[$r].lLbound 
1245                                                                   ), 
1246                                                         ")"
1247                                                 )
1248                                         )               
1249                                         
1250                                         #case 0xc                                                       ; VT_VARIANT | VT_ARRAY
1251                                         (
1252                                                 #(
1253                                                         "safearray of VARIANT = [",     
1254                                                                                                                                 
1255                                                         ; output the rank array
1256                                                         #array( expr: $c.rgsabound[$i].cElements, size: $c.cDims),              
1257                                                         
1258                                                         "](", 
1259                                                         
1260                                                         ; output the data elements
1261                                                         #array( 
1262                                                                         expr: ((tagVARIANT *)$c.pvData)[$i], 
1263                                                                         size: $c.rgsabound[$r].cElements, 
1264                                                                         rank: $c.cDims, 
1265                                                                         base: $c.rgsabound[$r].lLbound 
1266                                                                   ), 
1267                                                         ")"
1268                                                 )
1269                                         )       
1270                                         
1271                                         #case 0x10                                                      ; VT_I1 | VT_ARRAY
1272                                         (
1273                                                 #(
1274                                                         "safearray of I1 = [",  
1275                                                                                                                                 
1276                                                         ; output the rank array
1277                                                         #array( expr: $c.rgsabound[$i].cElements, size: $c.cDims),              
1278                                                         
1279                                                         "](", 
1280                                                         
1281                                                         ; output the data elements
1282                                                         #array( 
1283                                                                         expr: ((signed char *)$c.pvData)[$i], 
1284                                                                         size: $c.rgsabound[$r].cElements, 
1285                                                                         rank: $c.cDims, 
1286                                                                         base: $c.rgsabound[$r].lLbound 
1287                                                                   ), 
1288                                                         ")"
1289                                                 )
1290                                         )               
1291                                         
1292                                         #case 0x11                                                      ; VT_UI1 | VT_ARRAY
1293                                         (
1294                                                 #(
1295                                                         "safearray of UI1 = [", 
1296                                                                                                                                 
1297                                                         ; output the rank array
1298                                                         #array( expr: $c.rgsabound[$i].cElements, size: $c.cDims),              
1299                                                         
1300                                                         "](", 
1301                                                         
1302                                                         ; output the data elements
1303                                                         #array( 
1304                                                                         expr: ((unsigned char *)$c.pvData)[$i], 
1305                                                                         size: $c.rgsabound[$r].cElements, 
1306                                                                         rank: $c.cDims, 
1307                                                                         base: $c.rgsabound[$r].lLbound 
1308                                                                   ), 
1309                                                         ")"
1310                                                 )
1311                                         )               
1312                                         
1313                                         #case 0x12                                                      ; VT_UI2 | VT_ARRAY
1314                                         (
1315                                                 #(
1316                                                         "safearray of UI2 = [", 
1317                                                                                                                                 
1318                                                         ; output the rank array
1319                                                         #array( expr: $c.rgsabound[$i].cElements, size: $c.cDims),              
1320                                                         
1321                                                         "](", 
1322                                                         
1323                                                         ; output the data elements
1324                                                         #array( 
1325                                                                         expr: ((unsigned short *)$c.pvData)[$i], 
1326                                                                         size: $c.rgsabound[$r].cElements, 
1327                                                                         rank: $c.cDims, 
1328                                                                         base: $c.rgsabound[$r].lLbound 
1329                                                                   ), 
1330                                                         ")"
1331                                                 )
1332                                         )       
1333                                         
1334                                         #case 0x13                                                      ; VT_UI4 | VT_ARRAY
1335                                         (
1336                                                 #(
1337                                                         "safearray of UI4 = [", 
1338                                                                                                                                 
1339                                                         ; output the rank array
1340                                                         #array( expr: $c.rgsabound[$i].cElements, size: $c.cDims),              
1341                                                         
1342                                                         "](", 
1343                                                         
1344                                                         ; output the data elements
1345                                                         #array( 
1346                                                                         expr: ((unsigned int *)$c.pvData)[$i], 
1347                                                                         size: $c.rgsabound[$r].cElements, 
1348                                                                         rank: $c.cDims, 
1349                                                                         base: $c.rgsabound[$r].lLbound 
1350                                                                   ), 
1351                                                         ")"
1352                                                 )
1353                                         )       
1354                                         
1355                                         #case 0x14                                                      ; VT_I8 | VT_ARRAY
1356                                         (
1357                                                 #(
1358                                                         "safearray of I8 = [",  
1359                                                                                                                                 
1360                                                         ; output the rank array
1361                                                         #array( expr: $c.rgsabound[$i].cElements, size: $c.cDims),              
1362                                                         
1363                                                         "](", 
1364                                                         
1365                                                         ; output the data elements
1366                                                         #array( 
1367                                                                         expr: ((signed __int64 *)$c.pvData)[$i], 
1368                                                                         size: $c.rgsabound[$r].cElements, 
1369                                                                         rank: $c.cDims, 
1370                                                                         base: $c.rgsabound[$r].lLbound 
1371                                                                   ), 
1372                                                         ")"
1373                                                 )
1374                                         )       
1375                                         
1376                                         #case 0x15                                                      ; VT_UI8 | VT_ARRAY
1377                                         (
1378                                                 #(
1379                                                         "safearray of UI8 = [", 
1380                                                                                                                                 
1381                                                         ; output the rank array
1382                                                         #array( expr: $c.rgsabound[$i].cElements, size: $c.cDims),              
1383                                                         
1384                                                         "](", 
1385                                                         
1386                                                         ; output the data elements
1387                                                         #array( 
1388                                                                         expr: ((unsigned __int64 *)$c.pvData)[$i], 
1389                                                                         size: $c.rgsabound[$r].cElements, 
1390                                                                         rank: $c.cDims, 
1391                                                                         base: $c.rgsabound[$r].lLbound 
1392                                                                   ), 
1393                                                         ")"
1394                                                 )
1395                                         )       
1396                                         
1397                                         #case 0x16                                                      ; VT_INT | VT_ARRAY
1398                                         (
1399                                                 #(
1400                                                         "safearray of INT = [", 
1401                                                                                                                                 
1402                                                         ; output the rank array
1403                                                         #array( expr: $c.rgsabound[$i].cElements, size: $c.cDims),              
1404                                                         
1405                                                         "](", 
1406                                                         
1407                                                         ; output the data elements
1408                                                         #array( 
1409                                                                         expr: ((int *)$c.pvData)[$i], 
1410                                                                         size: $c.rgsabound[$r].cElements, 
1411                                                                         rank: $c.cDims, 
1412                                                                         base: $c.rgsabound[$r].lLbound 
1413                                                                   ), 
1414                                                         ")"
1415                                                 )
1416                                         )                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               
1417                                         
1418                                         #case 0x17                                                      ; VT_UINT | VT_ARRAY
1419                                         (
1420                                                 #(
1421                                                         "safearray of UINT = [",        
1422                                                                                                                                 
1423                                                         ; output the rank array
1424                                                         #array( expr: $c.rgsabound[$i].cElements, size: $c.cDims),              
1425                                                         
1426                                                         "](", 
1427                                                         
1428                                                         ; output the data elements
1429                                                         #array( 
1430                                                                         expr: ((unsigned *)$c.pvData)[$i], 
1431                                                                         size: $c.rgsabound[$r].cElements, 
1432                                                                         rank: $c.cDims, 
1433                                                                         base: $c.rgsabound[$r].lLbound 
1434                                                                   ), 
1435                                                         ")"
1436                                                 )
1437                                         )       
1438                                         
1439                                         #case 0x1e                                                      ; VT_LPSTR | VT_ARRAY
1440                                         (
1441                                                 #(
1442                                                         "safearray of LPSTR = [",       
1443                                                                                                                                 
1444                                                         ; output the rank array
1445                                                         #array( expr: $c.rgsabound[$i].cElements, size: $c.cDims),              
1446                                                         
1447                                                         "](", 
1448                                                         
1449                                                         ; output the data elements
1450                                                         #array( 
1451                                                                         expr: ((char **)$c.pvData)[$i], 
1452                                                                         size: $c.rgsabound[$r].cElements, 
1453                                                                         rank: $c.cDims, 
1454                                                                         base: $c.rgsabound[$r].lLbound 
1455                                                                   ), 
1456                                                         ")"
1457                                                 )
1458                                         )       
1459
1460                                         #case 0x1f                                                      ; VT_LPWSTR | VT_ARRAY
1461                                         (
1462                                                 #(
1463                                                         "safearray of LPWSTR = [",      
1464                                                                                                                                 
1465                                                         ; output the rank array
1466                                                         #array( expr: $c.rgsabound[$i].cElements, size: $c.cDims),              
1467                                                         
1468                                                         "](", 
1469                                                         
1470                                                         ; output the data elements
1471                                                         #array( 
1472                                                                         expr: ((wchar_t **)$c.pvData)[$i], 
1473                                                                         size: $c.rgsabound[$r].cElements, 
1474                                                                         rank: $c.cDims, 
1475                                                                         base: $c.rgsabound[$r].lLbound 
1476                                                                   ), 
1477                                                         ")"
1478                                                 )
1479                                         )       
1480                                         
1481                                         #case 0x40                                                      ; VT_FILETIME | VT_ARRAY
1482                                         (
1483                                                 #(
1484                                                         "safearray of FILETIME = [",    
1485                                                                                                                                 
1486                                                         ; output the rank array
1487                                                         #array( expr: $c.rgsabound[$i].cElements, size: $c.cDims),              
1488                                                         
1489                                                         "](", 
1490                                                         
1491                                                         ; output the data elements
1492                                                         #array( 
1493                                                                         expr: ((FILETIME *)$c.pvData)[$i], 
1494                                                                         size: $c.rgsabound[$r].cElements, 
1495                                                                         rank: $c.cDims, 
1496                                                                         base: $c.rgsabound[$r].lLbound 
1497                                                                   ), 
1498                                                         ")"
1499                                                 )
1500                                         )       
1501                                         
1502                                         #case 0x47                                                      ; VT_CLIPDATA | VT_ARRAY
1503                                         (
1504                                                 #(
1505                                                         "safearray of CLIPDATA = [",    
1506                                                                                                                                 
1507                                                         ; output the rank array
1508                                                         #array( expr: $c.rgsabound[$i].cElements, size: $c.cDims),              
1509                                                         
1510                                                         "](", 
1511                                                         
1512                                                         ; output the data elements
1513                                                         #array( 
1514                                                                         expr: ((CLIPDATA *)$c.pvData)[$i], 
1515                                                                         size: $c.rgsabound[$r].cElements, 
1516                                                                         rank: $c.cDims, 
1517                                                                         base: $c.rgsabound[$r].lLbound 
1518                                                                   ), 
1519                                                         ")"
1520                                                 )
1521                                         )       
1522                                         
1523                                         #case 0x48                                                      ; VT_CLSID | VT_ARRAY
1524                                         (
1525                                                 #(
1526                                                         "safearray of CLSID = [",       
1527                                                                                                                                 
1528                                                         ; output the rank array
1529                                                         #array( expr: $c.rgsabound[$i].cElements, size: $c.cDims),              
1530                                                         
1531                                                         "](", 
1532                                                         
1533                                                         ; output the data elements
1534                                                         #array( 
1535                                                                         expr: ((CLSID *)$c.pvData)[$i], 
1536                                                                         size: $c.rgsabound[$r].cElements, 
1537                                                                         rank: $c.cDims, 
1538                                                                         base: $c.rgsabound[$r].lLbound 
1539                                                                   ), 
1540                                                         ")"
1541                                                 )
1542                                         )                                                                                                                                                                                                                                                       
1543                         )
1544                         #elif ($c.fFeatures & 0x0100)           ; FADF_BSTR 
1545                         (
1546                                 #("safearray of BSTR = ",#array(expr: $c.rgsabound[$i].cElements, size: $c.cDims) : #("[",$e,"]"), "(", #array(expr: ((wchar_t * *)$c.pvData)[$i], size: $c.rgsabound[$r].cElements, rank: $c.cDims, base: $c.rgsabound[$r].lLbound ), ")")
1547                         )
1548                         #elif ($c.fFeatures & 0x0200)           ; FADF_UNKNOWN
1549                         (
1550                                 #("safearray of IUnknown* = ",#array(expr: $c.rgsabound[$i].cElements, size: $c.cDims) : #("[",$e,"]"), "(", #array(expr: ((IUnknown *)$c.pvData)[$i], size: $c.rgsabound[$r].cElements, rank: $c.cDims, base: $c.rgsabound[$r].lLbound ), ")")
1551                         )       
1552                         #elif ($c.fFeatures & 0x0400)           ; FADF_DISPATCH
1553                         (
1554                                 #("safearray of IDispatch* = ",#array(expr: $c.rgsabound[$i].cElements, size: $c.cDims) : #("[",$e,"]"), "(", #array(expr: ((IDispatch*)$c.pvData)[$i], size: $c.rgsabound[$r].cElements, rank: $c.cDims, base: $c.rgsabound[$r].lLbound ), ")")
1555                         )
1556                         #elif ($c.fFeatures & 0x0800)           ; FADF_VARIANT
1557                         (
1558                                 #("safearray of VARIANT = ",#array(expr: $c.rgsabound[$i].cElements, size: $c.cDims) : #("[",$e,"]"), "(", #array(expr: ((tagVARIANT *)$c.pvData)[$i], size: $c.rgsabound[$r].cElements, rank: $c.cDims, base: $c.rgsabound[$r].lLbound ), ")")
1559                         )
1560         )
1561         children(
1562                 #(                                                                      ;[actual members]: [$c,!],
1563                         #if ($c.fFeatures & 0x0080)             ; FADF_HAVEVARTYPE 
1564                         (
1565                                 #switch( ((unsigned *)&($c))[-1] )      ; for some reason the VT field is before the SAFEARRAY struct
1566                                         #case 2                                                 ; VT_I2|VT_ARRAY
1567                                         ( 
1568                                                 #array(
1569                                                                 expr: ((signed short *)$c.pvData)[$i], 
1570                                                                 size: $c.rgsabound[$r].cElements, 
1571                                                                 rank: $c.cDims, 
1572                                                                 base: $c.rgsabound[$r].lLbound 
1573                                                           )
1574                                         )                               
1575                                         
1576                                         #case 3                                                 ; VT_I4|VT_ARRAY
1577                                         ( 
1578                                                 #array(
1579                                                                 expr: ((signed int   *)$c.pvData)[$i], 
1580                                                                 size: $c.rgsabound[$r].cElements, 
1581                                                                 rank: $c.cDims, 
1582                                                                 base: $c.rgsabound[$r].lLbound 
1583                                                            )
1584                                         )               
1585                                                         
1586                                         #case 4                                                 ; VT_R4|VT_ARRAY
1587                                         ( 
1588                                                 #array(
1589                                                                 expr: ((float *)$c.pvData)[$i], 
1590                                                                 size: $c.rgsabound[$r].cElements,
1591                                                                 rank: $c.cDims, 
1592                                                                 base: $c.rgsabound[$r].lLbound 
1593                                                            )
1594                                         )               
1595                                                         
1596                                         #case 5                                                 ; VT_R8|VT_ARRAY
1597                                         ( 
1598                                                 #array(
1599                                                                 expr: ((double  *)$c.pvData)[$i], 
1600                                                                 size: $c.rgsabound[$r].cElements, 
1601                                                                 rank: $c.cDims, 
1602                                                                 base: $c.rgsabound[$r].lLbound 
1603                                                           )
1604                                         )               
1605                                                         
1606                                         #case 0x10                                              ; VT_I1|VT_ARRAY
1607                                         ( 
1608                                                 #array(
1609                                                                 expr: ((signed char *)$c.pvData)[$i], 
1610                                                                 size: $c.rgsabound[$r].cElements, 
1611                                                                 rank: $c.cDims, 
1612                                                                 base: $c.rgsabound[$r].lLbound 
1613                                                            )
1614                                         )       
1615                                                                 
1616                                         #case 0x11                                              ; VT_UI1|VT_ARRAY
1617                                         ( 
1618                                                 #array(
1619                                                                 expr: ((unsigned char *)$c.pvData)[$i], 
1620                                                                 size: $c.rgsabound[$r].cElements, 
1621                                                                 rank: $c.cDims, 
1622                                                                 base: $c.rgsabound[$r].lLbound 
1623                                                           )
1624                                         )               
1625                                                         
1626                                         #case 0x12                                              ; VT_UI2|VT_ARRAY
1627                                         ( 
1628                                                 #array(
1629                                                                 expr: ((unsigned short *)$c.pvData)[$i], 
1630                                                                 size: $c.rgsabound[$r].cElements, 
1631                                                                 rank: $c.cDims, 
1632                                                                 base: $c.rgsabound[$r].lLbound 
1633                                                            )
1634                                         )               
1635                                                         
1636                                         #case 0x13                                              ; VT_UI4|VT_ARRAY
1637                                         ( 
1638                                                 #array(
1639                                                                 expr: ((unsigned int *)$c.pvData)[$i], 
1640                                                                 size: $c.rgsabound[$r].cElements, 
1641                                                                 rank: $c.cDims, 
1642                                                                 base: $c.rgsabound[$r].lLbound
1643                                                            )    
1644                                         )
1645                                                                 
1646                                         #case 0x14                                              ; VT_I8|VT_ARRAY
1647                                         ( 
1648                                                 #array(
1649                                                                 expr: ((signed __int64 *)$c.pvData)[$i], 
1650                                                                 size: $c.rgsabound[$r].cElements, 
1651                                                                 rank: $c.cDims, 
1652                                                                 base: $c.rgsabound[$r].lLbound
1653                                                            )                            
1654                                         )                                                        
1655                                         #case 0x15                                              ; VT_UI8|VT_ARRAY
1656                                         ( 
1657                                                 #array(
1658                                                                 expr: ((unsigned __int64 *)$c.pvData)[$i], 
1659                                                                 size: $c.rgsabound[$r].cElements, 
1660                                                                 rank: $c.cDims, 
1661                                                                 base: $c.rgsabound[$r].lLbound
1662                                                           )                             
1663                                         )
1664                                         
1665                                         #case 0x1e                                              ; VT_LPSTR|VT_ARRAY
1666                                         ( 
1667                                                 #array(
1668                                                                 expr: ((char * *)$c.pvData)[$i], 
1669                                                                 size: $c.rgsabound[$r].cElements, 
1670                                                                 rank: $c.cDims, 
1671                                                                 base: $c.rgsabound[$r].lLbound
1672                                                           )                     
1673                                         )
1674                                         
1675                                         #case 0x1f                                              ; VT_LPWSTR|VT_ARRAY
1676                                         ( 
1677                                                 #array(
1678                                                                 expr: ((wchar_t **)$c.pvData)[$i], 
1679                                                                 size: $c.rgsabound[$r].cElements, 
1680                                                                 rank: $c.cDims, 
1681                                                                 base: $c.rgsabound[$r].lLbound
1682                                                           )             
1683                                         )
1684                                         
1685                                         #case 0xc                                               ; VT_VARIANT|VT_ARRAY
1686                                         ( 
1687                                                 #array(
1688                                                                 expr: ((tagVARIANT *)$c.pvData)[$i], 
1689                                                                 size: $c.rgsabound[$r].cElements, 
1690                                                                 rank: $c.cDims, 
1691                                                                 base: $c.rgsabound[$r].lLbound
1692                                                           )                     
1693                                         
1694                                         )
1695                                         
1696                                         #case 0xb                                               ; VT_BOOL|VT_ARRAY
1697                                         (                                       
1698                                                 #array(
1699                                                                 expr: ((short *)$c.pvData)[$i], 
1700                                                                 size: $c.rgsabound[$r].cElements, 
1701                                                                 rank: $c.cDims, 
1702                                                                 base: $c.rgsabound[$r].lLbound
1703                                                           )                     
1704                                         )
1705                                         
1706                                         #case 0xa                                               ; VT_ERROR|VT_ARRAY
1707                                         ( 
1708                                                 #array(
1709                                                                 expr: ((long *)$c.pvData)[$i], 
1710                                                                 size: $c.rgsabound[$r].cElements, 
1711                                                                 rank: $c.cDims, 
1712                                                                 base: $c.rgsabound[$r].lLbound
1713                                                           )                     
1714                                         )
1715                                         
1716                                         #case 6                                                 ; VT_CY|VT_ARRAY
1717                                         ( 
1718                                                 #array(
1719                                                                 expr: ((CY *)$c.pvData)[$i], 
1720                                                                 size: $c.rgsabound[$r].cElements, 
1721                                                                 rank: $c.cDims, 
1722                                                                 base: $c.rgsabound[$r].lLbound
1723                                                           )                             
1724                                         )
1725                                         
1726                                         #case 7                                                 ; VT_DATE|VT_ARRAY
1727                                         ( 
1728                                                 #array(
1729                                                                 expr: ((DATE *)$c.pvData)[$i], 
1730                                                                 size: $c.rgsabound[$r].cElements, 
1731                                                                 rank: $c.cDims, 
1732                                                                 base: $c.rgsabound[$r].lLbound
1733                                                           )                     
1734                                         )
1735                                         
1736                                         #case 0x40                                              ; VT_FILETIME|VT_ARRAY
1737                                         ( 
1738                                                 #array(
1739                                                                 expr: ((FILETIME *)$c.pvData)[$i], 
1740                                                                 size: $c.rgsabound[$r].cElements, 
1741                                                                 rank: $c.cDims, 
1742                                                                 base: $c.rgsabound[$r].lLbound
1743                                                           )             
1744                                         )
1745                                         
1746                                         #case 0x48                                              ; VT_CLSID|VT_ARRAY
1747                                         ( 
1748                                                 #array(
1749                                                                 expr: ((CLSID *)$c.pvData)[$i], 
1750                                                                 size: $c.rgsabound[$r].cElements, 
1751                                                                 rank: $c.cDims, 
1752                                                                 base: $c.rgsabound[$r].lLbound
1753                                                           )                     
1754                                         )
1755                                         
1756                                         #case 0x47                                              ; VT_CF|VT_ARRAY
1757                                         ( 
1758                                                 #array(
1759                                                                 expr: ((CLIPDATA *)$c.pvData)[$i], 
1760                                                                 size: $c.rgsabound[$r].cElements, 
1761                                                                 rank: $c.cDims, 
1762                                                                 base: $c.rgsabound[$r].lLbound
1763                                                           )                             
1764                                         )
1765                                         
1766                                         #case 8                                                 ; VT_BSTR|VT_ARRAY
1767                                         ( 
1768                                                 #array(
1769                                                                 expr: ((wchar_t * *)$c.pvData)[$i], 
1770                                                                 size: $c.rgsabound[$r].cElements, 
1771                                                                 rank: $c.cDims, 
1772                                                                 base: $c.rgsabound[$r].lLbound
1773                                                           )                     
1774                                         )
1775                                         
1776                                         #case 0x16                                              ; VT_INT|VT_ARRAY
1777                                         ( 
1778                                                 #array(
1779                                                                 expr: ((int *)$c.pvData)[$i],
1780                                                                 size: $c.rgsabound[$r].cElements, 
1781                                                                 rank: $c.cDims, 
1782                                                                 base: $c.rgsabound[$r].lLbound
1783                                                           )                             
1784                                         )
1785                                         
1786                                         #case 0x17                                              ; VT_UINT|VT_ARRAY              
1787                                         ( 
1788                                                 #array(
1789                                                                 expr: ((unsigned int*)$c.pvData)[$i], 
1790                                                                 size: $c.rgsabound[$r].cElements, 
1791                                                                 rank: $c.cDims, 
1792                                                                 base: $c.rgsabound[$r].lLbound
1793                                                           )     
1794                                         )                       
1795                                         
1796                                         #default
1797                                         (
1798                                                 #([actual members]: [$e,!])
1799                                         )
1800                                         #except
1801                                         (
1802                                                 #([actual members]: [$e,!])
1803                                         )
1804                         )
1805                         #elif ($c.fFeatures & 0x0100)           ; FADF_BSTR 
1806                         (
1807                                 #array(expr: ((wchar_t * *)$c.pvData)[$i], size: $c.rgsabound[$r].cElements, rank: $c.cDims, base: $c.rgsabound[$r].lLbound )   
1808                         )
1809                         #elif ($c.fFeatures & 0x0200)           ; FADF_UNKNOWN
1810                         (
1811                                 #array(expr: ((IUnknown *)$c.pvData)[$i], size: $c.rgsabound[$r].cElements, rank: $c.cDims, base: $c.rgsabound[$r].lLbound )    
1812                         )       
1813                         #elif ($c.fFeatures & 0x0400)           ; FADF_DISPATCH
1814                         (
1815                                 #array(expr: ((IDispatch *)$c.pvData)[$i], size: $c.rgsabound[$r].cElements, rank: $c.cDims, base: $c.rgsabound[$r].lLbound )   
1816                         )
1817                         #elif ($c.fFeatures & 0x0800)           ; FADF_VARIANT
1818                         (
1819                                 #array(expr: ((tagVARIANT *)$c.pvData)[$i], size: $c.rgsabound[$r].cElements, rank: $c.cDims, base: $c.rgsabound[$r].lLbound )  
1820                         )
1821                 )
1822         )
1823 }
1824
1825 tagPROPVARIANT|tagVARIANT|PROPVARIANT|VARIANT{
1826         preview(
1827                         #switch ($e.vt)
1828                                 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1829                                 ;;      Base Types                                          ;;
1830                                 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1831                                 #case 0 ( #("Empty") )                                                                          ; VT_EMPTY
1832                                 #case 1 ( #("NULL") )                                                                           ; VT_NULL
1833                                 #case 2 ( #("I2 = ", $e.iVal) )                                                         ; VT_I2
1834                                 #case 3 ( #("I4 = ", $e.lVal) )                                                         ; VT_I4
1835                                 #case 4 ( #("R4 = ", $e.fltVal) )                                                       ; VT_R4
1836                                 #case 5 ( #("R8 = ", $e.dblVal) )                                                       ; VT_R8
1837                                 #case 6 ( #("CY = ", $e.cyVal) )                                                        ; VT_CY
1838                                 #case 7 ( #("DATE =  ", $e.date) )                                                      ; VT_DATE
1839                                 #case 8 ( #("BSTR = ", $e.bstrVal) )                                            ; VT_BSTR
1840                                 #case 9 ( #("DISPATCH =  ", $e.pdispVal) )                                      ; VT_DISPATCH
1841                                 #case 10 ( #("ERROR =  ", $e.scode) )                                           ; VT_ERROR
1842                                 #case 0xB ( #("BOOL =  ", $e.boolVal) )                                         ; VT_BOOL
1843                                 #case 0xC ( #("VARIANT ") )                                                                     ; VT_VARIANT
1844                                 #case 0xD ( #("UNKNOWN =  ", $e.punkVal) )                                      ; VT_UNKNOWN
1845                                 #case 0xE ( #("DECIMAL = ", $e.hVal) )                                          ; VT_DECIMAL
1846                                 #case 0x10 ( #("I1 =  ", $e.cVal) )                                                     ; VT_I1
1847                                 #case 0x11 ( #("UI1 =  ", $e.bVal) )                                                    ; VT_UI1
1848                                 #case 0x12 ( #("UI2 =  ", $e.uiVal) )                                                   ; VT_UI2
1849                                 #case 0x13 ( #("UI4 =  ", $e.ulVal) )                                                   ; VT_UI4
1850                                 #case 0x14 ( #("I8 =  ", $e.hVal) )                                                     ; VT_I8
1851                                 #case 0x15 ( #("UI8 =  ", $e.uhVal) )                                                   ; VT_UI8
1852                                 #case 0x16 ( #("INT =  ", $e.intVal) )                                          ; VT_INT
1853                                 #case 0x17 ( #("UINT = ", $e.uintVal) )                                         ; VT_UINT
1854                                 #case 0x18 ( #("VOID ") )                                                                               ; VT_VOID
1855                                 #case 0x19 ( #("HRESULT ") )                                                                    ; VT_HRESULT
1856                                 #case 0x1A ( #("PTR ") )                                                                                ; VT_PTR
1857                                 #case 0x1B ( #("SAFEARRAY ") )                                                          ; VT_SAFEARRAY
1858                                 #case 0x1C ( #("CARRAY ") )                                                                     ; VT_CARRAY
1859                                 #case 0x1D ( #("USERDEFINED ") )                                                                ; VT_USERDEFINED
1860                                 #case 0x1E ( #("LPSTR =  ", $e.pszVal) )                                                ; VT_LPSTR
1861                                 #case 0x1F ( #("LPWSTR =  ", $e.pwszVal) )                                      ; VT_LPWSTR
1862                                 #case 0x24 ( #("RECORD  ") )                                                                    ; VT_RECORD
1863                                 #case 0x26 ( #("UINT_PTR ") )                                                                   ; VT_UINT_PTR
1864                                 #case 0x40 ( #("FILETIME =  ", $e.filetime) )                                   ; VT_FILETIME
1865                                 #case 0x42 ( #("STREAM =  ", $e.pStream) )                                      ; VT_STREAM
1866                                 #case 0x43 ( #("STORAGE = ", $e.pStorage) )                                     ; VT_STORAGE
1867                                 #case 0x44 ( #("STREAMED_OBJECT =  ", $e.pStream) )                     ; VT_STREAMED_OBJECT
1868                                 #case 0x45 ( #("STORED_OBJECT =  ", $e.pStorage) )                      ; VT_STORED_OBJECT
1869                                 #case 0x46 ( #("BLOB_OBJECT = ", $e.blob ) )                                    ; VT_BLOB_OBJECT
1870                                 #case 0x47 ( #("CF =  ", $e.pclipdata) )                                                ; VT_CF
1871                                 #case 0x48 ( #("CLSID = ", $e.puuid) )                                          ; VT_CLSID
1872                                 #case 0x49 ( #("VERSIONED_STREAM = ", $e.pVersionedStream) )    ; VT_VERSIONED_STREAM
1873                                 
1874                                 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1875                                 ;;   Vector types                                           ;;
1876                                 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1877                                 #case 0x1002 ( #("vector of I2 = ", $e.cai) )                                   ; VT_I2|VT_VECTOR
1878                                 #case 0x1003 ( #("vector of I4 = ", $e.cal) )                                   ; VT_I4|VT_VECTOR
1879                                 #case 0x1004 ( #("vector of R4 = ", $e.caflt) )                         ; VT_R4|VT_VECTOR
1880                                 #case 0x1005 ( #("vector of R8 = ", $e.cadbl) )                         ; VT_R8|VT_VECTOR
1881                                 #case 0x1010 ( #("vector of I1 =  ", $e.cac) )                          ; VT_I1|VT_VECTOR
1882                                 #case 0x1011 ( #("vector of UI1 =  ", $e.caub) )                                ; VT_UI1|VT_VECTOR
1883                                 #case 0x1012 ( #("vector of UI2 =  ", $e.caui) )                                ; VT_UI2|VT_VECTOR
1884                                 #case 0x1013 ( #("vector of UI4 =  ", $e.caul) )                                ; VT_UI4|VT_VECTOR
1885                                 #case 0x1014 ( #("vector of I8 =  ", $e.cah) )                          ; VT_I8|VT_VECTOR
1886                                 #case 0x1015 ( #("vector of UI8 =  ", $e.cauh) )                                ; VT_UI8|VT_VECTOR
1887                                 #case 0x101E ( #("vector of LPSTR =  ", $e.calpstr) )                   ; VT_LPSTR|VT_VECTOR
1888                                 #case 0x101F ( #("vector of LPWSTR =  ", $e.calpwstr) )         ; VT_LPWSTR|VT_VECTOR
1889                                 #case 0x100C ( #("vector of VARIANT ", $e.capropvar) )          ; VT_VARIANT|VT_VECTOR
1890                                 #case 0x100B ( #("vector of BOOL =  ", $e.cabool) )                 ; VT_BOOL|VT_VECTOR
1891                                 #case 0x100A ( #("vector of ERROR =  ", $e.cascode) )                   ; VT_ERROR|VT_VECTOR
1892                                 #case 0x1006 ( #("vector of CY = ", $e.cacy) )                          ; VT_CY|VT_VECTOR
1893                                 #case 0x1007 ( #("vector of DATE =  ", $e.cadate) )                     ; VT_DATE|VT_VECTOR
1894                                 #case 0x1040 ( #("vector of FILETIME =  ", $e.cafiletime) )     ; VT_FILETIME|VT_VECTOR
1895                                 #case 0x1048 ( #("vector of CLSID = ", $e.cauuid) )                     ; VT_CLSID|VT_VECTOR
1896                                 #case 0x1047 ( #("vector of CF =  ", $e.caclipdata) )                   ; VT_CF|VT_VECTOR
1897                                 #case 0x1008 ( #("vector of BSTR = ", $e.cabstr) )                      ; VT_BSTR|VT_VECTOR
1898                 
1899                                 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1900                                 ;;   Byref Types                                            ;;
1901                                 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1902                                 #case 0x4016 ( #("byref of INT =  ", $e.pintVal) )                              ; VT_INT|VT_BYREF
1903                                 #case 0x4017 ( #("byref of UINT = ", $e.puintVal) )                             ; VT_UINT|VT_BYREF
1904                                 #case 0x4002 ( #("byref of I2 = ", $e.piVal) )                                  ; VT_I2|VT_BYREF
1905                                 #case 0x4003 ( #("byref of I4 = ", $e.plVal) )                                  ; VT_I4|VT_BYREF
1906                                 #case 0x4004 ( #("byref of R4 = ", $e.pfltVal) )                                        ; VT_R4|VT_BYREF
1907                                 #case 0x4005 ( #("byref of R8 = ", $e.pdblVal) )                                        ; VT_R8|VT_BYREF
1908                                 #case 0x4010 ( #("byref of I1 =  ", $e.pcVal) )                                 ; VT_I1|VT_BYREF
1909                                 #case 0x4011 ( #("byref of UI1 =  ", $e.pbVal) )                                        ; VT_UI1|VT_BYREF
1910                                 #case 0x4012 ( #("byref of UI2 =  ", $e.puiVal) )                               ; VT_UI2|VT_BYREF
1911                                 #case 0x4013 ( #("byref of UI4 =  ", $e.pulVal) )                               ; VT_UI4|VT_BYREF
1912                                 #case 0x400C ( #("byref of VARIANT ", $e.pvarVal) )                             ; VT_VARIANT|VT_BYREF
1913                                 #case 0x400B ( #("byref of BOOL =  ", $e.pboolVal) )                            ; VT_BOOL|VT_BYREF
1914                                 #case 0x400A ( #("byref of ERROR =  ", $e.pscode) )                             ; VT_ERROR|VT_BYREF
1915                                 #case 0x4006 ( #("byref of CY = ", $e.pcyVal) )                                 ; VT_CY|VT_BYREF
1916                                 #case 0x4007 ( #("byref of DATE =  ", $e.pdate) )                               ; VT_DATE|VT_BYREF
1917                                 #case 0x4008 ( #("byref of BSTR = ", $e.pbstrVal) )                             ; VT_BSTR|VT_BYREF
1918                                 #case 0x400E ( #("byref of DECIMAL = ", $e.pdecVal) )                   ; VT_DECIMAL|VT_BYREF
1919                                 #case 0x400D ( #("byref of UNKNOWN =  ", $e.ppunkVal) )                 ; VT_UNKNOWN|VT_BYREF
1920                                 #case 0x4009 ( #("byref of DISPATCH =  ", $e.ppdispVal) )               ; VT_DISPATCH|VT_BYREF
1921                                 #case 0x6000 ( #("byref of ARRAY =  ", $e.pparray) )                            ; VT_ARRAY|VT_BYREF
1922                                                         
1923                                 #default 
1924                                 ( 
1925                                         #if ($e.vt & 0x2000)
1926                                         (
1927                                                 $e.parray
1928                                         )
1929                                         #else
1930                                         (
1931                                                 #("Unknown vt type = ", $e.vt) 
1932                                         )
1933                                 )
1934         )
1935         
1936         
1937         children(
1938                         #(vt: $e.vt, 
1939                         #switch ($e.vt)
1940                                 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1941                                 ;;      Base Types                                          ;;
1942                                 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1943                                 #case 0x2 ( #(I2  : $e.iVal) )                                                          ; VT_I2
1944                                 #case 0x3 ( #(I4  : $e.lVal) )                                                          ; VT_I4
1945                                 #case 0x4 ( #(R4  : $e.fltVal) )                                                                ; VT_R4
1946                                 #case 0x5 ( #(R8  : $e.dblVal) )                                                                ; VT_R8
1947                                 #case 0x6 ( #(CY  : $e.cyVal) )                                                         ; VT_CY
1948                                 #case 0x7 ( #(DATE   : $e.date) )                                                               ; VT_DATE
1949                                 #case 0x8 ( #(BSTR  : $e.bstrVal) )                                                     ; VT_BSTR
1950                                 #case 0x9 ( #(DISPATCH   : $e.pdispVal) )                                               ; VT_DISPATCH
1951                                 #case 0xA ( #(ERROR   : $e.scode) )                                                     ; VT_ERROR
1952                                 #case 0xB ( #(BOOL   : $e.boolVal) )                                                    ; VT_BOOL
1953                                 #case 0xD ( #(UNKNOWN   : $e.punkVal) )                                         ; VT_UNKNOWN
1954                                 #case 0xE ( #(DECIMAL  : $e.hVal) )                                                     ; VT_DECIMAL
1955                                 #case 0x10 ( #(I1   : $e.cVal) )                                                                ; VT_I1
1956                                 #case 0x11 ( #(UI1   : $e.bVal) )                                                               ; VT_UI1
1957                                 #case 0x12 ( #(UI2   : $e.uiVal) )                                                      ; VT_UI2
1958                                 #case 0x13 ( #(UI4   : $e.ulVal) )                                                      ; VT_UI4
1959                                 #case 0x14 ( #(I8   : $e.hVal) )                                                                ; VT_I8
1960                                 #case 0x15 ( #(UI8   : $e.uhVal) )                                                      ; VT_UI8
1961                                 #case 0x16 ( #(INT   : $e.intVal) )                                                     ; VT_INT
1962                                 #case 0x17 ( #(UINT  : $e.uintVal) )                                                    ; VT_UINT
1963                                 #case 0x1E ( #(LPSTR   : $e.pszVal) )                                                   ; VT_LPSTR
1964                                 #case 0x1F ( #(LPWSTR   : $e.pwszVal) )                                         ; VT_LPWSTR
1965                                 #case 0x40 ( #(FILETIME   : $e.filetime) )                                      ; VT_FILETIME
1966                                 #case 0x42 ( #(STREAM   : $e.pStream) )                                         ; VT_STREAM
1967                                 #case 0x43 ( #(STORAGE  : $e.pStorage) )                                                ; VT_STORAGE
1968                                 #case 0x44 ( #(STREAMED_OBJECT   : $e.pStream) )                                ; VT_STREAMED_OBJECT
1969                                 #case 0x45 ( #(STORED_OBJECT   : $e.pStorage) )                         ; VT_STORED_OBJECT
1970                                 #case 0x46 ( #(BLOB_OBJECT  : $e.blob ) )                                               ; VT_BLOB_OBJECT
1971                                 #case 0x47 ( #(CF   : $e.pclipdata) )                                                   ; VT_CF
1972                                 #case 0x48 ( #(CLSID  : $e.puuid) )                                                     ; VT_CLSID
1973                                 #case 0x49 ( #(VERSIONED_STREAM  : $e.pVersionedStream) )               ; VT_VERSIONED_STREAM
1974                                 
1975                                 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1976                                 ;;   Vector types                                           ;;
1977                                 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1978                                 #case 0x1002 ( #(vector of I2  : $e.cai) )                                      ; VT_I2|VT_VECTOR
1979                                 #case 0x1003 ( #(vector of I4  : $e.cal) )                                      ; VT_I4|VT_VECTOR
1980                                 #case 0x1004 ( #(vector of R4  : $e.caflt) )                                    ; VT_R4|VT_VECTOR
1981                                 #case 0x1005 ( #(vector of R8  : $e.cadbl) )                                    ; VT_R8|VT_VECTOR
1982                                 #case 0x1010 ( #(vector of I1   : $e.cac) )                                     ; VT_I1|VT_VECTOR
1983                                 #case 0x1011 ( #(vector of UI1   : $e.caub) )                                   ; VT_UI1|VT_VECTOR
1984                                 #case 0x1012 ( #(vector of UI2   : $e.caui) )                                   ; VT_UI2|VT_VECTOR
1985                                 #case 0x1013 ( #(vector of UI4   : $e.caul) )                                   ; VT_UI4|VT_VECTOR
1986                                 #case 0x1014 ( #(vector of I8   : $e.cah) )                                     ; VT_I8|VT_VECTOR
1987                                 #case 0x1015 ( #(vector of UI8   : $e.cauh) )                                   ; VT_UI8|VT_VECTOR
1988                                 #case 0x101E ( #(vector of LPSTR   : $e.calpstr) )                      ; VT_LPSTR|VT_VECTOR
1989                                 #case 0x101F ( #(vector of LPWSTR   : $e.calpwstr) )                    ; VT_LPWSTR|VT_VECTOR
1990                                 #case 0x100C ( #(vector of VARIANT : $e.capropvar) )                    ; VT_VARIANT|VT_VECTOR
1991                                 #case 0x100B ( #(vector of BOOL   : $e.cabool) )                                ; VT_BOOL|VT_VECTOR
1992                                 #case 0x100A ( #(vector of ERROR   : $e.cascode) )                      ; VT_ERROR|VT_VECTOR
1993                                 #case 0x1006 ( #(vector of CY  : $e.cacy) )                                     ; VT_CY|VT_VECTOR
1994                                 #case 0x1007 ( #(vector of DATE   : $e.cadate) )                                ; VT_DATE|VT_VECTOR
1995                                 #case 0x1040 ( #(vector of FILETIME   : $e.cafiletime) )                ; VT_FILETIME|VT_VECTOR
1996                                 #case 0x1048 ( #(vector of CLSID  : $e.cauuid) )                                ; VT_CLSID|VT_VECTOR
1997                                 #case 0x1047 ( #(vector of CF   : $e.caclipdata) )                      ; VT_CF|VT_VECTOR
1998                                 #case 0x1008 ( #(vector of BSTR  : $e.cabstr) )                         ; VT_BSTR|VT_VECTOR
1999
2000                                 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2001                                 ;;   Byref Types                                            ;;
2002                                 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2003                                 #case 0x4016 ( #(byref of INT   : $e.pintVal) )                         ; VT_INT|VT_BYREF
2004                                 #case 0x4017 ( #(byref of UINT  : $e.puintVal) )                                ; VT_UINT|VT_BYREF
2005                                 #case 0x4002 ( #(byref of I2  : $e.piVal) )                                     ; VT_I2|VT_BYREF
2006                                 #case 0x4003 ( #(byref of I4  : $e.plVal) )                                     ; VT_I4|VT_BYREF
2007                                 #case 0x4004 ( #(byref of R4  : $e.pfltVal) )                           ; VT_R4|VT_BYREF
2008                                 #case 0x4005 ( #(byref of R8  : $e.pdblVal) )                           ; VT_R8|VT_BYREF
2009                                 #case 0x4010 ( #(byref of I1   : $e.pcVal) )                                    ; VT_I1|VT_BYREF
2010                                 #case 0x4011 ( #(byref of UI1   : $e.pbVal) )                           ; VT_UI1|VT_BYREF
2011                                 #case 0x4012 ( #(byref of UI2   : $e.puiVal) )                          ; VT_UI2|VT_BYREF
2012                                 #case 0x4013 ( #(byref of UI4   : $e.pulVal) )                          ; VT_UI4|VT_BYREF
2013                                 #case 0x400C ( #(byref of VARIANT : $e.pvarVal) )                       ; VT_VARIANT|VT_BYREF
2014                                 #case 0x400B ( #(byref of BOOL   : $e.pboolVal) )                       ; VT_BOOL|VT_BYREF
2015                                 #case 0x400A ( #(byref of ERROR   : $e.pscode) )                                ; VT_ERROR|VT_BYREF
2016                                 #case 0x4006 ( #(byref of CY  : $e.pcyVal) )                                    ; VT_CY|VT_BYREF
2017                                 #case 0x4007 ( #(byref of DATE   : $e.pdate) )                          ; VT_DATE|VT_BYREF
2018                                 #case 0x4008 ( #(byref of BSTR  : $e.pbstrVal) )                                ; VT_BSTR|VT_BYREF
2019                                 #case 0x400E ( #(byref of DECIMAL  : $e.pdecVal) )                      ; VT_DECIMAL|VT_BYREF
2020                                 #case 0x400D ( #(byref of UNKNOWN   : $e.ppunkVal) )                    ; VT_UNKNOWN|VT_BYREF
2021                                 #case 0x4009 ( #(byref of DISPATCH   : $e.ppdispVal) )          ; VT_DISPATCH|VT_BYREF
2022                                 #case 0x6000 ( #(byref of ARRAY   : $e.pparray) )                       ; VT_ARRAY|VT_BYREF
2023                                 
2024                                 ; the following are either empty or invalid vt values for a variant
2025                                 ; #case 0 ( #(Empty :) )                                                                                ; VT_EMPTY
2026                                 ; #case 0x1 ( #(NULL :) )                                                                               ; VT_NULL
2027                                 ; #case 0xC ( #(VARIANT :) )                                                                    ; VT_VARIANT
2028                                 ; #case 0x18 ( #(VOID :) )                                                                              ; VT_VOID
2029                                 ; #case 0x19 ( #(HRESULT :) )                                                                   ; VT_HRESULT
2030                                 ; #case 0x1A ( #(PTR :) )                                                                               ; VT_PTR
2031                                 ; #case 0x1B ( #(SAFEARRAY :) )                                                                 ; VT_SAFEARRAY
2032                                 ; #case 0x1C ( #(CARRAY :) )                                                                    ; VT_CARRAY
2033                                 ; #case 0x1D ( #(USERDEFINED :) )                                                               ; VT_USERDEFINED
2034                                 ; #case 0x24 ( #(RECORD  :) )                                                                   ; VT_RECORD
2035                                 ; #case 0x26 ( #(UINT_PTR :) )                                                                  ; VT_UINT_PTR
2036                                                         
2037                                 #default 
2038                                 ( 
2039                                         #if ($e.vt & 0x2000 )
2040                                         (
2041                                                 #(safearray: $e.parray)
2042                                         )
2043                                         #else
2044                                         (
2045                                                 #(
2046                                                         [raw members]: [$e,!]   ; unformatted data members
2047                                                 )
2048                                         )
2049                                 )                                                       
2050                                 #except 
2051                                 ( 
2052                                         #(
2053                                                 [raw members]: [$e,!]   ; unformatted data members
2054                                         )
2055                                 )                                                       
2056         ))
2057 }
2058
2059 ; This section lets you define your own errors for the HRESULT display.
2060 ; You need to list the error code in unsigned decimal, followed by the message.
2061 ; Changes will take effect the next time you redisplay the variable.
2062 [hresult]
2063 ;1234=my custom error code
2064
2065
2066