可以参考这个网址
https://blog.csdn.net/u011822862/article/details/51952677
但是在vs2017的安装目录下并没有发现该文件，正好自己安装过vs2010，于是从vs2010同名目录下考虑了vs2017。
现在直接把全部内容复制在下面，没有的同志可以直接新建一个autoexp.dat的文件就可以了。
; AutoExp.Dat - templates for automatically expanding data ; Copyright(c) Microsoft Corporation. All Rights Reserved. ;--------------------------------------------------------------- ; ; While debugging, Data Tips and items in the Watch and Variable ; windows are automatically expanded to show their most important ; elements. The expansion follows the format given by the rules ; in this file. You can add rules for your types or change the ; predefined rules. ; ; For good examples, read the rules in this file. ; ; To find what the debugger considers the type of a variable to ; be, add it to the Watch window and look at the Type column. ; ; An AutoExpand rule is a line with the name of a type, an equals ; sign, and text with replaceable parts in angle brackets. The ; part in angle brackets names a member of the type and an ; optional Watch format specifier. ; ; AutoExpand rules use the following syntax. The equals sign (=), ; angle brackets (<>), and comma are taken literally. Square ; brackets ([]) indicate optional items. ; ; type=[text]<member[,format]>... ; ; type Name of the type (may be followed by <*> for template ; types such as the ATL types listed below). ; ; text Any text.Usually the name of the member to display, ; or a shorthand name for the member. ; ; member Name of a member to display. ; ; format Watch format specifier. One of the following: ; ; Letter Description Sample Display ; ------ -------------------------- ------------ ------------- ; d,i Signed decimal integer 0xF000F065,d -268373915 ; u Unsigned decimal integer 0x0065,u 101 ; o Unsigned octal integer 0xF065,o 0170145 ; x,X Hexadecimal integer 61541,X 0X0000F065 ; l,h long or short prefix for 00406042,hx 0x0c22 ; d, i, u, o, x, X ; f Signed floating-point 3./2.,f 1.500000 ; e Signed scientific-notation 3./2.,e 1.500000e+000 ; g Shorter of e and f 3./2.,g 1.5 ; c Single character 0x0065,c 'e' ; s Zero-terminated string pVar,s "Hello world" ; su Unicode string pVar,su "Hello world" ; ; For details of other format specifiers see Help under: ; "format specifiers/watch variable" ; ; The special format <,t> specifies the name of the most-derived ; type of the object. This is especially useful with pointers or ; references to a base class. ; ; If there is no rule for a class, the base classes are checked for ; a matching rule. ; ; There are some special entries allowed in the AutoExpand section: ; $BUILTIN is used to display more complex types that need to do more ; than just show a member variable or two. ; $ADDIN allows external DLLs to be added to display even more complex ; types via the EE Add-in API. The first argument is the DLL name, the ; second argument is the name of the export from the DLL to use. For ; further information on this API see the sample called EEAddIn. ; ; WARNING: if hexadecimal mode is on in the watch window, all numbers here are ; evaluated in hex, e.g. 42 becomes 0x42 [AutoExpand] ;QT_DEBUG_START (Qt5 Visual Studio Add-in v1.2.5) 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> ;QT_DEBUG_END ; 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) [Visualizer] ;QT_DEBUG_START (Qt5 Visual Studio Add-in v1.2.5) ; The Qt Company Ltd. Qt 5.x visualizers -----------------------------------------[ start ]-- ;------------------------------------------------------------------------------ ; Feel free to modify these visualizers to suit yours needs! But please let us ; know about the changes you make, so we continuously improve the visualizers. ; Qt4 ;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 ; ) ; ) ;} ; Qt4 ;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 ; ) ; ) ;} ; Qt5 QString|*::QString{ preview ([(unsigned short*)$e.d + $e.d->offset/2,su]) stringview ([(unsigned short*)$e.d + $e.d->offset/2,sub]) children ( #( d: $c.d, [size]: $c.d->size, [referenced]: $c.d->ref.atomic._q_value ) ) } ; Qt5 QByteArray|*::QByteArray{ preview ([(char*)$e.d + $e.d->offset,s]) stringview ([(char*)$e.d + $e.d->offset,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 ) ) ) } ;------------------------------------------------------------------------------ ; The Qt Company Ltd. Qt 5.x visualizers -------------------------------------------[ end ]-- ;QT_DEBUG_END ; 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 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::pair from <utility> ;------------------------------------------------------------------------------ std::pair<*>{ ; pair is previewed with "(<first>, <second>)". preview ( #( "(", $e.first, ", ", $e.second, ")" ) ) ; We gloss over the fact that first and second are actually stored in _Pair_base. children ( #( #(first : $e.first), #(second : $e.second) ) ) } ;------------------------------------------------------------------------------ ; std::plus, etc. from <functional> ;------------------------------------------------------------------------------ ; 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) ) } ;------------------------------------------------------------------------------ ; std::not1() from <functional> ; std::not2() from <functional> ;------------------------------------------------------------------------------ ; 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) ) } ;------------------------------------------------------------------------------ ; std::bind1st() from <functional> ; std::bind2nd() from <functional> ;------------------------------------------------------------------------------ ; STL binders are previewed with "bind1st(<op>, <value>)" or "bind2nd(<op>, <value>)". ; We gloss over the fact that they derive from unary_function. std::binder1st<*>{ preview ( #( "bind1st(", $e.op, ", ", $e.value, ")" ) ) children ( #( #(op : $e.op), #(value : $e.value) ) ) } std::binder2nd<*>{ preview ( #( "bind2nd(", $e.op, ", ", $e.value, ")" ) ) children ( #( #(op : $e.op), #(value : $e.value) ) ) } ;------------------------------------------------------------------------------ ; std::ptr_fun() from <functional> ;------------------------------------------------------------------------------ ; 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) ) } ;------------------------------------------------------------------------------ ; std::mem_fun() from <functional> ; std::mem_fun_ref() from <functional> ;------------------------------------------------------------------------------ ; See ptr_fun(). std::mem_fun_t<*>|std::mem_fun1_t<*>|std::const_mem_fun_t<*>|std::const_mem_fun1_t<*>{ preview ( #( "mem_fun(", $e._Pmemfun, ")" ) ) children ( #array(expr: 0, size: 0) ) } std::mem_fun_ref_t<*>|std::mem_fun1_ref_t<*>|std::const_mem_fun_ref_t<*>|std::const_mem_fun1_ref_t<*>{ preview ( #( "mem_fun_ref(", $e._Pmemfun, ")" ) ) children ( #array(expr: 0, size: 0) ) } ;------------------------------------------------------------------------------ ; std::auto_ptr from <memory> ;------------------------------------------------------------------------------ std::auto_ptr<*>{ ; An empty auto_ptr is previewed with "empty". ; Otherwise, it is previewed with "auto_ptr <object>". preview ( #if ($e._Myptr == 0) ( "empty" ) #else ( #( "auto_ptr ", *$e._Myptr ) ) ) ; An empty auto_ptr has no children. ; Otherwise, it has a single child, its stored pointer, with a fake name of [ptr]. children ( #if ($e._Myptr == 0) ( #array(expr: 0, size: 0) ) #else ( #([ptr] : $e._Myptr) ) ) } ;------------------------------------------------------------------------------ ; std::basic_string from <string> ;------------------------------------------------------------------------------ ; basic_string is previewed with its stored string. ; It has [size] and [capacity] children, followed by [0], [1], [2], etc. children ; displaying its stored characters. ; The ($e._Myres) < ($e._BUF_SIZE) test determines whether the Small String Optimization ; is in effect. ; NOTE: The parentheses in ($e._Myres) < ($e._BUF_SIZE) are necessary. 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 ( #( #([size] : $e._Mysize), #([capacity] : $e._Myres), #if (($e._Myres) < ($e._BUF_SIZE)) ( #array(expr: $e._Bx._Buf[$i], size: $e._Mysize) ) #else ( #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 ( #( #([size] : $e._Mysize), #([capacity] : $e._Myres), #if (($e._Myres) < ($e._BUF_SIZE)) ( #array(expr: $e._Bx._Buf[$i], size: $e._Mysize) ) #else ( #array(expr: $e._Bx._Ptr[$i], size: $e._Mysize) ) ) ) } std::_String_iterator<char,*>|std::_String_const_iterator<char,*>{ preview ( [$e._Ptr,s] ) stringview ( [$e._Ptr,sb] ) children ( #([ptr] : $e._Ptr) ) } std::_String_iterator<unsigned short,*>|std::_String_const_iterator<unsigned short,*>|std::_String_iterator<wchar_t,*>|std::_String_const_iterator<wchar_t,*>{ preview ( [$e._Ptr,su] ) stringview ( [$e._Ptr,sub] ) children ( #([ptr] : $e._Ptr) ) } ;------------------------------------------------------------------------------ ; std::vector<bool> from <vector> ;------------------------------------------------------------------------------ ; Despite its packed representation, vector<bool> is visualized like vector<T>. std::vector<bool,*>{ preview ( #( "[", $e._Mysize, "](", #array( expr: (bool)(($e._Myvec._Myfirst[$i / _VBITS] >> ($i % _VBITS)) & 1), size: $e._Mysize ), ")" ) ) children ( #( #([size] : $e._Mysize), #([capacity] : ($e._Myvec._Myend - $e._Myvec._Myfirst) * _VBITS), #array( expr: (bool)(($e._Myvec._Myfirst[$i / _VBITS] >> ($i % _VBITS)) & 1), size: $e._Mysize ) ) ) } std::_Vb_reference<*>|std::_Vb_iterator<*>|std::_Vb_const_iterator<*>{ preview ( (bool)((*$e._Myptr >> $e._Myoff) & 1) ) children ( #( #([ptr] : $e._Myptr), #([offset] : $e._Myoff) ) ) } ;------------------------------------------------------------------------------ ; std::vector from <vector> ;------------------------------------------------------------------------------ ; vector is previewed with "[<size>](<elements>)". ; It has [size] and [capacity] children, followed by its elements. ; The other containers follow its example. std::vector<*>{ preview ( #( "[", $e._Mylast - $e._Myfirst, "](", #array( expr: $e._Myfirst[$i], size: $e._Mylast - $e._Myfirst ), ")" ) ) children ( #( #([size] : $e._Mylast - $e._Myfirst), #([capacity] : $e._Myend - $e._Myfirst), #array( expr: $e._Myfirst[$i], size: $e._Mylast - $e._Myfirst ) ) ) } std::_Vector_iterator<*>|std::_Vector_const_iterator<*>{ preview ( *$e._Ptr ) children ( #([ptr] : $e._Ptr) ) } ;------------------------------------------------------------------------------ ; std::deque from <deque> ;------------------------------------------------------------------------------ std::deque<*>{ preview ( #( "[", $e._Mysize, "](", #array( expr: $e._Map[(($i + $e._Myoff) / $e._EEN_DS) % $e._Mapsize][($i + $e._Myoff) % $e._EEN_DS], size: $e._Mysize ), ")" ) ) children ( #( #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_const_iterator<*,*>{ preview ( #if ($e._Myoff >= ((std::deque<$T1,$T2> *)$e._Myproxy->_Mycont)->_Myoff + ((std::deque<$T1,$T2> *)$e._Myproxy->_Mycont)->_Mysize) ( "end" ) #else ( ((std::deque<$T1,$T2> *)$e._Myproxy->_Mycont)->_Map[($e._Myoff / ((std::deque<$T1,$T2> *)$e._Myproxy->_Mycont)->_EEN_DS) % ((std::deque<$T1,$T2> *)$e._Myproxy->_Mycont)->_Mapsize][$e._Myoff % ((std::deque<$T1,$T2> *)$e._Myproxy->_Mycont)->_EEN_DS] ) ) children ( #if ($e._Myoff >= ((std::deque<$T1,$T2> *)$e._Myproxy->_Mycont)->_Myoff + ((std::deque<$T1,$T2> *)$e._Myproxy->_Mycont)->_Mysize) ( #array(expr: 0, size: 0) ) #else ( #( #([index] : $e._Myoff - ((std::deque<$T1,$T2> *)$e._Myproxy->_Mycont)->_Myoff), #([ptr] : &((std::deque<$T1,$T2> *)$e._Myproxy->_Mycont)->_Map[($e._Myoff / ((std::deque<$T1,$T2> *)$e._Myproxy->_Mycont)->_EEN_DS) % ((std::deque<$T1,$T2> *)$e._Myproxy->_Mycont)->_Mapsize][$e._Myoff % ((std::deque<$T1,$T2> *)$e._Myproxy->_Mycont)->_EEN_DS] ) ) ) ) } ;------------------------------------------------------------------------------ ; std::list from <list> ;------------------------------------------------------------------------------ std::list<*>{ preview ( #( "[", $e._Mysize, "](", #list( head: $e._Myhead->_Next, size: $e._Mysize, next: _Next ) : $e._Myval, ")" ) ) children ( #list( head: $e._Myhead->_Next, size: $e._Mysize, next: _Next ) : $e._Myval ) } std::_List_iterator<*>|std::_List_const_iterator<*>{ preview ( $e._Ptr->_Myval ) children ( #([ptr] : &$e._Ptr->_Myval) ) } ;------------------------------------------------------------------------------ ; std::queue from <queue> ; std::stack from <stack> ;------------------------------------------------------------------------------ std::queue<*>|std::stack<*>{ preview ( $e.c ) children ( #(c : $e.c) ) } ;------------------------------------------------------------------------------ ; std::priority_queue from <queue> ;------------------------------------------------------------------------------ std::priority_queue<*>{ preview ( $e.c ) children ( #( #(c [heap]: $e.c), #(comp : $e.comp) ) ) } ;------------------------------------------------------------------------------ ; std::map from <map> ; std::multimap from <map> ; std::set from <set> ; std::multiset from <set> ;------------------------------------------------------------------------------ std::map<*>|std::multimap<*>|std::set<*>|std::multiset<*>{ preview ( #( "[", $e._Mysize, "](", #tree( head: $e._Myhead->_Parent, skip: $e._Myhead, left: _Left, right: _Right, size: $e._Mysize ) : $e._Myval, ")" ) ) children ( #( #([comp] : $e.comp), #tree( head: $e._Myhead->_Parent, skip: $e._Myhead, left: _Left, right: _Right, size: $e._Mysize ) : $e._Myval ) ) } std::_Tree_iterator<*>|std::_Tree_const_iterator<*>{ preview ( $e._Ptr->_Myval ) children ( #([ptr] : &$e._Ptr->_Myval) ) } ;------------------------------------------------------------------------------ ; std::bitset from <bitset> ;------------------------------------------------------------------------------ std::bitset<*>{ preview ( #( "[", $e._EEN_BITS, "](", #array( expr: [($e._Array[$i / $e._Bitsperword] >> ($i % $e._Bitsperword)) & 1,d], size: $e._EEN_BITS ), ")" ) ) children ( #array( expr: [($e._Array[$i / $e._Bitsperword] >> ($i % $e._Bitsperword)) & 1,d], size: $e._EEN_BITS ) ) } std::bitset<*>::reference{ preview ( [($e._Pbitset->_Array[$i / $e._Pbitset->_Bitsperword] >> ($e._Mypos % $e._Pbitset->_Bitsperword)) & 1,d] ) children ( #( #([bitset] : $e._Pbitset), #([pos] : $e._Mypos) ) ) } ;------------------------------------------------------------------------------ ; std::reverse_iterator from <iterator> ;------------------------------------------------------------------------------ std::reverse_iterator<std::_String_iterator<*> >|std::reverse_iterator<std::_String_const_iterator<*> >{ preview ( #( "reverse_iterator to ", $e.current._Ptr[-1] ) ) children ( #( #([to] : $e.current._Ptr - 1), #(current : $e.current) ) ) } std::reverse_iterator<std::_Vb_iterator<*> >|std::reverse_iterator<std::_Vb_const_iterator<*> >{ preview ( #( "reverse_iterator to ", #if ($e.current._Myoff != 0) ( (bool)((*$e.current._Myptr >> ($e.current._Myoff - 1)) & 1) ) #else ( (bool)(($e.current._Myptr[-1] >> (_VBITS - 1)) & 1) ) ) ) children ( #if ($e.current._Myoff != 0) ( #( #([to ptr] : $e.current._Myptr), #([to offset] : $e.current._Myoff - 1), #(current : $e.current) ) ) #else ( #( #([to ptr] : $e.current._Myptr - 1), #([to offset] : _VBITS - 1), #(current : $e.current) ) ) ) } std::reverse_iterator<std::_Vector_iterator<*> >|std::reverse_iterator<std::_Vector_const_iterator<*> >{ preview ( #( "reverse_iterator to ", $e.current._Ptr[-1] ) ) children ( #( #([to] : $e.current._Ptr - 1), #(current : $e.current) ) ) } std::reverse_iterator<std::_Deque_iterator<*,*> >|std::reverse_iterator<std::_Deque_const_iterator<*,*> >{ preview ( #( "reverse_iterator to ", #if ($e.current._Myoff == ((std::deque<$T1,$T2> *)$e.current._Myproxy->_Mycont)->_Myoff) ( "end" ) #else ( ((std::deque<$T1,$T2> *)$e.current._Myproxy->_Mycont)->_Map[(($e.current._Myoff - 1) / ((std::deque<$T1,$T2> *)$e.current._Myproxy->_Mycont)->_EEN_DS) % ((std::deque<$T1,$T2> *)$e.current._Myproxy->_Mycont)->_Mapsize][($e.current._Myoff - 1) % ((std::deque<$T1,$T2> *)$e.current._Myproxy->_Mycont)->_EEN_DS] ) ) ) children ( #if ($e.current._Myoff == ((std::deque<$T1,$T2> *)$e.current._Myproxy->_Mycont)->_Myoff) ( #(current : $e.current) ) #else ( #( #([to index] : ($e.current._Myoff - 1) - ((std::deque<$T1,$T2> *)$e.current._Myproxy->_Mycont)->_Myoff), #([to ptr] : &((std::deque<$T1,$T2> *)$e.current._Myproxy->_Mycont)->_Map[(($e.current._Myoff - 1) / ((std::deque<$T1,$T2> *)$e.current._Myproxy->_Mycont)->_EEN_DS) % ((std::deque<$T1,$T2> *)$e.current._Myproxy->_Mycont)->_Mapsize][($e.current._Myoff - 1) % ((std::deque<$T1,$T2> *)$e.current._Myproxy->_Mycont)->_EEN_DS] ), #(current : $e.current) ) ) ) } std::reverse_iterator<std::_List_iterator<*> >|std::reverse_iterator<std::_List_const_iterator<*> >{ preview ( #( "reverse_iterator to ", $e.current._Ptr->_Prev->_Myval ) ) children ( #( #([to] : &$e.current._Ptr->_Prev->_Myval), #(current : $e.current) ) ) } std::reverse_iterator<std::_Array_iterator<*> >|std::reverse_iterator<std::_Array_const_iterator<*> >{ preview ( #( "reverse_iterator to ", #if ($e.current._EEN_IDL == 0) ( $e.current._Ptr[-1] ) #else ( #if ($e.current._Idx == 0) ( "end" ) #else ( $e.current._Ptr[$e.current._Idx - 1] ) ) ) ) children ( #if ($e.current._EEN_IDL == 0) ( #( #([to] : $e.current._Ptr - 1), #(current : $e.current) ) ) #else ( #if ($e.current._Idx == 0) ( #(current : $e.current) ) #else ( #( #([to] : $e.current._Ptr + $e.current._Idx - 1), #(current : $e.current) ) ) ) ) } std::reverse_iterator<*>{ preview ( #( "reverse_iterator current ", $e.current ) ) children ( #(current : $e.current) ) } ;------------------------------------------------------------------------------ ; std::complex from <complex> ;------------------------------------------------------------------------------ std::complex<*>{ preview ( #if ($e._Val[1] == 0) ( ; Purely real. $e._Val[0] ) #else ( #if ($e._Val[0] == 0) ( ; Purely imaginary. #if ($e._Val[1] < 0) ( #("-i*", -$e._Val[1]) ) #else ( #("i*", $e._Val[1]) ) ) #else ( ; Mixed. #if ($e._Val[1] < 0) ( #($e._Val[0], "-i*", -$e._Val[1]) ) #else ( #($e._Val[0], "+i*", $e._Val[1]) ) ) ) ) children ( #( #(real : $e._Val[0]), #(imag : $e._Val[1]) ) ) } ;------------------------------------------------------------------------------ ; std::valarray from <valarray> ;------------------------------------------------------------------------------ std::valarray<*>{ preview ( #( "[", $e._Mysize, "](", #array( expr: $e._Myptr[$i], size: $e._Mysize ), ")" ) ) children ( #array( expr: $e._Myptr[$i], size: $e._Mysize ) ) } ;------------------------------------------------------------------------------ ; std::tr1::reference_wrapper from <functional> ;------------------------------------------------------------------------------ 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 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 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 from <memory> ;------------------------------------------------------------------------------ std::tr1::_Ref_count<*>{ preview ( "default" ) children ( #array(expr: 0, size: 0) ) } std::tr1::_Ref_count_del<*>{ preview ( "custom deleter" ) children ( #([deleter] : $e._Dtor) ) } std::tr1::_Ref_count_del_alloc<*>{ preview ( "custom deleter, custom allocator" ) children ( #( #([deleter] : $e._Dtor), #([allocator] : $e._Myal) ) ) } std::tr1::_Ref_count_obj<*>{ preview ( "make_shared" ) children ( #array(expr: 0, size: 0) ) } std::tr1::_Ref_count_obj_alloc<*>{ preview ( "allocate_shared" ) children ( #([allocator] : $e._Myal) ) } 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") ) ), "] [", *$e._Rep, "]" ) ; 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 two children: ; Its stored pointer, with a fake name of [ptr]. #([ptr] : $e._Ptr), ; Its deleter and allocator, which may be default or custom. #([deleter and allocator] : *$e._Rep) ) ) ) } ;------------------------------------------------------------------------------ ; std::tr1::weak_ptr from <memory> ;------------------------------------------------------------------------------ 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 [", *$e._Rep, "]" ) ) #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") ) ), "] [", *$e._Rep, "]" ) ) ) children ( #if ($e._Ptr == 0) ( #array(expr: 0, size: 0) ) #elif ($e._Rep->_Uses == 0) ( ; When a weak_ptr is expired, we show its deleter and allocator. ; The deleter has already been used, but the control block has not yet been deallocated. #([deleter and allocator] : *$e._Rep) ) #else ( #( #([ptr] : $e._Ptr), #([deleter and allocator] : *$e._Rep) ) ) ) } ;------------------------------------------------------------------------------ ; std::tr1::mem_fn() from <functional> ;------------------------------------------------------------------------------ ; 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 "mem_fn(<stored member function pointer>)". #( "mem_fn(", $e._Callee._Object, ")" ) ) children ( ; Member function pointers have no children. #array(expr: 0, size: 0) ) } ;------------------------------------------------------------------------------ ; std::tr1::bind() from <functional> ;------------------------------------------------------------------------------ ; 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::_Bind0<*> >|std::tr1::_Bind_fty<*,*,std::tr1::_Bind0<*> >{ preview ( #( "bind(", $e._Bx._Callee._Object, ")" ) ) children ( #( #([f] : $e._Bx._Callee._Object) ) ) } std::tr1::_Bind<*,*,std::tr1::_Bind1<*> >|std::tr1::_Bind_fty<*,*,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::_Bind2<*> >|std::tr1::_Bind_fty<*,*,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::_Bind3<*> >|std::tr1::_Bind_fty<*,*,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::_Bind4<*> >|std::tr1::_Bind_fty<*,*,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::_Bind5<*> >|std::tr1::_Bind_fty<*,*,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::_Bind6<*> >|std::tr1::_Bind_fty<*,*,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::_Bind7<*> >|std::tr1::_Bind_fty<*,*,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::_Bind8<*> >|std::tr1::_Bind_fty<*,*,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::_Bind9<*> >|std::tr1::_Bind_fty<*,*,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::_Bind10<*> >|std::tr1::_Bind_fty<*,*,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) ) ) } ;------------------------------------------------------------------------------ ; std::tr1::function from <functional> ;------------------------------------------------------------------------------ std::tr1::_Impl_no_alloc0<*>|std::tr1::_Impl_no_alloc1<*>|std::tr1::_Impl_no_alloc2<*>|std::tr1::_Impl_no_alloc3<*>|std::tr1::_Impl_no_alloc4<*>|std::tr1::_Impl_no_alloc5<*>|std::tr1::_Impl_no_alloc6<*>|std::tr1::_Impl_no_alloc7<*>|std::tr1::_Impl_no_alloc8<*>|std::tr1::_Impl_no_alloc9<*>|std::tr1::_Impl_no_alloc10<*>{ preview ( $e._Callee._Object ) children ( #([functor] : $e._Callee._Object) ) } std::tr1::_Impl0<*>|std::tr1::_Impl1<*>|std::tr1::_Impl2<*>|std::tr1::_Impl3<*>|std::tr1::_Impl4<*>|std::tr1::_Impl5<*>|std::tr1::_Impl6<*>|std::tr1::_Impl7<*>|std::tr1::_Impl8<*>|std::tr1::_Impl9<*>|std::tr1::_Impl10<*>{ preview ( $e._Callee._Object ) children ( #( #([functor] : $e._Callee._Object), #([allocator] : $e._Myal) ) ) } std::tr1::function<*>{ preview ( #if ($e._Impl == 0) ( ; Detecting empty functions is trivial. "empty" ) #else ( *$e._Impl ) ) children ( #if ($e._Impl == 0) ( ; We make empty functions appear to have no children. #array(expr: 0, size: 0) ) #else ( #([functor and allocator] : *$e._Impl) ) ) } ;------------------------------------------------------------------------------ ; std::tr1::tuple from <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 from <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::_Array_iterator<*>|std::_Array_const_iterator<*>{ preview ( #if ($e._EEN_IDL == 0) ( *$e._Ptr ) #else ( #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._EEN_IDL == 0) ( #([ptr] : $e._Ptr) ) #else ( #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) ) ) ) } ;------------------------------------------------------------------------------ ; stdext::hash_map from <hash_map> ; stdext::hash_multimap from <hash_map> ; stdext::hash_set from <hash_set> ; stdext::hash_multiset from <hash_set> ;------------------------------------------------------------------------------ stdext::hash_map<*>|stdext::hash_multimap<*>|stdext::hash_set<*>|stdext::hash_multiset<*>{ 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::tr1::unordered_map from <unordered_map> ; std::tr1::unordered_multimap from <unordered_map> ; std::tr1::unordered_set from <unordered_set> ; std::tr1::unordered_multiset from <unordered_set> ;------------------------------------------------------------------------------ std::hash<*>{ preview ( "hash" ) children ( #array(expr: 0, size: 0) ) } std::tr1::unordered_map<*>|std::tr1::unordered_multimap<*>|std::tr1::unordered_set<*>|std::tr1::unordered_multiset<*>{ preview ( #( "[", $e._List._Mysize, "](", #list( head: $e._List._Myhead->_Next, size: $e._List._Mysize, next: _Next ) : $e._Myval, ")" ) ) children ( #( #([hash] : $e.comp._Hashobj), #([equal] : $e.comp._Keyeqobj), #list( head: $e._List._Myhead->_Next, size: $e._List._Mysize, next: _Next ) : $e._Myval ) ) } ;------------------------------------------------------------------------------ ; std::tr1::basic_regex from <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 from <regex> ;------------------------------------------------------------------------------ std::tr1::sub_match<char const *>|std::tr1::sub_match<wchar_t const *>|std::tr1::sub_match<unsigned short const *>|std::tr1::sub_match<char *>|std::tr1::sub_match<wchar_t *>|std::tr1::sub_match<unsigned short *>{ 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<*> >|std::tr1::sub_match<std::_String_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._Ptr - $e.first._Ptr ) #else ( "false" ) ) children ( #( #(matched : $e.matched), #(first : $e.first), #(second : $e.second) ) ) } ;------------------------------------------------------------------------------ ; std::tr1::match_results from <regex> ;------------------------------------------------------------------------------ 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::regex_iterator from <regex> ;------------------------------------------------------------------------------ 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 from <regex> ;------------------------------------------------------------------------------ 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::identity, etc. from <functional> ;------------------------------------------------------------------------------ std::identity<*>{ preview ( "identity" ) children ( #array(expr: 0, size: 0) ) } std::bit_and<*>{ preview ( "bit_and" ) children ( #array(expr: 0, size: 0) ) } std::bit_or<*>{ preview ( "bit_or" ) children ( #array(expr: 0, size: 0) ) } std::bit_xor<*>{ preview ( "bit_xor" ) children ( #array(expr: 0, size: 0) ) } ;------------------------------------------------------------------------------ ; std::unique_ptr from <memory> ;------------------------------------------------------------------------------ std::unique_ptr<*>{ preview ( #if ($e._Myptr == 0) ( "empty" ) #else ( #( "unique_ptr ", *$e._Myptr ) ) ) children ( #if ($e._Myptr == 0) ( #array(expr: 0, size: 0) ) #else ( #([ptr] : $e._Myptr) ) ) } ;------------------------------------------------------------------------------ ; std::forward_list from <forward_list> ;------------------------------------------------------------------------------ std::forward_list<*>{ preview ( #( "(", #list( head: $e._Myhead, next: _Next ) : $e._Myval, ")" ) ) children ( #list( head: $e._Myhead, next: _Next ) : $e._Myval ) } std::_Flist_iterator<*>|std::_Flist_const_iterator<*>{ preview ( #if ($e._Ptr == 0) ( "end" ) #else ( $e._Ptr->_Myval ) ) children ( #if ($e._Ptr == 0) ( #array(expr: 0, size: 0) ) #else ( #([ptr] : &$e._Ptr->_Myval) ) ) } ;------------------------------------------------------------------------------ ; 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), "](", #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), "](", #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 ) ) ) ) } ; Visualizers for data structures in namespace Concurrency ;------------------------------------------------------------------------------ ; Concurrency::message from <agents.h> ;------------------------------------------------------------------------------ Concurrency::message<*>{ preview ( #( $e.payload ) ) children ( #( #(payload: $e.payload), #([msg_id]: $e._M_id) ) ) } ;------------------------------------------------------------------------------ ; Concurrency::multi_link_registry from <agents.h> ;------------------------------------------------------------------------------ Concurrency::multi_link_registry<*>{ preview ( #( "[", $e._M_vector._M_index, "](", #array( expr: *($e._M_vector._M_array[$i]), size: $e._M_vector._M_index ), ")" ) ) children ( #( #([size]: $e._M_vector._M_index), #array( expr: *($e._M_vector._M_array[$i]), size: $e._M_vector._M_index ) ) ) } ;------------------------------------------------------------------------------ ; Concurrency::details::_Queue from <agents.h> ;------------------------------------------------------------------------------ Concurrency::details::_Queue<*>{ preview ( #( "[", $e._M_count, "](", #list( head: $e._M_pHead, next: _M_pNext, size: _M_count ), ")" ) ) children ( #( #([size]: $e._M_count), #list( head: $e._M_pHead, next: _M_pNext, size: _M_count ) ) ) } ;------------------------------------------------------------------------------ ; Concurrency::unbounded_buffer from <agents.h> ;------------------------------------------------------------------------------ Concurrency::unbounded_buffer<*>{ preview ( #( $e._M_messageBuffer ) ) children ( #( #(unprocessed_messages: $e._M_messageProcessor._M_queuedMessages._M_queue), #(messages: $e._M_messageBuffer), #(message_filter: *($e._M_pFilter)), #(linked_sources: $e._M_connectedSources._M_links), #(linked_targets: $e._M_connectedTargets), #(reserving_target: *($e._M_pReservedFor)), #(Scheduler: *($e._M_messageProcessor._M_pScheduler)), #(ScheduleGroup: *($e._M_messageProcessor._M_pScheduleGroup)) ) ) } ;------------------------------------------------------------------------------ ; Concurrency::overwrite_buffer from <agents.h> ;------------------------------------------------------------------------------ Concurrency::overwrite_buffer<*>{ preview ( #( $e._M_pMessage ) ) children ( #( #(value: *($e._M_pMessage)), #(unprocessed_messages: $e._M_messageProcessor._M_queuedMessages._M_queue), #(message_filter: *($e._M_pFilter)), #(linked_sources: $e._M_connectedSources._M_links), #(linked_targets: $e._M_connectedTargets), #(reserving_target: *($e._M_pReservedFor)), #(reserved_message: *($e._M_pReservedMessage)), #(Scheduler: *($e._M_messageProcessor._M_pScheduler)), #(ScheduleGroup: *($e._M_messageProcessor._M_pScheduleGroup)) ) ) } ;------------------------------------------------------------------------------ ; Concurrency::single_assignment from <agents.h> ;------------------------------------------------------------------------------ Concurrency::single_assignment<*>{ preview ( #( $e._M_pMessage ) ) children ( #( #(value: *($e._M_pMessage)), #(unprocessed_messages: $e._M_messageProcessor._M_queuedMessages._M_queue), #(message_filter: *($e._M_pFilter)), #(linked_sources: $e._M_connectedSources._M_links), #(linked_targets: $e._M_connectedTargets), #(reserving_target: *($e._M_pReservedFor)), #(Scheduler: *($e._M_messageProcessor._M_pScheduler)), #(ScheduleGroup: *($e._M_messageProcessor._M_pScheduleGroup)) ) ) } ;------------------------------------------------------------------------------ ; Concurrency::call from <agents.h> ;------------------------------------------------------------------------------ Concurrency::call<*>{ preview ( #( $e._M_pFunc ) ) children ( #( #(call_method: $e._M_pFunc), #(unprocessed_messages: $e._M_messageProcessor._M_queuedMessages._M_queue), #(message_filter: *($e._M_pFilter)), #(linked_sources: $e._M_connectedSources._M_links), #(Scheduler: *($e._M_messageProcessor._M_pScheduler)), #(ScheduleGroup: *($e._M_messageProcessor._M_pScheduleGroup)) ) ) } ;------------------------------------------------------------------------------ ; Concurrency::transformer from <agents.h> ;------------------------------------------------------------------------------ Concurrency::transformer<*>{ preview ( #( $e._M_pFunc ) ) children ( #( #(transform_method: $e._M_pFunc), #(unprocessed_messages: $e._M_messageProcessor._M_queuedMessages._M_queue), #(messages: $e._M_messageBuffer), #(message_filter: *($e._M_pFilter)), #(linked_sources: $e._M_connectedSources._M_links), #(linked_target: *($e._M_connectedTargets._M_connectedLink)), #(reserving_target: *($e._M_pReservedFor)), #(Scheduler: *($e._M_messageProcessor._M_pScheduler)), #(ScheduleGroup: *($e._M_messageProcessor._M_pScheduleGroup)) ) ) } ;------------------------------------------------------------------------------ ; Concurrency::choice from <agents.h> ;------------------------------------------------------------------------------ Concurrency::choice<*>{ preview ( #( "[", #if ($e._M_pSingleAssignment->_M_fIsInitialized) ("initialized") #else ("not_initialized"), "] ", $e._M_sourceTuple ) ) children ( #( #([input_count]: $e._M_pSingleAssignment->_M_connectedSources._M_links._M_vector._M_index), #(index: $e._M_pSingleAssignment->_M_pMessage->payload), #(source_tuple: $e._M_sourceTuple), #(linked_sources: $e._M_pSingleAssignment->_M_connectedSources._M_links), #(linked_targets: $e._M_pSingleAssignment->_M_connectedTargets), #(reserving_target: *($e._M_pSingleAssignment->_M_pReservedFor)), #(Scheduler: *($e._M_pScheduler)), #(ScheduleGroup: *($e._M_pScheduleGroup)), #([raw _M_pSourceChoices] : $e._M_pSourceChoices) ) ) } ;------------------------------------------------------------------------------ ; Concurrency::join<*,*>::_MessageArray from <agents.h> ;------------------------------------------------------------------------------ Concurrency::join<*,*>::_MessageArray{ preview ( #( "[", $e._M_count, "](", #array( expr: *(((Concurrency::message<$T1>**)$e._M_messages)[$i]), size: $e._M_count ), ")" ) ) children ( #( #([size]: $e._M_count), #array( expr: *(((Concurrency::message<$T1>**)$e._M_messages)[$i]), size: $e._M_count ) ) ) } ;------------------------------------------------------------------------------ ; Concurrency::join<*,*>::_SavedMessageIdArray from <agents.h> ;------------------------------------------------------------------------------ Concurrency::join<*,*>::_SavedMessageIdArray{ preview ( #( "[", $e._M_count, "](", #array( expr: ((int*)$e._M_savedIds)[$i], size: $e._M_count ), ")" ) ) children ( #( #([size]: $e._M_count), #array( expr: ((int*)$e._M_savedIds)[$i], size: $e._M_count ) ) ) } ;------------------------------------------------------------------------------ ; Concurrency::join from <agents.h> ;------------------------------------------------------------------------------ Concurrency::join<*,*>{ preview ( #( "[", $e._M_messageArray._M_count - $e._M_messagesRemaining, "/", $e._M_messageArray._M_count, "](", #array( expr: *($e._M_connectedSources._M_links._M_vector._M_array[$i]), size: $e._M_connectedSources._M_links._M_vector._M_index ), ")" ) ) children ( #( #([join_type]: (Concurrency::join_type)$T2), #([offer_count]: $e._M_messageArray._M_count - $e._M_messagesRemaining), #(offer_IDs: $e._M_savedMessageIdArray), #([input_count]: $e._M_messageArray._M_count), #(input_values: $e._M_messageArray), #(messages: $e._M_messageBuffer), #(message_filter: *($e._M_pFilter)), #(linked_sources: $e._M_connectedSources._M_links), #(linked_target: $e._M_connectedTargets._M_connectedLink), #(reserving_target: *($e._M_pReservedFor)), #(Scheduler: *($e._M_messageProcessor._M_pScheduler)), #(ScheduleGroup: *($e._M_messageProcessor._M_pScheduleGroup)) ) ) } ;------------------------------------------------------------------------------ ; Concurrency::multitype_join from <agents.h> ;------------------------------------------------------------------------------ Concurrency::multitype_join<*,*>{ preview ( #( "[", $e._M_pJoinNode->_M_connectedSources._M_links._M_vector._M_index - $e._M_pJoinNode->_M_counter, "/", $e._M_pJoinNode->_M_connectedSources._M_links._M_vector._M_index, "]", $e._M_sourceTuple ) ) children ( #( #([join_type]: (Concurrency::join_type)$T2), #([offer_count]: $e._M_pJoinNode->_M_connectedSources._M_links._M_vector._M_index - $e._M_pJoinNode->_M_counter), #([input_count]: $e._M_pJoinNode->_M_connectedSources._M_links._M_vector._M_index), #(source_tuple: $e._M_sourceTuple), #(messages: $e._M_pJoinNode->_M_messageBuffer), #(linked_sources: $e._M_pJoinNode->_M_connectedSources._M_links), #(linked_target: $e._M_pJoinNode->_M_connectedTargets._M_connectedLink), #(reserving_target: *($e._M_pJoinNode->_M_pReservedFor)), #(Scheduler: *($e._M_pJoinNode->_M_messageProcessor._M_pScheduler)), #(ScheduleGroup: *($e._M_pJoinNode->_M_messageProcessor._M_pScheduleGroup)), #([raw _M_pSourceJoins] : $e._M_pSourceJoins) ) ) } ;------------------------------------------------------------------------------ ; Concurrency::timer from <agents.h> ;------------------------------------------------------------------------------ Concurrency::timer<*>{ preview ( #( $e._M_state ) ) children ( #( #(state: $e._M_state), #(value: $e._M_value), #(repeating: $e._M_fRepeating), #(interval_ms: $e._M_ms), #(linked_target: *($e._M_connectedTargets._M_connectedLink)), #(reserving_target: *($e._M_pReservedFor)), #(Scheduler: *($e._M_messageProcessor._M_pScheduler)), #(ScheduleGroup: *($e._M_messageProcessor._M_pScheduleGroup)) ) ) } ;------------------------------------------------------------------------------ ; Concurrency::details::SchedulerBase from <SchedulerBase.h> ; Concurrency::details::ThreadScheduler from <ThreadScheduler.h> ; Concurrency::details::UMSThreadScheduler from <UMSThreadScheduler.h> ;------------------------------------------------------------------------------ Concurrency::details::SchedulerBase|Concurrency::details::ThreadScheduler|Concurrency::details::UMSThreadScheduler{ preview ( #( "[", $e.m_id, "] ", #if ($e.m_schedulerKind == 0) ("ThreadScheduler") #else ("UmsScheduler"), #if ($e.m_id == $e.s_pDefaultScheduler->m_id) (", default") #else ("") ) ) children ( #( #(ID: $e.m_id), #(SchedulerPolicy: $e.m_policy), #(VirtualProcessorCount: $e.m_virtualProcessorCount), #(ReferenceCount: $e.m_refCount), #([isDefaultScheduler]: $e.m_id == $e.s_pDefaultScheduler->m_id) ) ) } ;------------------------------------------------------------------------------ ; Concurrency::details::ScheduleGroupBase from <ScheduleGroupBase.h> ; Concurrency::details::CacheLocalScheduleGroup from <CacheLocalScheduleGroup.h> ; Concurrency::details::FairScheduleGroup from <FairScheduleGroup.h> ;------------------------------------------------------------------------------ Concurrency::details::ScheduleGroupBase|Concurrency::details::CacheLocalScheduleGroup|Concurrency::details::FairScheduleGroup{ preview ( #( "[", $e.m_id, "]", #if ($e.m_kind & 4) (" AnonymousScheduleGroup") #else ("") ) ) children ( #( #(ID: $e.m_id), #(Scheduler: *($e.m_pScheduler)) ) ) } ;------------------------------------------------------------------------------ ; Concurrency::details::ContextBase from <ContextBase.h> ; Concurrency::details::InternalContextBase from <InternalContextBase.h> ; Concurrency::details::ThreadInternalContext from <ThreadInternalContext.h> ; Concurrency::details::UMSThreadInternalContext from <UMSThreadInternalContext.h> ;------------------------------------------------------------------------------ Concurrency::details::ContextBase|Concurrency::details::InternalContextBase|Concurrency::details::ThreadInternalContext|Concurrency::details::UMSThreadInternalContext{ preview ( #( "[", $e.m_threadId, "] ", #if ($e.m_blockedState == 0) ("not_concrt_blocked") #elif ($e.m_blockedState == 1) ("concrt_blocked") #elif ($e.m_blockedState == 2) ("ums_sync_blocked") #elif ($e.m_blockedState == 4) ("ums_async_blocked") #else ("") ) ) children ( #( #(ID: $e.m_id), #(ThreadID: $e.m_threadId), #(Scheduler: *($e.m_pScheduler)), #(ScheduleGroup: *($e.m_pGroup)) ) ) } ;------------------------------------------------------------------------------ ; Concurrency::details::ExternalContextBase from <ExternalContextBase.h> ;------------------------------------------------------------------------------ Concurrency::details::ExternalContextBase{ preview ( #( "[", $e.m_threadId, "] ", #if ($e.m_contextSwitchingFence == 1) ("concrt_blocked") #else ("not_concrt_blocked") ) ) children ( #( #(ID: $e.m_id), #(ThreadID: $e.m_threadId), #(Scheduler: *($e.m_pScheduler)), #(ScheduleGroup: *($e.m_pGroup)) ) ) } ;------------------------------------------------------------------------------ ; Concurrency::SchedulerPolicy from <concrt.h> ;------------------------------------------------------------------------------ Concurrency::SchedulerPolicy{ preview ( #( $e._M_pPolicyBag->_M_values._M_specificValues._M_schedulerKind, ", Min=", $e._M_pPolicyBag->_M_values._M_specificValues._M_minConcurrency, ", Max=", $e._M_pPolicyBag->_M_values._M_specificValues._M_maxConcurrency ) ) children ( #( #(SchedulerKind: $e._M_pPolicyBag->_M_values._M_specificValues._M_schedulerKind), #(MinConcurrency: $e._M_pPolicyBag->_M_values._M_specificValues._M_minConcurrency), #(MaxConcurrency: $e._M_pPolicyBag->_M_values._M_specificValues._M_maxConcurrency), #(TargetOversubscriptionFactor: $e._M_pPolicyBag->_M_values._M_specificValues._M_targetOversubscriptionFactor), #(LocalContextCacheSize: $e._M_pPolicyBag->_M_values._M_specificValues._M_localContextCacheSize), #(ContextStackSize: $e._M_pPolicyBag->_M_values._M_specificValues._M_contextStackSize), #(ContextPriority: $e._M_pPolicyBag->_M_values._M_specificValues._M_contextPriority), #(SchedulingProtocol: $e._M_pPolicyBag->_M_values._M_specificValues._M_schedulingProtocol), #(DynamicProgressFeedback: $e._M_pPolicyBag->_M_values._M_specificValues._M_dynamicProgressFeedback) ) ) } ;------------------------------------------------------------------------------ ; Concurrency::event from <concrt.h> ;------------------------------------------------------------------------------ Concurrency::event{ preview ( #( #if ($e._M_pWaitChain == 1) ("set") #else ("not_set") ) ) children ( #( #([is_set]: ($e._M_pWaitChain == 1)), #([has_waiters]: (($e._M_pWaitChain != 0) && ($e._M_pWaitChain != 1))) ) ) } ;------------------------------------------------------------------------------ ; Concurrency::critical_section from <concrt.h> ;------------------------------------------------------------------------------ Concurrency::critical_section{ preview ( #( #if ($e._M_pHead != 0) ("locked") #else ("not_locked") ) ) children ( #( #([is_locked]: ($e._M_pHead != 0)), #(OwningContext: *((Concurrency::Context*)($e._M_activeNode[0]))) ) ) } ;------------------------------------------------------------------------------ ; Concurrency::critical_section::scoped_lock from <concrt.h> ;------------------------------------------------------------------------------ Concurrency::critical_section::scoped_lock{ preview ( #( $e._M_critical_section ) ) children ( #( CriticalSection: $e._M_critical_section ) ) } ;------------------------------------------------------------------------------ ; Concurrency::reader_writer_lock from <concrt.h> ;------------------------------------------------------------------------------ Concurrency::reader_writer_lock{ preview ( #( #if (($e._M_lockState < 8) && ($e._M_lockState & 2)) ("held_by_writer") #elif ($e._M_lockState >= 8) ( #( "held_by_reader(s) [", ($e._M_lockState / 8), "]" ) ) #else ("not_held") ) ) children ( #( #([is_reader_lock_held]: ($e._M_lockState >= 8)), #([num_reader_lock_holders]: ($e._M_lockState / 8)), #([is_writer_lock_held]: ($e._M_lockState < 8) && ($e._M_lockState & 2)), #(OwningWriterContext: *((Concurrency::Context*)($e._M_activeWriter[0]))) ) ) } ;------------------------------------------------------------------------------ ; Concurrency::reader_writer_lock::scoped_lock from <concrt.h> ; Concurrency::reader_writer_lock::scoped_lock_read from <concrt.h> ;------------------------------------------------------------------------------ Concurrency::reader_writer_lock::scoped_lock|Concurrency::reader_writer_lock::scoped_lock_read{ preview ( #( $e._M_reader_writer_lock ) ) children ( #( ReaderWriterLock: $e._M_reader_writer_lock ) ) } ;------------------------------------------------------------------------------ ; Concurrency::details::_TaskCollectionBase from <concrt.h> ;------------------------------------------------------------------------------ Concurrency::details::_TaskCollectionBase{ preview ( #( #if ((((int)$e._M_pException & ~0x3) != 0) && (((int)$e._M_pException & ~0x3) != 0xC)) ("exception") #else ("no_exception") ) ) children ( #( #([has_exception]: (((int)$e._M_pException & ~0x3) != 0) && (((int)$e._M_pException & ~0x3) != 0xC)), #(CreatingContext: *((Concurrency::Context*)$e._M_pOwningContext)) ) ) } ;------------------------------------------------------------------------------ ; Concurrency::task_group from <ppl.h> ; Concurrency::structured_task_group from <ppl.h> ;------------------------------------------------------------------------------ Concurrency::task_group|Concurrency::structured_task_group{ preview ( #( #if ((((int)$e._M_task_collection._M_pException & ~0x3) != 0) && (((int)$e._M_task_collection._M_pException & ~0x3) != 0xC)) ("exception") #else ("no_exception") ) ) children ( #( #([has_exception]: (((int)$e._M_task_collection._M_pException & ~0x3) != 0) && (((int)$e._M_task_collection._M_pException & ~0x3) != 0xC)), #(CreatingContext: *((Concurrency::Context*)$e._M_task_collection._M_pOwningContext)) ) ) } ;------------------------------------------------------------------------------ ; Concurrency::task_handle from <ppl.h> ;------------------------------------------------------------------------------ Concurrency::task_handle<*>{ preview ( #( $e._M_function ) ) children ( #( #(Function: $e._M_function), #(RuntimeOwnsLifetime: $e._M_fRuntimeOwnsLifetime), #(TaskCollection: *($e._M_pTaskCollection)) ) ) } ;------------------------------------------------------------------------------ ; Concurrency::combinable from <ppl.h> ;------------------------------------------------------------------------------ Concurrency::combinable<*>{ preview( #( "(", #array( expr: *($e._M_buckets[$i]), size: $e._M_size ) : #list( head: $e, next: _M_chain ) : $e._M_value, ")" ) ) children( #( #array( expr: *($e._M_buckets[$i]), size: $e._M_size ) : #list( head: $e, next: _M_chain ) : $e._M_value, #(InitFunction : $e._M_fnInitialize) ) ) } ;------------------------------------------------------------------------------ ; Concurrency::concurrent_vector from <concurrent_vector.h> ;------------------------------------------------------------------------------ Concurrency::concurrent_vector<*,*>{ preview( #( "[", $e._My_early_size._M_value, "](", #array ( expr: #( #if (($i >> 1) == 0) ((($T1*)$e._My_segment._M_value[0]._My_array)[$i]) #else ((($T1*)$e._My_segment._M_value[__log2($i)]._My_array)[$i - (0x1 << __log2($i))]) ), size: $e._My_early_size._M_value ), ")" ) ) children( #( [size] : $e._My_early_size._M_value, #array ( expr: #( #if (($i >> 1) == 0) ((($T1*)$e._My_segment._M_value[0]._My_array)[$i]) #else ((($T1*)$e._My_segment._M_value[__log2($i)]._My_array)[$i - (0x1 << __log2($i))]) ), size: $e._My_early_size._M_value ) ) ) } ;------------------------------------------------------------------------------ ; Concurrency::details::_Vector_iterator from <concurrent_vector.h> ;------------------------------------------------------------------------------ Concurrency::details::_Vector_iterator<Concurrency::concurrent_vector<*,*>,*>{ preview( #( #if (($e._My_index >> 1) == 0) ((($T1*)$e._My_vector->_My_segment._M_value[0]._My_array)[$e._My_index]) #else ((($T1*)$e._My_vector->_My_segment._M_value[__log2($e._My_index)]._My_array)[$e._My_index - (0x1 << __log2($e._My_index))]) ) ) children( #( [ptr]: #if (($e._My_index >> 1) == 0) (&((($T1*)$e._My_vector->_My_segment._M_value[0]._My_array)[$e._My_index])) #else (&((($T1*)$e._My_vector->_My_segment._M_value[__log2($e._My_index)]._My_array)[$e._My_index - (0x1 << __log2($e._My_index))])) ) ) } ;------------------------------------------------------------------------------ ; Concurrency::concurrent_queue from <concurrent_queue.h> ;------------------------------------------------------------------------------ Concurrency::concurrent_queue<*,*>{ preview ( #( "[", $e._My_rep->_Tail_counter._M_value - $e._My_rep->_Head_counter._M_value, "](", #array ( expr : #if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 0) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 1) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 2) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 3) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 4) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 5) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 6) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 7) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 8) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 9) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 10) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 11) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 12) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 13) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 14) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 15) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 16) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 17) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 18) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 19) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1])))))))))))))))))))), size : #if ($e._My_rep->_Tail_counter._M_value-$e._My_rep->_Head_counter._M_value < 20*8*$e._Items_per_page) ($e._My_rep->_Tail_counter._M_value-$e._My_rep->_Head_counter._M_value) #else (20*8*$e._Items_per_page) ), ")" ) ) children ( #( #([unsafe_size]: $e._My_rep->_Tail_counter._M_value-$e._My_rep->_Head_counter._M_value), #array ( expr : #if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 0) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 1) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 2) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 3) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 4) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 5) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 6) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 7) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 8) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 9) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 10) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 11) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 12) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 13) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 14) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 15) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 16) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 17) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 18) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else (#if (($i+($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)))/(8*$e._Items_per_page)-($e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>(8*($e._Items_per_page-1)))*($i%8+$e._My_rep->_Head_counter._M_value%(8*$e._Items_per_page)>=(8*$e._Items_per_page)) == 19) ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1]) #else ((($T1*)(($e._My_rep->_Array[(($i+$e._My_rep->_Head_counter._M_value)*3%8)]._Head_page._M_value->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next->_Next) + 1))[(($i+$e._My_rep->_Head_counter._M_value)&-8)/8&$e._Items_per_page-1])))))))))))))))))))), size : #if ($e._My_rep->_Tail_counter._M_value-$e._My_rep->_Head_counter._M_value < 20*8*$e._Items_per_page) ($e._My_rep->_Tail_counter._M_value-$e._My_rep->_Head_counter._M_value) #else (20*8*$e._Items_per_page) ) ) ) } ;------------------------------------------------------------------------------ ; Concurrency::details::_Concurrent_queue_iterator from <concurrent_queue.h> ;------------------------------------------------------------------------------ Concurrency::details::_Concurrent_queue_iterator<Concurrency::concurrent_queue<*,*>,*>{ preview( #( *(($T1*)$e._My_item) ) ) children( #( [ptr]: (($T1*)$e._My_item) ) ) } ; 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