mirror of
https://port.numenaute.org/aleajactaest/khanat-code-old.git
synced 2024-12-05 01:34:48 +00:00
5329 lines
155 KiB
Text
5329 lines
155 KiB
Text
|
; AutoExp.Dat - templates for automatically expanding data
|
||
|
; Copyright(c) Microsoft Corporation. All Rights Reserved.
|
||
|
;---------------------------------------------------------------
|
||
|
;
|
||
|
; Location: C:\Program Files\Microsoft Visual Studio\Common\MSDev98\Bin
|
||
|
;
|
||
|
; 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]
|
||
|
|
||
|
; Qt Integration
|
||
|
|
||
|
; autoexpand
|
||
|
QByteArray=<d->data,s> size=<d->size,u>
|
||
|
QPoint =x=<xp> y=<yp>
|
||
|
QPointF =x=<xp> y=<yp>
|
||
|
QRect =x1=<x1> y1=<y1> x2=<x2> y2=<y2>
|
||
|
QRectF =x=<xp> y=<yp> w=<w> h=<h>
|
||
|
QSize =width=<wd> height=<ht>
|
||
|
QSizeF =width=<wd> height=<ht>
|
||
|
QHash<*> =size=<d->size>
|
||
|
QVarLengthArray<*> =size=<s> data=<ptr>
|
||
|
|
||
|
;QObject =classname=<staticMetaObject.d.stringdata,s> superclassname=<staticMetaObject.d.superdata->d.stringdata,s>
|
||
|
;QList<*>=size=<d->end,i>
|
||
|
;QLinkedList<*>=size=<d->end,i>
|
||
|
;QString=<d->data,su> size=<d->size,u>
|
||
|
;QUrl =<d->encodedOriginal.d->data,s>
|
||
|
;QUrlInfo =<d->name.d->data,su>
|
||
|
;QMap<*> =size=<d->size>
|
||
|
;QVector<*> =size=<d->size>
|
||
|
;QFont =family=<d->request.family.d->data,su> size=<d->request.pointSize, f>
|
||
|
;QDomNode =name=<impl->name.d->data,su> value=<impl->value.d->data,su>
|
||
|
|
||
|
; 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]
|
||
|
QString|*::QString{
|
||
|
preview ([$e.d->data,su])
|
||
|
stringview ([$e.d->data,sub])
|
||
|
children
|
||
|
(
|
||
|
#(
|
||
|
d: $c.d,
|
||
|
[size]: $c.d->size,
|
||
|
[referenced]: $c.d->ref._q_value
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
QByteArray|*::QByteArray{
|
||
|
preview ([$e.d->data,s])
|
||
|
stringview ([$e.d->data,sb])
|
||
|
children
|
||
|
(
|
||
|
#(
|
||
|
d: $c.d,
|
||
|
[size]: $c.d->size,
|
||
|
[referenced]: $c.d->ref._q_value
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
QFileInfo|*::QFileInfo{
|
||
|
preview
|
||
|
(
|
||
|
#(
|
||
|
"private=", $c.d_ptr
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
QUrl|*::QUrl{
|
||
|
preview
|
||
|
(
|
||
|
#if ($e.d.stateFlags == 0) (
|
||
|
$e.d
|
||
|
) #else (
|
||
|
#( $e.d->scheme, $e.d->host, $e.d->path )
|
||
|
)
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#(
|
||
|
scheme: $c.d->scheme,
|
||
|
host: $c.d->host,
|
||
|
path: $c.d->path,
|
||
|
username: $c.d->userName,
|
||
|
password: $c.d->password,
|
||
|
encodedOriginal: $c.d->encodedOriginal,
|
||
|
query: $c.d->query,
|
||
|
fragment: $c.d->fragment
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
QTime|*::QTime{
|
||
|
preview
|
||
|
(
|
||
|
#(
|
||
|
"hour=", [$e.mds / 3600000, d],
|
||
|
", minute=", [($e.mds % 3600000) / 60000, d],
|
||
|
", second=", [($e.mds / 1000) % 60, d],
|
||
|
", millisecond=", [$e.mds % 1000, d]
|
||
|
)
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#(
|
||
|
[hour]: [$e.mds / 3600000, d],
|
||
|
[minute]: [($e.mds % 3600000) / 60000, d],
|
||
|
[second]: [($e.mds / 1000) % 60, d],
|
||
|
[millisecond]: [$e.mds % 1000, d]
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
QVariant{
|
||
|
preview
|
||
|
(
|
||
|
#if ($e.d.type == 1) (
|
||
|
#("bool = ", [$e.d.data.b])
|
||
|
) #elif ($e.d.type == 2) (
|
||
|
#("int = ", [$e.d.data.i])
|
||
|
) #elif ($e.d.type == 3) (
|
||
|
#("usigned int = ", [$e.d.data.u])
|
||
|
) #elif ($e.d.type == 4) (
|
||
|
#("long long = ", [$e.d.data.ll])
|
||
|
) #elif ($e.d.type == 5) (
|
||
|
#("unsigned long long = ", [$e.d.data.ull])
|
||
|
) #elif ($e.d.type == 6) (
|
||
|
#("double = ", [$e.d.data.d])
|
||
|
) #elif ($e.d.type == 7) (
|
||
|
#("char = ", [$e.d.data.c])
|
||
|
) #elif ($e.d.type == 8) (
|
||
|
#("QMap = ", [(QMap) $e.d.data.ptr])
|
||
|
) #elif ($e.d.type == 10) (
|
||
|
#("QString = ", [(QString) $e.d.data.ptr])
|
||
|
) #elif ($e.d.type == 11) (
|
||
|
#("QStringList = ", [(QStringList) $e.d.data.ptr])
|
||
|
) #elif ($e.d.type == 17) (
|
||
|
#("QUrl = ", [(QUrl) $e.d.data.ptr])
|
||
|
) #else (
|
||
|
#("type = ", [$e.d.type])
|
||
|
)
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#if ($e.d.type == 1) (
|
||
|
$c.d.data.b
|
||
|
) #elif ($e.d.type == 2) (
|
||
|
$c.d.data.i
|
||
|
) #elif ($e.d.type == 3) (
|
||
|
$c.d.data.u
|
||
|
) #elif ($e.d.type == 4) (
|
||
|
$c.d.data.ll
|
||
|
) #elif ($e.d.type == 5) (
|
||
|
$c.d.data.ull
|
||
|
) #elif ($e.d.type == 6) (
|
||
|
$c.d.data.d
|
||
|
) #elif ($e.d.type == 7) (
|
||
|
$c.d.data.c
|
||
|
) #elif ($e.d.type == 8) (
|
||
|
) #elif ($e.d.type == 10) (
|
||
|
#(
|
||
|
[size]: ((QString) $c.d.data.ptr).d->size
|
||
|
)
|
||
|
) #elif ($e.d.type == 11) (
|
||
|
#if ((((QStringList) $e.d.data.ptr).d->end - ((QStringList) $e.d.data.ptr).d->begin) <= 10) (
|
||
|
#array
|
||
|
(
|
||
|
expr: (QString)((((QStringList) $e.d.data.ptr).d->array + ((QStringList) $e.d.data.ptr).d->begin)[$i]),
|
||
|
size: ((QStringList) $e.d.data.ptr).d->end-((QStringList) $e.d.data.ptr).d->begin
|
||
|
)
|
||
|
) #else (
|
||
|
#array
|
||
|
(
|
||
|
expr: (QString)((((QStringList) $e.d.data.ptr).d->array + ((QStringList) $e.d.data.ptr).d->begin)[$i]),
|
||
|
size: 10
|
||
|
)
|
||
|
)
|
||
|
) #elif ($e.d.type == 17) (
|
||
|
#(
|
||
|
scheme: ((QUrl) $e.d.data.ptr).d->scheme,
|
||
|
host: ((QUrl) $e.d.data.ptr).d->host,
|
||
|
path: ((QUrl) $e.d.data.ptr).d->path,
|
||
|
username: ((QUrl) $e.d.data.ptr).d->userName,
|
||
|
password: ((QUrl) $e.d.data.ptr).d->password,
|
||
|
encodedOriginal: ((QUrl) $e.d.data.ptr).d->encodedOriginal,
|
||
|
query: ((QUrl) $e.d.data.ptr).d->query,
|
||
|
fragment: ((QUrl) $e.d.data.ptr).d->fragment
|
||
|
)
|
||
|
) #else (
|
||
|
#("type = ", [$e.d.type])
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
*::QVariant{
|
||
|
preview
|
||
|
(
|
||
|
#if ($e.d.type == 1) (
|
||
|
#("bool = ", [$e.d.data.b])
|
||
|
) #elif ($e.d.type == 2) (
|
||
|
#("int = ", [$e.d.data.i])
|
||
|
) #elif ($e.d.type == 3) (
|
||
|
#("usigned int = ", [$e.d.data.u])
|
||
|
) #elif ($e.d.type == 4) (
|
||
|
#("long long = ", [$e.d.data.ll])
|
||
|
) #elif ($e.d.type == 5) (
|
||
|
#("unsigned long long = ", [$e.d.data.ull])
|
||
|
) #elif ($e.d.type == 6) (
|
||
|
#("double = ", [$e.d.data.d])
|
||
|
) #elif ($e.d.type == 7) (
|
||
|
#("char = ", [$e.d.data.c])
|
||
|
) #elif ($e.d.type == 8) (
|
||
|
#("QMap = ", [($T1::QMap) $e.d.data.ptr])
|
||
|
) #elif ($e.d.type == 10) (
|
||
|
#("QString = ", [($T1::QString) $e.d.data.ptr])
|
||
|
) #elif ($e.d.type == 11) (
|
||
|
#("QStringList = ", [($T1::QStringList) $e.d.data.ptr])
|
||
|
) #elif ($e.d.type == 17) (
|
||
|
#("QUrl = ", [($T1::QUrl) $e.d.data.ptr])
|
||
|
) #else (
|
||
|
#("type = ", [$e.d.type])
|
||
|
)
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#if ($e.d.type == 1) (
|
||
|
$c.d.data.b
|
||
|
) #elif ($e.d.type == 2) (
|
||
|
$c.d.data.i
|
||
|
) #elif ($e.d.type == 3) (
|
||
|
$c.d.data.u
|
||
|
) #elif ($e.d.type == 4) (
|
||
|
$c.d.data.ll
|
||
|
) #elif ($e.d.type == 5) (
|
||
|
$c.d.data.ull
|
||
|
) #elif ($e.d.type == 6) (
|
||
|
$c.d.data.d
|
||
|
) #elif ($e.d.type == 7) (
|
||
|
$c.d.data.c
|
||
|
) #elif ($e.d.type == 8) (
|
||
|
) #elif ($e.d.type == 10) (
|
||
|
#(
|
||
|
[size]: (($T1::QString) $c.d.data.ptr).d->size
|
||
|
)
|
||
|
) #elif ($e.d.type == 11) (
|
||
|
#if (((($T1::QStringList) $e.d.data.ptr).d->end - (($T1::QStringList) $e.d.data.ptr).d->begin) <= 10) (
|
||
|
#array
|
||
|
(
|
||
|
expr: ($T1::QString)(((($T1::QStringList) $e.d.data.ptr).d->array + (($T1::QStringList) $e.d.data.ptr).d->begin)[$i]),
|
||
|
size: (($T1::QStringList) $e.d.data.ptr).d->end-(($T1::QStringList) $e.d.data.ptr).d->begin
|
||
|
)
|
||
|
) #else (
|
||
|
#array
|
||
|
(
|
||
|
expr: ($T1::QString)(((($T1::QStringList) $e.d.data.ptr).d->array + (($T1::QStringList) $e.d.data.ptr).d->begin)[$i]),
|
||
|
size: 10
|
||
|
)
|
||
|
)
|
||
|
) #elif ($e.d.type == 17) (
|
||
|
#(
|
||
|
scheme: (($T1::QUrl) $e.d.data.ptr).d->scheme,
|
||
|
host: (($T1::QUrl) $e.d.data.ptr).d->host,
|
||
|
path: (($T1::QUrl) $e.d.data.ptr).d->path,
|
||
|
username: (($T1::QUrl) $e.d.data.ptr).d->userName,
|
||
|
password: (($T1::QUrl) $e.d.data.ptr).d->password,
|
||
|
encodedOriginal: (($T1::QUrl) $e.d.data.ptr).d->encodedOriginal,
|
||
|
query: (($T1::QUrl) $e.d.data.ptr).d->query,
|
||
|
fragment: (($T1::QUrl) $e.d.data.ptr).d->fragment
|
||
|
)
|
||
|
) #else (
|
||
|
#("type = ", [$e.d.type])
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
;------------------------------------------------------------------------------
|
||
|
; QStringList
|
||
|
;------------------------------------------------------------------------------
|
||
|
QStringList{
|
||
|
preview
|
||
|
(
|
||
|
#if (($c.d->end - $c.d->begin) <= 10) (
|
||
|
#(
|
||
|
"[", $c.d->end - $c.d->begin, "](",
|
||
|
#array
|
||
|
(
|
||
|
expr: (QString)(($c.d->array + $c.d->begin)[$i]),
|
||
|
size: $c.d->end-$c.d->begin
|
||
|
), ")"
|
||
|
)
|
||
|
) #else (
|
||
|
#(
|
||
|
"[", $c.d->end - $c.d->begin, "](",
|
||
|
#array
|
||
|
(
|
||
|
expr: (QString)(($c.d->array + $c.d->begin)[$i]),
|
||
|
size: 10
|
||
|
), ", ...)"
|
||
|
)
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
*::QStringList{
|
||
|
preview
|
||
|
(
|
||
|
#if (($c.d->end - $c.d->begin) <= 10) (
|
||
|
#(
|
||
|
"[", $c.d->end - $c.d->begin, "](",
|
||
|
#array
|
||
|
(
|
||
|
expr: ($T1::QString)(($c.d->array + $c.d->begin)[$i]),
|
||
|
size: $c.d->end-$c.d->begin
|
||
|
), ")"
|
||
|
)
|
||
|
) #else (
|
||
|
#(
|
||
|
"[", $c.d->end - $c.d->begin, "](",
|
||
|
#array
|
||
|
(
|
||
|
expr: ($T1::QString)(($c.d->array + $c.d->begin)[$i]),
|
||
|
size: 10
|
||
|
), ", ...)"
|
||
|
)
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
;------------------------------------------------------------------------------
|
||
|
; QList, QQueue
|
||
|
;------------------------------------------------------------------------------
|
||
|
QList<*>|QQueue<*>{
|
||
|
preview
|
||
|
(
|
||
|
#if (int(sizeof($T1)) <= int(sizeof(void*))) (
|
||
|
#if (($c.d->end - $c.d->begin) <= 10) (
|
||
|
#(
|
||
|
"[", $c.d->end - $c.d->begin, "](",
|
||
|
#array
|
||
|
(
|
||
|
expr: ($T1)(($c.d->array + $c.d->begin)[$i]),
|
||
|
size: $c.d->end-$c.d->begin
|
||
|
), ")"
|
||
|
)
|
||
|
) #else (
|
||
|
#(
|
||
|
"[", $c.d->end - $c.d->begin, "](",
|
||
|
#array
|
||
|
(
|
||
|
expr: ($T1)(($c.d->array + $c.d->begin)[$i]),
|
||
|
size: 10
|
||
|
), ", ...)"
|
||
|
)
|
||
|
)
|
||
|
) #else (
|
||
|
#if (($c.d->end - $c.d->begin) <= 10) (
|
||
|
#(
|
||
|
"[", $c.d->end - $c.d->begin, "](",
|
||
|
#array
|
||
|
(
|
||
|
expr: *($T1*)(($c.d->array + $c.d->begin)[$i]),
|
||
|
size: $c.d->end-$c.d->begin
|
||
|
), ")"
|
||
|
)
|
||
|
) #else (
|
||
|
#(
|
||
|
"[", $c.d->end - $c.d->begin, "](",
|
||
|
#array
|
||
|
(
|
||
|
expr: *($T1*)(($c.d->array + $c.d->begin)[$i]),
|
||
|
size: 10
|
||
|
), ", ...)"
|
||
|
)
|
||
|
)
|
||
|
)
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#if (int(sizeof($T1)) <= int(sizeof(void*))) (
|
||
|
#array (
|
||
|
expr: ($T1)(($c.d->array + $c.d->begin)[$i]),
|
||
|
size: $c.d->end - $c.d->begin
|
||
|
)
|
||
|
) #else (
|
||
|
#array (
|
||
|
expr: *($T1*)(($c.d->array + $c.d->begin)[$i]),
|
||
|
size: $c.d->end - $c.d->begin
|
||
|
)
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
*::QList<*>|*::QQueue<*>{
|
||
|
preview
|
||
|
(
|
||
|
#if (int(sizeof($T2)) <= int(sizeof(void*))) (
|
||
|
#if (($c.d->end - $c.d->begin) <= 10) (
|
||
|
#(
|
||
|
"[", $c.d->end - $c.d->begin, "](",
|
||
|
#array
|
||
|
(
|
||
|
expr: ($T2)(($c.d->array + $c.d->begin)[$i]),
|
||
|
size: $c.d->end-$c.d->begin
|
||
|
), ")"
|
||
|
)
|
||
|
) #else (
|
||
|
#(
|
||
|
"[", $c.d->end - $c.d->begin, "](",
|
||
|
#array
|
||
|
(
|
||
|
expr: ($T2)(($c.d->array + $c.d->begin)[$i]),
|
||
|
size: 10
|
||
|
), ", ...)"
|
||
|
)
|
||
|
)
|
||
|
) #else (
|
||
|
#if (($c.d->end - $c.d->begin) <= 10) (
|
||
|
#(
|
||
|
"[", $c.d->end - $c.d->begin, "](",
|
||
|
#array
|
||
|
(
|
||
|
expr: *($T2*)(($c.d->array + $c.d->begin)[$i]),
|
||
|
size: $c.d->end-$c.d->begin
|
||
|
), ")"
|
||
|
)
|
||
|
) #else (
|
||
|
#(
|
||
|
"[", $c.d->end - $c.d->begin, "](",
|
||
|
#array
|
||
|
(
|
||
|
expr: *($T2*)(($c.d->array + $c.d->begin)[$i]),
|
||
|
size: 10
|
||
|
), ", ...)"
|
||
|
)
|
||
|
)
|
||
|
)
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#if (int(sizeof($T2)) <= int(sizeof(void*))) (
|
||
|
#array (
|
||
|
expr: ($T2)(($c.d->array + $c.d->begin)[$i]),
|
||
|
size: $c.d->end - $c.d->begin
|
||
|
)
|
||
|
) #else (
|
||
|
#array (
|
||
|
expr: *($T2*)(($c.d->array + $c.d->begin)[$i]),
|
||
|
size: $c.d->end - $c.d->begin
|
||
|
)
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
;------------------------------------------------------------------------------
|
||
|
; QList::iterator, QQueue::iterator
|
||
|
;------------------------------------------------------------------------------
|
||
|
QList<*>::iterator|QList<*>::const_iterator|QQueue<*>::iterator|QQueue<*>::const_iterator{
|
||
|
preview
|
||
|
(
|
||
|
#(
|
||
|
($T1*)$c.ptr
|
||
|
)
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#(
|
||
|
ptr: ($T1)$c.ptr
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
*::QList<*>::iterator|*::QList<*>::const_iterator|*::QQueue<*>::iterator|*::QQueue<*>::const_iterator{
|
||
|
preview
|
||
|
(
|
||
|
#(
|
||
|
($T2)$c.i->v
|
||
|
)
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#(
|
||
|
ptr: ($T2)$c.i->v
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
;------------------------------------------------------------------------------
|
||
|
; QListIterator
|
||
|
;------------------------------------------------------------------------------
|
||
|
QListIterator<*>|QMutableListIterator<*>{
|
||
|
preview
|
||
|
(
|
||
|
#(
|
||
|
*($T1*)($c.i.i->v)
|
||
|
)
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#(
|
||
|
Value: *($T1*)($c.i.i->v)
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
*::QListIterator<*>|*::QMutableListIterator<*>{
|
||
|
preview
|
||
|
(
|
||
|
#(
|
||
|
*($T2*)($c.i.i->v)
|
||
|
)
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#(
|
||
|
Value: *($T2*)($c.i.i->v)
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
;------------------------------------------------------------------------------
|
||
|
; QLinkedList
|
||
|
;------------------------------------------------------------------------------
|
||
|
QLinkedList<*>{
|
||
|
preview
|
||
|
(
|
||
|
#if ($e.d->size >= 10) (
|
||
|
#(
|
||
|
"[", $e.d->size, "](",
|
||
|
#list
|
||
|
(
|
||
|
head: $c.d->n,
|
||
|
size: 10,
|
||
|
next: n
|
||
|
) : ( (*(QLinkedListNode<$T1>*)&$e).t ), ", ...)"
|
||
|
)
|
||
|
) #else (
|
||
|
#(
|
||
|
"[", $e.d->size, "](",
|
||
|
#list
|
||
|
(
|
||
|
head: $c.d->n,
|
||
|
size: $c.d->size,
|
||
|
next: n
|
||
|
) : ( (*(QLinkedListNode<$T1>*)&$e).t ), ")"
|
||
|
)
|
||
|
)
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#(
|
||
|
#list
|
||
|
(
|
||
|
head: $c.d->n,
|
||
|
size: $c.d->size,
|
||
|
next: n
|
||
|
) : (*(QLinkedListNode<$T1>*)&$e).t
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
*::QLinkedList<*>{
|
||
|
preview
|
||
|
(
|
||
|
#if ($e.d->size >= 10) (
|
||
|
#(
|
||
|
"[", $e.d->size, "](",
|
||
|
#list
|
||
|
(
|
||
|
head: $c.d->n,
|
||
|
size: 10,
|
||
|
next: n
|
||
|
) : ( (*($T1::QLinkedListNode<$T2>*)&$e).t ), ", ...)"
|
||
|
)
|
||
|
) #else (
|
||
|
#(
|
||
|
"[", $e.d->size, "](",
|
||
|
#list
|
||
|
(
|
||
|
head: $c.d->n,
|
||
|
size: $c.d->size,
|
||
|
next: n
|
||
|
) : ( (*($T1::QLinkedListNode<$T2>*)&$e).t ), ")"
|
||
|
)
|
||
|
)
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#(
|
||
|
#list
|
||
|
(
|
||
|
head: $c.d->n,
|
||
|
size: $c.d->size,
|
||
|
next: n
|
||
|
) : (*($T1::QLinkedListNode<$T2>*)&$e).t
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
;------------------------------------------------------------------------------
|
||
|
; QLinkedList::iterator
|
||
|
;------------------------------------------------------------------------------
|
||
|
QLinkedList<*>::iterator|*::QLinkedList<*>::iterator|QLinkedList<*>::const_iterator|*::QLinkedList<*>::const_iterator{
|
||
|
preview
|
||
|
(
|
||
|
#(
|
||
|
$e.i->t
|
||
|
)
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#(
|
||
|
ptr: $e.i->t
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
QLinkedListIterator<*>|*::QLinkedListIterator<*>{
|
||
|
preview
|
||
|
(
|
||
|
#(
|
||
|
$c.i
|
||
|
)
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#(
|
||
|
value: $c.i
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
;------------------------------------------------------------------------------
|
||
|
; QVector, QStack
|
||
|
;
|
||
|
; By default, this visualizer supports only Qt 4.6.x. If you're going to use
|
||
|
; Qt 4.5.x code, then you may want to replace all expr lines with this:
|
||
|
; expr: (((size_t)($c.d) + (size_t)(sizeof(QVectorData)) ))[$i],
|
||
|
;
|
||
|
; This will allow this visualizer to display Qt 4.5.x and Qt 4.6.x QVector
|
||
|
; objects. But be aware of some limitations. For example enum types can't be
|
||
|
; displayed properly this way.
|
||
|
;
|
||
|
; Qt 4.5.x:
|
||
|
; QVector::d is QVectorTypedData<T>
|
||
|
; QVector::p is QVectorData
|
||
|
; expr: $c.d->array[$i]
|
||
|
;
|
||
|
; Qt 4.6.x:
|
||
|
; QVector::d is QVectorData
|
||
|
; QVector::p is QVectorTypedData<T>
|
||
|
; expr: $c.p->array[$i]
|
||
|
;
|
||
|
;------------------------------------------------------------------------------
|
||
|
QVector<*>|*::QVector<*>|QStack<*>|*::QStack<*>{
|
||
|
preview
|
||
|
(
|
||
|
#if ($c.d->size <= 10) (
|
||
|
#(
|
||
|
"[", $c.d->size, "](",
|
||
|
#array
|
||
|
(
|
||
|
expr: $c.p->array[$i],
|
||
|
size: $c.d->size
|
||
|
), ")"
|
||
|
)
|
||
|
) #else (
|
||
|
#(
|
||
|
"[", $c.d->size, "](",
|
||
|
#array
|
||
|
(
|
||
|
expr: $c.p->array[$i],
|
||
|
size: 10
|
||
|
), ", ...)"
|
||
|
)
|
||
|
)
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#array
|
||
|
(
|
||
|
expr: $c.p->array[$i],
|
||
|
size: $c.d->size
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
;------------------------------------------------------------------------------
|
||
|
; QMap
|
||
|
;------------------------------------------------------------------------------
|
||
|
QMapNode<*,*>{
|
||
|
preview
|
||
|
(
|
||
|
#(
|
||
|
"(",
|
||
|
$e.key,
|
||
|
"; ",
|
||
|
$e.value,
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
|
||
|
children
|
||
|
(
|
||
|
#(
|
||
|
key: $e.key,
|
||
|
value: $e.value
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
QMap<*>{
|
||
|
children
|
||
|
(
|
||
|
#(
|
||
|
raw data: [$c,!],
|
||
|
#tree
|
||
|
(
|
||
|
head : $c.d->forward[0],
|
||
|
skip : $c.d,
|
||
|
size : $c.d->size,
|
||
|
left : backward,
|
||
|
right : forward
|
||
|
) : ( (QMapNode<$T1>*)((char*)&$e - (sizeof(QMapPayloadNode<$T1>) - sizeof(QMapData::Node*))) )
|
||
|
)
|
||
|
)
|
||
|
|
||
|
preview
|
||
|
(
|
||
|
#(
|
||
|
"[",
|
||
|
$e.d->size,
|
||
|
"](",
|
||
|
#tree
|
||
|
(
|
||
|
head : $c.d->forward[0],
|
||
|
size : $c.d->size,
|
||
|
left : backward,
|
||
|
right : forward
|
||
|
) : $e,
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
;------------------------------------------------------------------------------
|
||
|
; QHash
|
||
|
;------------------------------------------------------------------------------
|
||
|
QHash<*>{
|
||
|
preview
|
||
|
(
|
||
|
#(
|
||
|
"[", $e.d->size, "] (...)"
|
||
|
)
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#if ($e.d->size <= 255) (
|
||
|
#(
|
||
|
#array (
|
||
|
expr: (QHashNode<$T1>*)$c.d->buckets[$i],
|
||
|
size: $c.d->numBuckets
|
||
|
) : #list (
|
||
|
head: $e,
|
||
|
next: next
|
||
|
) : #switch ($e.next != 0) #case 1 (
|
||
|
$e
|
||
|
)
|
||
|
)
|
||
|
) #else (
|
||
|
#(
|
||
|
#array (
|
||
|
expr: (QHashNode<$T1>*)$c.d->buckets[$i],
|
||
|
size: 255
|
||
|
) : #list (
|
||
|
head: $e,
|
||
|
next: next
|
||
|
) : #switch ($e.next != 0) #case 1 (
|
||
|
$e
|
||
|
)
|
||
|
)
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
*::QHash<*>{
|
||
|
preview
|
||
|
(
|
||
|
#(
|
||
|
"[", $e.d->size, "] (...)"
|
||
|
)
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#if ($e.d->size <= 255) (
|
||
|
#(
|
||
|
#array (
|
||
|
expr: ($T1::QHashNode<$T2> *)$c.d->buckets[$i],
|
||
|
size: $c.d->numBuckets
|
||
|
) : #list (
|
||
|
head: $e,
|
||
|
next: next
|
||
|
) : #switch ($e.next != 0) #case 1 (
|
||
|
$e
|
||
|
)
|
||
|
)
|
||
|
) #else (
|
||
|
#(
|
||
|
#array (
|
||
|
expr: ($T1::QHashNode<$T2> *)$c.d->buckets[$i],
|
||
|
size: 255
|
||
|
) : #list (
|
||
|
head: $e,
|
||
|
next: next
|
||
|
) : #switch ($e.next != 0) #case 1 (
|
||
|
$e
|
||
|
)
|
||
|
)
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
;------------------------------------------------------------------------------
|
||
|
; QMultiHash
|
||
|
;------------------------------------------------------------------------------
|
||
|
QMultiHash<*>{
|
||
|
preview
|
||
|
(
|
||
|
(*(QHash<$T1>*)(&$c))
|
||
|
)
|
||
|
}
|
||
|
|
||
|
*::QMultiHash<*>{
|
||
|
preview
|
||
|
(
|
||
|
(*($T1::QHash<$T2>*)(&$c))
|
||
|
)
|
||
|
}
|
||
|
|
||
|
;------------------------------------------------------------------------------
|
||
|
; QHash::iterator
|
||
|
;------------------------------------------------------------------------------
|
||
|
QHash<*>::iterator{
|
||
|
preview
|
||
|
(
|
||
|
#(
|
||
|
"(", ((QHashNode<$T1>*)($c.i))->key, ", ", ((QHashNode<$T1>*)($c.i))->value, ")"
|
||
|
)
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#(
|
||
|
key: ((QHashNode<$T1>*)($c.i))->key,
|
||
|
value: ((QHashNode<$T1>*)($c.i))->value
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
*::QHash<*>::iterator{
|
||
|
preview
|
||
|
(
|
||
|
#(
|
||
|
"(", (($T1::QHashNode<$T2>*)($c.i))->key, ", ", (($T1::QHashNode<$T2>*)($c.i))->key, ")"
|
||
|
)
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#(
|
||
|
key: (($T1::QHashNode<$T2>*)($c.i))->key,
|
||
|
value: (($T1::QHashNode<$T2>*)($c.i))->value
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
;------------------------------------------------------------------------------
|
||
|
; QHashIterator
|
||
|
;------------------------------------------------------------------------------
|
||
|
QHashIterator<*>{
|
||
|
preview
|
||
|
(
|
||
|
#(
|
||
|
"(", ((QHashNode<$T1>*)((($c).i).i))->key, ", ", ((QHashNode<$T1>*)((($c).i).i))->key, ")"
|
||
|
)
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#(
|
||
|
key: ((QHashNode<$T1>*)((($c).i).i))->key,
|
||
|
value: ((QHashNode<$T1>*)((($c).i).i))->value
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
*::QHashIterator<*>{
|
||
|
preview
|
||
|
(
|
||
|
#(
|
||
|
"(", (($T1::QHashNode<$T2>*)((($c).i).i))->key, ", ", (($T1::QHashNode<$T2>*)((($c).i).i))->key, ")"
|
||
|
)
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#(
|
||
|
key: (($T1::QHashNode<$T2>*)((($c).i).i))->key,
|
||
|
value: (($T1::QHashNode<$T2>*)((($c).i).i))->value
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
;------------------------------------------------------------------------------
|
||
|
; QHashNode
|
||
|
;------------------------------------------------------------------------------
|
||
|
QHashNode<*>|*::QHashNode<*>{
|
||
|
preview
|
||
|
(
|
||
|
#(
|
||
|
"(key = ", $c.key,"; value = ", $c.value, ")"
|
||
|
)
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#(
|
||
|
key: $c.key,
|
||
|
value: $c.value
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
;------------------------------------------------------------------------------
|
||
|
; QSet
|
||
|
;------------------------------------------------------------------------------
|
||
|
QSet<*>{
|
||
|
preview
|
||
|
(
|
||
|
#(
|
||
|
"[", $e.q_hash.d->size, "] (...)"
|
||
|
)
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#if ($e.q_hash.d->size <= 255) (
|
||
|
#(
|
||
|
#array (
|
||
|
expr: (QHashNode<$T1,QHashDummyValue> *)$c.q_hash.d->buckets[$i],
|
||
|
size: $c.q_hash.d->numBuckets
|
||
|
) : #list (
|
||
|
head: $e,
|
||
|
next: next
|
||
|
) : #switch ($e.next != 0) #case 1 (
|
||
|
$e.key
|
||
|
)
|
||
|
)
|
||
|
) #else (
|
||
|
#(
|
||
|
#array (
|
||
|
expr: (QHashNode<$T1,QHashDummyValue> *)$c.q_hash.d->buckets[$i],
|
||
|
size: 255
|
||
|
) : #list (
|
||
|
head: $e,
|
||
|
next: next
|
||
|
) : #switch ($e.next != 0) #case 1 (
|
||
|
$e.key
|
||
|
)
|
||
|
)
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
*::QSet<*>{
|
||
|
preview
|
||
|
(
|
||
|
#(
|
||
|
"[", $e.q_hash.d->size, "] (...)"
|
||
|
)
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#if ($e.q_hash.d->size <= 255) (
|
||
|
#(
|
||
|
#array (
|
||
|
expr: ($T1::QHashNode<$T2,QHashDummyValue> *)$c.q_hash.d->buckets[$i],
|
||
|
size: $c.q_hash.d->numBuckets
|
||
|
) : #list (
|
||
|
head: $e,
|
||
|
next: next
|
||
|
) : #switch ($e.next != 0) #case 1 (
|
||
|
$e.key
|
||
|
)
|
||
|
)
|
||
|
) #else (
|
||
|
#(
|
||
|
#array (
|
||
|
expr: ($T1::QHashNode<$T2,QHashDummyValue> *)$c.q_hash.d->buckets[$i],
|
||
|
size: 255
|
||
|
) : #list (
|
||
|
head: $e,
|
||
|
next: next
|
||
|
) : #switch ($e.next != 0) #case 1 (
|
||
|
$e.key
|
||
|
)
|
||
|
)
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
;------------------------------------------------------------------------------
|
||
|
; QPalette
|
||
|
;------------------------------------------------------------------------------
|
||
|
QPalette{
|
||
|
children
|
||
|
(
|
||
|
#(
|
||
|
WindowText_active:
|
||
|
((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+ 0)->d,
|
||
|
Button_active:
|
||
|
((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+ 1)->d,
|
||
|
Light_active:
|
||
|
((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+ 2)->d,
|
||
|
Midlight_active:
|
||
|
((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+ 3)->d,
|
||
|
Dark_active:
|
||
|
((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+ 4)->d,
|
||
|
Mid_active:
|
||
|
((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+ 5)->d,
|
||
|
Text_active:
|
||
|
((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+ 6)->d,
|
||
|
BrightText_active:
|
||
|
((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+ 7)->d,
|
||
|
ButtonText_active:
|
||
|
((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+ 8)->d,
|
||
|
Base_active:
|
||
|
((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+ 9)->d,
|
||
|
Window_active:
|
||
|
((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+10)->d,
|
||
|
Shadow_active:
|
||
|
((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+11)->d,
|
||
|
Highlight_active:
|
||
|
((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+12)->d,
|
||
|
HighlightedText_active:
|
||
|
((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+13)->d,
|
||
|
Link_active:
|
||
|
((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+14)->d,
|
||
|
LinkVisited_active:
|
||
|
((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+15)->d,
|
||
|
AlternateBase_active:
|
||
|
((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+16)->d,
|
||
|
NoRole_active:
|
||
|
((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+17)->d,
|
||
|
ToolTipBase_active:
|
||
|
((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+18)->d,
|
||
|
ToolTipText_active:
|
||
|
((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+19)->d,
|
||
|
|
||
|
WindowText_disabled:
|
||
|
((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+ 0)->d,
|
||
|
Button_disabled:
|
||
|
((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+ 1)->d,
|
||
|
Light_disabled:
|
||
|
((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+ 2)->d,
|
||
|
Midlight_disabled:
|
||
|
((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+ 3)->d,
|
||
|
Dark_disabled:
|
||
|
((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+ 4)->d,
|
||
|
Mid_disabled:
|
||
|
((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+ 5)->d,
|
||
|
Text_disabled:
|
||
|
((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+ 6)->d,
|
||
|
BrightText_disabled:
|
||
|
((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+ 7)->d,
|
||
|
ButtonText_disabled:
|
||
|
((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+ 8)->d,
|
||
|
Base_disabled:
|
||
|
((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+ 9)->d,
|
||
|
Window_disabled:
|
||
|
((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+10)->d,
|
||
|
Shadow_disabled:
|
||
|
((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+11)->d,
|
||
|
Highlight_disabled:
|
||
|
((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+12)->d,
|
||
|
HighlightedText_disabled:
|
||
|
((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+13)->d,
|
||
|
Link_disabled:
|
||
|
((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+14)->d,
|
||
|
LinkVisited_disabled:
|
||
|
((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+15)->d,
|
||
|
AlternateBase_disabled:
|
||
|
((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+16)->d,
|
||
|
NoRole_disabled:
|
||
|
((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+17)->d,
|
||
|
ToolTipBase_disabled:
|
||
|
((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+18)->d,
|
||
|
ToolTipText_disabled:
|
||
|
((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+19)->d,
|
||
|
|
||
|
WindowText_inactive:
|
||
|
((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+ 0)->d,
|
||
|
Button_inactive:
|
||
|
((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+ 1)->d,
|
||
|
Light_inactive:
|
||
|
((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+ 2)->d,
|
||
|
Midlight_inactive:
|
||
|
((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+ 3)->d,
|
||
|
Dark_inactive:
|
||
|
((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+ 4)->d,
|
||
|
Mid_inactive:
|
||
|
((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+ 5)->d,
|
||
|
Text_inactive:
|
||
|
((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+ 6)->d,
|
||
|
BrightText_inactive:
|
||
|
((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+ 7)->d,
|
||
|
ButtonText_inactive:
|
||
|
((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+ 8)->d,
|
||
|
Base_inactive:
|
||
|
((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+ 9)->d,
|
||
|
Window_inactive:
|
||
|
((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+10)->d,
|
||
|
Shadow_inactive:
|
||
|
((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+11)->d,
|
||
|
Highlight_inactive:
|
||
|
((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+12)->d,
|
||
|
HighlightedText_inactive:
|
||
|
((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+13)->d,
|
||
|
Link_inactive:
|
||
|
((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+14)->d,
|
||
|
LinkVisited_inactive:
|
||
|
((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+15)->d,
|
||
|
AlternateBase_inactive:
|
||
|
((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+16)->d,
|
||
|
NoRole_inactive:
|
||
|
((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+17)->d,
|
||
|
ToolTipBase_inactive:
|
||
|
((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+18)->d,
|
||
|
ToolTipText_inactive:
|
||
|
((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+19)->d
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
*::QPalette{
|
||
|
children
|
||
|
(
|
||
|
#(
|
||
|
WindowText_active:
|
||
|
(($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+ 0)->d,
|
||
|
Button_active:
|
||
|
(($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+ 1)->d,
|
||
|
Light_active:
|
||
|
(($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+ 2)->d,
|
||
|
Midlight_active:
|
||
|
(($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+ 3)->d,
|
||
|
Dark_active:
|
||
|
(($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+ 4)->d,
|
||
|
Mid_active:
|
||
|
(($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+ 5)->d,
|
||
|
Text_active:
|
||
|
(($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+ 6)->d,
|
||
|
BrightText_active:
|
||
|
(($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+ 7)->d,
|
||
|
ButtonText_active:
|
||
|
(($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+ 8)->d,
|
||
|
Base_active:
|
||
|
(($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+ 9)->d,
|
||
|
Window_active:
|
||
|
(($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+10)->d,
|
||
|
Shadow_active:
|
||
|
(($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+11)->d,
|
||
|
Highlight_active:
|
||
|
(($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+12)->d,
|
||
|
HighlightedText_active:
|
||
|
(($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+13)->d,
|
||
|
Link_active:
|
||
|
(($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+14)->d,
|
||
|
LinkVisited_active:
|
||
|
(($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+15)->d,
|
||
|
AlternateBase_active:
|
||
|
(($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+16)->d,
|
||
|
NoRole_active:
|
||
|
(($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+17)->d,
|
||
|
ToolTipBase_active:
|
||
|
(($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+18)->d,
|
||
|
ToolTipText_active:
|
||
|
(($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+19)->d,
|
||
|
|
||
|
WindowText_disabled:
|
||
|
(($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+ 0)->d,
|
||
|
Button_disabled:
|
||
|
(($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+ 1)->d,
|
||
|
Light_disabled:
|
||
|
(($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+ 2)->d,
|
||
|
Midlight_disabled:
|
||
|
(($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+ 3)->d,
|
||
|
Dark_disabled:
|
||
|
(($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+ 4)->d,
|
||
|
Mid_disabled:
|
||
|
(($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+ 5)->d,
|
||
|
Text_disabled:
|
||
|
(($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+ 6)->d,
|
||
|
BrightText_disabled:
|
||
|
(($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+ 7)->d,
|
||
|
ButtonText_disabled:
|
||
|
(($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+ 8)->d,
|
||
|
Base_disabled:
|
||
|
(($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+ 9)->d,
|
||
|
Window_disabled:
|
||
|
(($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+10)->d,
|
||
|
Shadow_disabled:
|
||
|
(($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+11)->d,
|
||
|
Highlight_disabled:
|
||
|
(($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+12)->d,
|
||
|
HighlightedText_disabled:
|
||
|
(($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+13)->d,
|
||
|
Link_disabled:
|
||
|
(($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+14)->d,
|
||
|
LinkVisited_disabled:
|
||
|
(($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+15)->d,
|
||
|
AlternateBase_disabled:
|
||
|
(($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+16)->d,
|
||
|
NoRole_disabled:
|
||
|
(($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+17)->d,
|
||
|
ToolTipBase_disabled:
|
||
|
(($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+18)->d,
|
||
|
ToolTipText_disabled:
|
||
|
(($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+19)->d,
|
||
|
|
||
|
WindowText_inactive:
|
||
|
(($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+ 0)->d,
|
||
|
Button_inactive:
|
||
|
(($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+ 1)->d,
|
||
|
Light_inactive:
|
||
|
(($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+ 2)->d,
|
||
|
Midlight_inactive:
|
||
|
(($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+ 3)->d,
|
||
|
Dark_inactive:
|
||
|
(($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+ 4)->d,
|
||
|
Mid_inactive:
|
||
|
(($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+ 5)->d,
|
||
|
Text_inactive:
|
||
|
(($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+ 6)->d,
|
||
|
BrightText_inactive:
|
||
|
(($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+ 7)->d,
|
||
|
ButtonText_inactive:
|
||
|
(($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+ 8)->d,
|
||
|
Base_inactive:
|
||
|
(($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+ 9)->d,
|
||
|
Window_inactive:
|
||
|
(($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+10)->d,
|
||
|
Shadow_inactive:
|
||
|
(($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+11)->d,
|
||
|
Highlight_inactive:
|
||
|
(($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+12)->d,
|
||
|
HighlightedText_inactive:
|
||
|
(($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+13)->d,
|
||
|
Link_inactive:
|
||
|
(($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+14)->d,
|
||
|
LinkVisited_inactive:
|
||
|
(($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+15)->d,
|
||
|
AlternateBase_inactive:
|
||
|
(($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+16)->d,
|
||
|
NoRole_inactive:
|
||
|
(($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+17)->d,
|
||
|
ToolTipBase_inactive:
|
||
|
(($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+18)->d,
|
||
|
ToolTipText_inactive:
|
||
|
(($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+19)->d
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
;------------------------------------------------------------------------------
|
||
|
; QBrush
|
||
|
;------------------------------------------------------------------------------
|
||
|
QBrush|*::QBrush{
|
||
|
preview
|
||
|
(
|
||
|
#(
|
||
|
"[", $c.d->style, "] (...)"
|
||
|
)
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#(
|
||
|
style: $c.d->style,
|
||
|
color: $c.d->color,
|
||
|
transform: $c.d->transform
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
QBrushData|*::QBrushData{
|
||
|
preview
|
||
|
(
|
||
|
#(
|
||
|
"[", $c.style, "] (...)"
|
||
|
)
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#(
|
||
|
style: $c.style,
|
||
|
color: $c.color,
|
||
|
transform: $c.transform
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
;------------------------------------------------------------------------------
|
||
|
; QColor
|
||
|
;------------------------------------------------------------------------------
|
||
|
QColor|*::QColor{
|
||
|
preview
|
||
|
(
|
||
|
#(
|
||
|
#if ($c.cspec == 1) (
|
||
|
#(
|
||
|
"[", $c.cspec, "] [", "r = ", [$c.ct.argb.red,x],
|
||
|
", g = ", [$c.ct.argb.green,x],
|
||
|
", b = ", [$c.ct.argb.blue,x], "] (...)"
|
||
|
)
|
||
|
) #elif ($c.cspec == 2) (
|
||
|
#(
|
||
|
"[", $c.cspec, "] [", "h = ", [$c.ct.ahsv.hue,x],
|
||
|
", s = ", [$c.ct.ahsv.saturation,x],
|
||
|
", v = ", [$c.ct.ahsv.value,x], "] (...)"
|
||
|
)
|
||
|
) #elif ($c.cspec == 3) (
|
||
|
#(
|
||
|
"[", $c.cspec, "] [", "c = ", [$c.ct.acmyk.cyan,x],
|
||
|
", m = ", [$c.ct.acmyk.magenta,x],
|
||
|
", y = ", [$c.ct.acmyk.yellow,x],
|
||
|
", k = ", [$c.ct.acmyk.black,x], "] (...)"
|
||
|
)
|
||
|
) #else (
|
||
|
#(
|
||
|
"[Invalid]"
|
||
|
)
|
||
|
)
|
||
|
)
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#(
|
||
|
#if ($c.cspec == 1) (
|
||
|
#(
|
||
|
red: [$c.ct.argb.red,x],
|
||
|
green: [$c.ct.argb.green,x],
|
||
|
blue: [$c.ct.argb.blue,x],
|
||
|
alpha: [$c.ct.argb.alpha,x],
|
||
|
pad: [$c.ct.argb.pad,x]
|
||
|
)
|
||
|
) #elif ($c.cspec == 2) (
|
||
|
#(
|
||
|
hue: [$c.ct.ahsv.hue,x],
|
||
|
saturation: [$c.ct.ahsv.saturation,x],
|
||
|
value: [$c.ct.ahsv.value,x],
|
||
|
alpha: [$c.ct.ahsv.alpha,x],
|
||
|
pad: [$c.ct.ahsv.pad,x]
|
||
|
)
|
||
|
) #elif ($c.cspec == 3) (
|
||
|
#(
|
||
|
cyan: [$c.ct.acmyk.cyan,x],
|
||
|
magenta: [$c.ct.acmyk.magenta,x],
|
||
|
yellow: [$c.ct.acmyk.yellow,x],
|
||
|
black: [$c.ct.acmyk.black,x],
|
||
|
alpha: [$c.ct.acmyk.alpha,x]
|
||
|
)
|
||
|
)
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
;------------------------------------------------------------------------------
|
||
|
; QTransform
|
||
|
;------------------------------------------------------------------------------
|
||
|
QTransform|*::QTransform{
|
||
|
preview
|
||
|
(
|
||
|
#(
|
||
|
"[",[$c.affine._m11,g]," ",[$c.affine._m12,g]," ",[$c.m_13,g],"]",
|
||
|
"[",[$c.affine._m21,g]," ",[$c.affine._m22,g]," ",[$c.m_23,g],"]",
|
||
|
"[",[$c.affine._dx,g]," ",[$c.affine._dy,g]," ",[$c.m_33,g],"]"
|
||
|
)
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#(
|
||
|
translation_horizontal_m31_dx: [$c.affine._dx,g],
|
||
|
translation_vertical_m32_dy: [$c.affine._dy,g],
|
||
|
scaling_horizontal_m11: [$c.affine._m11,g],
|
||
|
scaling_vertical_m22: [$c.affine._m22,g],
|
||
|
projection_factor_m33: [$c.m_33,g],
|
||
|
projection_horizontal_m13: [$c.m_13,g],
|
||
|
projection_vertical_m23: [$c.m_23,g],
|
||
|
shearing_horizontal_m21: [$c.affine._m21,g],
|
||
|
shearing_vertical_m12: [$c.affine._m12,g],
|
||
|
type: $c.m_type,
|
||
|
dirty: (bool)$c.m_dirty
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
;------------------------------------------------------------------------------
|
||
|
; QMatrix
|
||
|
;------------------------------------------------------------------------------
|
||
|
QMatrix|*::QMatrix{
|
||
|
preview
|
||
|
(
|
||
|
#(
|
||
|
"[",[$c._m11,g]," ",[$c._m12,g],"]",
|
||
|
"[",[$c._m21,g]," ",[$c._m22,g],"]",
|
||
|
"[",[$c._dx,g]," ",[$c._dy,g],"]"
|
||
|
)
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#(
|
||
|
translation_horizontal_dx: [$c._dx,g],
|
||
|
translation_vertical_dy: [$c._dy,g],
|
||
|
scaling_horizontal_m11: [$c._m11,g],
|
||
|
scaling_vertical_m22: [$c._m22,g],
|
||
|
shearing_horizontal_m21: [$c._m21,g],
|
||
|
shearing_vertical_m12: [$c._m12,g]
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
;------------------------------------------------------------------------------
|
||
|
; QPolygon
|
||
|
;------------------------------------------------------------------------------
|
||
|
QPolygon{
|
||
|
preview
|
||
|
(
|
||
|
#(
|
||
|
"[", ((QVector<QPoint>*)(&$c))->d->size, "] (...)"
|
||
|
)
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#(
|
||
|
#array
|
||
|
(
|
||
|
expr: ((QPoint*)(((void*)$c.d) + sizeof(QVectorData)))[$i],
|
||
|
size: ((QVector<QPoint>*)(&$c))->d->size
|
||
|
)
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
*::QPolygon{
|
||
|
preview
|
||
|
(
|
||
|
#(
|
||
|
"[", (($T1::QVector<$T1::QPoint>*)(&$c))->d->size, "] (...)"
|
||
|
)
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#(
|
||
|
#array
|
||
|
(
|
||
|
expr: (($T1::QPoint*)(((void*)$c.d) + sizeof(QVectorData)))[$i],
|
||
|
size: (($T1::QVector<$T1::QPoint>*)(&$c))->d->size
|
||
|
)
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
;------------------------------------------------------------------------------
|
||
|
; QPolygonF
|
||
|
;------------------------------------------------------------------------------
|
||
|
QPolygonF{
|
||
|
preview
|
||
|
(
|
||
|
#(
|
||
|
"[", ((QVector<QPointF>*)(&$c))->d->size, "] (...)"
|
||
|
)
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#(
|
||
|
#array
|
||
|
(
|
||
|
expr: ((QVector<QPointF>*)(&$c))->p->array[$i],
|
||
|
size: ((QVector<QPointF>*)(&$c))->d->size
|
||
|
)
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
*::QPolygonF{
|
||
|
preview
|
||
|
(
|
||
|
#(
|
||
|
"[", (($T1::QVector<$T1::QPointF>*)(&$c))->d->size, "] (...)"
|
||
|
)
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#(
|
||
|
#array
|
||
|
(
|
||
|
expr: (($T1::QVector<$T1::QPointF>*)(&$c))->p->array[$i],
|
||
|
size: (($T1::QVector<$T1::QPointF>*)(&$c))->d->size
|
||
|
)
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
;------------------------------------------------------------------------------
|
||
|
; stlport::basic_string
|
||
|
;------------------------------------------------------------------------------
|
||
|
stlp_std::basic_string<char,*>|stlpx_std::basic_string<char,*>|stlpmtx_std::basic_string<char,*>|stlpxmtx_std::basic_string<char,*>|stlpd_std::priv::_NonDbg_str<char,*>|stlpdx_std::priv::_NonDbg_str<char,*>|stlpdmtx_std::priv::_NonDbg_str<char,*>|stlpdxmtx_std::priv::_NonDbg_str<char,*>{
|
||
|
preview
|
||
|
(
|
||
|
[$c._M_start_of_storage._M_data, s]
|
||
|
)
|
||
|
|
||
|
stringview
|
||
|
(
|
||
|
[$c._M_start_of_storage._M_data, s]
|
||
|
)
|
||
|
|
||
|
children
|
||
|
(
|
||
|
#(
|
||
|
[raw view]: [$c,!],
|
||
|
buffer: [(unsigned int)$c._M_start_of_storage._M_data, x],
|
||
|
length: $c._M_finish - $c._M_start_of_storage._M_data,
|
||
|
capacity: #if($c._M_start_of_storage._M_data == $c._M_buffers._M_static_buf)
|
||
|
(
|
||
|
$c._DEFAULT_SIZE
|
||
|
)
|
||
|
#else
|
||
|
(
|
||
|
$c._M_buffers._M_end_of_storage - $c._M_start_of_storage._M_data
|
||
|
),
|
||
|
#array
|
||
|
(
|
||
|
expr: $c._M_start_of_storage._M_data[$i],
|
||
|
size: $c._M_finish - $c._M_start_of_storage._M_data
|
||
|
)
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
stlp_std::basic_string<unsigned short,*>|stlp_std::basic_string<wchar_t,*>|stlpx_std::basic_string<unsigned short,*>|stlpx_std::basic_string<wchar_t,*>|stlpmtx_std::basic_string<unsigned short,*>|stlpmtx_std::basic_string<wchar_t,*>|stlpxmtx_std::basic_string<unsigned short,*>|stlpxmtx_std::basic_string<wchar_t,*>|stlpd_std::priv::_NonDbg_str<unsigned short,*>|stlpd_std::priv::_NonDbg_str<wchar_t,*>|stlpdx_std::priv::_NonDbg_str<unsigned short,*>|stlpdx_std::priv::_NonDbg_str<wchar_t,*>|stlpdmtx_std::priv::_NonDbg_str<unsigned short,*>|stlpdmtx_std::priv::_NonDbg_str<wchar_t,*>|stlpdxmtx_std::priv::_NonDbg_str<unsigned short,*>|stlpdxmtx_std::priv::_NonDbg_str<wchar_t,*>{
|
||
|
preview
|
||
|
(
|
||
|
[$c._M_start_of_storage._M_data, su]
|
||
|
)
|
||
|
|
||
|
stringview
|
||
|
(
|
||
|
[$c._M_start_of_storage._M_data, su]
|
||
|
)
|
||
|
|
||
|
children
|
||
|
(
|
||
|
#(
|
||
|
[raw view]: [$c,!],
|
||
|
buffer: [(unsigned int)$c._M_start_of_storage._M_data, x],
|
||
|
length: $c._M_finish - $c._M_start_of_storage._M_data,
|
||
|
capacity: #if($c._M_start_of_storage._M_data == $c._M_buffers._M_static_buf)
|
||
|
(
|
||
|
$c._DEFAULT_SIZE
|
||
|
)
|
||
|
#else
|
||
|
(
|
||
|
$c._M_buffers._M_end_of_storage - $c._M_start_of_storage._M_data
|
||
|
),
|
||
|
#array
|
||
|
(
|
||
|
expr: $c._M_start_of_storage._M_data[$i],
|
||
|
size: $c._M_finish - $c._M_start_of_storage._M_data
|
||
|
)
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
stlpd_std::basic_string<*>|stlpdx_std::basic_string<*>|stlpdmtx_std::basic_string<*>|stlpdxmtx_std::basic_string<*>{
|
||
|
preview
|
||
|
(
|
||
|
$c._M_non_dbg_impl
|
||
|
)
|
||
|
|
||
|
stringview
|
||
|
(
|
||
|
$c._M_non_dbg_impl
|
||
|
)
|
||
|
|
||
|
children
|
||
|
(
|
||
|
#(
|
||
|
[raw view]: [$c,!],
|
||
|
string: $c._M_non_dbg_impl
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
;------------------------------------------------------------------------------
|
||
|
; stlport::vector
|
||
|
;------------------------------------------------------------------------------
|
||
|
stlp_std::vector<bool,*>|stlpx_std::vector<bool,*>|stlpmtx_std::vector<bool,*>|stlpxmtx_std::vector<bool,*>|stlpd_std::priv::_NonDbg_vector<bool,*>|stlpdx_std::priv::_NonDbg_vector<bool,*>|stlpdmtx_std::priv::_NonDbg_vector<bool,*>|stlpdxmtx_std::priv::_NonDbg_vector<bool,*>{
|
||
|
preview
|
||
|
(
|
||
|
#(
|
||
|
"[",
|
||
|
($c._M_finish._M_p - $c._M_start._M_p) * sizeof(unsigned int) * 8 + $c._M_finish._M_offset,
|
||
|
"](",
|
||
|
#array
|
||
|
(
|
||
|
expr : ($c._M_start._M_p[$i / (sizeof(unsigned int) * 8)] >> ($i % (sizeof(unsigned int) * 8))),
|
||
|
size : (($c._M_finish._M_p - $c._M_start._M_p) * sizeof(unsigned int) * 8 + $c._M_finish._M_offset)
|
||
|
) : (bool)($e & 1),
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#(
|
||
|
[raw view]: [$c,!],
|
||
|
buffer : [(unsigned int)$c._M_start._M_p, x],
|
||
|
size : (($c._M_finish._M_p - $c._M_start._M_p) * sizeof(unsigned int) * 8 + $c._M_finish._M_offset),
|
||
|
#array
|
||
|
(
|
||
|
expr : ($c._M_start._M_p[$i / (sizeof(unsigned int) * 8)] >> ($i % (sizeof(unsigned int) * 8))),
|
||
|
size : (($c._M_finish._M_p - $c._M_start._M_p) * sizeof(unsigned int) * 8 + $c._M_finish._M_offset)
|
||
|
) : (bool)($e & 1)
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
stlp_std::priv::_Bit_iter<*>|stlpx_std::priv::_Bit_iter<*>|stlpmtx_std::priv::_Bit_iter<*>|stlpxmtx_std::priv::_Bit_iter<*>|stlpd_std::priv::_Bit_iter<*>|stlpdx_std::priv::_Bit_iter<*>|stlpdmtx_std::priv::::_Bit_iter<*>|stlpdxmtx_std::priv::_Bit_iter<*>{
|
||
|
preview
|
||
|
(
|
||
|
#(
|
||
|
(bool) (((*$c._M_p) >> $c._M_offset) & 1)
|
||
|
)
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#(
|
||
|
[raw view]: [$c,!],
|
||
|
value : (bool) (((*$c._M_p) >> $c._M_offset) & 1)
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
stlp_std::vector<*>|stlpx_std::vector<*>|stlpmtx_std::vector<*>|stlpxmtx_std::vector<*>|stlpd_std::priv::_NonDbg_vector<*>|stlpdx_std::priv::_NonDbg_vector<*>|stlpdmtx_std::priv::_NonDbg_vector<*>|stlpdxmtx_std::priv::_NonDbg_vector<*>{
|
||
|
preview
|
||
|
(
|
||
|
#(
|
||
|
"[",
|
||
|
$c._M_finish - $c._M_start,
|
||
|
"/",
|
||
|
$c._M_end_of_storage._M_data - $c._M_start,
|
||
|
"](",
|
||
|
#array
|
||
|
(
|
||
|
expr : ($c._M_start)[$i],
|
||
|
size : $c._M_finish - $c._M_start
|
||
|
),
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#(
|
||
|
[raw view]: [$c,!],
|
||
|
size : $c._M_finish - $c._M_start,
|
||
|
capacity : $c._M_end_of_storage._M_data - $c._M_start,
|
||
|
#array
|
||
|
(
|
||
|
expr : ($c._M_start)[$i],
|
||
|
size : $c._M_finish - $c._M_start
|
||
|
)
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
stlpd_std::vector<*>|stlpdx_std::vector<*>|stlpdmtx_std::vector<*>|stlpdxmtx_std::vector<*>{
|
||
|
preview
|
||
|
(
|
||
|
$c._M_non_dbg_impl
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#(
|
||
|
[raw view] : [$c,!],
|
||
|
vector : $c._M_non_dbg_impl
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
;------------------------------------------------------------------------------
|
||
|
; stlport::deque
|
||
|
;------------------------------------------------------------------------------
|
||
|
stlp_std::deque<*,*>|stlpx_std::deque<*,*>|stlpmtx_std::deque<*,*>|stlpxmtx_std::deque<*,*>|stlpd_std::priv::_NonDbg_deque<*,*>|stlpdx_std::priv::_NonDbg_deque<*,*>|stlpdmtx_std::priv::_NonDbg_deque<*,*>|stlpdxmtx_std::priv::_NonDbg_deque<*,*>{
|
||
|
preview
|
||
|
(
|
||
|
#if (((unsigned int)($c._M_start._M_cur + 1) - ((unsigned int)$c._M_start._M_cur)) < _MAX_BYTES)
|
||
|
(
|
||
|
#(
|
||
|
"[",
|
||
|
(($c._M_finish._M_node - $c._M_start._M_node + 1) * (_MAX_BYTES / sizeof($T1))) - ($c._M_start._M_cur - $c._M_start._M_first) - ($c._M_finish._M_last - $c._M_finish._M_cur),
|
||
|
"/",
|
||
|
($c._M_finish._M_node - $c._M_start._M_node + 1) * (_MAX_BYTES / sizeof($T1)) - 1,
|
||
|
"](",
|
||
|
#array
|
||
|
(
|
||
|
expr : *(*($c._M_start._M_node + (($i + ($c._M_start._M_cur - $c._M_start._M_first)) / (_MAX_BYTES / sizeof($T1)))) + (($i + ($c._M_start._M_cur - $c._M_start._M_first)) % (_MAX_BYTES / sizeof($T1)))),
|
||
|
size : (($c._M_finish._M_node - $c._M_start._M_node + 1) * (_MAX_BYTES / sizeof($T1))) - ($c._M_start._M_cur - $c._M_start._M_first) - ($c._M_finish._M_last - $c._M_finish._M_cur)
|
||
|
),
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
#else
|
||
|
(
|
||
|
#(
|
||
|
"[",
|
||
|
$c._M_finish._M_node - $c._M_start._M_node,
|
||
|
"/",
|
||
|
$c._M_finish._M_node - $c._M_start._M_node,
|
||
|
"](",
|
||
|
#array
|
||
|
(
|
||
|
expr : **($c._M_start._M_node + $i),
|
||
|
size : $c._M_finish._M_node - $c._M_start._M_node
|
||
|
),
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#if (((unsigned int)($c._M_start._M_cur + 1) - ((unsigned int)$c._M_start._M_cur)) < _MAX_BYTES)
|
||
|
(
|
||
|
#(
|
||
|
[raw view]: [$c,!],
|
||
|
size : (($c._M_finish._M_node - $c._M_start._M_node + 1) * (_MAX_BYTES / sizeof($T1))) - ($c._M_start._M_cur - $c._M_start._M_first) - ($c._M_finish._M_last - $c._M_finish._M_cur),
|
||
|
capacity : ($c._M_finish._M_node - $c._M_start._M_node + 1) * (_MAX_BYTES / sizeof($T1)) - 1,
|
||
|
front free space : $c._M_start._M_cur - $c._M_start._M_first,
|
||
|
back free space : $c._M_finish._M_last - $c._M_finish._M_cur - 1,
|
||
|
#array
|
||
|
(
|
||
|
expr : *(*($c._M_start._M_node + (($i + ($c._M_start._M_cur - $c._M_start._M_first)) / (_MAX_BYTES / sizeof($T1)))) + (($i + ($c._M_start._M_cur - $c._M_start._M_first)) % (_MAX_BYTES / sizeof($T1)))),
|
||
|
size : (($c._M_finish._M_node - $c._M_start._M_node + 1) * (_MAX_BYTES / sizeof($T1))) - ($c._M_start._M_cur - $c._M_start._M_first) - ($c._M_finish._M_last - $c._M_finish._M_cur)
|
||
|
)
|
||
|
)
|
||
|
)
|
||
|
#else
|
||
|
(
|
||
|
#(
|
||
|
[raw view] : [$c,!],
|
||
|
size : $c._M_finish._M_node - $c._M_start._M_node,
|
||
|
capacity : $c._M_finish._M_node - $c._M_start._M_node,
|
||
|
front free space : $c._M_start._M_cur - $c._M_start._M_first,
|
||
|
back free space : $c._M_finish._M_last - $c._M_finish._M_cur - 1,
|
||
|
#array
|
||
|
(
|
||
|
expr : **($c._M_start._M_node + $i),
|
||
|
size : $c._M_finish._M_node - $c._M_start._M_node
|
||
|
)
|
||
|
)
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
stlp_std::priv::_Deque_iterator<*>|stlpx_std::priv::_Deque_iterator<*>|stlpmtx_std::priv::_Deque_iterator<*>|stlpxmtx_std::priv::_Deque_iterator<*>|stlpd_std::priv::_Deque_iterator<*>|stlpdx_std::priv::_Deque_iterator<*>|stlpdmtx_std::priv::_Deque_iterator<*>|stlpdxmtx_std::priv::_Deque_iterator<*>{
|
||
|
preview
|
||
|
(
|
||
|
*($c._M_cur)
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#(
|
||
|
[raw view] : [$c, !],
|
||
|
ptr : [(unsigned int)($c._M_cur), x],
|
||
|
value : *($c._M_cur)
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
stlpd_std::deque<*>|stlpdx_std::deque<*>|stlpdmtx_std::deque<*>|stlpdxmtx_std::deque<*>{
|
||
|
preview
|
||
|
(
|
||
|
$c._M_non_dbg_impl
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#(
|
||
|
[raw view] : [$c,!],
|
||
|
deque : $c._M_non_dbg_impl
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
;------------------------------------------------------------------------------
|
||
|
; stlport::list
|
||
|
;------------------------------------------------------------------------------
|
||
|
stlp_std::list<*,*>|stlpx_std::list<*,*>|stlpmtx_std::list<*,*>|stlpxmtx_std::list<*,*>|stlpd_std::priv::_NonDbg_list<*,*>|stlpdx_std::priv::_NonDbg_list<*,*>|stlpdmtx_std::priv::_NonDbg_list<*,*>|stlpdxmtx_std::priv::_NonDbg_list<*,*>{
|
||
|
preview
|
||
|
(
|
||
|
#(
|
||
|
"(",
|
||
|
#list
|
||
|
(
|
||
|
head : $c._M_node._M_data._M_next,
|
||
|
skip : &($c._M_node._M_data),
|
||
|
next : _M_next,
|
||
|
): #( *($T1*)(&($e) + 1)),
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#(
|
||
|
[raw view]: [$c,!],
|
||
|
#list
|
||
|
(
|
||
|
head : $c._M_node._M_data._M_next,
|
||
|
skip : &($c._M_node._M_data),
|
||
|
next : _M_next,
|
||
|
): #( *($T1*)(&($e) + 1))
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
stlp_std::priv::_List_iterator<*,*>|stlpx_std::priv::_List_iterator<*,*>|stlpmtx_std::priv::_List_iterator<*,*>|stlpxmtx_std::priv::_List_iterator<*,*>|stlpd_std::priv::_List_iterator<*,*>|stlpdx_std::priv::_List_iterator<*,*>|stlpdmtx_std::priv::_List_iterator<*,*>|stlpdxmtx_std::priv::_List_iterator<*,*>{
|
||
|
preview
|
||
|
(
|
||
|
#(*($T1 *)($c._M_node + 1))
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#(
|
||
|
[raw view] : [$c, !],
|
||
|
ptr : [(unsigned int)($c._M_node + 1), x],
|
||
|
value : *($T1 *)($c._M_node + 1)
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
stlpd_std::list<*,*>|stlpdx_std::list<*,*>|stlpdmtx_std::list<*,*>|stlpdxmtx_std::list<*,*>{
|
||
|
preview
|
||
|
(
|
||
|
$c._M_non_dbg_impl
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#(
|
||
|
[raw view] : [$c,!],
|
||
|
list : $c._M_non_dbg_impl
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
;------------------------------------------------------------------------------
|
||
|
; stlport::slist
|
||
|
;------------------------------------------------------------------------------
|
||
|
stlp_std::slist<*,*>|stlpx_std::slist<*,*>|stlpmtx_std::slist<*,*>|stlpxmtx_std::slist<*,*>|stlpd_std::priv::_NonDbg_slist<*,*>|stlpdx_std::priv::_NonDbg_slist<*,*>|stlpdmtx_std::priv::_NonDbg_slist<*,*>|stlpdxmtx_std::priv::_NonDbg_slist<*,*>{
|
||
|
preview
|
||
|
(
|
||
|
#(
|
||
|
"(",
|
||
|
#list
|
||
|
(
|
||
|
head : $c._M_head._M_data._M_next,
|
||
|
skip : &($c._M_head._M_data),
|
||
|
next : _M_next,
|
||
|
): #( *($T1*)(&($e) + 1)),
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#(
|
||
|
[raw view]: [$c,!],
|
||
|
#list
|
||
|
(
|
||
|
head : $c._M_head._M_data._M_next,
|
||
|
skip : &($c._M_head._M_data),
|
||
|
next : _M_next,
|
||
|
): #( *($T1*)(&($e) + 1))
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
stlp_std::priv::_Slist_iterator<*,*>|stlpx_std::priv::_Slist_iterator<*,*>|stlpmtx_std::priv::_Slist_iterator<*,*>|stlpxmtx_std::priv::_Slist_iterator<*,*>|stlpd_std::priv::_Slist_iterator<*,*>|stlpdx_std::priv::_Slist_iterator<*,*>|stlpdmtx_std::priv::_Slist_iterator<*,*>|stlpdxmtx_std::priv::_Slist_iterator<*,*>{
|
||
|
preview
|
||
|
(
|
||
|
#(*($T1 *)($c._M_node + 1))
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#(
|
||
|
[raw view] : [$c,!],
|
||
|
ptr : [(unsigned int)($c._M_node + 1), x],
|
||
|
value : *($T1 *)($c._M_node + 1)
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
stlpd_std::slist<*,*>|stlpdx_std::slist<*,*>|stlpdmtx_std::slist<*,*>|stlpdxmtx_std::slist<*,*>{
|
||
|
preview
|
||
|
(
|
||
|
$c._M_non_dbg_impl
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#(
|
||
|
[raw view] : [$c,!],
|
||
|
[slist] : $c._M_non_dbg_impl
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
;------------------------------------------------------------------------------
|
||
|
; stlport::pair
|
||
|
;------------------------------------------------------------------------------
|
||
|
stlp_std::pair<*,*>|stlpx_std::pair<*,*>|stlpmtx_std::pair<*,*>|stlpxmtx_std::pair<*,*>|stlpd_std::pair<*,*>|stlpdx_std::pair<*,*>|stlpdmtx_std::pair<*,*>|stlpdxmtx_std::pair<*,*>{
|
||
|
preview
|
||
|
(
|
||
|
#(
|
||
|
"(",
|
||
|
$c.first,
|
||
|
", ",
|
||
|
$c.second,
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
;------------------------------------------------------------------------------
|
||
|
; stlport::map, stlport::multimap, stlport::set, stlport::multiset
|
||
|
;------------------------------------------------------------------------------
|
||
|
stlp_std::map<*>|stlpx_std::map<*>|stlpmtx_std::map<*>|stlpxmtx_std::map<*>|stlp_std::multimap<*>|stlpx_std::multimap<*>|stlpmtx_std::multimap<*>|stlpxmtx_std::multimap<*>|stlp_std::set<*>|stlpx_std::set<*>|stlpmtx_std::set<*>|stlpxmtx_std::set<*>|stlp_std::multiset<*>|stlpx_std::multiset<*>|stlpmtx_std::multiset<*>|stlpxmtx_std::multiset<*>{
|
||
|
preview
|
||
|
(
|
||
|
#(
|
||
|
"[",
|
||
|
$c._M_t._M_node_count,
|
||
|
"](",
|
||
|
$c._M_t,
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#(
|
||
|
[raw view]: [$c,!],
|
||
|
size: [$c._M_t._M_node_count],
|
||
|
tree: $c._M_t
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
stlpd_std::map<*>|stlpdx_std::map<*>|stlpdmtx_std::map<*>|stlpdxmtx_std::map<*>|stlpd_std::multimap<*>|stlpdx_std::multimap<*>|stlpdmtx_std::multimap<*>|stlpdxmtx_std::multimap<*>|stlpd_std::set<*>|stlpdx_std::set<*>|stlpdmtx_std::set<*>|stlpdxmtx_std::set<*>|stlpd_std::multiset<*>|stlpdx_std::multiset<*>|stlpdmtx_std::multiset<*>|stlpdxmtx_std::multiset<*>{
|
||
|
preview
|
||
|
(
|
||
|
#(
|
||
|
"[",
|
||
|
$c._M_t._M_non_dbg_impl._M_node_count,
|
||
|
"](",
|
||
|
$c._M_t._M_non_dbg_impl,
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#(
|
||
|
[raw view]: [$c,!],
|
||
|
size: $c._M_t._M_non_dbg_impl._M_node_count,
|
||
|
tree: $c._M_t._M_non_dbg_impl
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
stlp_std::priv::_Rb_tree<*,*,*,*,*>|stlpx_std::priv::_Rb_tree<*,*,*,*,*>|stlpmtx_std::priv::_Rb_tree<*,*,*,*,*>|stlpxmtx_std::priv::_Rb_tree<*,*,*,*,*>|stlpd_std::priv::_NonDbg_Rb_tree<*,*,*,*,*>|stlpdx_std::priv::_NonDbg_Rb_tree<*,*,*,*,*>|stlpdmtx_std::priv::_NonDbg_Rb_tree<*,*,*,*,*>|stlpdxmtx_std::priv::_NonDbg_Rb_tree<*,*,*,*,*>{
|
||
|
preview
|
||
|
(
|
||
|
#tree
|
||
|
(
|
||
|
head : $c._M_header._M_data._M_parent,
|
||
|
skip : &($c._M_header._M_data),
|
||
|
size : $c._M_node_count,
|
||
|
left : _M_left,
|
||
|
right : _M_right
|
||
|
): #(*($T3 *)(&($e) + 1))
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#(
|
||
|
[raw view]: [$c,!],
|
||
|
#tree
|
||
|
(
|
||
|
head : $c._M_header._M_data._M_parent,
|
||
|
skip : &($c._M_header._M_data),
|
||
|
size : $c._M_node_count,
|
||
|
left : _M_left,
|
||
|
right : _M_right
|
||
|
) : #(*($T3 *)(&($e) + 1))
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
stlp_std::priv::_Rb_tree_iterator<*,*>|stlpx_std::priv::_Rb_tree_iterator<*,*>|stlpmtx_std::priv::_Rb_tree_iterator<*,*>|stlpxmtx_std::priv::_Rb_tree_iterator<*,*>|stlpd_std::priv::_Rb_tree_iterator<*,*>|stlpdx_std::priv::_Rb_tree_iterator<*,*>|stlpdmtx_std::priv::_Rb_tree_iterator<*,*>|stlpdxmtx_std::priv::_Rb_tree_iterator<*,*>{
|
||
|
preview
|
||
|
(
|
||
|
[*($T1*)($c._M_node + 1)]
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#(
|
||
|
[raw view]: [$c,!],
|
||
|
value: [*($T1*)($c._M_node + 1)],
|
||
|
ptr: [(unsigned int)($c._M_node + 1), x]
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
;------------------------------------------------------------------------------
|
||
|
; stlport::hash_map, stlport::hash_multimap, stlport::hash_set, stlport::hash_multiset
|
||
|
; stlport::unordered_map, stlport::unordered_multimap, stlport::unordered_set, stlport::unordered_multiset
|
||
|
;------------------------------------------------------------------------------
|
||
|
stlp_std::hash_map<*>|stlpx_std::hash_map<*>|stlpmtx_std::hash_map<*>|stlpxmtx_std::hash_map<*>|stlp_std::hash_multimap<*>|stlpx_std::hash_multimap<*>|stlpmtx_std::hash_multimap<*>|stlpxmtx_std::hash_multimap<*>|stlp_std::hash_set<*>|stlpx_std::hash_set<*>|stlpmtx_std::hash_set<*>|stlpxmtx_std::hash_set<*>|stlp_std::hash_multiset<*>|stlpx_std::hash_multiset<*>|stlpmtx_std::hash_multiset<*>|stlpxmtx_std::hash_multiset<*>|stlp_std::tr1::unordered_map<*>|stlpx_std::tr1::unordered_map<*>|stlpmtx_std::tr1::unordered_map<*>|stlpxmtx_std::tr1::unordered_map<*>|stlp_std::tr1::unordered_multimap<*>|stlpx_std::tr1::unordered_multimap<*>|stlpmtx_std::tr1::unordered_multimap<*>|stlpxmtx_std::tr1::unordered_multimap<*>|stlp_std::tr1::unordered_set<*>|stlpx_std::tr1::unordered_set<*>|stlpmtx_std::tr1::unordered_set<*>|stlpxmtx_std::tr1::unordered_set<*>|stlp_std::tr1::unordered_multiset<*>|stlpx_std::tr1::unordered_multiset<*>|stlpmtx_std::tr1::unordered_multiset<*>|stlpxmtx_std::tr1::unordered_multiset<*>{
|
||
|
preview
|
||
|
(
|
||
|
#(
|
||
|
"[",
|
||
|
$c._M_ht._M_num_elements,
|
||
|
"]",
|
||
|
$c._M_ht
|
||
|
)
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#(
|
||
|
[raw view]: [$c,!],
|
||
|
hashtable: $c._M_ht
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
stlpd_std::hash_map<*>|stlpdx_std::hash_map<*>|stlpdmtx_std::hash_map<*>|stlpdxmtx_std::hash_map<*>|stlpd_std::hash_multimap<*>|stlpdx_std::hash_multimap<*>|stlpdmtx_std::hash_multimap<*>|stlpdxmtx_std::hash_multimap<*>|stlpd_std::hash_set<*>|stlpdx_std::hash_set<*>|stlpdmtx_std::hash_set<*>|stlpdxmtx_std::hash_set<*>|stlpd_std::hash_multiset<*>|stlpdx_std::hash_multiset<*>|stlpdmtx_std::hash_multiset<*>|stlpdxmtx_std::hash_multiset<*>|stlpd_std::tr1::unordered_map<*>|stlpdx_std::tr1::unordered_map<*>|stlpdmtx_std::tr1::unordered_map<*>|stlpdxmtx_std::tr1::unordered_map<*>|stlpd_std::tr1::unordered_multimap<*>|stlpdx_std::tr1::unordered_multimap<*>|stlpdmtx_std::tr1::unordered_multimap<*>|stlpdxmtx_std::tr1::unordered_multimap<*>|stlpd_std::tr1::unordered_set<*>|stlpdx_std::tr1::unordered_set<*>|stlpdmtx_std::tr1::unordered_set<*>|stlpdxmtx_std::tr1::unordered_set<*>|stlpd_std::tr1::unordered_multiset<*>|stlpdx_std::tr1::unordered_multiset<*>|stlpdmtx_std::tr1::unordered_multiset<*>|stlpdxmtx_std::tr1::unordered_multiset<*>{
|
||
|
preview
|
||
|
(
|
||
|
#(
|
||
|
"[",
|
||
|
$c._M_ht._M_non_dbg_impl._M_num_elements,
|
||
|
"]",
|
||
|
$c._M_ht._M_non_dbg_impl
|
||
|
)
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#(
|
||
|
[raw view]: [$c,!],
|
||
|
hashtable: $c._M_ht._M_non_dbg_impl
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
stlp_std::hashtable<*,*>|stlpx_std::hashtable<*,*>|stlpmtx_std::hashtable<*,*>|stlpxmtx_std::hashtable<*,*>|stlpd_std::priv::_NonDbg_hashtable<*,*>|stlpdx_std::priv::_NonDbg_hashtable<*,*>|stlpdmtx_std::priv::_NonDbg_hashtable<*,*>|stlpdxmtx_std::priv::_NonDbg_hashtable<*,*>{
|
||
|
preview
|
||
|
(
|
||
|
$c._M_elems
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#(
|
||
|
[raw view]: [$c,!],
|
||
|
size : $c._M_num_elements,
|
||
|
load factor : (float)$c._M_num_elements / ($c._M_buckets._M_finish - $c._M_buckets._M_start),
|
||
|
max load factor: $c._M_max_load_factor,
|
||
|
buckets : $c._M_buckets,
|
||
|
elements : $c._M_elems
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
;------------------------------------------------------------------------------
|
||
|
; stlport::queue, stlport::priority_queue, stlport::stack
|
||
|
;------------------------------------------------------------------------------
|
||
|
stlp_std::queue<*>|stlpx_std::queue<*>|stlpmtx_std::queue<*>|stlpxmtx_std::queue<*>|stlpd_std::queue<*>|stlpdx_std::queue<*>|stlpdmtx_std::queue<*>|stlpdxmtx_std::queue<*>|stlp_std::priority_queue<*>|stlpx_std::priority_queue<*>|stlpmtx_std::priority_queue<*>|stlpxmtx_std::priority_queue<*>|stlpd_std::priority_queue<*>|stlpdx_std::priority_queue<*>|stlpdmtx_std::priority_queue<*>|stlpdxmtx_std::priority_queue<*>|stlp_std::stack<*>|stlpx_std::stack<*>|stlpmtx_std::stack<*>|stlpxmtx_std::stack<*>|stlpd_std::stack<*>|stlpdx_std::stack<*>|stlpdmtx_std::stack<*>|stlpdxmtx_std::stack<*>{
|
||
|
preview
|
||
|
(
|
||
|
$c.c
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#(
|
||
|
[raw view] : [$c,!],
|
||
|
container : $c.c
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
;------------------------------------------------------------------------------
|
||
|
; stlport debug iterator
|
||
|
;------------------------------------------------------------------------------
|
||
|
stlp_std::priv::_DBG_iter<*>|stlpx_std::priv::_DBG_iter<*>|stlpmtx_std::priv::_DBG_iter<*>|stlpxmtx_std::priv::_DBG_iter<*>|stlpd_std::priv::_DBG_iter<*>|stlpdx_std::priv::_DBG_iter<*>|stlpdmtx_std::priv::_DBG_iter<*>|stlpdxmtx_std::priv::_DBG_iter<*>{
|
||
|
preview
|
||
|
(
|
||
|
#if($c._M_owner != 0)
|
||
|
(
|
||
|
$c._M_iterator
|
||
|
)
|
||
|
#else
|
||
|
(
|
||
|
"undefined"
|
||
|
)
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#(
|
||
|
#if($c._M_owner != 0)
|
||
|
(
|
||
|
#(
|
||
|
[raw view] : [$c,!],
|
||
|
[iterator] : $c._M_iterator,
|
||
|
[valid] : [true]
|
||
|
)
|
||
|
)
|
||
|
#else
|
||
|
(
|
||
|
#(
|
||
|
[raw view] : [$c,!],
|
||
|
[valid] : [false]
|
||
|
)
|
||
|
)
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
;------------------------------------------------------------------------------
|
||
|
; stlport::bitset
|
||
|
; TODO: Fix it, it doesn't work as expected even when adding an enum to the bitset
|
||
|
; class to get access to the bitset static size rather than using $T1.
|
||
|
;------------------------------------------------------------------------------
|
||
|
stdp_std::bitset<*,*>|stdpx_std::bitset<*,*>|stdpmtx_std::bitset<*,*>|stdpxmtx_std::bitset<*,*>|stdpd_std::bitset<*>|stdpdx_std::bitset<*>|stdpdmtx_std::bitset<*>|stdpdxmtx_std::bitset<*>{
|
||
|
preview
|
||
|
(
|
||
|
#(
|
||
|
"[",
|
||
|
$T1,
|
||
|
"](",
|
||
|
#array
|
||
|
(
|
||
|
expr : ($c._M_w[$i / (sizeof(unsigned long) * 8)] >> ($i % (sizeof(unsigned long) * 8))),
|
||
|
size : $T1
|
||
|
) : [($e & 1),d],
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#array
|
||
|
(
|
||
|
expr : ($c._M_w[$i / (sizeof(unsigned long) * 8)] >> ($i % (sizeof(unsigned long) * 8))),
|
||
|
size : $T1
|
||
|
) : (bool)($e & 1)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
stdp_std::bitset<*>::reference|stdpx_std::bitset<*>::reference|stdpmtx_std::bitset<*>::reference|stdpxmtx_std::bitset<*>::reference|stdpd_std::bitset<*>::reference|stdpdx_std::bitset<*>::reference|stdpdmtx_std::bitset<*>::reference|stdpdxmtx_std::bitset<*>{
|
||
|
preview
|
||
|
(
|
||
|
#(
|
||
|
"bitset[", $c._M_bpos, "] = ",
|
||
|
(bool)(*($c._M_wp) >> $c._M_bpos) & 1)
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
;------------------------------------------------------------------------------
|
||
|
; stlport::auto_ptr
|
||
|
;------------------------------------------------------------------------------
|
||
|
stlp_std::auto_ptr<*>|stlpx_std::auto_ptr<*>|stlpmtx_std::auto_ptr<*>|stlpxmtx_std::auto_ptr<*>|stlpd_std::auto_ptr<*>|stlpdx_std::auto_ptr<*>|stlpdmtx_std::auto_ptr<*>|stlpdxmtx_std::auto_ptr<*>{
|
||
|
preview
|
||
|
(
|
||
|
#if(($c._M_p) != 0)
|
||
|
(
|
||
|
[*($T1 *)$c._M_p]
|
||
|
)
|
||
|
#else
|
||
|
(
|
||
|
"null"
|
||
|
)
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#if(($c._M_p) != 0)
|
||
|
(
|
||
|
#(
|
||
|
[raw view]: [$c,!],
|
||
|
ptr: [(unsigned int)$c._M_p, x],
|
||
|
value: [*($T1 *)$c._M_p]
|
||
|
)
|
||
|
)
|
||
|
#else
|
||
|
(
|
||
|
#(
|
||
|
[raw view]: [$c,!]
|
||
|
)
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
;------------------------------------------------------------------------------
|
||
|
; stlport::complex
|
||
|
;------------------------------------------------------------------------------
|
||
|
stlp_std::complex<*>|stlpx_std::complex<*>|stlpmtx_std::complex<*>|stlpxmtx_std::complex<*>|stlpd_std::complex<*>|stlpdx_std::complex<*>|stlpdmtx_std::complex<*>|stlpdxmtx_std::complex<*>{
|
||
|
children
|
||
|
(
|
||
|
#(
|
||
|
real: $e._M_re,
|
||
|
imaginary: $e._M_im
|
||
|
)
|
||
|
)
|
||
|
preview
|
||
|
(
|
||
|
#if($e._M_im != 0)
|
||
|
(
|
||
|
#if ($e._M_re != 0)
|
||
|
( ; Real and Imaginary components
|
||
|
#if ($e._M_im >= 0)
|
||
|
(
|
||
|
#($e._M_re,"+i*", $e._M_im)
|
||
|
)
|
||
|
#else
|
||
|
(
|
||
|
#($e._M_re,"-i*", -$e._M_im)
|
||
|
)
|
||
|
)
|
||
|
#else
|
||
|
( ; Purely imaginary
|
||
|
#if ($e._M_im >= 0.0)
|
||
|
(
|
||
|
#("i*", $e._M_im)
|
||
|
)
|
||
|
#else
|
||
|
(
|
||
|
#("-i*", -$e._M_im)
|
||
|
)
|
||
|
)
|
||
|
)
|
||
|
#else
|
||
|
( ; Purely real
|
||
|
$e._M_re
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
;------------------------------------------------------------------------------
|
||
|
; stlport::valarray
|
||
|
;------------------------------------------------------------------------------
|
||
|
|
||
|
stlp_std::valarray<*>|stlpx_std::valarray<*>|stlpmtx_std::valarray<*>|stlpxmtx_std::valarray<*>|stlpd_std::valarray<*>|stlpdx_std::valarray<*>|stlpdmtx_std::valarray<*>|stlpdxmtx_std::valarray<*>{
|
||
|
preview
|
||
|
(
|
||
|
#(
|
||
|
"[",
|
||
|
$c._M_size ,
|
||
|
"](",
|
||
|
#array
|
||
|
(
|
||
|
expr : ($c._M_first)[$i],
|
||
|
size : $c._M_size
|
||
|
),
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
|
||
|
children
|
||
|
(
|
||
|
#array
|
||
|
(
|
||
|
expr : ($c._M_first)[$i],
|
||
|
size : $c._M_size
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
stlp_std::slice|stlpx_std::slice|stlpmtx_std::slice|stlpxmtx_std::slice|stlpd_std::slice|stlpdx_std::slice|stlpdmtx_std::slice|stlpdxmtx_std::slice{
|
||
|
preview
|
||
|
(
|
||
|
#(
|
||
|
"start = ",
|
||
|
$c._M_start,
|
||
|
", size = ",
|
||
|
$c._M_length,
|
||
|
", stride = ",
|
||
|
$c._M_stride
|
||
|
)
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#(
|
||
|
[raw view] : [$c,!],
|
||
|
start : $c._M_start,
|
||
|
size : $c._M_length,
|
||
|
stride : $c._M_stride
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
stlp_std::gslice|stlpx_std::gslice|stlpmtx_std::gslice|stlpxmtx_std::gslice|stlpd_std::gslice|stlpdx_std::gslice|stlpdmtx_std::gslice|stlpdxmtx_std::gslice{
|
||
|
preview
|
||
|
(
|
||
|
#(
|
||
|
"start = ",
|
||
|
$c._M_start,
|
||
|
", sizes = ",
|
||
|
$c._M_lengths,
|
||
|
", strides = ",
|
||
|
$c._M_strides
|
||
|
)
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#(
|
||
|
[raw view] : [$c,!],
|
||
|
start : $c._M_start,
|
||
|
sizes : $c._M_lengths,
|
||
|
strides : $c._M_strides
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
; This section contains visualizers for STL and ATL containers
|
||
|
; DO NOT MODIFY
|
||
|
ATL::CStringT<char,*>|CSimpleStringT<char,*>|ATL::CSimpleStringT<char,*>{
|
||
|
preview ([$e.m_pszData,s])
|
||
|
stringview ([$e.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 ([$e.m_pszData,su])
|
||
|
stringview ([$e.m_pszData,sub])
|
||
|
}
|
||
|
ATL::CComBSTR{
|
||
|
preview ([$e.m_str,su])
|
||
|
stringview ([$e.m_str,sub])
|
||
|
}
|
||
|
|
||
|
; Many TR1 visualizers use nested #()s.
|
||
|
; Why not use #(foo, bar) instead of #(#(foo), #(bar))?
|
||
|
; The former alphabetically sorts its fields, while the latter does not.
|
||
|
;------------------------------------------------------------------------------
|
||
|
; std::tr1::reference_wrapper
|
||
|
;------------------------------------------------------------------------------
|
||
|
std::tr1::reference_wrapper<*>{
|
||
|
preview (
|
||
|
#if ($e._Callee._EEN_INDIRECT == 1) (
|
||
|
; For ordinary T, reference_wrapper<T> stores a T * _Callee._Ptr
|
||
|
; which is non-null. Actual references are previewed with what they
|
||
|
; refer to, so reference_wrapper<T> is previewed with dereferencing its
|
||
|
; stored pointer.
|
||
|
*$e._Callee._Ptr
|
||
|
) #else (
|
||
|
; When T is a pointer to function, pointer to member function,
|
||
|
; or pointer to data member type, reference_wrapper<T> stores a
|
||
|
; T _Callee._Object directly.
|
||
|
$e._Callee._Object
|
||
|
)
|
||
|
)
|
||
|
|
||
|
children (
|
||
|
#if ($e._Callee._EEN_INDIRECT == 1) (
|
||
|
; Actual references have the same children as what they refer to.
|
||
|
; Unfortunately, there appears to be no way to imitate this exactly.
|
||
|
; Therefore, we make reference_wrapper<T> appear to have a single
|
||
|
; child, its stored pointer, with a fake name of [ptr].
|
||
|
#([ptr] : $e._Callee._Ptr)
|
||
|
) #else (
|
||
|
; When T is a pointer to function, pointer to member function,
|
||
|
; or pointer to data member type, T has no children, so we make
|
||
|
; reference_wrapper<T> appear to have no children.
|
||
|
#array(expr: 0, size: 0)
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
;------------------------------------------------------------------------------
|
||
|
; std::tr1::shared_ptr
|
||
|
;------------------------------------------------------------------------------
|
||
|
std::tr1::shared_ptr<*>{
|
||
|
preview (
|
||
|
; shared_ptr<T> stores a T * _Ptr .
|
||
|
#if ($e._Ptr == 0) (
|
||
|
; A default-constructed shared_ptr has a null _Ptr and a null _Rep,
|
||
|
; and is formally said to be empty.
|
||
|
; A shared_ptr constructed from a null pointer has a null _Ptr
|
||
|
; and a NON-null _Rep . It is formally said to own the null pointer.
|
||
|
; We preview both with "empty".
|
||
|
"empty"
|
||
|
) #else (
|
||
|
; Raw pointers are previewed with "<pointer value> <object>".
|
||
|
; auto_ptr is previewed with "auto_ptr <object>".
|
||
|
; Following these examples, shared_ptr is previewed with
|
||
|
; "shared_ptr <object> [N strong refs, M weak refs]".
|
||
|
#(
|
||
|
"shared_ptr ",
|
||
|
*$e._Ptr,
|
||
|
" [",
|
||
|
$e._Rep->_Uses,
|
||
|
#if ($e._Rep->_Uses == 1) (" strong ref") #else (" strong refs"),
|
||
|
#if ($e._Rep->_Weaks - 1 > 0) (
|
||
|
#(
|
||
|
", ",
|
||
|
$e._Rep->_Weaks - 1,
|
||
|
#if ($e._Rep->_Weaks - 1 == 1) (" weak ref") #else (" weak refs")
|
||
|
)
|
||
|
),
|
||
|
"]"
|
||
|
)
|
||
|
; Note: _Rep->_Uses counts how many shared_ptrs share ownership of the object,
|
||
|
; so we directly display it as the strong reference count.
|
||
|
; _Rep->_Weaks counts how many shared_ptrs and weak_ptrs share ownership of
|
||
|
; the "representation object" (or "control block"). All of the shared_ptrs are
|
||
|
; counted as a single owner. That is, _Weaks is initialized to 1, and when
|
||
|
; _Uses falls to 0, _Weaks is decremented. This avoids incrementing and decrementing
|
||
|
; _Weaks every time that a shared_ptr gains or loses ownership. Therefore,
|
||
|
; _Weaks - 1 is the weak reference count, the number of weak_ptrs that are observing
|
||
|
; the shared object.
|
||
|
)
|
||
|
)
|
||
|
|
||
|
children (
|
||
|
#if ($e._Ptr == 0) (
|
||
|
; We make empty shared_ptrs (and shared_ptrs that own
|
||
|
; the null pointer) appear to have no children.
|
||
|
#array(expr: 0, size: 0)
|
||
|
) #else (
|
||
|
#(
|
||
|
; We make shared_ptr appear to have a single child,
|
||
|
; its stored pointer, with a fake name of [ptr].
|
||
|
#([ptr] : $e._Ptr),
|
||
|
|
||
|
; Visualizers can't determine whether a shared_ptr has a custom deleter.
|
||
|
; Therefore, we also show the actual members.
|
||
|
; Look at what std::tr1::shared_ptr<T> > [actual members] > std::tr1::_Ptr_base<T> > _Rep points to.
|
||
|
; Default deleter: std::tr1::_Ref_count<T>
|
||
|
; Custom deleter: std::tr1::_Ref_count_d<T, D> > _Dtor
|
||
|
#([actual members] : [$e,!])
|
||
|
)
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
;------------------------------------------------------------------------------
|
||
|
; std::tr1::weak_ptr
|
||
|
;------------------------------------------------------------------------------
|
||
|
std::tr1::weak_ptr<*>{
|
||
|
preview (
|
||
|
#if ($e._Ptr == 0) (
|
||
|
"empty"
|
||
|
) #elif ($e._Rep->_Uses == 0) (
|
||
|
; weak_ptr is just like shared_ptr, except that a weak_ptr can be expired.
|
||
|
"expired"
|
||
|
) #else (
|
||
|
#(
|
||
|
"weak_ptr ",
|
||
|
*$e._Ptr,
|
||
|
" [",
|
||
|
$e._Rep->_Uses,
|
||
|
#if ($e._Rep->_Uses == 1) (" strong ref") #else (" strong refs"),
|
||
|
#if ($e._Rep->_Weaks - 1 > 0) (
|
||
|
#(
|
||
|
", ",
|
||
|
$e._Rep->_Weaks - 1,
|
||
|
#if ($e._Rep->_Weaks - 1 == 1) (" weak ref") #else (" weak refs")
|
||
|
)
|
||
|
),
|
||
|
"]"
|
||
|
)
|
||
|
)
|
||
|
)
|
||
|
|
||
|
children (
|
||
|
#if ($e._Ptr == 0) (
|
||
|
#array(expr: 0, size: 0)
|
||
|
) #elif ($e._Rep->_Uses == 0) (
|
||
|
; When a weak_ptr is expired, we make it appear to have no children.
|
||
|
#array(expr: 0, size: 0)
|
||
|
) #else (
|
||
|
#(
|
||
|
#([ptr] : $e._Ptr),
|
||
|
#([actual members] : [$e,!])
|
||
|
)
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
;------------------------------------------------------------------------------
|
||
|
; std::tr1::tuple
|
||
|
;------------------------------------------------------------------------------
|
||
|
; tuple is visualized like pair, except that we have to give fake names to tuple's children.
|
||
|
std::tr1::tuple<std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil>{
|
||
|
preview (
|
||
|
"()"
|
||
|
)
|
||
|
|
||
|
children (
|
||
|
#array(expr: 0, size: 0)
|
||
|
)
|
||
|
}
|
||
|
std::tr1::tuple<*,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil>{
|
||
|
preview (
|
||
|
#(
|
||
|
"(", $e._Impl._Value,
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
|
||
|
children (
|
||
|
#(
|
||
|
[0] : $e._Impl._Value
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
std::tr1::tuple<*,*,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil>{
|
||
|
preview (
|
||
|
#(
|
||
|
"(", $e._Impl._Value,
|
||
|
",", $e._Impl._Tail._Value,
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
|
||
|
children (
|
||
|
#(
|
||
|
[0] : $e._Impl._Value,
|
||
|
[1] : $e._Impl._Tail._Value
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
std::tr1::tuple<*,*,*,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil>{
|
||
|
preview (
|
||
|
#(
|
||
|
"(", $e._Impl._Value,
|
||
|
",", $e._Impl._Tail._Value,
|
||
|
",", $e._Impl._Tail._Tail._Value,
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
|
||
|
children (
|
||
|
#(
|
||
|
[0] : $e._Impl._Value,
|
||
|
[1] : $e._Impl._Tail._Value,
|
||
|
[2] : $e._Impl._Tail._Tail._Value
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
std::tr1::tuple<*,*,*,*,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil>{
|
||
|
preview (
|
||
|
#(
|
||
|
"(", $e._Impl._Value,
|
||
|
",", $e._Impl._Tail._Value,
|
||
|
",", $e._Impl._Tail._Tail._Value,
|
||
|
",", $e._Impl._Tail._Tail._Tail._Value,
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
|
||
|
children (
|
||
|
#(
|
||
|
[0] : $e._Impl._Value,
|
||
|
[1] : $e._Impl._Tail._Value,
|
||
|
[2] : $e._Impl._Tail._Tail._Value,
|
||
|
[3] : $e._Impl._Tail._Tail._Tail._Value
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
std::tr1::tuple<*,*,*,*,*,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil>{
|
||
|
preview (
|
||
|
#(
|
||
|
"(", $e._Impl._Value,
|
||
|
",", $e._Impl._Tail._Value,
|
||
|
",", $e._Impl._Tail._Tail._Value,
|
||
|
",", $e._Impl._Tail._Tail._Tail._Value,
|
||
|
",", $e._Impl._Tail._Tail._Tail._Tail._Value,
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
|
||
|
children (
|
||
|
#(
|
||
|
[0] : $e._Impl._Value,
|
||
|
[1] : $e._Impl._Tail._Value,
|
||
|
[2] : $e._Impl._Tail._Tail._Value,
|
||
|
[3] : $e._Impl._Tail._Tail._Tail._Value,
|
||
|
[4] : $e._Impl._Tail._Tail._Tail._Tail._Value
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
std::tr1::tuple<*,*,*,*,*,*,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil>{
|
||
|
preview (
|
||
|
#(
|
||
|
"(", $e._Impl._Value,
|
||
|
",", $e._Impl._Tail._Value,
|
||
|
",", $e._Impl._Tail._Tail._Value,
|
||
|
",", $e._Impl._Tail._Tail._Tail._Value,
|
||
|
",", $e._Impl._Tail._Tail._Tail._Tail._Value,
|
||
|
",", $e._Impl._Tail._Tail._Tail._Tail._Tail._Value,
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
|
||
|
children (
|
||
|
#(
|
||
|
[0] : $e._Impl._Value,
|
||
|
[1] : $e._Impl._Tail._Value,
|
||
|
[2] : $e._Impl._Tail._Tail._Value,
|
||
|
[3] : $e._Impl._Tail._Tail._Tail._Value,
|
||
|
[4] : $e._Impl._Tail._Tail._Tail._Tail._Value,
|
||
|
[5] : $e._Impl._Tail._Tail._Tail._Tail._Tail._Value
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
std::tr1::tuple<*,*,*,*,*,*,*,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil>{
|
||
|
preview (
|
||
|
#(
|
||
|
"(", $e._Impl._Value,
|
||
|
",", $e._Impl._Tail._Value,
|
||
|
",", $e._Impl._Tail._Tail._Value,
|
||
|
",", $e._Impl._Tail._Tail._Tail._Value,
|
||
|
",", $e._Impl._Tail._Tail._Tail._Tail._Value,
|
||
|
",", $e._Impl._Tail._Tail._Tail._Tail._Tail._Value,
|
||
|
",", $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Value,
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
|
||
|
children (
|
||
|
#(
|
||
|
[0] : $e._Impl._Value,
|
||
|
[1] : $e._Impl._Tail._Value,
|
||
|
[2] : $e._Impl._Tail._Tail._Value,
|
||
|
[3] : $e._Impl._Tail._Tail._Tail._Value,
|
||
|
[4] : $e._Impl._Tail._Tail._Tail._Tail._Value,
|
||
|
[5] : $e._Impl._Tail._Tail._Tail._Tail._Tail._Value,
|
||
|
[6] : $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Value
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
std::tr1::tuple<*,*,*,*,*,*,*,*,std::tr1::_Nil,std::tr1::_Nil>{
|
||
|
preview (
|
||
|
#(
|
||
|
"(", $e._Impl._Value,
|
||
|
",", $e._Impl._Tail._Value,
|
||
|
",", $e._Impl._Tail._Tail._Value,
|
||
|
",", $e._Impl._Tail._Tail._Tail._Value,
|
||
|
",", $e._Impl._Tail._Tail._Tail._Tail._Value,
|
||
|
",", $e._Impl._Tail._Tail._Tail._Tail._Tail._Value,
|
||
|
",", $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Value,
|
||
|
",", $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Value,
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
|
||
|
children (
|
||
|
#(
|
||
|
[0] : $e._Impl._Value,
|
||
|
[1] : $e._Impl._Tail._Value,
|
||
|
[2] : $e._Impl._Tail._Tail._Value,
|
||
|
[3] : $e._Impl._Tail._Tail._Tail._Value,
|
||
|
[4] : $e._Impl._Tail._Tail._Tail._Tail._Value,
|
||
|
[5] : $e._Impl._Tail._Tail._Tail._Tail._Tail._Value,
|
||
|
[6] : $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Value,
|
||
|
[7] : $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Value
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
std::tr1::tuple<*,*,*,*,*,*,*,*,*,std::tr1::_Nil>{
|
||
|
preview (
|
||
|
#(
|
||
|
"(", $e._Impl._Value,
|
||
|
",", $e._Impl._Tail._Value,
|
||
|
",", $e._Impl._Tail._Tail._Value,
|
||
|
",", $e._Impl._Tail._Tail._Tail._Value,
|
||
|
",", $e._Impl._Tail._Tail._Tail._Tail._Value,
|
||
|
",", $e._Impl._Tail._Tail._Tail._Tail._Tail._Value,
|
||
|
",", $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Value,
|
||
|
",", $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Value,
|
||
|
",", $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Value,
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
|
||
|
children (
|
||
|
#(
|
||
|
[0] : $e._Impl._Value,
|
||
|
[1] : $e._Impl._Tail._Value,
|
||
|
[2] : $e._Impl._Tail._Tail._Value,
|
||
|
[3] : $e._Impl._Tail._Tail._Tail._Value,
|
||
|
[4] : $e._Impl._Tail._Tail._Tail._Tail._Value,
|
||
|
[5] : $e._Impl._Tail._Tail._Tail._Tail._Tail._Value,
|
||
|
[6] : $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Value,
|
||
|
[7] : $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Value,
|
||
|
[8] : $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Value
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
std::tr1::tuple<*,*,*,*,*,*,*,*,*,*>{
|
||
|
preview (
|
||
|
#(
|
||
|
"(", $e._Impl._Value,
|
||
|
",", $e._Impl._Tail._Value,
|
||
|
",", $e._Impl._Tail._Tail._Value,
|
||
|
",", $e._Impl._Tail._Tail._Tail._Value,
|
||
|
",", $e._Impl._Tail._Tail._Tail._Tail._Value,
|
||
|
",", $e._Impl._Tail._Tail._Tail._Tail._Tail._Value,
|
||
|
",", $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Value,
|
||
|
",", $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Value,
|
||
|
",", $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Value,
|
||
|
",", $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Value,
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
|
||
|
children (
|
||
|
#(
|
||
|
[0] : $e._Impl._Value,
|
||
|
[1] : $e._Impl._Tail._Value,
|
||
|
[2] : $e._Impl._Tail._Tail._Value,
|
||
|
[3] : $e._Impl._Tail._Tail._Tail._Value,
|
||
|
[4] : $e._Impl._Tail._Tail._Tail._Tail._Value,
|
||
|
[5] : $e._Impl._Tail._Tail._Tail._Tail._Tail._Value,
|
||
|
[6] : $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Value,
|
||
|
[7] : $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Value,
|
||
|
[8] : $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Value,
|
||
|
[9] : $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Value
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
;------------------------------------------------------------------------------
|
||
|
; std::tr1::array
|
||
|
;------------------------------------------------------------------------------
|
||
|
std::tr1::array<*>{
|
||
|
preview (
|
||
|
; An actual array is previewed with its address.
|
||
|
; array<T, N> is previewed like vector<T>.
|
||
|
#(
|
||
|
"[",
|
||
|
$e._EEN_SIZE,
|
||
|
"](",
|
||
|
#array(expr: $e._Elems[$i], size: $e._EEN_SIZE),
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
|
||
|
children (
|
||
|
; Just like an actual array.
|
||
|
#array(expr: $e._Elems[$i], size: $e._EEN_SIZE)
|
||
|
)
|
||
|
}
|
||
|
std::tr1::_Array_iterator<*>|std::tr1::_Array_const_iterator<*>{
|
||
|
preview (
|
||
|
#if ($e._Idx == $e._EEN_SIZE) (
|
||
|
; array iterators are represented by _Ptr + _Idx,
|
||
|
; and they know how large their parent arrays are. Therefore, detecting
|
||
|
; end iterators is trivial.
|
||
|
"end"
|
||
|
) #else (
|
||
|
; Like vector iterators, array iterators are previewed with what they point to.
|
||
|
$e._Ptr[$e._Idx]
|
||
|
)
|
||
|
)
|
||
|
|
||
|
children (
|
||
|
#if ($e._Idx == $e._EEN_SIZE) (
|
||
|
; We make end iterators appear to have no children.
|
||
|
#array(expr: 0, size: 0)
|
||
|
) #else (
|
||
|
; An array iterator is conceptually a pointer, so we make it appear to store one.
|
||
|
#([ptr] : $e._Ptr + $e._Idx)
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
;------------------------------------------------------------------------------
|
||
|
; std::tr1::function
|
||
|
;------------------------------------------------------------------------------
|
||
|
std::tr1::function<*>{
|
||
|
preview (
|
||
|
#if ($e._Impl == 0) (
|
||
|
; Detecting empty functions is trivial.
|
||
|
"empty"
|
||
|
) #else (
|
||
|
; The only thing that we can preview non-empty
|
||
|
; functions with is the fact that they are non-empty.
|
||
|
"full"
|
||
|
)
|
||
|
)
|
||
|
|
||
|
children (
|
||
|
#if ($e._Impl == 0) (
|
||
|
; We make empty functions appear to have no children.
|
||
|
#array(expr: 0, size: 0)
|
||
|
) #else (
|
||
|
; The callee is stored in (vaguely speaking) $e._Impl->_Callee._Object,
|
||
|
; but visualizers can't show this. Therefore, we show the actual members.
|
||
|
#([actual members] : [$e,!])
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
;------------------------------------------------------------------------------
|
||
|
; std::tr1::unordered_set
|
||
|
; std::tr1::unordered_multiset
|
||
|
; std::tr1::unordered_map
|
||
|
; std::tr1::unordered_multimap
|
||
|
;------------------------------------------------------------------------------
|
||
|
; See the stdext::hash_set visualizer.
|
||
|
;------------------------------------------------------------------------------
|
||
|
; std::tr1::basic_regex
|
||
|
;------------------------------------------------------------------------------
|
||
|
std::tr1::basic_regex<*>{
|
||
|
preview (
|
||
|
#if ($e._Rep == 0) (
|
||
|
; Default construction creates an empty basic_regex.
|
||
|
"empty"
|
||
|
) #elif ($e._EEN_VIS == 1) (
|
||
|
; By default, _ENHANCED_REGEX_VISUALIZER is defined to be 1 in debug and 0 in ship.
|
||
|
; When it is 1, basic_regex stores the string from which it was constructed.
|
||
|
; When it is 0, basic_regex stores only the resulting finite state machine.
|
||
|
$e._Visualization
|
||
|
) #else (
|
||
|
; basic_regex contains many static const flags, which would be shown in the preview by default.
|
||
|
; Its actual members are _Rep and _Traits. _Rep holds the finite state machine, so we
|
||
|
; use it to preview basic_regex. (It does contain some human-readable information.)
|
||
|
*$e._Rep
|
||
|
)
|
||
|
)
|
||
|
|
||
|
children (
|
||
|
#if ($e._Rep == 0) (
|
||
|
; We make empty basic_regexes appear to have no children.
|
||
|
#array(expr: 0, size: 0)
|
||
|
) #elif ($e._EEN_VIS == 1) (
|
||
|
; We want to hide those static const flags.
|
||
|
; We also want to give _Visualization a fake name.
|
||
|
#(
|
||
|
#([str] : $e._Visualization),
|
||
|
#(_Rep : $e._Rep),
|
||
|
#(_Traits : $e._Traits)
|
||
|
)
|
||
|
) #else (
|
||
|
; We want to hide those static const flags.
|
||
|
#(
|
||
|
_Rep : $e._Rep,
|
||
|
_Traits : $e._Traits
|
||
|
)
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
;------------------------------------------------------------------------------
|
||
|
; std::tr1::sub_match
|
||
|
;------------------------------------------------------------------------------
|
||
|
std::tr1::sub_match<char const *>|std::tr1::sub_match<wchar_t const *>|std::tr1::sub_match<unsigned short const *>{
|
||
|
preview (
|
||
|
; It would be nice if we could preview sub_match with its str().
|
||
|
; However, visualizers cannot handle strings represented by pointer pairs.
|
||
|
; Therefore, our preview contains more limited information.
|
||
|
#if ($e.matched) (
|
||
|
; If this sub_match participated in a match,
|
||
|
; we preview it with its length().
|
||
|
$e.second - $e.first
|
||
|
) #else (
|
||
|
; Otherwise, we preview it with its matched bool (i.e. "false").
|
||
|
; (Why not length() (i.e. "0")? It's meaningful to have
|
||
|
; matched == true and length() == 0.
|
||
|
"false"
|
||
|
)
|
||
|
)
|
||
|
|
||
|
children (
|
||
|
#(
|
||
|
; sub_match's three data members are public, but we list them here
|
||
|
; (a) to display matched before first and second, and
|
||
|
; (b) to gloss over the fact that sub_match derives from std::pair.
|
||
|
#(matched : $e.matched),
|
||
|
#(first : $e.first),
|
||
|
#(second : $e.second)
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
std::tr1::sub_match<std::_String_const_iterator<*> >{
|
||
|
preview (
|
||
|
#if ($e.matched) (
|
||
|
; We visualize ssub_match and wssub_match just like csub_match and wcsub_match,
|
||
|
; except that when determining the length(), we can't subtract iterators.
|
||
|
; We have to subtract their stored pointers.
|
||
|
$e.second._Myptr - $e.first._Myptr
|
||
|
) #else (
|
||
|
"false"
|
||
|
)
|
||
|
)
|
||
|
|
||
|
children (
|
||
|
#(
|
||
|
#(matched : $e.matched),
|
||
|
#(first : $e.first),
|
||
|
#(second : $e.second)
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
;------------------------------------------------------------------------------
|
||
|
; std::tr1::match_results
|
||
|
;------------------------------------------------------------------------------
|
||
|
std::tr1::match_results<*>{
|
||
|
preview (
|
||
|
; A match_results object is empty iff its vector _Matches is empty.
|
||
|
#if ($e._Matches._Myfirst == $e._Matches._Mylast) (
|
||
|
"empty"
|
||
|
) #else (
|
||
|
; We preview a non-empty match_results object with its vector.
|
||
|
$e._Matches
|
||
|
)
|
||
|
)
|
||
|
|
||
|
children (
|
||
|
#if ($e._Matches._Myfirst == $e._Matches._Mylast) (
|
||
|
; We make empty match_results appear to have no children.
|
||
|
#array(expr: 0, size: 0)
|
||
|
) #else (
|
||
|
; As match_results has operator[](), prefix(), and suffix() member functions,
|
||
|
; we make it appear to directly contain [0], [1], [2], etc. elements,
|
||
|
; as well as [prefix] and [suffix] elements.
|
||
|
#(
|
||
|
#array(expr: $e._Matches._Myfirst[$i], size: $e._Matches._Mylast - $e._Matches._Myfirst),
|
||
|
#([prefix] : $e._Prefix),
|
||
|
#([suffix] : $e._Suffix)
|
||
|
)
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
;------------------------------------------------------------------------------
|
||
|
; std::tr1::mem_fn()
|
||
|
;------------------------------------------------------------------------------
|
||
|
; Note that when mem_fn() is given a data member pointer, it returns a _Call_wrapper<_Callable_pmd<*> > .
|
||
|
; Data member pointers themselves don't have useful previews, so we don't attempt to visualize this.
|
||
|
; When mem_fn() is given a member function pointer, it returns a _Mem_fn[N], which we can visualize.
|
||
|
std::tr1::_Mem_fn1<*>|std::tr1::_Mem_fn2<*>|std::tr1::_Mem_fn3<*>|std::tr1::_Mem_fn4<*>|std::tr1::_Mem_fn5<*>|std::tr1::_Mem_fn6<*>|std::tr1::_Mem_fn7<*>|std::tr1::_Mem_fn8<*>|std::tr1::_Mem_fn9<*>|std::tr1::_Mem_fn10<*>{
|
||
|
preview (
|
||
|
; We preview the functor returned by mem_fn() with its stored member function pointer.
|
||
|
$e._Callee._Object
|
||
|
)
|
||
|
|
||
|
children (
|
||
|
; Member function pointers have no children.
|
||
|
#array(expr: 0, size: 0)
|
||
|
)
|
||
|
}
|
||
|
;------------------------------------------------------------------------------
|
||
|
; std::tr1::regex_iterator
|
||
|
;------------------------------------------------------------------------------
|
||
|
std::tr1::regex_iterator<*>{
|
||
|
preview (
|
||
|
#if ($e._MyRe == 0) (
|
||
|
; We represent end-of-sequence regex_iterators with null regex pointers.
|
||
|
"end"
|
||
|
) #else (
|
||
|
; Dereferenceable regex_iterators return match_results when dereferenced,
|
||
|
; so we'll preview them with that.
|
||
|
$e._MyVal
|
||
|
)
|
||
|
)
|
||
|
|
||
|
children (
|
||
|
#if ($e._MyRe == 0) (
|
||
|
; We make end-of-sequence regex_iterators appear to have no children.
|
||
|
#array(expr: 0, size: 0)
|
||
|
) #else (
|
||
|
; For ease of understanding, we make dereferenceable regex_iterators
|
||
|
; appear to have data members with the "for exposition only" names from TR1.
|
||
|
#(
|
||
|
#([begin] : $e._Begin),
|
||
|
#([end] : $e._End),
|
||
|
#([pregex] : $e._MyRe),
|
||
|
#([flags] : $e._Flags),
|
||
|
#([match] : $e._MyVal)
|
||
|
)
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
;------------------------------------------------------------------------------
|
||
|
; std::tr1::regex_token_iterator
|
||
|
;------------------------------------------------------------------------------
|
||
|
std::tr1::regex_token_iterator<*>{
|
||
|
preview (
|
||
|
#if ($e._Res == 0) (
|
||
|
; We represent end-of-sequence regex_token_iterators with null result pointers.
|
||
|
"end"
|
||
|
) #else (
|
||
|
; Dereferenceable regex_token_iterators return *result when dereferenced,
|
||
|
; so we'll preview them with that.
|
||
|
*$e._Res
|
||
|
)
|
||
|
)
|
||
|
|
||
|
children (
|
||
|
#if ($e._Res == 0) (
|
||
|
; We make end-of-sequence regex_token_iterators appear to have no children.
|
||
|
#array(expr: 0, size: 0)
|
||
|
) #else (
|
||
|
; For ease of understanding, we make dereferenceable regex_token_iterators
|
||
|
; appear to have data members with the "for exposition only" names from TR1.
|
||
|
#(
|
||
|
#([position] : $e._Pos),
|
||
|
#([result] : $e._Res),
|
||
|
#([suffix] : $e._Suffix),
|
||
|
#([N] : $e._Cur),
|
||
|
#([subs] : $e._Subs)
|
||
|
)
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
;------------------------------------------------------------------------------
|
||
|
; std::tr1::bind()
|
||
|
;------------------------------------------------------------------------------
|
||
|
|
||
|
; STL functors are previewed with their names.
|
||
|
; They have no state, so they have no children.
|
||
|
std::plus<*>{
|
||
|
preview ( "plus" )
|
||
|
children ( #array(expr: 0, size: 0) )
|
||
|
}
|
||
|
std::minus<*>{
|
||
|
preview ( "minus" )
|
||
|
children ( #array(expr: 0, size: 0) )
|
||
|
}
|
||
|
std::multiplies<*>{
|
||
|
preview ( "multiplies" )
|
||
|
children ( #array(expr: 0, size: 0) )
|
||
|
}
|
||
|
std::divides<*>{
|
||
|
preview ( "divides" )
|
||
|
children ( #array(expr: 0, size: 0) )
|
||
|
}
|
||
|
std::modulus<*>{
|
||
|
preview ( "modulus" )
|
||
|
children ( #array(expr: 0, size: 0) )
|
||
|
}
|
||
|
std::negate<*>{
|
||
|
preview ( "negate" )
|
||
|
children ( #array(expr: 0, size: 0) )
|
||
|
}
|
||
|
std::equal_to<*>{
|
||
|
preview ( "equal_to" )
|
||
|
children ( #array(expr: 0, size: 0) )
|
||
|
}
|
||
|
std::not_equal_to<*>{
|
||
|
preview ( "not_equal_to" )
|
||
|
children ( #array(expr: 0, size: 0) )
|
||
|
}
|
||
|
std::greater<*>{
|
||
|
preview ( "greater" )
|
||
|
children ( #array(expr: 0, size: 0) )
|
||
|
}
|
||
|
std::less<*>{
|
||
|
preview ( "less" )
|
||
|
children ( #array(expr: 0, size: 0) )
|
||
|
}
|
||
|
std::greater_equal<*>{
|
||
|
preview ( "greater_equal" )
|
||
|
children ( #array(expr: 0, size: 0) )
|
||
|
}
|
||
|
std::less_equal<*>{
|
||
|
preview ( "less_equal" )
|
||
|
children ( #array(expr: 0, size: 0) )
|
||
|
}
|
||
|
std::logical_and<*>{
|
||
|
preview ( "logical_and" )
|
||
|
children ( #array(expr: 0, size: 0) )
|
||
|
}
|
||
|
std::logical_or<*>{
|
||
|
preview ( "logical_or" )
|
||
|
children ( #array(expr: 0, size: 0) )
|
||
|
}
|
||
|
std::logical_not<*>{
|
||
|
preview ( "logical_not" )
|
||
|
children ( #array(expr: 0, size: 0) )
|
||
|
}
|
||
|
|
||
|
; STL function pointer adaptors are previewed with "ptr_fun(<stored function pointer>)".
|
||
|
; Function pointers have no children, so the adaptors have no children.
|
||
|
std::pointer_to_unary_function<*>|std::pointer_to_binary_function<*>{
|
||
|
preview (
|
||
|
#(
|
||
|
"ptr_fun(",
|
||
|
$e._Pfun,
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
|
||
|
children ( #array(expr: 0, size: 0) )
|
||
|
}
|
||
|
|
||
|
; STL negators are previewed with "not[12](<stored functor>)".
|
||
|
; They have a child with the fake name of [pred], so that the
|
||
|
; stored functor can be inspected.
|
||
|
std::unary_negate<*>{
|
||
|
preview (
|
||
|
#(
|
||
|
"not1(",
|
||
|
$e._Functor,
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
|
||
|
children (
|
||
|
#([pred] : $e._Functor)
|
||
|
)
|
||
|
}
|
||
|
std::binary_negate<*>{
|
||
|
preview (
|
||
|
#(
|
||
|
"not2(",
|
||
|
$e._Functor,
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
|
||
|
children (
|
||
|
#([pred] : $e._Functor)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
; bind() placeholders are previewed with their names.
|
||
|
; They have no state, so they have no children.
|
||
|
std::tr1::_Ph<1>{
|
||
|
preview ( "_1" )
|
||
|
children ( #array(expr: 0, size: 0) )
|
||
|
}
|
||
|
std::tr1::_Ph<2>{
|
||
|
preview ( "_2" )
|
||
|
children ( #array(expr: 0, size: 0) )
|
||
|
}
|
||
|
std::tr1::_Ph<3>{
|
||
|
preview ( "_3" )
|
||
|
children ( #array(expr: 0, size: 0) )
|
||
|
}
|
||
|
std::tr1::_Ph<4>{
|
||
|
preview ( "_4" )
|
||
|
children ( #array(expr: 0, size: 0) )
|
||
|
}
|
||
|
std::tr1::_Ph<5>{
|
||
|
preview ( "_5" )
|
||
|
children ( #array(expr: 0, size: 0) )
|
||
|
}
|
||
|
std::tr1::_Ph<6>{
|
||
|
preview ( "_6" )
|
||
|
children ( #array(expr: 0, size: 0) )
|
||
|
}
|
||
|
std::tr1::_Ph<7>{
|
||
|
preview ( "_7" )
|
||
|
children ( #array(expr: 0, size: 0) )
|
||
|
}
|
||
|
std::tr1::_Ph<8>{
|
||
|
preview ( "_8" )
|
||
|
children ( #array(expr: 0, size: 0) )
|
||
|
}
|
||
|
std::tr1::_Ph<9>{
|
||
|
preview ( "_9" )
|
||
|
children ( #array(expr: 0, size: 0) )
|
||
|
}
|
||
|
std::tr1::_Ph<10>{
|
||
|
preview ( "_10" )
|
||
|
children ( #array(expr: 0, size: 0) )
|
||
|
}
|
||
|
|
||
|
; The functor returned by bind(f, t1, t2) is previewed with "bind(f, t1, t2)".
|
||
|
; It has children with the fake names of [f], [t1], [t2], etc.
|
||
|
std::tr1::_Bind<std::tr1::_Notforced,std::tr1::_Bind0<*> >{
|
||
|
preview (
|
||
|
#(
|
||
|
"bind(", $e._Bx._Callee._Object,
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
|
||
|
children (
|
||
|
#(
|
||
|
#([f] : $e._Bx._Callee._Object)
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
std::tr1::_Bind<std::tr1::_Notforced,std::tr1::_Bind1<*> >{
|
||
|
preview (
|
||
|
#(
|
||
|
"bind(", $e._Bx._Callee._Object,
|
||
|
", ", $e._Bx._Vx0,
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
|
||
|
children (
|
||
|
#(
|
||
|
#([f] : $e._Bx._Callee._Object),
|
||
|
#([t1] : $e._Bx._Vx0)
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
std::tr1::_Bind<std::tr1::_Notforced,std::tr1::_Bind2<*> >{
|
||
|
preview (
|
||
|
#(
|
||
|
"bind(", $e._Bx._Callee._Object,
|
||
|
", ", $e._Bx._Vx0,
|
||
|
", ", $e._Bx._Vx1,
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
|
||
|
children (
|
||
|
#(
|
||
|
#([f] : $e._Bx._Callee._Object),
|
||
|
#([t1] : $e._Bx._Vx0),
|
||
|
#([t2] : $e._Bx._Vx1)
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
std::tr1::_Bind<std::tr1::_Notforced,std::tr1::_Bind3<*> >{
|
||
|
preview (
|
||
|
#(
|
||
|
"bind(", $e._Bx._Callee._Object,
|
||
|
", ", $e._Bx._Vx0,
|
||
|
", ", $e._Bx._Vx1,
|
||
|
", ", $e._Bx._Vx2,
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
|
||
|
children (
|
||
|
#(
|
||
|
#([f] : $e._Bx._Callee._Object),
|
||
|
#([t1] : $e._Bx._Vx0),
|
||
|
#([t2] : $e._Bx._Vx1),
|
||
|
#([t3] : $e._Bx._Vx2)
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
std::tr1::_Bind<std::tr1::_Notforced,std::tr1::_Bind4<*> >{
|
||
|
preview (
|
||
|
#(
|
||
|
"bind(", $e._Bx._Callee._Object,
|
||
|
", ", $e._Bx._Vx0,
|
||
|
", ", $e._Bx._Vx1,
|
||
|
", ", $e._Bx._Vx2,
|
||
|
", ", $e._Bx._Vx3,
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
|
||
|
children (
|
||
|
#(
|
||
|
#([f] : $e._Bx._Callee._Object),
|
||
|
#([t1] : $e._Bx._Vx0),
|
||
|
#([t2] : $e._Bx._Vx1),
|
||
|
#([t3] : $e._Bx._Vx2),
|
||
|
#([t4] : $e._Bx._Vx3)
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
std::tr1::_Bind<std::tr1::_Notforced,std::tr1::_Bind5<*> >{
|
||
|
preview (
|
||
|
#(
|
||
|
"bind(", $e._Bx._Callee._Object,
|
||
|
", ", $e._Bx._Vx0,
|
||
|
", ", $e._Bx._Vx1,
|
||
|
", ", $e._Bx._Vx2,
|
||
|
", ", $e._Bx._Vx3,
|
||
|
", ", $e._Bx._Vx4,
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
|
||
|
children (
|
||
|
#(
|
||
|
#([f] : $e._Bx._Callee._Object),
|
||
|
#([t1] : $e._Bx._Vx0),
|
||
|
#([t2] : $e._Bx._Vx1),
|
||
|
#([t3] : $e._Bx._Vx2),
|
||
|
#([t4] : $e._Bx._Vx3),
|
||
|
#([t5] : $e._Bx._Vx4)
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
std::tr1::_Bind<std::tr1::_Notforced,std::tr1::_Bind6<*> >{
|
||
|
preview (
|
||
|
#(
|
||
|
"bind(", $e._Bx._Callee._Object,
|
||
|
", ", $e._Bx._Vx0,
|
||
|
", ", $e._Bx._Vx1,
|
||
|
", ", $e._Bx._Vx2,
|
||
|
", ", $e._Bx._Vx3,
|
||
|
", ", $e._Bx._Vx4,
|
||
|
", ", $e._Bx._Vx5,
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
|
||
|
children (
|
||
|
#(
|
||
|
#([f] : $e._Bx._Callee._Object),
|
||
|
#([t1] : $e._Bx._Vx0),
|
||
|
#([t2] : $e._Bx._Vx1),
|
||
|
#([t3] : $e._Bx._Vx2),
|
||
|
#([t4] : $e._Bx._Vx3),
|
||
|
#([t5] : $e._Bx._Vx4),
|
||
|
#([t6] : $e._Bx._Vx5)
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
std::tr1::_Bind<std::tr1::_Notforced,std::tr1::_Bind7<*> >{
|
||
|
preview (
|
||
|
#(
|
||
|
"bind(", $e._Bx._Callee._Object,
|
||
|
", ", $e._Bx._Vx0,
|
||
|
", ", $e._Bx._Vx1,
|
||
|
", ", $e._Bx._Vx2,
|
||
|
", ", $e._Bx._Vx3,
|
||
|
", ", $e._Bx._Vx4,
|
||
|
", ", $e._Bx._Vx5,
|
||
|
", ", $e._Bx._Vx6,
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
|
||
|
children (
|
||
|
#(
|
||
|
#([f] : $e._Bx._Callee._Object),
|
||
|
#([t1] : $e._Bx._Vx0),
|
||
|
#([t2] : $e._Bx._Vx1),
|
||
|
#([t3] : $e._Bx._Vx2),
|
||
|
#([t4] : $e._Bx._Vx3),
|
||
|
#([t5] : $e._Bx._Vx4),
|
||
|
#([t6] : $e._Bx._Vx5),
|
||
|
#([t7] : $e._Bx._Vx6)
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
std::tr1::_Bind<std::tr1::_Notforced,std::tr1::_Bind8<*> >{
|
||
|
preview (
|
||
|
#(
|
||
|
"bind(", $e._Bx._Callee._Object,
|
||
|
", ", $e._Bx._Vx0,
|
||
|
", ", $e._Bx._Vx1,
|
||
|
", ", $e._Bx._Vx2,
|
||
|
", ", $e._Bx._Vx3,
|
||
|
", ", $e._Bx._Vx4,
|
||
|
", ", $e._Bx._Vx5,
|
||
|
", ", $e._Bx._Vx6,
|
||
|
", ", $e._Bx._Vx7,
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
|
||
|
children (
|
||
|
#(
|
||
|
#([f] : $e._Bx._Callee._Object),
|
||
|
#([t1] : $e._Bx._Vx0),
|
||
|
#([t2] : $e._Bx._Vx1),
|
||
|
#([t3] : $e._Bx._Vx2),
|
||
|
#([t4] : $e._Bx._Vx3),
|
||
|
#([t5] : $e._Bx._Vx4),
|
||
|
#([t6] : $e._Bx._Vx5),
|
||
|
#([t7] : $e._Bx._Vx6),
|
||
|
#([t8] : $e._Bx._Vx7)
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
std::tr1::_Bind<std::tr1::_Notforced,std::tr1::_Bind9<*> >{
|
||
|
preview (
|
||
|
#(
|
||
|
"bind(", $e._Bx._Callee._Object,
|
||
|
", ", $e._Bx._Vx0,
|
||
|
", ", $e._Bx._Vx1,
|
||
|
", ", $e._Bx._Vx2,
|
||
|
", ", $e._Bx._Vx3,
|
||
|
", ", $e._Bx._Vx4,
|
||
|
", ", $e._Bx._Vx5,
|
||
|
", ", $e._Bx._Vx6,
|
||
|
", ", $e._Bx._Vx7,
|
||
|
", ", $e._Bx._Vx8,
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
|
||
|
children (
|
||
|
#(
|
||
|
#([f] : $e._Bx._Callee._Object),
|
||
|
#([t1] : $e._Bx._Vx0),
|
||
|
#([t2] : $e._Bx._Vx1),
|
||
|
#([t3] : $e._Bx._Vx2),
|
||
|
#([t4] : $e._Bx._Vx3),
|
||
|
#([t5] : $e._Bx._Vx4),
|
||
|
#([t6] : $e._Bx._Vx5),
|
||
|
#([t7] : $e._Bx._Vx6),
|
||
|
#([t8] : $e._Bx._Vx7),
|
||
|
#([t9] : $e._Bx._Vx8)
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
std::tr1::_Bind<std::tr1::_Notforced,std::tr1::_Bind10<*> >{
|
||
|
preview (
|
||
|
#(
|
||
|
"bind(", $e._Bx._Callee._Object,
|
||
|
", ", $e._Bx._Vx0,
|
||
|
", ", $e._Bx._Vx1,
|
||
|
", ", $e._Bx._Vx2,
|
||
|
", ", $e._Bx._Vx3,
|
||
|
", ", $e._Bx._Vx4,
|
||
|
", ", $e._Bx._Vx5,
|
||
|
", ", $e._Bx._Vx6,
|
||
|
", ", $e._Bx._Vx7,
|
||
|
", ", $e._Bx._Vx8,
|
||
|
", ", $e._Bx._Vx9,
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
|
||
|
children (
|
||
|
#(
|
||
|
#([f] : $e._Bx._Callee._Object),
|
||
|
#([t1] : $e._Bx._Vx0),
|
||
|
#([t2] : $e._Bx._Vx1),
|
||
|
#([t3] : $e._Bx._Vx2),
|
||
|
#([t4] : $e._Bx._Vx3),
|
||
|
#([t5] : $e._Bx._Vx4),
|
||
|
#([t6] : $e._Bx._Vx5),
|
||
|
#([t7] : $e._Bx._Vx6),
|
||
|
#([t8] : $e._Bx._Vx7),
|
||
|
#([t9] : $e._Bx._Vx8),
|
||
|
#([t10] : $e._Bx._Vx9)
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
; The functor returned by bind<RetType>(f, t1, t2) is previewed with "bind<R>(f, t1, t2)",
|
||
|
; because we cannot stringify a type name into the preview.
|
||
|
; Its first child has the fake name of [R *] and is a null pointer of type RetType *.
|
||
|
; This allows RetType to be found easily, instead of digging through the bound functor's type.
|
||
|
; This is followed by children with the fake names of [f], [t1], [t2], etc.
|
||
|
std::tr1::_Bind<*,std::tr1::_Bind0<*> >{
|
||
|
preview (
|
||
|
#(
|
||
|
"bind<R>(", $e._Bx._Callee._Object,
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
|
||
|
children (
|
||
|
#(
|
||
|
#([R *] : ($T1 *) 0),
|
||
|
#([f] : $e._Bx._Callee._Object)
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
std::tr1::_Bind<*,std::tr1::_Bind1<*> >{
|
||
|
preview (
|
||
|
#(
|
||
|
"bind<R>(", $e._Bx._Callee._Object,
|
||
|
", ", $e._Bx._Vx0,
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
|
||
|
children (
|
||
|
#(
|
||
|
#([R *] : ($T1 *) 0),
|
||
|
#([f] : $e._Bx._Callee._Object),
|
||
|
#([t1] : $e._Bx._Vx0)
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
std::tr1::_Bind<*,std::tr1::_Bind2<*> >{
|
||
|
preview (
|
||
|
#(
|
||
|
"bind<R>(", $e._Bx._Callee._Object,
|
||
|
", ", $e._Bx._Vx0,
|
||
|
", ", $e._Bx._Vx1,
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
|
||
|
children (
|
||
|
#(
|
||
|
#([R *] : ($T1 *) 0),
|
||
|
#([f] : $e._Bx._Callee._Object),
|
||
|
#([t1] : $e._Bx._Vx0),
|
||
|
#([t2] : $e._Bx._Vx1)
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
std::tr1::_Bind<*,std::tr1::_Bind3<*> >{
|
||
|
preview (
|
||
|
#(
|
||
|
"bind<R>(", $e._Bx._Callee._Object,
|
||
|
", ", $e._Bx._Vx0,
|
||
|
", ", $e._Bx._Vx1,
|
||
|
", ", $e._Bx._Vx2,
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
|
||
|
children (
|
||
|
#(
|
||
|
#([R *] : ($T1 *) 0),
|
||
|
#([f] : $e._Bx._Callee._Object),
|
||
|
#([t1] : $e._Bx._Vx0),
|
||
|
#([t2] : $e._Bx._Vx1),
|
||
|
#([t3] : $e._Bx._Vx2)
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
std::tr1::_Bind<*,std::tr1::_Bind4<*> >{
|
||
|
preview (
|
||
|
#(
|
||
|
"bind<R>(", $e._Bx._Callee._Object,
|
||
|
", ", $e._Bx._Vx0,
|
||
|
", ", $e._Bx._Vx1,
|
||
|
", ", $e._Bx._Vx2,
|
||
|
", ", $e._Bx._Vx3,
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
|
||
|
children (
|
||
|
#(
|
||
|
#([R *] : ($T1 *) 0),
|
||
|
#([f] : $e._Bx._Callee._Object),
|
||
|
#([t1] : $e._Bx._Vx0),
|
||
|
#([t2] : $e._Bx._Vx1),
|
||
|
#([t3] : $e._Bx._Vx2),
|
||
|
#([t4] : $e._Bx._Vx3)
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
std::tr1::_Bind<*,std::tr1::_Bind5<*> >{
|
||
|
preview (
|
||
|
#(
|
||
|
"bind<R>(", $e._Bx._Callee._Object,
|
||
|
", ", $e._Bx._Vx0,
|
||
|
", ", $e._Bx._Vx1,
|
||
|
", ", $e._Bx._Vx2,
|
||
|
", ", $e._Bx._Vx3,
|
||
|
", ", $e._Bx._Vx4,
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
|
||
|
children (
|
||
|
#(
|
||
|
#([R *] : ($T1 *) 0),
|
||
|
#([f] : $e._Bx._Callee._Object),
|
||
|
#([t1] : $e._Bx._Vx0),
|
||
|
#([t2] : $e._Bx._Vx1),
|
||
|
#([t3] : $e._Bx._Vx2),
|
||
|
#([t4] : $e._Bx._Vx3),
|
||
|
#([t5] : $e._Bx._Vx4)
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
std::tr1::_Bind<*,std::tr1::_Bind6<*> >{
|
||
|
preview (
|
||
|
#(
|
||
|
"bind<R>(", $e._Bx._Callee._Object,
|
||
|
", ", $e._Bx._Vx0,
|
||
|
", ", $e._Bx._Vx1,
|
||
|
", ", $e._Bx._Vx2,
|
||
|
", ", $e._Bx._Vx3,
|
||
|
", ", $e._Bx._Vx4,
|
||
|
", ", $e._Bx._Vx5,
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
|
||
|
children (
|
||
|
#(
|
||
|
#([R *] : ($T1 *) 0),
|
||
|
#([f] : $e._Bx._Callee._Object),
|
||
|
#([t1] : $e._Bx._Vx0),
|
||
|
#([t2] : $e._Bx._Vx1),
|
||
|
#([t3] : $e._Bx._Vx2),
|
||
|
#([t4] : $e._Bx._Vx3),
|
||
|
#([t5] : $e._Bx._Vx4),
|
||
|
#([t6] : $e._Bx._Vx5)
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
std::tr1::_Bind<*,std::tr1::_Bind7<*> >{
|
||
|
preview (
|
||
|
#(
|
||
|
"bind<R>(", $e._Bx._Callee._Object,
|
||
|
", ", $e._Bx._Vx0,
|
||
|
", ", $e._Bx._Vx1,
|
||
|
", ", $e._Bx._Vx2,
|
||
|
", ", $e._Bx._Vx3,
|
||
|
", ", $e._Bx._Vx4,
|
||
|
", ", $e._Bx._Vx5,
|
||
|
", ", $e._Bx._Vx6,
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
|
||
|
children (
|
||
|
#(
|
||
|
#([R *] : ($T1 *) 0),
|
||
|
#([f] : $e._Bx._Callee._Object),
|
||
|
#([t1] : $e._Bx._Vx0),
|
||
|
#([t2] : $e._Bx._Vx1),
|
||
|
#([t3] : $e._Bx._Vx2),
|
||
|
#([t4] : $e._Bx._Vx3),
|
||
|
#([t5] : $e._Bx._Vx4),
|
||
|
#([t6] : $e._Bx._Vx5),
|
||
|
#([t7] : $e._Bx._Vx6)
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
std::tr1::_Bind<*,std::tr1::_Bind8<*> >{
|
||
|
preview (
|
||
|
#(
|
||
|
"bind<R>(", $e._Bx._Callee._Object,
|
||
|
", ", $e._Bx._Vx0,
|
||
|
", ", $e._Bx._Vx1,
|
||
|
", ", $e._Bx._Vx2,
|
||
|
", ", $e._Bx._Vx3,
|
||
|
", ", $e._Bx._Vx4,
|
||
|
", ", $e._Bx._Vx5,
|
||
|
", ", $e._Bx._Vx6,
|
||
|
", ", $e._Bx._Vx7,
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
|
||
|
children (
|
||
|
#(
|
||
|
#([R *] : ($T1 *) 0),
|
||
|
#([f] : $e._Bx._Callee._Object),
|
||
|
#([t1] : $e._Bx._Vx0),
|
||
|
#([t2] : $e._Bx._Vx1),
|
||
|
#([t3] : $e._Bx._Vx2),
|
||
|
#([t4] : $e._Bx._Vx3),
|
||
|
#([t5] : $e._Bx._Vx4),
|
||
|
#([t6] : $e._Bx._Vx5),
|
||
|
#([t7] : $e._Bx._Vx6),
|
||
|
#([t8] : $e._Bx._Vx7)
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
std::tr1::_Bind<*,std::tr1::_Bind9<*> >{
|
||
|
preview (
|
||
|
#(
|
||
|
"bind<R>(", $e._Bx._Callee._Object,
|
||
|
", ", $e._Bx._Vx0,
|
||
|
", ", $e._Bx._Vx1,
|
||
|
", ", $e._Bx._Vx2,
|
||
|
", ", $e._Bx._Vx3,
|
||
|
", ", $e._Bx._Vx4,
|
||
|
", ", $e._Bx._Vx5,
|
||
|
", ", $e._Bx._Vx6,
|
||
|
", ", $e._Bx._Vx7,
|
||
|
", ", $e._Bx._Vx8,
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
|
||
|
children (
|
||
|
#(
|
||
|
#([R *] : ($T1 *) 0),
|
||
|
#([f] : $e._Bx._Callee._Object),
|
||
|
#([t1] : $e._Bx._Vx0),
|
||
|
#([t2] : $e._Bx._Vx1),
|
||
|
#([t3] : $e._Bx._Vx2),
|
||
|
#([t4] : $e._Bx._Vx3),
|
||
|
#([t5] : $e._Bx._Vx4),
|
||
|
#([t6] : $e._Bx._Vx5),
|
||
|
#([t7] : $e._Bx._Vx6),
|
||
|
#([t8] : $e._Bx._Vx7),
|
||
|
#([t9] : $e._Bx._Vx8)
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
std::tr1::_Bind<*,std::tr1::_Bind10<*> >{
|
||
|
preview (
|
||
|
#(
|
||
|
"bind<R>(", $e._Bx._Callee._Object,
|
||
|
", ", $e._Bx._Vx0,
|
||
|
", ", $e._Bx._Vx1,
|
||
|
", ", $e._Bx._Vx2,
|
||
|
", ", $e._Bx._Vx3,
|
||
|
", ", $e._Bx._Vx4,
|
||
|
", ", $e._Bx._Vx5,
|
||
|
", ", $e._Bx._Vx6,
|
||
|
", ", $e._Bx._Vx7,
|
||
|
", ", $e._Bx._Vx8,
|
||
|
", ", $e._Bx._Vx9,
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
|
||
|
children (
|
||
|
#(
|
||
|
#([R *] : ($T1 *) 0),
|
||
|
#([f] : $e._Bx._Callee._Object),
|
||
|
#([t1] : $e._Bx._Vx0),
|
||
|
#([t2] : $e._Bx._Vx1),
|
||
|
#([t3] : $e._Bx._Vx2),
|
||
|
#([t4] : $e._Bx._Vx3),
|
||
|
#([t5] : $e._Bx._Vx4),
|
||
|
#([t6] : $e._Bx._Vx5),
|
||
|
#([t7] : $e._Bx._Vx6),
|
||
|
#([t8] : $e._Bx._Vx7),
|
||
|
#([t9] : $e._Bx._Vx8),
|
||
|
#([t10] : $e._Bx._Vx9)
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
|
||
|
;------------------------------------------------------------------------------
|
||
|
; std::vector<bool,*> specialization
|
||
|
;------------------------------------------------------------------------------
|
||
|
std::vector<bool,*>{
|
||
|
children
|
||
|
(
|
||
|
#array
|
||
|
(
|
||
|
expr : ($e._Myvec._Myfirst[$i / _VBITS] >> ($i % _VBITS)),
|
||
|
size : ($e._Mysize)
|
||
|
) : (bool)($e & 1)
|
||
|
)
|
||
|
preview
|
||
|
(
|
||
|
#(
|
||
|
"[", $e._Mysize , "](",
|
||
|
#array
|
||
|
(
|
||
|
expr : ($e._Myvec._Myfirst[$i / _VBITS] >> ($i % _VBITS)),
|
||
|
size : ($e._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 : ($e._Myfirst)[$i],
|
||
|
size : $e._Mylast-$e._Myfirst
|
||
|
)
|
||
|
)
|
||
|
preview
|
||
|
(
|
||
|
#(
|
||
|
"[", $e._Mylast - $e._Myfirst , "](",
|
||
|
#array
|
||
|
(
|
||
|
expr : ($e._Myfirst)[$i],
|
||
|
size : $e._Mylast-$e._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 *)$e._Myptr))
|
||
|
)
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#(
|
||
|
ptr: (*(($T1 *)$e._Myptr))
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
;------------------------------------------------------------------------------
|
||
|
; std::map
|
||
|
;------------------------------------------------------------------------------
|
||
|
std::map<*>{
|
||
|
children
|
||
|
(
|
||
|
#tree
|
||
|
(
|
||
|
head : $e._Myhead->_Parent,
|
||
|
skip : $e._Myhead,
|
||
|
size : $e._Mysize,
|
||
|
left : _Left,
|
||
|
right : _Right
|
||
|
) : $e._Myval
|
||
|
)
|
||
|
preview
|
||
|
(
|
||
|
#(
|
||
|
"[", $e._Mysize, "](",
|
||
|
#tree
|
||
|
(
|
||
|
head : $e._Myhead->_Parent,
|
||
|
skip : $e._Myhead,
|
||
|
size : $e._Mysize,
|
||
|
left : _Left,
|
||
|
right : _Right
|
||
|
) : $e._Myval,
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
;------------------------------------------------------------------------------
|
||
|
; std::multi_map
|
||
|
;------------------------------------------------------------------------------
|
||
|
std::multimap<*>{
|
||
|
children
|
||
|
(
|
||
|
#tree
|
||
|
(
|
||
|
head : $e._Myhead->_Parent,
|
||
|
skip : $e._Myhead,
|
||
|
size : $e._Mysize,
|
||
|
left : _Left,
|
||
|
right : _Right
|
||
|
) : $e._Myval
|
||
|
)
|
||
|
preview
|
||
|
(
|
||
|
#(
|
||
|
"[", $e._Mysize, "](",
|
||
|
#tree
|
||
|
(
|
||
|
head : $e._Myhead->_Parent,
|
||
|
skip : $e._Myhead,
|
||
|
size : $e._Mysize,
|
||
|
left : _Left,
|
||
|
right : _Right
|
||
|
) : $e._Myval,
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
;------------------------------------------------------------------------------
|
||
|
; std::list
|
||
|
;------------------------------------------------------------------------------
|
||
|
std::list<*>{
|
||
|
children
|
||
|
(
|
||
|
#list
|
||
|
(
|
||
|
head : $e._Myhead->_Next,
|
||
|
size : $e._Mysize,
|
||
|
next : _Next
|
||
|
) : $e._Myval
|
||
|
)
|
||
|
preview
|
||
|
(
|
||
|
#(
|
||
|
"[", $e._Mysize, "](",
|
||
|
#list
|
||
|
(
|
||
|
head : $e._Myhead->_Next,
|
||
|
size : $e._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
|
||
|
(
|
||
|
#(
|
||
|
"[", $e.digits, "](",
|
||
|
#array
|
||
|
(
|
||
|
expr : ($e._Array[$i / $e._Bitsperword] >> ($i % $e._Bitsperword)),
|
||
|
size : $e.digits
|
||
|
) : [($e & 1),d],
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#array
|
||
|
(
|
||
|
expr : ($e._Array[$i / $e._Bitsperword] >> ($i % $e._Bitsperword)),
|
||
|
size : $e.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 : $e._Map[ (($i + $e._Myoff) / $e._EEN_DS) % $e._Mapsize][($i + $e._Myoff) % $e._EEN_DS],
|
||
|
size : $e._Mysize
|
||
|
)
|
||
|
)
|
||
|
preview
|
||
|
(
|
||
|
#(
|
||
|
"[", $e._Mysize, "](",
|
||
|
#array
|
||
|
(
|
||
|
expr : $e._Map[ (($i + $e._Myoff) / $e._EEN_DS) % $e._Mapsize][($i + $e._Myoff) % $e._EEN_DS],
|
||
|
size : $e._Mysize
|
||
|
),
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
std::deque<*,*>::iterator|std::_Deque_iterator<*,*,*>|std::_Deque_const_iterator<*,*,*>{
|
||
|
preview
|
||
|
(
|
||
|
#if( $e._EEN_HID == 0 )
|
||
|
(
|
||
|
#if( $e._Myoff >= ((std::deque<$T1,$T2 > *)($e._Myaux->_Mycontainer))->_Myoff + ((std::deque<$T1,$T2 > *)($e._Myaux->_Mycontainer))->_Mysize)
|
||
|
(
|
||
|
#("<end>")
|
||
|
)
|
||
|
#else
|
||
|
(
|
||
|
#(
|
||
|
"deque[",
|
||
|
$e._Myoff - ((std::deque<$T1,$T2 > *)($e._Myaux->_Mycontainer))->_Myoff,
|
||
|
"] = ",
|
||
|
((std::deque<$T1,$T2 > *)($e._Myaux->_Mycontainer))->_Map[ (($e._Myoff) / ((std::deque<$T1,$T2 > *)($e._Myaux->_Mycontainer))->_EEN_DS) % ((std::deque<$T1,$T2 > *)$e._Myaux->_Mycontainer)->_Mapsize][$e._Myoff % ((std::deque<$T1,$T2 > *)($e._Myaux->_Mycontainer))->_EEN_DS]
|
||
|
)
|
||
|
)
|
||
|
)
|
||
|
#else
|
||
|
(
|
||
|
#if( $e._Myoff >= ((std::deque<$T1,$T2 > *)$e._Mycont)->_Myoff + ((std::deque<$T1,$T2 > *)$e._Mycont)->_Mysize)
|
||
|
(
|
||
|
#("<end>")
|
||
|
)
|
||
|
#else
|
||
|
(
|
||
|
#(
|
||
|
"deque[",
|
||
|
$e._Myoff - ((std::deque<$T1,$T2 > *)$e._Mycont)->_Myoff,
|
||
|
"] = ",
|
||
|
((std::deque<$T1,$T2 > *)$e._Mycont)->_Map[ (($e._Myoff) / ((std::deque<$T1,$T2 > *)$e._Mycont)->_EEN_DS) % ((std::deque<$T1,$T2 > *)$e._Mycont)->_Mapsize][$e._Myoff % ((std::deque<$T1,$T2 > *)$e._Mycont)->_EEN_DS]
|
||
|
)
|
||
|
)
|
||
|
)
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#if( $e._EEN_HID == 0 )
|
||
|
(
|
||
|
#if( ((std::deque<$T1,$T2 > *)($e._Myaux->_Mycontainer))->_Myoff + ((std::deque<$T1,$T2 > *)($e._Myaux->_Mycontainer))->_Mysize > $e._Myoff)
|
||
|
(
|
||
|
#(
|
||
|
ptr: ((std::deque<$T1,$T2 > *)($e._Myaux->_Mycontainer))->_Map[ ($e._Myoff / ((std::deque<$T1,$T2 > *)($e._Myaux->_Mycontainer))->_EEN_DS) % ((std::deque<$T1,$T2 > *)($e._Myaux->_Mycontainer))->_Mapsize][$e._Myoff % ((std::deque<$T1,$T2 > *)($e._Myaux->_Mycontainer))->_EEN_DS]
|
||
|
)
|
||
|
)
|
||
|
)
|
||
|
#else
|
||
|
(
|
||
|
#if( ((std::deque<$T1,$T2 > *)$e._Mycont)->_Myoff + ((std::deque<$T1,$T2 > *)$e._Mycont)->_Mysize > $e._Myoff)
|
||
|
(
|
||
|
#(
|
||
|
ptr: ((std::deque<$T1,$T2 > *)$e._Mycont)->_Map[ ($e._Myoff / ((std::deque<$T1,$T2 > *)$e._Mycont)->_EEN_DS) % ((std::deque<$T1,$T2 > *)$e._Mycont)->_Mapsize][$e._Myoff % ((std::deque<$T1,$T2 > *)$e._Mycont)->_EEN_DS]
|
||
|
)
|
||
|
)
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
;------------------------------------------------------------------------------
|
||
|
; std::queue
|
||
|
;------------------------------------------------------------------------------
|
||
|
std::queue<*>{
|
||
|
children
|
||
|
(
|
||
|
#array
|
||
|
(
|
||
|
expr : $e.c._Map[ (($i + $e.c._Myoff) / $e.c._EEN_DS) % $e.c._Mapsize][($i + $e.c._Myoff) % $e.c._EEN_DS],
|
||
|
size : $e.c._Mysize
|
||
|
)
|
||
|
)
|
||
|
preview
|
||
|
(
|
||
|
#(
|
||
|
"[", $e.c._Mysize, "](",
|
||
|
#array
|
||
|
(
|
||
|
expr : $e.c._Map[ (($i + $e.c._Myoff) / $e.c._EEN_DS) % $e.c._Mapsize][($i + $e.c._Myoff) % $e.c._EEN_DS],
|
||
|
size : $e.c._Mysize
|
||
|
),
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
;------------------------------------------------------------------------------
|
||
|
; std::priority_queue
|
||
|
;------------------------------------------------------------------------------
|
||
|
std::priority_queue<*>{
|
||
|
preview ( $e.c)
|
||
|
}
|
||
|
;------------------------------------------------------------------------------
|
||
|
; std::set
|
||
|
;------------------------------------------------------------------------------
|
||
|
std::set<*>{
|
||
|
preview
|
||
|
(
|
||
|
#(
|
||
|
"[", $e._Mysize , "](",
|
||
|
#tree
|
||
|
(
|
||
|
head : $e._Myhead->_Parent,
|
||
|
skip : $e._Myhead,
|
||
|
left : _Left,
|
||
|
right : _Right,
|
||
|
size : $e._Mysize
|
||
|
) : $e._Myval,
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#tree
|
||
|
(
|
||
|
head : $e._Myhead->_Parent,
|
||
|
skip : $e._Myhead,
|
||
|
left : _Left,
|
||
|
right : _Right,
|
||
|
size : $e._Mysize
|
||
|
) : $e._Myval
|
||
|
)
|
||
|
}
|
||
|
;------------------------------------------------------------------------------
|
||
|
; std::multi_set
|
||
|
;------------------------------------------------------------------------------
|
||
|
std::multiset<*>{
|
||
|
preview
|
||
|
(
|
||
|
#(
|
||
|
"[", $e._Mysize , "](",
|
||
|
#tree
|
||
|
(
|
||
|
head : $e._Myhead->_Parent,
|
||
|
skip : $e._Myhead,
|
||
|
left : _Left,
|
||
|
right : _Right,
|
||
|
size : $e._Mysize
|
||
|
) : $e._Myval,
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#tree
|
||
|
(
|
||
|
head : $e._Myhead->_Parent,
|
||
|
skip : $e._Myhead,
|
||
|
left : _Left,
|
||
|
right : _Right,
|
||
|
size : $e._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 : $e.c._Map[ (($i + $e.c._Myoff) / $e.c._EEN_DS) % $e.c._Mapsize][($i + $e.c._Myoff) % $e.c._EEN_DS],
|
||
|
size : $e.c._Mysize
|
||
|
)
|
||
|
)
|
||
|
preview
|
||
|
(
|
||
|
#(
|
||
|
"[", $e.c._Mysize , "](",
|
||
|
#array
|
||
|
(
|
||
|
expr : $e.c._Map[ (($i + $e.c._Myoff) / $e.c._EEN_DS) % $e.c._Mapsize][($i + $e.c._Myoff) % $e.c._EEN_DS],
|
||
|
size : $e.c._Mysize
|
||
|
),
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
;------------------------------------------------------------------------------
|
||
|
; stdext::hash_map
|
||
|
; stdext::hash_multimap
|
||
|
; stdext::hash_set
|
||
|
; stdext::hash_multiset
|
||
|
; std::tr1::unordered_set
|
||
|
; std::tr1::unordered_multiset
|
||
|
; std::tr1::unordered_map
|
||
|
; std::tr1::unordered_multimap
|
||
|
;------------------------------------------------------------------------------
|
||
|
stdext::hash_map<*>|stdext::hash_multimap<*>|stdext::hash_set<*>|stdext::hash_multiset<*>|std::tr1::unordered_set<*>|std::tr1::unordered_multiset<*>|std::tr1::unordered_map<*>|std::tr1::unordered_multimap<*>{
|
||
|
preview
|
||
|
(
|
||
|
#(
|
||
|
"[", $e._List._Mysize, "](",
|
||
|
#list
|
||
|
(
|
||
|
head : $e._List._Myhead->_Next,
|
||
|
size : $e._List._Mysize,
|
||
|
next : _Next
|
||
|
) : $e._Myval,
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#list
|
||
|
(
|
||
|
head : $e._List._Myhead->_Next,
|
||
|
size : $e._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 : ($e._Myptr)[$i],
|
||
|
size : $e._Mysize
|
||
|
),
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#array
|
||
|
(
|
||
|
expr : ($e._Myptr)[$i],
|
||
|
size : $e._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 : ($e.pElems)[$i],
|
||
|
size : $e.cElems
|
||
|
),
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#array
|
||
|
(
|
||
|
expr : ($e.pElems)[$i],
|
||
|
size : $e.cElems
|
||
|
)
|
||
|
)
|
||
|
}
|
||
|
; Visualizers for SAFE ARRAY
|
||
|
tagSAFEARRAY|SAFEARRAY{
|
||
|
preview(
|
||
|
#if ($e.fFeatures & 0x0080) ; FADF_HAVEVARTYPE
|
||
|
(
|
||
|
; Switch on the variant type field - which is stored 4 bytes
|
||
|
; before the beginning of the SAFEARRAY type
|
||
|
#switch( ((unsigned *)&($e))[-1] )
|
||
|
#case 0x2 ; VT_I2 | VT_ARRAY
|
||
|
(
|
||
|
#(
|
||
|
"safearray of I2 = [",
|
||
|
; output the rank array
|
||
|
#array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
|
||
|
"](",
|
||
|
; output the data elements
|
||
|
#array(
|
||
|
expr: ((signed short *)$e.pvData)[$i],
|
||
|
size: $e.rgsabound[$r].cElements,
|
||
|
rank: $e.cDims,
|
||
|
base: $e.rgsabound[$r].lLbound
|
||
|
),
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
#case 0x3 ; VT_I4 | VT_ARRAY
|
||
|
(
|
||
|
#(
|
||
|
"safearray of I4 = [",
|
||
|
; output the rank array
|
||
|
#array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
|
||
|
"](",
|
||
|
; output the data elements
|
||
|
#array(
|
||
|
expr: ((signed int *)$e.pvData)[$i],
|
||
|
size: $e.rgsabound[$r].cElements,
|
||
|
rank: $e.cDims,
|
||
|
base: $e.rgsabound[$r].lLbound
|
||
|
),
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
#case 0x4 ; VT_R4 | VT_ARRAY
|
||
|
(
|
||
|
#(
|
||
|
"safearray of R4 = [",
|
||
|
; output the rank array
|
||
|
#array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
|
||
|
"](",
|
||
|
; output the data elements
|
||
|
#array(
|
||
|
expr: ((float *)$e.pvData)[$i],
|
||
|
size: $e.rgsabound[$r].cElements,
|
||
|
rank: $e.cDims,
|
||
|
base: $e.rgsabound[$r].lLbound
|
||
|
),
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
#case 0x5 ; VT_R8 | VT_ARRAY
|
||
|
(
|
||
|
#(
|
||
|
"safearray of R8 = [",
|
||
|
; output the rank array
|
||
|
#array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
|
||
|
"](",
|
||
|
; output the data elements
|
||
|
#array(
|
||
|
expr: ((double *)$e.pvData)[$i],
|
||
|
size: $e.rgsabound[$r].cElements,
|
||
|
rank: $e.cDims,
|
||
|
base: $e.rgsabound[$r].lLbound
|
||
|
),
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
#case 0x6 ; VT_CY | VT_ARRAY
|
||
|
(
|
||
|
#(
|
||
|
"safearray of CY = [",
|
||
|
; output the rank array
|
||
|
#array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
|
||
|
"](",
|
||
|
; output the data elements
|
||
|
#array(
|
||
|
expr: ((CY *)$e.pvData)[$i],
|
||
|
size: $e.rgsabound[$r].cElements,
|
||
|
rank: $e.cDims,
|
||
|
base: $e.rgsabound[$r].lLbound
|
||
|
),
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
#case 0x7 ; VT_DATE | VT_ARRAY
|
||
|
(
|
||
|
#(
|
||
|
"safearray of DATE = [",
|
||
|
; output the rank array
|
||
|
#array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
|
||
|
"](",
|
||
|
; output the data elements
|
||
|
#array(
|
||
|
expr: ((DATE *)$e.pvData)[$i],
|
||
|
size: $e.rgsabound[$r].cElements,
|
||
|
rank: $e.cDims,
|
||
|
base: $e.rgsabound[$r].lLbound
|
||
|
),
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
#case 0x8 ; VT_BSTR | VT_ARRAY
|
||
|
(
|
||
|
#(
|
||
|
"safearray of BSTR = [",
|
||
|
; output the rank array
|
||
|
#array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
|
||
|
"](",
|
||
|
; output the data elements
|
||
|
#array(
|
||
|
expr: ((wchar_t **)$e.pvData)[$i],
|
||
|
size: $e.rgsabound[$r].cElements,
|
||
|
rank: $e.cDims,
|
||
|
base: $e.rgsabound[$r].lLbound
|
||
|
),
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
#case 0xa ; VT_ERROR | VT_ARRAY
|
||
|
(
|
||
|
#(
|
||
|
"safearray of ERROR = [",
|
||
|
; output the rank array
|
||
|
#array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
|
||
|
"](",
|
||
|
; output the data elements
|
||
|
#array(
|
||
|
expr: ((long *)$e.pvData)[$i],
|
||
|
size: $e.rgsabound[$r].cElements,
|
||
|
rank: $e.cDims,
|
||
|
base: $e.rgsabound[$r].lLbound
|
||
|
),
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
#case 0xb ; VT_BOOL | VT_ARRAY
|
||
|
(
|
||
|
#(
|
||
|
"safearray of BOOL = [",
|
||
|
; output the rank array
|
||
|
#array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
|
||
|
"](",
|
||
|
; output the data elements
|
||
|
#array(
|
||
|
expr: ((short *)$e.pvData)[$i],
|
||
|
size: $e.rgsabound[$r].cElements,
|
||
|
rank: $e.cDims,
|
||
|
base: $e.rgsabound[$r].lLbound
|
||
|
),
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
#case 0xc ; VT_VARIANT | VT_ARRAY
|
||
|
(
|
||
|
#(
|
||
|
"safearray of VARIANT = [",
|
||
|
; output the rank array
|
||
|
#array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
|
||
|
"](",
|
||
|
; output the data elements
|
||
|
#array(
|
||
|
expr: ((tagVARIANT *)$e.pvData)[$i],
|
||
|
size: $e.rgsabound[$r].cElements,
|
||
|
rank: $e.cDims,
|
||
|
base: $e.rgsabound[$r].lLbound
|
||
|
),
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
#case 0x10 ; VT_I1 | VT_ARRAY
|
||
|
(
|
||
|
#(
|
||
|
"safearray of I1 = [",
|
||
|
; output the rank array
|
||
|
#array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
|
||
|
"](",
|
||
|
; output the data elements
|
||
|
#array(
|
||
|
expr: ((signed char *)$e.pvData)[$i],
|
||
|
size: $e.rgsabound[$r].cElements,
|
||
|
rank: $e.cDims,
|
||
|
base: $e.rgsabound[$r].lLbound
|
||
|
),
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
#case 0x11 ; VT_UI1 | VT_ARRAY
|
||
|
(
|
||
|
#(
|
||
|
"safearray of UI1 = [",
|
||
|
; output the rank array
|
||
|
#array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
|
||
|
"](",
|
||
|
; output the data elements
|
||
|
#array(
|
||
|
expr: ((unsigned char *)$e.pvData)[$i],
|
||
|
size: $e.rgsabound[$r].cElements,
|
||
|
rank: $e.cDims,
|
||
|
base: $e.rgsabound[$r].lLbound
|
||
|
),
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
#case 0x12 ; VT_UI2 | VT_ARRAY
|
||
|
(
|
||
|
#(
|
||
|
"safearray of UI2 = [",
|
||
|
; output the rank array
|
||
|
#array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
|
||
|
"](",
|
||
|
; output the data elements
|
||
|
#array(
|
||
|
expr: ((unsigned short *)$e.pvData)[$i],
|
||
|
size: $e.rgsabound[$r].cElements,
|
||
|
rank: $e.cDims,
|
||
|
base: $e.rgsabound[$r].lLbound
|
||
|
),
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
#case 0x13 ; VT_UI4 | VT_ARRAY
|
||
|
(
|
||
|
#(
|
||
|
"safearray of UI4 = [",
|
||
|
; output the rank array
|
||
|
#array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
|
||
|
"](",
|
||
|
; output the data elements
|
||
|
#array(
|
||
|
expr: ((unsigned int *)$e.pvData)[$i],
|
||
|
size: $e.rgsabound[$r].cElements,
|
||
|
rank: $e.cDims,
|
||
|
base: $e.rgsabound[$r].lLbound
|
||
|
),
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
#case 0x14 ; VT_I8 | VT_ARRAY
|
||
|
(
|
||
|
#(
|
||
|
"safearray of I8 = [",
|
||
|
; output the rank array
|
||
|
#array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
|
||
|
"](",
|
||
|
; output the data elements
|
||
|
#array(
|
||
|
expr: ((signed __int64 *)$e.pvData)[$i],
|
||
|
size: $e.rgsabound[$r].cElements,
|
||
|
rank: $e.cDims,
|
||
|
base: $e.rgsabound[$r].lLbound
|
||
|
),
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
#case 0x15 ; VT_UI8 | VT_ARRAY
|
||
|
(
|
||
|
#(
|
||
|
"safearray of UI8 = [",
|
||
|
; output the rank array
|
||
|
#array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
|
||
|
"](",
|
||
|
; output the data elements
|
||
|
#array(
|
||
|
expr: ((unsigned __int64 *)$e.pvData)[$i],
|
||
|
size: $e.rgsabound[$r].cElements,
|
||
|
rank: $e.cDims,
|
||
|
base: $e.rgsabound[$r].lLbound
|
||
|
),
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
#case 0x16 ; VT_INT | VT_ARRAY
|
||
|
(
|
||
|
#(
|
||
|
"safearray of INT = [",
|
||
|
; output the rank array
|
||
|
#array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
|
||
|
"](",
|
||
|
; output the data elements
|
||
|
#array(
|
||
|
expr: ((int *)$e.pvData)[$i],
|
||
|
size: $e.rgsabound[$r].cElements,
|
||
|
rank: $e.cDims,
|
||
|
base: $e.rgsabound[$r].lLbound
|
||
|
),
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
#case 0x17 ; VT_UINT | VT_ARRAY
|
||
|
(
|
||
|
#(
|
||
|
"safearray of UINT = [",
|
||
|
; output the rank array
|
||
|
#array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
|
||
|
"](",
|
||
|
; output the data elements
|
||
|
#array(
|
||
|
expr: ((unsigned *)$e.pvData)[$i],
|
||
|
size: $e.rgsabound[$r].cElements,
|
||
|
rank: $e.cDims,
|
||
|
base: $e.rgsabound[$r].lLbound
|
||
|
),
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
#case 0x1e ; VT_LPSTR | VT_ARRAY
|
||
|
(
|
||
|
#(
|
||
|
"safearray of LPSTR = [",
|
||
|
; output the rank array
|
||
|
#array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
|
||
|
"](",
|
||
|
; output the data elements
|
||
|
#array(
|
||
|
expr: ((char **)$e.pvData)[$i],
|
||
|
size: $e.rgsabound[$r].cElements,
|
||
|
rank: $e.cDims,
|
||
|
base: $e.rgsabound[$r].lLbound
|
||
|
),
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
#case 0x1f ; VT_LPWSTR | VT_ARRAY
|
||
|
(
|
||
|
#(
|
||
|
"safearray of LPWSTR = [",
|
||
|
; output the rank array
|
||
|
#array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
|
||
|
"](",
|
||
|
; output the data elements
|
||
|
#array(
|
||
|
expr: ((wchar_t **)$e.pvData)[$i],
|
||
|
size: $e.rgsabound[$r].cElements,
|
||
|
rank: $e.cDims,
|
||
|
base: $e.rgsabound[$r].lLbound
|
||
|
),
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
#case 0x40 ; VT_FILETIME | VT_ARRAY
|
||
|
(
|
||
|
#(
|
||
|
"safearray of FILETIME = [",
|
||
|
; output the rank array
|
||
|
#array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
|
||
|
"](",
|
||
|
; output the data elements
|
||
|
#array(
|
||
|
expr: ((FILETIME *)$e.pvData)[$i],
|
||
|
size: $e.rgsabound[$r].cElements,
|
||
|
rank: $e.cDims,
|
||
|
base: $e.rgsabound[$r].lLbound
|
||
|
),
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
#case 0x47 ; VT_CLIPDATA | VT_ARRAY
|
||
|
(
|
||
|
#(
|
||
|
"safearray of CLIPDATA = [",
|
||
|
; output the rank array
|
||
|
#array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
|
||
|
"](",
|
||
|
; output the data elements
|
||
|
#array(
|
||
|
expr: ((CLIPDATA *)$e.pvData)[$i],
|
||
|
size: $e.rgsabound[$r].cElements,
|
||
|
rank: $e.cDims,
|
||
|
base: $e.rgsabound[$r].lLbound
|
||
|
),
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
#case 0x48 ; VT_CLSID | VT_ARRAY
|
||
|
(
|
||
|
#(
|
||
|
"safearray of CLSID = [",
|
||
|
; output the rank array
|
||
|
#array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
|
||
|
"](",
|
||
|
; output the data elements
|
||
|
#array(
|
||
|
expr: ((CLSID *)$e.pvData)[$i],
|
||
|
size: $e.rgsabound[$r].cElements,
|
||
|
rank: $e.cDims,
|
||
|
base: $e.rgsabound[$r].lLbound
|
||
|
),
|
||
|
")"
|
||
|
)
|
||
|
)
|
||
|
)
|
||
|
#elif ($e.fFeatures & 0x0100) ; FADF_BSTR
|
||
|
(
|
||
|
#("safearray of BSTR = ",#array(expr: $e.rgsabound[$i].cElements, size: $e.cDims) : #("[",$e,"]"), "(", #array(expr: ((wchar_t * *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound ), ")")
|
||
|
)
|
||
|
#elif ($e.fFeatures & 0x0200) ; FADF_UNKNOWN
|
||
|
(
|
||
|
#("safearray of IUnknown* = ",#array(expr: $e.rgsabound[$i].cElements, size: $e.cDims) : #("[",$e,"]"), "(", #array(expr: ((IUnknown *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound ), ")")
|
||
|
)
|
||
|
#elif ($e.fFeatures & 0x0400) ; FADF_DISPATCH
|
||
|
(
|
||
|
#("safearray of IDispatch* = ",#array(expr: $e.rgsabound[$i].cElements, size: $e.cDims) : #("[",$e,"]"), "(", #array(expr: ((IDispatch*)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound ), ")")
|
||
|
)
|
||
|
#elif ($e.fFeatures & 0x0800) ; FADF_VARIANT
|
||
|
(
|
||
|
#("safearray of VARIANT = ",#array(expr: $e.rgsabound[$i].cElements, size: $e.cDims) : #("[",$e,"]"), "(", #array(expr: ((tagVARIANT *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound ), ")")
|
||
|
)
|
||
|
)
|
||
|
children
|
||
|
(
|
||
|
#( ;[actual members]: [$e,!],
|
||
|
#if ($e.fFeatures & 0x0080) ; FADF_HAVEVARTYPE
|
||
|
(
|
||
|
#switch( ((unsigned *)&($e))[-1] ) ; for some reason the VT field is before the SAFEARRAY struct
|
||
|
#case 2 ; VT_I2|VT_ARRAY
|
||
|
(
|
||
|
#array(
|
||
|
expr: ((signed short *)$e.pvData)[$i],
|
||
|
size: $e.rgsabound[$r].cElements,
|
||
|
rank: $e.cDims,
|
||
|
base: $e.rgsabound[$r].lLbound
|
||
|
)
|
||
|
)
|
||
|
#case 3 ; VT_I4|VT_ARRAY
|
||
|
(
|
||
|
#array(
|
||
|
expr: ((signed int *)$e.pvData)[$i],
|
||
|
size: $e.rgsabound[$r].cElements,
|
||
|
rank: $e.cDims,
|
||
|
base: $e.rgsabound[$r].lLbound
|
||
|
)
|
||
|
)
|
||
|
#case 4 ; VT_R4|VT_ARRAY
|
||
|
(
|
||
|
#array(
|
||
|
expr: ((float *)$e.pvData)[$i],
|
||
|
size: $e.rgsabound[$r].cElements,
|
||
|
rank: $e.cDims,
|
||
|
base: $e.rgsabound[$r].lLbound
|
||
|
)
|
||
|
)
|
||
|
#case 5 ; VT_R8|VT_ARRAY
|
||
|
(
|
||
|
#array(
|
||
|
expr: ((double *)$e.pvData)[$i],
|
||
|
size: $e.rgsabound[$r].cElements,
|
||
|
rank: $e.cDims,
|
||
|
base: $e.rgsabound[$r].lLbound
|
||
|
)
|
||
|
)
|
||
|
#case 0x10 ; VT_I1|VT_ARRAY
|
||
|
(
|
||
|
#array(
|
||
|
expr: ((signed char *)$e.pvData)[$i],
|
||
|
size: $e.rgsabound[$r].cElements,
|
||
|
rank: $e.cDims,
|
||
|
base: $e.rgsabound[$r].lLbound
|
||
|
)
|
||
|
)
|
||
|
#case 0x11 ; VT_UI1|VT_ARRAY
|
||
|
(
|
||
|
#array(
|
||
|
expr: ((unsigned char *)$e.pvData)[$i],
|
||
|
size: $e.rgsabound[$r].cElements,
|
||
|
rank: $e.cDims,
|
||
|
base: $e.rgsabound[$r].lLbound
|
||
|
)
|
||
|
)
|
||
|
#case 0x12 ; VT_UI2|VT_ARRAY
|
||
|
(
|
||
|
#array(
|
||
|
expr: ((unsigned short *)$e.pvData)[$i],
|
||
|
size: $e.rgsabound[$r].cElements,
|
||
|
rank: $e.cDims,
|
||
|
base: $e.rgsabound[$r].lLbound
|
||
|
)
|
||
|
)
|
||
|
#case 0x13 ; VT_UI4|VT_ARRAY
|
||
|
(
|
||
|
#array(
|
||
|
expr: ((unsigned int *)$e.pvData)[$i],
|
||
|
size: $e.rgsabound[$r].cElements,
|
||
|
rank: $e.cDims,
|
||
|
base: $e.rgsabound[$r].lLbound
|
||
|
)
|
||
|
)
|
||
|
#case 0x14 ; VT_I8|VT_ARRAY
|
||
|
(
|
||
|
#array(
|
||
|
expr: ((signed __int64 *)$e.pvData)[$i],
|
||
|
size: $e.rgsabound[$r].cElements,
|
||
|
rank: $e.cDims,
|
||
|
base: $e.rgsabound[$r].lLbound
|
||
|
)
|
||
|
)
|
||
|
#case 0x15 ; VT_UI8|VT_ARRAY
|
||
|
(
|
||
|
#array(
|
||
|
expr: ((unsigned __int64 *)$e.pvData)[$i],
|
||
|
size: $e.rgsabound[$r].cElements,
|
||
|
rank: $e.cDims,
|
||
|
base: $e.rgsabound[$r].lLbound
|
||
|
)
|
||
|
)
|
||
|
#case 0x1e ; VT_LPSTR|VT_ARRAY
|
||
|
(
|
||
|
#array(
|
||
|
expr: ((char * *)$e.pvData)[$i],
|
||
|
size: $e.rgsabound[$r].cElements,
|
||
|
rank: $e.cDims,
|
||
|
base: $e.rgsabound[$r].lLbound
|
||
|
)
|
||
|
)
|
||
|
#case 0x1f ; VT_LPWSTR|VT_ARRAY
|
||
|
(
|
||
|
#array(
|
||
|
expr: ((wchar_t **)$e.pvData)[$i],
|
||
|
size: $e.rgsabound[$r].cElements,
|
||
|
rank: $e.cDims,
|
||
|
base: $e.rgsabound[$r].lLbound
|
||
|
)
|
||
|
)
|
||
|
#case 0xc ; VT_VARIANT|VT_ARRAY
|
||
|
(
|
||
|
#array(
|
||
|
expr: ((tagVARIANT *)$e.pvData)[$i],
|
||
|
size: $e.rgsabound[$r].cElements,
|
||
|
rank: $e.cDims,
|
||
|
base: $e.rgsabound[$r].lLbound
|
||
|
)
|
||
|
)
|
||
|
#case 0xb ; VT_BOOL|VT_ARRAY
|
||
|
(
|
||
|
#array(
|
||
|
expr: ((short *)$e.pvData)[$i],
|
||
|
size: $e.rgsabound[$r].cElements,
|
||
|
rank: $e.cDims,
|
||
|
base: $e.rgsabound[$r].lLbound
|
||
|
)
|
||
|
)
|
||
|
#case 0xa ; VT_ERROR|VT_ARRAY
|
||
|
(
|
||
|
#array(
|
||
|
expr: ((long *)$e.pvData)[$i],
|
||
|
size: $e.rgsabound[$r].cElements,
|
||
|
rank: $e.cDims,
|
||
|
base: $e.rgsabound[$r].lLbound
|
||
|
)
|
||
|
)
|
||
|
#case 6 ; VT_CY|VT_ARRAY
|
||
|
(
|
||
|
#array(
|
||
|
expr: ((CY *)$e.pvData)[$i],
|
||
|
size: $e.rgsabound[$r].cElements,
|
||
|
rank: $e.cDims,
|
||
|
base: $e.rgsabound[$r].lLbound
|
||
|
)
|
||
|
)
|
||
|
#case 7 ; VT_DATE|VT_ARRAY
|
||
|
(
|
||
|
#array(
|
||
|
expr: ((DATE *)$e.pvData)[$i],
|
||
|
size: $e.rgsabound[$r].cElements,
|
||
|
rank: $e.cDims,
|
||
|
base: $e.rgsabound[$r].lLbound
|
||
|
)
|
||
|
)
|
||
|
#case 0x40 ; VT_FILETIME|VT_ARRAY
|
||
|
(
|
||
|
#array(
|
||
|
expr: ((FILETIME *)$e.pvData)[$i],
|
||
|
size: $e.rgsabound[$r].cElements,
|
||
|
rank: $e.cDims,
|
||
|
base: $e.rgsabound[$r].lLbound
|
||
|
)
|
||
|
)
|
||
|
#case 0x48 ; VT_CLSID|VT_ARRAY
|
||
|
(
|
||
|
#array(
|
||
|
expr: ((CLSID *)$e.pvData)[$i],
|
||
|
size: $e.rgsabound[$r].cElements,
|
||
|
rank: $e.cDims,
|
||
|
base: $e.rgsabound[$r].lLbound
|
||
|
)
|
||
|
)
|
||
|
#case 0x47 ; VT_CF|VT_ARRAY
|
||
|
(
|
||
|
#array(
|
||
|
expr: ((CLIPDATA *)$e.pvData)[$i],
|
||
|
size: $e.rgsabound[$r].cElements,
|
||
|
rank: $e.cDims,
|
||
|
base: $e.rgsabound[$r].lLbound
|
||
|
)
|
||
|
)
|
||
|
#case 8 ; VT_BSTR|VT_ARRAY
|
||
|
(
|
||
|
#array(
|
||
|
expr: ((wchar_t * *)$e.pvData)[$i],
|
||
|
size: $e.rgsabound[$r].cElements,
|
||
|
rank: $e.cDims,
|
||
|
base: $e.rgsabound[$r].lLbound
|
||
|
)
|
||
|
)
|
||
|
#case 0x16 ; VT_INT|VT_ARRAY
|
||
|
(
|
||
|
#array(
|
||
|
expr: ((int *)$e.pvData)[$i],
|
||
|
size: $e.rgsabound[$r].cElements,
|
||
|
rank: $e.cDims,
|
||
|
base: $e.rgsabound[$r].lLbound
|
||
|
)
|
||
|
)
|
||
|
#case 0x17 ; VT_UINT|VT_ARRAY
|
||
|
(
|
||
|
#array(
|
||
|
expr: ((unsigned int*)$e.pvData)[$i],
|
||
|
size: $e.rgsabound[$r].cElements,
|
||
|
rank: $e.cDims,
|
||
|
base: $e.rgsabound[$r].lLbound
|
||
|
)
|
||
|
)
|
||
|
#default
|
||
|
(
|
||
|
#([actual members]: [$e,!])
|
||
|
)
|
||
|
#except
|
||
|
(
|
||
|
#([actual members]: [$e,!])
|
||
|
)
|
||
|
)
|
||
|
#elif ($e.fFeatures & 0x0100) ; FADF_BSTR
|
||
|
(
|
||
|
#array(expr: ((wchar_t * *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound )
|
||
|
)
|
||
|
#elif ($e.fFeatures & 0x0200) ; FADF_UNKNOWN
|
||
|
(
|
||
|
#array(expr: ((IUnknown *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound )
|
||
|
)
|
||
|
#elif ($e.fFeatures & 0x0400) ; FADF_DISPATCH
|
||
|
(
|
||
|
#array(expr: ((IDispatch *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound )
|
||
|
)
|
||
|
#elif ($e.fFeatures & 0x0800) ; FADF_VARIANT
|
||
|
(
|
||
|
#array(expr: ((tagVARIANT *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.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_UNKOWN
|
||
|
#case 0xE ( #("DECIMAL = ", $e.decVal) ) ; 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 = ", *(__int64*)&$e.dblVal) ) ; VT_I8
|
||
|
#case 0x15 ( #("UI8 = ", *(unsigned __int64*)&$e.dblVal) ) ; 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 0x4014 ( #("byref of I8 = ", (__int64*)$e.pdblVal) ) ; VT_I8|VT_BYREF
|
||
|
#case 0x4015 ( #("byref of UI8 = ", (unsigned __int64*)$e.pudblVal) ) ; VT_UI8|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_UNKOWN|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_UNKOWN
|
||
|
#case 0xE ( #(DECIMAL : $e.decVal) ) ; 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 : *(__int64*)&$e.dblVal) ) ; VT_I8
|
||
|
#case 0x15 ( #(UI8 : *(unsigned __int64*)&$e.dblVal) ) ; 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 0x4014 ( #(byref of I8 : (__int64*)$e.pdblVal) ) ; VT_I8|VT_BYREF
|
||
|
#case 0x4015 ( #(byref of UI8 : (unsigned __int64*)$e.pdblVal) ) ; VT_UI8|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_UNKOWN|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
|
||
|
|