src/AUTOEXP.DAT

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