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