;---------------------------------------------------------------
; This comment block added by the CLR dev team.
;
; This is a custom autoexp.dat that causes VS2005 to nicely
; pretty-print common CLR data types (MethodDesc, EEClass, etc.)
; in the debugger watch window. For example, instead of
; seeing
;
;     pString     {...}         
;
; you will see the more useful
;
;     pString     {0x<addr> "Hello" }
;
;
;
;
; To use this file, replace the autoexp.dat file in your VS
; installation with this one. This file is normally found under
; this path:
;
;    C:\Program Files\Microsoft Visual Studio 8\Common7\Packages\Debugger
;
; If you have your own custom rules that you don't want messed
; up or you're just healthily paranoid, you can cut and paste
; the CLR-specific section only. The section begins with
;
;   ;---- [BEGIN] CLR-specific autoexps ---------------------------
;
; and ends with
;
;   ;---- [END] CLR-specific autoexps ---------------------------
;
; Note that this *must* go into the [AutoExpand] section of the file.
; Don't just append to the end of the file or the debugger won't
; see it.
;
; 
;
;---------------------------------------------------------------








;---------------------------------------------------------------
; AutoExp.Dat - templates for automatically expanding data
; Copyright(c) Microsoft Corporation. All Rights Reserved.
;---------------------------------------------------------------
;
; While debugging, Data Tips and items in the Watch and Variable
; windows are automatically expanded to show their most important
; elements. The expansion follows the format given by the rules
; in this file. You can add rules for your types or change the
; predefined rules.
;
; For good examples, read the rules in this file.
;
; To find what the debugger considers the type of a variable to
; be, add it to the Watch window and look at the Type column.
;
; An AutoExpand rule is a line with the name of a type, an equals 
; sign, and text with replaceable parts in angle brackets. The 
; part in angle brackets names a member of the type and an 
; optional Watch format specifier.
;
; AutoExpand rules use the following syntax. The equals sign (=), 
; angle brackets (<>), and comma are taken literally. Square
; brackets ([]) indicate optional items.
;
; type=[text]<member[,format]>...
;
; type      Name of the type (may be followed by <*> for template
;           types such as the ATL types listed below).
;
; text      Any text.Usually the name of the member to display, 
;           or a shorthand name for the member.
;
; member    Name of a member to display.
;
; format    Watch format specifier. One of the following:
;
;   Letter  Description                 Sample         Display
;   ------  --------------------------  ------------   -------------
;   d,i     Signed decimal integer      0xF000F065,d   -268373915
;   u       Unsigned decimal integer    0x0065,u       101
;   o       Unsigned octal integer      0xF065,o       0170145
;   x,X     Hexadecimal integer         61541,X        0X0000F065
;   l,h     long or short prefix for    00406042,hx    0x0c22
;             d, i, u, o, x, X
;   f       Signed floating-point       3./2.,f        1.500000
;   e       Signed scientific-notation  3./2.,e        1.500000e+000
;   g       Shorter of e and f          3./2.,g        1.5
;   c       Single character            0x0065,c       'e'
;   s       Zero-terminated string      pVar,s         "Hello world"
;   su      Unicode string              pVar,su        "Hello world"
;
; For details of other format specifiers see Help under:
; "format specifiers/watch variable"
;
; The special format <,t> specifies the name of the most-derived 
; type of the object. This is especially useful with pointers or
; references to a base class.
;
; If there is no rule for a class, the base classes are checked for
; a matching rule.
;
; There are some special entries allowed in the AutoExpand section:
; $BUILTIN is used to display more complex types that need to do more
; than just show a member variable or two.
; $ADDIN allows external DLLs to be added to display even more complex
; types via the EE Add-in API. The first argument is the DLL name, the
; second argument is the name of the export from the DLL to use. For 
; further information on this API see the sample called EEAddIn.
;
; WARNING: if hexadecimal mode is on in the watch window, all numbers here are
; evaluated in hex, e.g. 42 becomes 0x42

[AutoExpand]

;---- [BEGIN] CLR-specific autoexps ---------------------------
; 


PEFile=<m_pDebugName,su>
Module=<m_file->m_pDebugName, su>
Assembly=<m_pManifestFile->m_pDebugName,su>
ClassLoader=<m_pAssembly->m_pManifestFile->m_pDebugName,su>
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>

TypeHandle=<m_asMT->m_pEEClass->m_szDebugClassName,s>
ParamTypeDesc=<m_TemplateMT->m_pEEClass->m_szDebugClassName, s>


EEClass=<m_szDebugClassName,s>
MethodTable=<m_pEEClass->m_szDebugClassName,s>
MethodDesc=<m_pszDebugClassName,s>::<m_pszDebugMethodName,s> 
ReflectMethod=<pMethod->m_pszDebugClassName,s>::<pMethod->m_pszDebugMethodName,s> 
FieldDesc=<m_pMTOfEnclosingClass->m_pEEClass->m_szDebugClassName,s>::<m_debugName,s>

Thread=<m_ThreadId,x>

BaseObject=<m_pMethTab->m_pEEClass->m_szDebugClassName,s>
Object=<m_pMethTab->m_pEEClass->m_szDebugClassName,s>
StringObject=<m_Characters>
OBJECTREF= <m_asObj->m_pMethTab->m_pEEClass->m_szDebugClassName,s>
REF<StringObject>=<m_asString->m_Characters>
REF<*>= <m_asObj->m_pMethTab->m_pEEClass->m_szDebugClassName,s>

; SStrings are annoying because their internal buffer can be in either
; unicode or ansi depending on the code path. Thus, this rule attempts
; to print it both ways. We will do the ascii attempt first as it's
; less likely to produce verbose garbage (usually, it'll print just the
; first character.)
;
; So the typical output you'll see is...
;
;   {"A"/"ABCD"}              ; sbuffer is using unicode representation
;   {"ABCD"/"<square boxes>"} ; sbuffer was using ansi representation
;
; The rule below also kicks in as desired for StackSString and InlineSString.

SString =<m_buffer, s>|<m_buffer, su>


HolderBase<*>=<m_value>

NATIVE_BINDER_SPACE::IEntry=<_tag,su>
HolderBase<NATIVE_BINDER_SPACE::IEntry *>=<m_value> <m_value->_tag,su>
HolderBase<NATIVE_BINDER_SPACE::CILEntry *>=<m_value> <m_value->_tag,su>
HolderBase<NATIVE_BINDER_SPACE::CNgenEntry *>=<m_value> <m_value->_tag,su>

NATIVE_BINDER_SPACE::CILEntryBind=<_pILEntry->_tag,su>
HolderBase<NATIVE_BINDER_SPACE::CILEntryBind *>=<m_value> <m_value->_pILEntry->_tag,su>

NATIVE_BINDER_SPACE::CNgenEntryBind=<_pNgenEntry->_tag,su>
HolderBase<NATIVE_BINDER_SPACE::CNgenEntryBind *>=<m_value> <m_value->_pNgenEntry->_tag,su>

NATIVE_BINDER_SPACE::CDependencyEntry=<_pEntry->_tag,su>
HolderBase<NATIVE_BINDER_SPACE::CDependencyEntry *>=<m_value> <m_value->_pEntry->_tag,su>

CAssemblyName=<_rProp._rProp[3].asStr>
HolderBase<CAssemblyName *>=<m_value->_rProp._rProp[3].asStr>
HolderBase<IAssemblyName *>=<m_pAutoExpVisibleValue->_asCAssemblyName->_rProp._rProp[3].asStr>

BindResult=<m_tag,su>
HolderBase<BindResult *>=<m_value->m_tag,su>
HolderBase<IBindResult *>=<m_pAutoExpVisibleValue->_asBindResult->m_tag,su>

AssemblyLocation=<m_pwzAssemblyPath>
HolderBase<AssemblyLocation *>=<m_value->m_pwzAssemblyPath>
HolderBase<IAssemblyLocation *>=<m_pAutoExpVisibleValue->_asAssemblyLocation->m_pwzAssemblyPath>


;---- [END] CLR-specific autoexps ---------------------------






; from windef.h
tagPOINT =x=<x> y=<y>
tagRECT =top=<top> bottom=<bottom> left=<left> right=<right>

; from winuser.h
tagMSG =msg=<message,x> wp=<wParam,x> lp=<lParam,x>

; intrinsics
__m64 =<m64_i64,x>
__m128=$BUILTIN(M128)
__m128i=$BUILTIN(M128I)
__m128d=$BUILTIN(M128D)

; from afxwin.h
CDC =hDC=<m_hDC> attrib=<m_hAttribDC>
CPaintDC =<,t> hWnd=<m_hWnd>
CPoint =x=<x> y=<y>
CRect =top=<top> bottom=<bottom> left=<left> right=<right>
CSize =cx=<cx> cy=<cy>
CWnd =<,t> hWnd=<m_hWnd>
CWinApp =<,t> <m_pszAppName,s>
CWinThread =<,t> h=<m_hThread> proc=<m_pfnThreadProc>

; from afxcoll.h
CPtrList =cnt=<m_nCount>

; from afxstat_.h
CProcessLocalObject =<,t>
CThreadLocalObject =<,t>

; from afx.h
CArchiveException =cause=<m_cause>
CFile =hFile=<m_hFile> name=<m_strFileName.m_pchData,s>
CFileException =cause=<m_cause> OS Error=m_lOsError
CMemFile =pos=<m_nPosition> size=<m_nFileSize>
CObject =<,t>
CRuntimeClass =<m_lpszClassName,s>
CStdioFile =FILE*=<m_pStream> name=<m_strFilename.m_pchData,s>
CTimeSpan =time=<m_time>
CTime =time=<m_time>

; from afxcoll.h
CByteArray =count=<m_nCount>
CStringList =count=<m_nCount>
; same for all CXXXArray classes
; same for CXXXList
; same for CMapXXToXX

; various string classes from MFC & ATL

_com_error=<m_hresult,hr>
_bstr_t=<m_Data->m_wstr,su> (<m_Data->m_RefCount,u>)
_com_ptr_t<*>=<m_pInterface>
_LARGE_INTEGER=<QuadPart>
_ULARGE_INTEGER=<QuadPart>
ATL::CComPtr<*>=<p>

ATL::CComQIPtr<*>=<p>

tagVARIANT=$BUILTIN(VARIANT)
VARIANT=$BUILTIN(VARIANT)
_GUID=$BUILTIN(GUID)

; see EEAddIn sample for how to use these
;_SYSTEMTIME=$ADDIN(EEAddIn.dll,AddIn_SystemTime)
;_FILETIME=$ADDIN(EEAddIn.dll,AddIn_FileTime)

std::binder1st<*>= op=<op> value=<value>
std::binder2nd<*>= op=<op> value=<value>
std::less<*>=lessthan
std::greater<*>=greaterthan

[Visualizer]
; This section contains visualizers for STL and ATL containers
; DO NOT MODIFY



ATL::CStringT<char,*>|CSimpleStringT<char,*>|ATL::CSimpleStringT<char,*>{
	preview([$c.m_pszData,s])
        stringview([$c.m_pszData,sb])
}

ATL::CStringT<wchar_t,*>|CSimpleStringT<wchar_t,*>|ATL::CSimpleStringT<wchar_t,*>|ATL::CStringT<unsigned short,*>|CSimpleStringT<unsigned short,*>|ATL::CSimpleStringT<unsigned short,*>{
	preview([$c.m_pszData,su])
        stringview([$c.m_pszData,sub])
}

ATL::CComBSTR{
	preview([$c.m_str,su])
        stringview([$c.m_str,sub])
}


;------------------------------------------------------------------------------
;  std::vector<bool,*> specialization
;------------------------------------------------------------------------------

std::vector<bool,*>{
	children
	(
		#array
		(
			expr : ($c._Myvec._Myfirst[$i / _VBITS] >> ($i % _VBITS)), 
			size : ($c._Mysize)
		)  : (bool)($e & 1)
	)
		
    preview
    ( 
            #( 
				"[", 
				$e._Mysize , 
				"](", 
				#array
				(
					expr : ($c._Myvec._Myfirst[$i / _VBITS] >> ($i % _VBITS)), 
					size : ($c._Mysize)
				)  : (bool)($e & 1), ")")
	)		
}

std::vector<bool,*>::iterator|std::vector<bool,*>::const_iterator|std::_Vb_iterator<*>|std::_Vb_const_iterator<*>{
	preview
	(
		#( 
			(bool) (((*$e._Myptr) >> $e._Myoff) & 1)   
		)
	)
	
	children
	(
		#( 
			ptr: (bool) (((*$e._Myptr) >> $e._Myoff) & 1)   
		)
	)

	
}


;------------------------------------------------------------------------------
;  std::vector
;------------------------------------------------------------------------------
std::vector<*>{
	children
	(
	    #array
	    (
			expr :	($c._Myfirst)[$i],  
			size :	$c._Mylast-$c._Myfirst
		)
	)
	
    preview
    ( 
        #( 
			"[", 
            $e._Mylast - $e._Myfirst , 
            "](", 
            
            #array
            (
				expr : 	($c._Myfirst)[$i],  
				size : 	$c._Mylast-$c._Myfirst
			), 
			")"
		)
	)
	

}

std::_Vector_iterator<*>|std::_Vector_const_iterator<*>{
	preview 
	(
		#(*$e._Myptr)
	)
	
	children
	(
		#(ptr: *$e._Myptr)
	)
}



;------------------------------------------------------------------------------
;  std::string/basic_string
;------------------------------------------------------------------------------

std::basic_string<char,*>{
	preview
	( 
		#if(($e._Myres) < ($e._BUF_SIZE))
		(
			[$e._Bx._Buf,s]
		)
		#else
		(
			[$e._Bx._Ptr,s]
		)
	)
	
	stringview
	(
		#if(($e._Myres) < ($e._BUF_SIZE))
		(
			[$e._Bx._Buf,sb]
		)
		#else
		(
			[$e._Bx._Ptr,sb]
		)
	)
	
	children
	(
		#if(($e._Myres) < ($e._BUF_SIZE))
		(
			#([actual members]: [$e,!] , #array( expr: $e._Bx._Buf[$i], size: $e._Mysize))
		)
		#else
		(
			#([actual members]: [$e,!],  #array( expr: $e._Bx._Ptr[$i], size: $e._Mysize))
		)	
	)	

}

std::basic_string<unsigned short,*>|std::basic_string<wchar_t,*>{
	preview
	( 
		#if(($e._Myres) < ($e._BUF_SIZE)) ( [$e._Bx._Buf,su] )
		#else ( [$e._Bx._Ptr,su] )
	)
	
	stringview
	( 
		#if(($e._Myres) < ($e._BUF_SIZE)) ( [$e._Bx._Buf,sub] )
		#else ( [$e._Bx._Ptr,sub] )
	)
	
	children
	(
		#if(($e._Myres) < ($e._BUF_SIZE))
		(
			#([actual members]: [$e,!] , #array( expr: $e._Bx._Buf[$i], size: $e._Mysize))
		)
		#else
		(
			#([actual members]: [$e,!],  #array( expr: $e._Bx._Ptr[$i], size: $e._Mysize))
		)	
	)	
}

std::basic_string<*>::iterator|std::basic_string<*>::const_iterator|std::_String_iterator<*>|std::_String_const_iterator<*>{
	preview
	( 
		#( $e._Myptr ) 
	)

	children
	( 
		#( ptr: $e._Myptr ) 
	)
}

std::pair<*>{
	preview
	(
		#( 
			"(", 
			$e.first, 
			",", 
			$e.second , 
			")"
		)
	)
}

;------------------------------------------------------------------------------
;  std::auto_ptr
;------------------------------------------------------------------------------

std::auto_ptr<*>{
	preview
	( 
		#(	"auto_ptr ",
			(*(($T1 *)$c._Myptr))
		 )
	)
	children
	( 
		#( 
			ptr: (*(($T1 *)$c._Myptr)) 
		)
	)
}

;------------------------------------------------------------------------------
;  std::map
;------------------------------------------------------------------------------

std::map<*>{
	children
	(
		#tree
		(
			head : $c._Myhead->_Parent, 
		    skip : $c._Myhead, 
		    size : $c._Mysize, 
		    left : _Left, 
		    right : _Right
		) : $e._Myval
	)
		     
	preview
	(
		#(
			"[", 
			$e._Mysize, 
			"](", 

			#tree
			(
				head : $c._Myhead->_Parent, 
				skip : $c._Myhead, 
				size : $c._Mysize, 
				left : _Left, 
				right : _Right
			) : $e._Myval,
			
			")"
		)
	)		     
}

;------------------------------------------------------------------------------
;  std::multi_map
;------------------------------------------------------------------------------

std::multimap<*>{
	children
	(
		#tree
		(
			head : $c._Myhead->_Parent, 
		    skip : $c._Myhead, 
		    size : $c._Mysize, 
		    left : _Left, 
		    right : _Right
		) : $e._Myval
	)
		     
	preview
	(
		#(
			"[", 
			$e._Mysize, 
			"](", 
			
			#tree
			(	
				head : $c._Myhead->_Parent, 
				skip : $c._Myhead, 
				size : $c._Mysize, 
				left : _Left, 
				right : _Right
			) : $e._Myval,
			
			")"
		)
	)		     
}


;------------------------------------------------------------------------------
;  std::list
;------------------------------------------------------------------------------

std::list<*>{

	children
	(
		#list
		(
			head : $c._Myhead->_Next, 
		    size : $c._Mysize, 
		    next : _Next
		) : $e._Myval
	)
		          
	preview
	(
		#(
			"[", 
			$e._Mysize, 
			"](", 
		  
			#list
			(
				head : $c._Myhead->_Next, 
				size : $c._Mysize, 
				next : _Next
			) : $e._Myval,
		 
			")"
		)
	)			      
}

std::list<*>::iterator|std::list<*>::const_iterator|std::list<*>::_Iterator<1>|std::list<*>::_Const_iterator<1>{
	preview
	(
		#($e._Ptr->_Myval)
	)
	
	children
	(
		#(ptr: $e._Ptr->_Myval)
	)

}


;------------------------------------------------------------------------------
;  std::bitset  <bitset>
;------------------------------------------------------------------------------

std::bitset<*>{       
	preview
	(
		#(
		"[",
			$c.digits,
		"](",
		#array
		(	
			expr : 	($c._Array[$i / $c._Bitsperword] >> ($i % $c._Bitsperword)),  
			size : 	$c.digits
		) : [($e & 1),d],
		")"
		)
	)
	children
	(
		#array
		(	
			expr : 	($c._Array[$i / $c._Bitsperword] >> ($i % $c._Bitsperword)),  
			size : 	$c.digits
		) : (bool)($e & 1))
}

std::bitset<*>::reference{
    preview
    (
		#(
			"bitset[", $e._Mypos, "] = ", 
			(bool)(($e._Pbitset->_Array[$i / _Bitsperword] >> ($e._Mypos % _Bitsperword)) & 1) 
		)
    )
}

;------------------------------------------------------------------------------
;  std::deque
;------------------------------------------------------------------------------

std::deque<*>{
	children
	(
		#array
		(
			expr : $c._Map[ (($i + $c._Myoff) / $c._EEN_DS) % $c._Mapsize][($i + $c._Myoff) % $c._EEN_DS],  
			size : $c._Mysize
		)
	)

	preview
	(
		#(
			"[", 
			$e._Mysize, 
			"](", 
		  
			#array
			(
				expr : $c._Map[ (($i + $c._Myoff) / $c._EEN_DS) % $c._Mapsize][($i + $c._Myoff) % $c._EEN_DS],  
				size : $c._Mysize
			),
		 
			")"
		)
	)		       
}

std::deque<*,*>::iterator|std::_Deque_iterator<*,*,*>|std::_Deque_const_iterator<*,*,*>{
   preview
   (
	   #if( $e._Myoff >= ((std::deque<$T1,$T2 > *)$c._Mycont)->_Myoff + ((std::deque<$T1,$T2 > *)$c._Mycont)->_Mysize)
	   (
	   		#("<end>")
	   )
	   #else(
			#(
				"deque[", 
				$e._Myoff - ((std::deque<$T1,$T2 > *)$c._Mycont)->_Myoff, 
				"] = ",
				((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] 
			)
		)
	)
	children
	(
	   #if( ((std::deque<$T1,$T2 > *)$c._Mycont)->_Myoff + ((std::deque<$T1,$T2 > *)$c._Mycont)->_Mysize > $e._Myoff) 
	   (
			#(
				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] 
			)
		)
	)
}

;------------------------------------------------------------------------------
;  std::queue
;------------------------------------------------------------------------------

std::queue<*>{
	children
	(
		#array
		(
			expr : $c.c._Map[ (($i + $c.c._Myoff) / $c.c._EEN_DS) % $c.c._Mapsize][($i + $c.c._Myoff) % $c.c._EEN_DS],  
			size : $c.c._Mysize
		)
	)
		   
 preview
	(
		#(
			"[", 
			$e.c._Mysize, 
			"](", 
		  
			#array
			(
				expr : $c.c._Map[ (($i + $c.c._Myoff) / $c.c._EEN_DS) % $c.c._Mapsize][($i + $c.c._Myoff) % $c.c._EEN_DS],  
				size : $c.c._Mysize
			),
		 
			")"
		)
	)			   
}


;------------------------------------------------------------------------------
;  std::priority_queue
;------------------------------------------------------------------------------

std::priority_queue<*>{
	preview
	( 
		$e.c 
	)
}

;------------------------------------------------------------------------------
;  std::set
;------------------------------------------------------------------------------

std::set<*>{
    preview
    ( 
		#( 
			"[", 
            $e._Mysize , 
            "](", 
            
            #tree
            (
				head : $c._Myhead->_Parent, 
				skip : $c._Myhead, 
				left : _Left, 
				right : _Right,
				size  : $c._Mysize
			) : $e._Myval, 
			
			")"
		)
	)
			   
	children
	(
		#tree
		(
			head : $c._Myhead->_Parent, 
			skip : $c._Myhead, 
			left : _Left, 
			right : _Right,
			size  : $c._Mysize
		) : $e._Myval
	)
}

;------------------------------------------------------------------------------
;  std::multi_set
;------------------------------------------------------------------------------

std::multiset<*>{
    preview
    (
		#( 
			"[", 
            $e._Mysize , 
            "](", 
            
            #tree
            (
				head : $c._Myhead->_Parent, 
				skip : $c._Myhead, 
				left : _Left, 
				right : _Right,
				size  : $c._Mysize
			) : $e._Myval, 
			
			")"
		)
	)
			   
	children
	(
		#tree
		(
			head : $c._Myhead->_Parent, 
			skip : $c._Myhead, 
			left : _Left, 
			right : _Right,
			size  : $c._Mysize
		) : $e._Myval
	)
}


;------------------------------------------------------------------------------
;  std::_Tree (shared my map/multimap/set/multiset)
;------------------------------------------------------------------------------

std::_Tree<*>::iterator|std::_Tree<*>::const_iterator{
	preview
	(
		#($e._Ptr->_Myval)
	)
	
	children
	(
		#(ptr: $e._Ptr->_Myval)
	)

	
}


;------------------------------------------------------------------------------
;  std::stack
;------------------------------------------------------------------------------

std::stack<*>{
	children
	(
		#array
		(
			expr : $c.c._Map[ (($i + $c.c._Myoff) / $c.c._EEN_DS) % $c.c._Mapsize][($i + $c.c._Myoff) % $c.c._EEN_DS],  
			size : $c.c._Mysize
		)
	)
           
    preview
    (
		#( 
			"[", 
            $e.c._Mysize , 
            "](", 
            
            #array
            (
				expr : $c.c._Map[ (($i + $c.c._Myoff) / $c.c._EEN_DS) % $c.c._Mapsize][($i + $c.c._Myoff) % $c.c._EEN_DS],  
				size : $c.c._Mysize
			), 
			
			")"
		)
	)           
}

;------------------------------------------------------------------------------
;  stdext::hash_map
;  stdext::hash_multimap
;  stdext::hash_set
;  stdext::hash_multiset
;------------------------------------------------------------------------------

stdext::hash_map<*>|stdext::hash_multimap<*>|stdext::hash_set<*>|stdext::hash_multiset<*>{
	
	preview
	(
		#(
			"[", 
			$e._List._Mysize, 
			"](", 
		 
			#list
			(
				head : $c._List._Myhead->_Next, 
          	    size : $c._List._Mysize,
				next : _Next
			) : $e._Myval,
			
			")"
		)
	)	

	children
	(
    
		#list
		(
			head : $c._List._Myhead->_Next, 
			size : $c._List._Mysize, 
			next : _Next
		) : $e._Myval
	)
}

;------------------------------------------------------------------------------
;  std::complex
;------------------------------------------------------------------------------

std::complex<*>{
	children
	(
		#(
			real: $e._Val[0],
			imaginary: $e._Val[1]
		)
	)
	preview
	(
		#if($e._Val[1] != 0)
		(										
			#if ($e._Val[0] != 0)				
			(									; Real and Imaginary components 
				#if ($e._Val[1] >= 0)
				(
					#($e._Val[0],"+i*", $e._Val[1])
				)
				#else
				(
					#($e._Val[0],"-i*", -$e._Val[1])							  
				)
			)
			#else
			(									; Purely imaginary
				#if ($e._Val[1] >= 0.0)
				(
					#("i*", $e._Val[1])
				)
				#else
				(
					#("-i*", -$e._Val[1])						
				)
			)
		)
		#else
		(										; Purely real
			$e._Val[0]		
		)
	)
}

;------------------------------------------------------------------------------
;  std::valarray
;------------------------------------------------------------------------------

std::valarray<*>{
    preview
    ( 
		#( 
			"[", 
            $e._Mysize , 
            "](", 
            
            #array
            (
				expr : 	($c._Myptr)[$i],  
				size : 	$c._Mysize
			), 
			
			")"
		)
	)
	
	children
	(
		#array
		(
			expr :	($c._Myptr)[$i],  
			size :	$c._Mysize
		)
	)
}

;------------------------------------------------------------------------------
;  PROPVARIANT
;------------------------------------------------------------------------------

; Visualizers for VT_VECTOR C arrays
tagCAC|tagCAUB|tagCAI|tagCAUI|tagCAL|tagCAUL|tagCAFLT|tagCADBL|tagCACY|tagCADATE|tagCABSTR|tagCABSTRBLOB|tagCABOOL|tagCASCODE|tagCAPROPVARIANT|tagCAH|tagCAUH|tagCALPSTR|tagCALPWSTR|tagCAFILETIME|tagCACLIPDATA|tagCACLSID{
	preview(
		#( 
			"[", 
            $e.cElems , 
            "](", 
            
            #array
            (
				expr : 	($c.pElems)[$i],  
				size : 	$c.cElems
			), 			
			")"
		)
	)

	children
	(
		#array
		(
			expr :	($c.pElems)[$i],  
			size :	$c.cElems
		)
	)	
	
}

; Visualizers for SAFE ARRAY
tagSAFEARRAY|SAFEARRAY{
	preview(		
			#if ($c.fFeatures & 0x0080)		; FADF_HAVEVARTYPE 
			(
				;
				;	Switch on the variant type field - which is stored 4 bytes
				;	before the beginning of the SAFEARRAY type
				;
				#switch( ((unsigned *)&($c))[-1] )						
					#case 0x2							; VT_I2 | VT_ARRAY
					(
						#(
							"safearray of I2 = [",	
																
							; output the rank array
							#array(	expr: $c.rgsabound[$i].cElements, size: $c.cDims),		
							
							"](", 
							
							; output the data elements
							#array( 
									expr: ((signed short *)$c.pvData)[$i], 
									size: $c.rgsabound[$r].cElements, 
									rank: $c.cDims, 
									base: $c.rgsabound[$r].lLbound 
								  ), 
							")"
						)
					)	
					
					#case 0x3							; VT_I4 | VT_ARRAY
					(
						#(
							"safearray of I4 = [",	
																
							; output the rank array
							#array(	expr: $c.rgsabound[$i].cElements, size: $c.cDims),		
							
							"](", 
							
							; output the data elements
							#array( 
									expr: ((signed int *)$c.pvData)[$i], 
									size: $c.rgsabound[$r].cElements, 
									rank: $c.cDims, 
									base: $c.rgsabound[$r].lLbound 
								  ), 
							")"
						)
					)	
					
					#case 0x4							; VT_R4 | VT_ARRAY
					(
						#(
							"safearray of R4 = [",	
																
							; output the rank array
							#array(	expr: $c.rgsabound[$i].cElements, size: $c.cDims),		
							
							"](", 
							
							; output the data elements
							#array( 
									expr: ((float *)$c.pvData)[$i], 
									size: $c.rgsabound[$r].cElements, 
									rank: $c.cDims, 
									base: $c.rgsabound[$r].lLbound 
								  ), 
							")"
						)
					)	
					
					#case 0x5							; VT_R8 | VT_ARRAY
					(
						#(
							"safearray of R8 = [",	
																
							; output the rank array
							#array(	expr: $c.rgsabound[$i].cElements, size: $c.cDims),		
							
							"](", 
							
							; output the data elements
							#array( 
									expr: ((double *)$c.pvData)[$i], 
									size: $c.rgsabound[$r].cElements, 
									rank: $c.cDims, 
									base: $c.rgsabound[$r].lLbound 
								  ), 
							")"
						)
					)	
					
					#case 0x6							; VT_CY | VT_ARRAY
					(
						#(
							"safearray of CY = [",	
																
							; output the rank array
							#array(	expr: $c.rgsabound[$i].cElements, size: $c.cDims),		
							
							"](", 
							
							; output the data elements
							#array( 
									expr: ((CY *)$c.pvData)[$i], 
									size: $c.rgsabound[$r].cElements, 
									rank: $c.cDims, 
									base: $c.rgsabound[$r].lLbound 
								  ), 
							")"
						)
					)
					
					#case 0x7							; VT_DATE | VT_ARRAY
					(
						#(
							"safearray of DATE = [",	
																
							; output the rank array
							#array(	expr: $c.rgsabound[$i].cElements, size: $c.cDims),		
							
							"](", 
							
							; output the data elements
							#array( 
									expr: ((DATE *)$c.pvData)[$i], 
									size: $c.rgsabound[$r].cElements, 
									rank: $c.cDims, 
									base: $c.rgsabound[$r].lLbound 
								  ), 
							")"
						)
					)		
					
					#case 0x8							; VT_BSTR | VT_ARRAY
					(
						#(
							"safearray of BSTR = [",	
																
							; output the rank array
							#array(	expr: $c.rgsabound[$i].cElements, size: $c.cDims),		
							
							"](", 
							
							; output the data elements
							#array( 
									expr: ((wchar_t **)$c.pvData)[$i], 
									size: $c.rgsabound[$r].cElements, 
									rank: $c.cDims, 
									base: $c.rgsabound[$r].lLbound 
								  ), 
							")"
						)
					)	

					#case 0xa							; VT_ERROR | VT_ARRAY
					(
						#(
							"safearray of ERROR = [",	
																
							; output the rank array
							#array(	expr: $c.rgsabound[$i].cElements, size: $c.cDims),		
							
							"](", 
							
							; output the data elements
							#array( 
									expr: ((long *)$c.pvData)[$i], 
									size: $c.rgsabound[$r].cElements, 
									rank: $c.cDims, 
									base: $c.rgsabound[$r].lLbound 
								  ), 
							")"
						)
					)
					
					#case 0xb							; VT_BOOL | VT_ARRAY
					(
						#(
							"safearray of BOOL = [",	
																
							; output the rank array
							#array(	expr: $c.rgsabound[$i].cElements, size: $c.cDims),		
							
							"](", 
							
							; output the data elements
							#array( 
									expr: ((short *)$c.pvData)[$i], 
									size: $c.rgsabound[$r].cElements, 
									rank: $c.cDims, 
									base: $c.rgsabound[$r].lLbound 
								  ), 
							")"
						)
					)		
					
					#case 0xc							; VT_VARIANT | VT_ARRAY
					(
						#(
							"safearray of VARIANT = [",	
																
							; output the rank array
							#array(	expr: $c.rgsabound[$i].cElements, size: $c.cDims),		
							
							"](", 
							
							; output the data elements
							#array( 
									expr: ((tagVARIANT *)$c.pvData)[$i], 
									size: $c.rgsabound[$r].cElements, 
									rank: $c.cDims, 
									base: $c.rgsabound[$r].lLbound 
								  ), 
							")"
						)
					)	
					
					#case 0x10							; VT_I1 | VT_ARRAY
					(
						#(
							"safearray of I1 = [",	
																
							; output the rank array
							#array(	expr: $c.rgsabound[$i].cElements, size: $c.cDims),		
							
							"](", 
							
							; output the data elements
							#array( 
									expr: ((signed char *)$c.pvData)[$i], 
									size: $c.rgsabound[$r].cElements, 
									rank: $c.cDims, 
									base: $c.rgsabound[$r].lLbound 
								  ), 
							")"
						)
					)		
					
					#case 0x11							; VT_UI1 | VT_ARRAY
					(
						#(
							"safearray of UI1 = [",	
																
							; output the rank array
							#array(	expr: $c.rgsabound[$i].cElements, size: $c.cDims),		
							
							"](", 
							
							; output the data elements
							#array( 
									expr: ((unsigned char *)$c.pvData)[$i], 
									size: $c.rgsabound[$r].cElements, 
									rank: $c.cDims, 
									base: $c.rgsabound[$r].lLbound 
								  ), 
							")"
						)
					)		
					
					#case 0x12							; VT_UI2 | VT_ARRAY
					(
						#(
							"safearray of UI2 = [",	
																
							; output the rank array
							#array(	expr: $c.rgsabound[$i].cElements, size: $c.cDims),		
							
							"](", 
							
							; output the data elements
							#array( 
									expr: ((unsigned short *)$c.pvData)[$i], 
									size: $c.rgsabound[$r].cElements, 
									rank: $c.cDims, 
									base: $c.rgsabound[$r].lLbound 
								  ), 
							")"
						)
					)	
					
					#case 0x13							; VT_UI4 | VT_ARRAY
					(
						#(
							"safearray of UI4 = [",	
																
							; output the rank array
							#array(	expr: $c.rgsabound[$i].cElements, size: $c.cDims),		
							
							"](", 
							
							; output the data elements
							#array( 
									expr: ((unsigned int *)$c.pvData)[$i], 
									size: $c.rgsabound[$r].cElements, 
									rank: $c.cDims, 
									base: $c.rgsabound[$r].lLbound 
								  ), 
							")"
						)
					)	
					
					#case 0x14							; VT_I8 | VT_ARRAY
					(
						#(
							"safearray of I8 = [",	
																
							; output the rank array
							#array(	expr: $c.rgsabound[$i].cElements, size: $c.cDims),		
							
							"](", 
							
							; output the data elements
							#array( 
									expr: ((signed __int64 *)$c.pvData)[$i], 
									size: $c.rgsabound[$r].cElements, 
									rank: $c.cDims, 
									base: $c.rgsabound[$r].lLbound 
								  ), 
							")"
						)
					)	
					
					#case 0x15							; VT_UI8 | VT_ARRAY
					(
						#(
							"safearray of UI8 = [",	
																
							; output the rank array
							#array(	expr: $c.rgsabound[$i].cElements, size: $c.cDims),		
							
							"](", 
							
							; output the data elements
							#array( 
									expr: ((unsigned __int64 *)$c.pvData)[$i], 
									size: $c.rgsabound[$r].cElements, 
									rank: $c.cDims, 
									base: $c.rgsabound[$r].lLbound 
								  ), 
							")"
						)
					)	
					
					#case 0x16							; VT_INT | VT_ARRAY
					(
						#(
							"safearray of INT = [",	
																
							; output the rank array
							#array(	expr: $c.rgsabound[$i].cElements, size: $c.cDims),		
							
							"](", 
							
							; output the data elements
							#array( 
									expr: ((int *)$c.pvData)[$i], 
									size: $c.rgsabound[$r].cElements, 
									rank: $c.cDims, 
									base: $c.rgsabound[$r].lLbound 
								  ), 
							")"
						)
					)																																																																																
					
					#case 0x17							; VT_UINT | VT_ARRAY
					(
						#(
							"safearray of UINT = [",	
																
							; output the rank array
							#array(	expr: $c.rgsabound[$i].cElements, size: $c.cDims),		
							
							"](", 
							
							; output the data elements
							#array( 
									expr: ((unsigned *)$c.pvData)[$i], 
									size: $c.rgsabound[$r].cElements, 
									rank: $c.cDims, 
									base: $c.rgsabound[$r].lLbound 
								  ), 
							")"
						)
					)	
					
					#case 0x1e							; VT_LPSTR | VT_ARRAY
					(
						#(
							"safearray of LPSTR = [",	
																
							; output the rank array
							#array(	expr: $c.rgsabound[$i].cElements, size: $c.cDims),		
							
							"](", 
							
							; output the data elements
							#array( 
									expr: ((char **)$c.pvData)[$i], 
									size: $c.rgsabound[$r].cElements, 
									rank: $c.cDims, 
									base: $c.rgsabound[$r].lLbound 
								  ), 
							")"
						)
					)	

					#case 0x1f							; VT_LPWSTR | VT_ARRAY
					(
						#(
							"safearray of LPWSTR = [",	
																
							; output the rank array
							#array(	expr: $c.rgsabound[$i].cElements, size: $c.cDims),		
							
							"](", 
							
							; output the data elements
							#array( 
									expr: ((wchar_t **)$c.pvData)[$i], 
									size: $c.rgsabound[$r].cElements, 
									rank: $c.cDims, 
									base: $c.rgsabound[$r].lLbound 
								  ), 
							")"
						)
					)	
					
					#case 0x40							; VT_FILETIME | VT_ARRAY
					(
						#(
							"safearray of FILETIME = [",	
																
							; output the rank array
							#array(	expr: $c.rgsabound[$i].cElements, size: $c.cDims),		
							
							"](", 
							
							; output the data elements
							#array( 
									expr: ((FILETIME *)$c.pvData)[$i], 
									size: $c.rgsabound[$r].cElements, 
									rank: $c.cDims, 
									base: $c.rgsabound[$r].lLbound 
								  ), 
							")"
						)
					)	
					
					#case 0x47							; VT_CLIPDATA | VT_ARRAY
					(
						#(
							"safearray of CLIPDATA = [",	
																
							; output the rank array
							#array(	expr: $c.rgsabound[$i].cElements, size: $c.cDims),		
							
							"](", 
							
							; output the data elements
							#array( 
									expr: ((CLIPDATA *)$c.pvData)[$i], 
									size: $c.rgsabound[$r].cElements, 
									rank: $c.cDims, 
									base: $c.rgsabound[$r].lLbound 
								  ), 
							")"
						)
					)	
					
					#case 0x48							; VT_CLSID | VT_ARRAY
					(
						#(
							"safearray of CLSID = [",	
																
							; output the rank array
							#array(	expr: $c.rgsabound[$i].cElements, size: $c.cDims),		
							
							"](", 
							
							; output the data elements
							#array( 
									expr: ((CLSID *)$c.pvData)[$i], 
									size: $c.rgsabound[$r].cElements, 
									rank: $c.cDims, 
									base: $c.rgsabound[$r].lLbound 
								  ), 
							")"
						)
					)																															
			)
			#elif ($c.fFeatures & 0x0100)		; FADF_BSTR 
			(
				#("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 ), ")")
			)
			#elif ($c.fFeatures & 0x0200)		; FADF_UNKNOWN
			(
				#("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 ), ")")
			)	
			#elif ($c.fFeatures & 0x0400)		; FADF_DISPATCH
			(
				#("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 ), ")")
			)
			#elif ($c.fFeatures & 0x0800)		; FADF_VARIANT
			(
				#("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 ), ")")
			)
	)
	children(
		#(									;[actual members]: [$c,!],
			#if ($c.fFeatures & 0x0080)		; FADF_HAVEVARTYPE 
			(
				#switch( ((unsigned *)&($c))[-1] )	; for some reason the VT field is before the SAFEARRAY struct
					#case 2							; VT_I2|VT_ARRAY
					( 
						#array(
								expr: ((signed short *)$c.pvData)[$i], 
								size: $c.rgsabound[$r].cElements, 
								rank: $c.cDims, 
								base: $c.rgsabound[$r].lLbound 
							  )
					)				
					
					#case 3							; VT_I4|VT_ARRAY
					( 
						#array(
								expr: ((signed int   *)$c.pvData)[$i], 
								size: $c.rgsabound[$r].cElements, 
								rank: $c.cDims, 
								base: $c.rgsabound[$r].lLbound 
							   )
					)		
							
					#case 4							; VT_R4|VT_ARRAY
					( 
						#array(
								expr: ((float *)$c.pvData)[$i], 
								size: $c.rgsabound[$r].cElements,
								rank: $c.cDims, 
								base: $c.rgsabound[$r].lLbound 
							   )
					)		
							
					#case 5							; VT_R8|VT_ARRAY
					( 
						#array(
								expr: ((double  *)$c.pvData)[$i], 
								size: $c.rgsabound[$r].cElements, 
								rank: $c.cDims, 
								base: $c.rgsabound[$r].lLbound 
							  )
					)		
							
					#case 0x10						; VT_I1|VT_ARRAY
					( 
						#array(
								expr: ((signed char *)$c.pvData)[$i], 
								size: $c.rgsabound[$r].cElements, 
								rank: $c.cDims, 
								base: $c.rgsabound[$r].lLbound 
							   )
					)	
								
					#case 0x11						; VT_UI1|VT_ARRAY
					( 
						#array(
								expr: ((unsigned char *)$c.pvData)[$i], 
								size: $c.rgsabound[$r].cElements, 
								rank: $c.cDims, 
								base: $c.rgsabound[$r].lLbound 
							  )
					)		
							
					#case 0x12						; VT_UI2|VT_ARRAY
					( 
						#array(
								expr: ((unsigned short *)$c.pvData)[$i], 
								size: $c.rgsabound[$r].cElements, 
								rank: $c.cDims, 
								base: $c.rgsabound[$r].lLbound 
							   )
					)		
							
					#case 0x13						; VT_UI4|VT_ARRAY
					( 
						#array(
								expr: ((unsigned int *)$c.pvData)[$i], 
								size: $c.rgsabound[$r].cElements, 
								rank: $c.cDims, 
								base: $c.rgsabound[$r].lLbound
							   )	
					)
								
					#case 0x14						; VT_I8|VT_ARRAY
					( 
						#array(
								expr: ((signed __int64 *)$c.pvData)[$i], 
								size: $c.rgsabound[$r].cElements, 
								rank: $c.cDims, 
								base: $c.rgsabound[$r].lLbound
							   )				
					)							 
					#case 0x15						; VT_UI8|VT_ARRAY
					( 
						#array(
								expr: ((unsigned __int64 *)$c.pvData)[$i], 
								size: $c.rgsabound[$r].cElements, 
								rank: $c.cDims, 
								base: $c.rgsabound[$r].lLbound
							  )				
					)
					
					#case 0x1e						; VT_LPSTR|VT_ARRAY
					( 
						#array(
								expr: ((char * *)$c.pvData)[$i], 
								size: $c.rgsabound[$r].cElements, 
								rank: $c.cDims, 
								base: $c.rgsabound[$r].lLbound
							  )			
					)
					
					#case 0x1f						; VT_LPWSTR|VT_ARRAY
					( 
						#array(
								expr: ((wchar_t **)$c.pvData)[$i], 
								size: $c.rgsabound[$r].cElements, 
								rank: $c.cDims, 
								base: $c.rgsabound[$r].lLbound
							  )		
					)
					
					#case 0xc						; VT_VARIANT|VT_ARRAY
					( 
						#array(
								expr: ((tagVARIANT *)$c.pvData)[$i], 
								size: $c.rgsabound[$r].cElements, 
								rank: $c.cDims, 
								base: $c.rgsabound[$r].lLbound
							  )			
					
					)
					
					#case 0xb						; VT_BOOL|VT_ARRAY
					(					
						#array(
								expr: ((short *)$c.pvData)[$i], 
								size: $c.rgsabound[$r].cElements, 
								rank: $c.cDims, 
								base: $c.rgsabound[$r].lLbound
							  )			
					)
					
					#case 0xa						; VT_ERROR|VT_ARRAY
					( 
						#array(
								expr: ((long *)$c.pvData)[$i], 
								size: $c.rgsabound[$r].cElements, 
								rank: $c.cDims, 
								base: $c.rgsabound[$r].lLbound
							  )			
					)
					
					#case 6							; VT_CY|VT_ARRAY
					( 
						#array(
								expr: ((CY *)$c.pvData)[$i], 
								size: $c.rgsabound[$r].cElements, 
								rank: $c.cDims, 
								base: $c.rgsabound[$r].lLbound
							  )				
					)
					
					#case 7							; VT_DATE|VT_ARRAY
					( 
						#array(
								expr: ((DATE *)$c.pvData)[$i], 
								size: $c.rgsabound[$r].cElements, 
								rank: $c.cDims, 
								base: $c.rgsabound[$r].lLbound
							  )			
					)
					
					#case 0x40						; VT_FILETIME|VT_ARRAY
					( 
						#array(
								expr: ((FILETIME *)$c.pvData)[$i], 
								size: $c.rgsabound[$r].cElements, 
								rank: $c.cDims, 
								base: $c.rgsabound[$r].lLbound
							  )		
					)
					
					#case 0x48						; VT_CLSID|VT_ARRAY
					( 
						#array(
								expr: ((CLSID *)$c.pvData)[$i], 
								size: $c.rgsabound[$r].cElements, 
								rank: $c.cDims, 
								base: $c.rgsabound[$r].lLbound
							  )			
					)
					
					#case 0x47						; VT_CF|VT_ARRAY
					( 
						#array(
								expr: ((CLIPDATA *)$c.pvData)[$i], 
								size: $c.rgsabound[$r].cElements, 
								rank: $c.cDims, 
								base: $c.rgsabound[$r].lLbound
							  )				
					)
					
					#case 8							; VT_BSTR|VT_ARRAY
					( 
						#array(
								expr: ((wchar_t * *)$c.pvData)[$i], 
								size: $c.rgsabound[$r].cElements, 
								rank: $c.cDims, 
								base: $c.rgsabound[$r].lLbound
							  )			
					)
					
					#case 0x16						; VT_INT|VT_ARRAY
					( 
						#array(
								expr: ((int *)$c.pvData)[$i],
								size: $c.rgsabound[$r].cElements, 
								rank: $c.cDims, 
								base: $c.rgsabound[$r].lLbound
							  )				
					)
					
					#case 0x17						; VT_UINT|VT_ARRAY		
					( 
						#array(
								expr: ((unsigned int*)$c.pvData)[$i], 
								size: $c.rgsabound[$r].cElements, 
								rank: $c.cDims, 
								base: $c.rgsabound[$r].lLbound
							  )	
					)			
					
					#default
					(
						#([actual members]: [$e,!])
					)
					#except
					(
						#([actual members]: [$e,!])
					)
			)
			#elif ($c.fFeatures & 0x0100)		; FADF_BSTR 
			(
				#array(expr: ((wchar_t * *)$c.pvData)[$i], size: $c.rgsabound[$r].cElements, rank: $c.cDims, base: $c.rgsabound[$r].lLbound )	
			)
			#elif ($c.fFeatures & 0x0200)		; FADF_UNKNOWN
			(
				#array(expr: ((IUnknown *)$c.pvData)[$i], size: $c.rgsabound[$r].cElements, rank: $c.cDims, base: $c.rgsabound[$r].lLbound )	
			)	
			#elif ($c.fFeatures & 0x0400)		; FADF_DISPATCH
			(
				#array(expr: ((IDispatch *)$c.pvData)[$i], size: $c.rgsabound[$r].cElements, rank: $c.cDims, base: $c.rgsabound[$r].lLbound )	
			)
			#elif ($c.fFeatures & 0x0800)		; FADF_VARIANT
			(
				#array(expr: ((tagVARIANT *)$c.pvData)[$i], size: $c.rgsabound[$r].cElements, rank: $c.cDims, base: $c.rgsabound[$r].lLbound )	
			)
		)
	)
}

tagPROPVARIANT|tagVARIANT|PROPVARIANT|VARIANT{
	preview(
			#switch ($e.vt)
				;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
				;;      Base Types                                          ;;
				;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
				#case 0 ( #("Empty") )										; VT_EMPTY
				#case 1 ( #("NULL") )										; VT_NULL
				#case 2 ( #("I2 = ", $e.iVal) )								; VT_I2
				#case 3 ( #("I4 = ", $e.lVal) )								; VT_I4
				#case 4 ( #("R4 = ", $e.fltVal) )							; VT_R4
				#case 5 ( #("R8 = ", $e.dblVal) )							; VT_R8
				#case 6 ( #("CY = ", $e.cyVal) )							; VT_CY
				#case 7 ( #("DATE =  ", $e.date) )							; VT_DATE
				#case 8 ( #("BSTR = ", $e.bstrVal) )						; VT_BSTR
				#case 9 ( #("DISPATCH =  ", $e.pdispVal) )					; VT_DISPATCH
				#case 10 ( #("ERROR =  ", $e.scode) )						; VT_ERROR
				#case 0xB ( #("BOOL =  ", $e.boolVal) )						; VT_BOOL
				#case 0xC ( #("VARIANT ") )									; VT_VARIANT
				#case 0xD ( #("UNKNOWN =  ", $e.punkVal) )					; VT_UNKNOWN
				#case 0xE ( #("DECIMAL = ", $e.hVal) )						; VT_DECIMAL
				#case 0x10 ( #("I1 =  ", $e.cVal) )							; VT_I1
				#case 0x11 ( #("UI1 =  ", $e.bVal) )							; VT_UI1
				#case 0x12 ( #("UI2 =  ", $e.uiVal) )							; VT_UI2
				#case 0x13 ( #("UI4 =  ", $e.ulVal) )							; VT_UI4
				#case 0x14 ( #("I8 =  ", $e.hVal) )							; VT_I8
				#case 0x15 ( #("UI8 =  ", $e.uhVal) )							; VT_UI8
				#case 0x16 ( #("INT =  ", $e.intVal) )						; VT_INT
				#case 0x17 ( #("UINT = ", $e.uintVal) )						; VT_UINT
				#case 0x18 ( #("VOID ") )										; VT_VOID
				#case 0x19 ( #("HRESULT ") )									; VT_HRESULT
				#case 0x1A ( #("PTR ") )										; VT_PTR
				#case 0x1B ( #("SAFEARRAY ") )								; VT_SAFEARRAY
				#case 0x1C ( #("CARRAY ") )									; VT_CARRAY
				#case 0x1D ( #("USERDEFINED ") )								; VT_USERDEFINED
				#case 0x1E ( #("LPSTR =  ", $e.pszVal) )						; VT_LPSTR
				#case 0x1F ( #("LPWSTR =  ", $e.pwszVal) )					; VT_LPWSTR
				#case 0x24 ( #("RECORD  ") )									; VT_RECORD
				#case 0x26 ( #("UINT_PTR ") )									; VT_UINT_PTR
				#case 0x40 ( #("FILETIME =  ", $e.filetime) )					; VT_FILETIME
				#case 0x42 ( #("STREAM =  ", $e.pStream) )					; VT_STREAM
				#case 0x43 ( #("STORAGE = ", $e.pStorage) )					; VT_STORAGE
				#case 0x44 ( #("STREAMED_OBJECT =  ", $e.pStream) )			; VT_STREAMED_OBJECT
				#case 0x45 ( #("STORED_OBJECT =  ", $e.pStorage) )			; VT_STORED_OBJECT
				#case 0x46 ( #("BLOB_OBJECT = ", $e.blob ) )					; VT_BLOB_OBJECT
				#case 0x47 ( #("CF =  ", $e.pclipdata) )						; VT_CF
				#case 0x48 ( #("CLSID = ", $e.puuid) )						; VT_CLSID
				#case 0x49 ( #("VERSIONED_STREAM = ", $e.pVersionedStream) )	; VT_VERSIONED_STREAM
				
				;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
				;;   Vector types                                           ;;
				;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
				#case 0x1002 ( #("vector of I2 = ", $e.cai) )					; VT_I2|VT_VECTOR
				#case 0x1003 ( #("vector of I4 = ", $e.cal) )					; VT_I4|VT_VECTOR
				#case 0x1004 ( #("vector of R4 = ", $e.caflt) )				; VT_R4|VT_VECTOR
				#case 0x1005 ( #("vector of R8 = ", $e.cadbl) )				; VT_R8|VT_VECTOR
				#case 0x1010 ( #("vector of I1 =  ", $e.cac) )				; VT_I1|VT_VECTOR
				#case 0x1011 ( #("vector of UI1 =  ", $e.caub) )				; VT_UI1|VT_VECTOR
				#case 0x1012 ( #("vector of UI2 =  ", $e.caui) )				; VT_UI2|VT_VECTOR
				#case 0x1013 ( #("vector of UI4 =  ", $e.caul) )				; VT_UI4|VT_VECTOR
				#case 0x1014 ( #("vector of I8 =  ", $e.cah) )				; VT_I8|VT_VECTOR
				#case 0x1015 ( #("vector of UI8 =  ", $e.cauh) )				; VT_UI8|VT_VECTOR
				#case 0x101E ( #("vector of LPSTR =  ", $e.calpstr) )			; VT_LPSTR|VT_VECTOR
				#case 0x101F ( #("vector of LPWSTR =  ", $e.calpwstr) )		; VT_LPWSTR|VT_VECTOR
				#case 0x100C ( #("vector of VARIANT ", $e.capropvar) )		; VT_VARIANT|VT_VECTOR
				#case 0x100B ( #("vector of BOOL =  ", $e.cabool) )		    ; VT_BOOL|VT_VECTOR
				#case 0x100A ( #("vector of ERROR =  ", $e.cascode) )			; VT_ERROR|VT_VECTOR
				#case 0x1006 ( #("vector of CY = ", $e.cacy) )				; VT_CY|VT_VECTOR
				#case 0x1007 ( #("vector of DATE =  ", $e.cadate) )			; VT_DATE|VT_VECTOR
				#case 0x1040 ( #("vector of FILETIME =  ", $e.cafiletime) )	; VT_FILETIME|VT_VECTOR
				#case 0x1048 ( #("vector of CLSID = ", $e.cauuid) )			; VT_CLSID|VT_VECTOR
				#case 0x1047 ( #("vector of CF =  ", $e.caclipdata) )			; VT_CF|VT_VECTOR
				#case 0x1008 ( #("vector of BSTR = ", $e.cabstr) )			; VT_BSTR|VT_VECTOR
		
				;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
				;;   Byref Types                                            ;;
				;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
				#case 0x4016 ( #("byref of INT =  ", $e.pintVal) )				; VT_INT|VT_BYREF
				#case 0x4017 ( #("byref of UINT = ", $e.puintVal) )				; VT_UINT|VT_BYREF
				#case 0x4002 ( #("byref of I2 = ", $e.piVal) )					; VT_I2|VT_BYREF
				#case 0x4003 ( #("byref of I4 = ", $e.plVal) )					; VT_I4|VT_BYREF
				#case 0x4004 ( #("byref of R4 = ", $e.pfltVal) )					; VT_R4|VT_BYREF
				#case 0x4005 ( #("byref of R8 = ", $e.pdblVal) )					; VT_R8|VT_BYREF
				#case 0x4010 ( #("byref of I1 =  ", $e.pcVal) )					; VT_I1|VT_BYREF
				#case 0x4011 ( #("byref of UI1 =  ", $e.pbVal) )					; VT_UI1|VT_BYREF
				#case 0x4012 ( #("byref of UI2 =  ", $e.puiVal) )				; VT_UI2|VT_BYREF
				#case 0x4013 ( #("byref of UI4 =  ", $e.pulVal) )				; VT_UI4|VT_BYREF
				#case 0x400C ( #("byref of VARIANT ", $e.pvarVal) )				; VT_VARIANT|VT_BYREF
				#case 0x400B ( #("byref of BOOL =  ", $e.pboolVal) )				; VT_BOOL|VT_BYREF
				#case 0x400A ( #("byref of ERROR =  ", $e.pscode) )				; VT_ERROR|VT_BYREF
				#case 0x4006 ( #("byref of CY = ", $e.pcyVal) )					; VT_CY|VT_BYREF
				#case 0x4007 ( #("byref of DATE =  ", $e.pdate) )				; VT_DATE|VT_BYREF
				#case 0x4008 ( #("byref of BSTR = ", $e.pbstrVal) )				; VT_BSTR|VT_BYREF
				#case 0x400E ( #("byref of DECIMAL = ", $e.pdecVal) )			; VT_DECIMAL|VT_BYREF
				#case 0x400D ( #("byref of UNKNOWN =  ", $e.ppunkVal) )			; VT_UNKNOWN|VT_BYREF
				#case 0x4009 ( #("byref of DISPATCH =  ", $e.ppdispVal) )		; VT_DISPATCH|VT_BYREF
				#case 0x6000 ( #("byref of ARRAY =  ", $e.pparray) )				; VT_ARRAY|VT_BYREF
							
				#default 
				( 
					#if ($e.vt & 0x2000)
					(
						$e.parray
					)
					#else
					(
						#("Unknown vt type = ", $e.vt) 
					)
				)
	)
	
	
	children(
			#(vt: $e.vt, 
			#switch ($e.vt)
				;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
				;;      Base Types                                          ;;
				;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
				#case 0x2 ( #(I2  : $e.iVal) )								; VT_I2
				#case 0x3 ( #(I4  : $e.lVal) )								; VT_I4
				#case 0x4 ( #(R4  : $e.fltVal) )								; VT_R4
				#case 0x5 ( #(R8  : $e.dblVal) )								; VT_R8
				#case 0x6 ( #(CY  : $e.cyVal) )								; VT_CY
				#case 0x7 ( #(DATE   : $e.date) )								; VT_DATE
				#case 0x8 ( #(BSTR  : $e.bstrVal) )							; VT_BSTR
				#case 0x9 ( #(DISPATCH   : $e.pdispVal) )						; VT_DISPATCH
				#case 0xA ( #(ERROR   : $e.scode) )							; VT_ERROR
				#case 0xB ( #(BOOL   : $e.boolVal) )							; VT_BOOL
				#case 0xD ( #(UNKNOWN   : $e.punkVal) )						; VT_UNKNOWN
				#case 0xE ( #(DECIMAL  : $e.hVal) )							; VT_DECIMAL
				#case 0x10 ( #(I1   : $e.cVal) )								; VT_I1
				#case 0x11 ( #(UI1   : $e.bVal) )								; VT_UI1
				#case 0x12 ( #(UI2   : $e.uiVal) )							; VT_UI2
				#case 0x13 ( #(UI4   : $e.ulVal) )							; VT_UI4
				#case 0x14 ( #(I8   : $e.hVal) )								; VT_I8
				#case 0x15 ( #(UI8   : $e.uhVal) )							; VT_UI8
				#case 0x16 ( #(INT   : $e.intVal) )							; VT_INT
				#case 0x17 ( #(UINT  : $e.uintVal) )							; VT_UINT
				#case 0x1E ( #(LPSTR   : $e.pszVal) )							; VT_LPSTR
				#case 0x1F ( #(LPWSTR   : $e.pwszVal) )						; VT_LPWSTR
				#case 0x40 ( #(FILETIME   : $e.filetime) )					; VT_FILETIME
				#case 0x42 ( #(STREAM   : $e.pStream) )						; VT_STREAM
				#case 0x43 ( #(STORAGE  : $e.pStorage) )						; VT_STORAGE
				#case 0x44 ( #(STREAMED_OBJECT   : $e.pStream) )				; VT_STREAMED_OBJECT
				#case 0x45 ( #(STORED_OBJECT   : $e.pStorage) )				; VT_STORED_OBJECT
				#case 0x46 ( #(BLOB_OBJECT  : $e.blob ) )						; VT_BLOB_OBJECT
				#case 0x47 ( #(CF   : $e.pclipdata) )							; VT_CF
				#case 0x48 ( #(CLSID  : $e.puuid) )							; VT_CLSID
				#case 0x49 ( #(VERSIONED_STREAM  : $e.pVersionedStream) )		; VT_VERSIONED_STREAM
				
				;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
				;;   Vector types                                           ;;
				;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
				#case 0x1002 ( #(vector of I2  : $e.cai) )					; VT_I2|VT_VECTOR
				#case 0x1003 ( #(vector of I4  : $e.cal) )					; VT_I4|VT_VECTOR
				#case 0x1004 ( #(vector of R4  : $e.caflt) )					; VT_R4|VT_VECTOR
				#case 0x1005 ( #(vector of R8  : $e.cadbl) )					; VT_R8|VT_VECTOR
				#case 0x1010 ( #(vector of I1   : $e.cac) )					; VT_I1|VT_VECTOR
				#case 0x1011 ( #(vector of UI1   : $e.caub) )					; VT_UI1|VT_VECTOR
				#case 0x1012 ( #(vector of UI2   : $e.caui) )					; VT_UI2|VT_VECTOR
				#case 0x1013 ( #(vector of UI4   : $e.caul) )					; VT_UI4|VT_VECTOR
				#case 0x1014 ( #(vector of I8   : $e.cah) )					; VT_I8|VT_VECTOR
				#case 0x1015 ( #(vector of UI8   : $e.cauh) )					; VT_UI8|VT_VECTOR
				#case 0x101E ( #(vector of LPSTR   : $e.calpstr) )			; VT_LPSTR|VT_VECTOR
				#case 0x101F ( #(vector of LPWSTR   : $e.calpwstr) )			; VT_LPWSTR|VT_VECTOR
				#case 0x100C ( #(vector of VARIANT : $e.capropvar) )			; VT_VARIANT|VT_VECTOR
				#case 0x100B ( #(vector of BOOL   : $e.cabool) )				; VT_BOOL|VT_VECTOR
				#case 0x100A ( #(vector of ERROR   : $e.cascode) )			; VT_ERROR|VT_VECTOR
				#case 0x1006 ( #(vector of CY  : $e.cacy) )					; VT_CY|VT_VECTOR
				#case 0x1007 ( #(vector of DATE   : $e.cadate) )				; VT_DATE|VT_VECTOR
				#case 0x1040 ( #(vector of FILETIME   : $e.cafiletime) )		; VT_FILETIME|VT_VECTOR
				#case 0x1048 ( #(vector of CLSID  : $e.cauuid) )				; VT_CLSID|VT_VECTOR
				#case 0x1047 ( #(vector of CF   : $e.caclipdata) )			; VT_CF|VT_VECTOR
				#case 0x1008 ( #(vector of BSTR  : $e.cabstr) )				; VT_BSTR|VT_VECTOR

				;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
				;;   Byref Types                                            ;;
				;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
				#case 0x4016 ( #(byref of INT   : $e.pintVal) )				; VT_INT|VT_BYREF
				#case 0x4017 ( #(byref of UINT  : $e.puintVal) )				; VT_UINT|VT_BYREF
				#case 0x4002 ( #(byref of I2  : $e.piVal) )					; VT_I2|VT_BYREF
				#case 0x4003 ( #(byref of I4  : $e.plVal) )					; VT_I4|VT_BYREF
				#case 0x4004 ( #(byref of R4  : $e.pfltVal) )				; VT_R4|VT_BYREF
				#case 0x4005 ( #(byref of R8  : $e.pdblVal) )				; VT_R8|VT_BYREF
				#case 0x4010 ( #(byref of I1   : $e.pcVal) )					; VT_I1|VT_BYREF
				#case 0x4011 ( #(byref of UI1   : $e.pbVal) )				; VT_UI1|VT_BYREF
				#case 0x4012 ( #(byref of UI2   : $e.puiVal) )				; VT_UI2|VT_BYREF
				#case 0x4013 ( #(byref of UI4   : $e.pulVal) )				; VT_UI4|VT_BYREF
				#case 0x400C ( #(byref of VARIANT : $e.pvarVal) )			; VT_VARIANT|VT_BYREF
				#case 0x400B ( #(byref of BOOL   : $e.pboolVal) )			; VT_BOOL|VT_BYREF
				#case 0x400A ( #(byref of ERROR   : $e.pscode) )				; VT_ERROR|VT_BYREF
				#case 0x4006 ( #(byref of CY  : $e.pcyVal) )					; VT_CY|VT_BYREF
				#case 0x4007 ( #(byref of DATE   : $e.pdate) )				; VT_DATE|VT_BYREF
				#case 0x4008 ( #(byref of BSTR  : $e.pbstrVal) )				; VT_BSTR|VT_BYREF
				#case 0x400E ( #(byref of DECIMAL  : $e.pdecVal) )			; VT_DECIMAL|VT_BYREF
				#case 0x400D ( #(byref of UNKNOWN   : $e.ppunkVal) )			; VT_UNKNOWN|VT_BYREF
				#case 0x4009 ( #(byref of DISPATCH   : $e.ppdispVal) )		; VT_DISPATCH|VT_BYREF
				#case 0x6000 ( #(byref of ARRAY   : $e.pparray) )			; VT_ARRAY|VT_BYREF
				
				; the following are either empty or invalid vt values for a variant
				; #case 0 ( #(Empty :) )										; VT_EMPTY
				; #case 0x1 ( #(NULL :) )										; VT_NULL
				; #case 0xC ( #(VARIANT :) )									; VT_VARIANT
				; #case 0x18 ( #(VOID :) )										; VT_VOID
				; #case 0x19 ( #(HRESULT :) )									; VT_HRESULT
				; #case 0x1A ( #(PTR :) )										; VT_PTR
				; #case 0x1B ( #(SAFEARRAY :) )									; VT_SAFEARRAY
				; #case 0x1C ( #(CARRAY :) )									; VT_CARRAY
				; #case 0x1D ( #(USERDEFINED :) )								; VT_USERDEFINED
				; #case 0x24 ( #(RECORD  :) )									; VT_RECORD
				; #case 0x26 ( #(UINT_PTR :) )									; VT_UINT_PTR
							
				#default 
				( 
					#if ($e.vt & 0x2000 )
					(
						#(safearray: $e.parray)
					)
					#else
					(
						#(
							[raw members]: [$e,!]	; unformatted data members
						)
					)
				)							
				#except 
				( 
					#(
						[raw members]: [$e,!]	; unformatted data members
					)
				)							
	))
}

; This section lets you define your own errors for the HRESULT display.
; You need to list the error code in unsigned decimal, followed by the message.
; Changes will take effect the next time you redisplay the variable.
[hresult]
;1234=my custom error code