tool/visual_studio_macros/autoexp.dat

   1 ; AutoExp.Dat - templates for automatically expanding data
   2 ; Copyright(c) Microsoft Corporation. All Rights Reserved.
   3 ;---------------------------------------------------------------
   4 ;
   5 ; Location: C:\Program Files\Microsoft Visual Studio\Common\MSDev98\Bin
   6 ;
   7 ; While debugging, Data Tips and items in the Watch and Variable
   8 ; windows are automatically expanded to show their most important
   9 ; elements. The expansion follows the format given by the rules
  10 ; in this file. You can add rules for your types or change the
  11 ; predefined rules.
  12 ;
  13 ; For good examples, read the rules in this file.
  14 ;
  15 ; To find what the debugger considers the type of a variable to
  16 ; be, add it to the Watch window and look at the Type column.
  17 ;
  18 ; An AutoExpand rule is a line with the name of a type, an equals
  19 ; sign, and text with replaceable parts in angle brackets. The
  20 ; part in angle brackets names a member of the type and an
  21 ; optional Watch format specifier.
  22 ;
  23 ; AutoExpand rules use the following syntax. The equals sign (=),
  24 ; angle brackets (<>), and comma are taken literally. Square
  25 ; brackets ([]) indicate optional items.
  26 ;
  27 ; type=[text]<member[,format]>...
  28 ;
  29 ; type          Name of the type (may be followed by <*> for template
  30 ;                       types such as the ATL types listed below).
  31 ;
  32 ; text          Any text.Usually the name of the member to display,
  33 ;                       or a shorthand name for the member.
  34 ;
  35 ; member        Name of a member to display.
  36 ;
  37 ; format        Watch format specifier. One of the following:
  38 ;
  39 ;       Letter  Description                                     Sample             Display
  40 ;       ------  --------------------------      ------------   -------------
  41 ;       d,i             Signed decimal integer          0xF000F065,d   -268373915
  42 ;       u               Unsigned decimal integer        0x0065,u           101
  43 ;       o               Unsigned octal integer          0xF065,o           0170145
  44 ;       x,X             Hexadecimal integer                     61541,X            0X0000F065
  45 ;       l,h             long or short prefix for        00406042,hx    0x0c22
  46 ;                         d, i, u, o, x, X
  47 ;       f               Signed floating-point           3./2.,f            1.500000
  48 ;       e               Signed scientific-notation      3./2.,e            1.500000e+000
  49 ;       g               Shorter of e and f                      3./2.,g            1.5
  50 ;       c               Single character                        0x0065,c           'e'
  51 ;       s               Zero-terminated string          pVar,s             "Hello world"
  52 ;       su              Unicode string                          pVar,su            "Hello world"
  53 ;
  54 ; For details of other format specifiers see Help under:
  55 ; "format specifiers/watch variable"
  56 ;
  57 ; The special format <,t> specifies the name of the most-derived
  58 ; type of the object. This is especially useful with pointers or
  59 ; references to a base class.
  60 ;
  61 ; If there is no rule for a class, the base classes are checked for
  62 ; a matching rule.
  63 ;
  64 ; There are some special entries allowed in the AutoExpand section:
  65 ; $BUILTIN is used to display more complex types that need to do more
  66 ; than just show a member variable or two.
  67 ; $ADDIN allows external DLLs to be added to display even more complex
  68 ; types via the EE Add-in API. The first argument is the DLL name, the
  69 ; second argument is the name of the export from the DLL to use. For
  70 ; further information on this API see the sample called EEAddIn.
  71 ;
  72 ; WARNING: if hexadecimal mode is on in the watch window, all numbers here are
  73 ; evaluated in hex, e.g. 42 becomes 0x42
  74
  75 [AutoExpand]
  76
  77 ; Qt Integration
  78
  79 ; autoexpand
  80 QByteArray=<d->data,s> size=<d->size,u>
  81 QPoint =x=<xp> y=<yp>
  82 QPointF =x=<xp> y=<yp>
  83 QRect =x1=<x1> y1=<y1> x2=<x2> y2=<y2>
  84 QRectF =x=<xp> y=<yp> w=<w> h=<h>
  85 QSize =width=<wd> height=<ht>
  86 QSizeF =width=<wd> height=<ht>
  87 QHash<*> =size=<d->size>
  88 QVarLengthArray<*> =size=<s> data=<ptr>
  89
  90 ;QObject =classname=<staticMetaObject.d.stringdata,s> superclassname=<staticMetaObject.d.superdata->d.stringdata,s>
  91 ;QList<*>=size=<d->end,i>
  92 ;QLinkedList<*>=size=<d->end,i>
  93 ;QString=<d->data,su> size=<d->size,u>
  94 ;QUrl =<d->encodedOriginal.d->data,s>
  95 ;QUrlInfo =<d->name.d->data,su>
  96 ;QMap<*> =size=<d->size>
  97 ;QVector<*> =size=<d->size>
  98 ;QFont =family=<d->request.family.d->data,su> size=<d->request.pointSize, f>
  99 ;QDomNode =name=<impl->name.d->data,su> value=<impl->value.d->data,su>
 100
 101 ; from windef.h
 102 tagPOINT =x=<x> y=<y>
 103 tagRECT =top=<top> bottom=<bottom> left=<left> right=<right>
 104
 105 ; from winuser.h
 106 tagMSG =msg=<message,x> wp=<wParam,x> lp=<lParam,x>
 107
 108 ; intrinsics
 109 __m64 =<m64_i64,x>
 110 __m128=$BUILTIN(M128)
 111 __m128i=$BUILTIN(M128I)
 112 __m128d=$BUILTIN(M128D)
 113
 114 ; from afxwin.h
 115 CDC =hDC=<m_hDC> attrib=<m_hAttribDC>
 116 CPaintDC =<,t> hWnd=<m_hWnd>
 117 CPoint =x=<x> y=<y>
 118 CRect =top=<top> bottom=<bottom> left=<left> right=<right>
 119 CSize =cx=<cx> cy=<cy>
 120 CWnd =<,t> hWnd=<m_hWnd>
 121 CWinApp =<,t> <m_pszAppName,s>
 122 CWinThread =<,t> h=<m_hThread> proc=<m_pfnThreadProc>
 123
 124 ; from afxcoll.h
 125 CPtrList =cnt=<m_nCount>
 126
 127 ; from afxstat_.h
 128 CProcessLocalObject =<,t>
 129 CThreadLocalObject =<,t>
 130
 131 ; from afx.h
 132 CArchiveException =cause=<m_cause>
 133 CFile =hFile=<m_hFile> name=<m_strFileName.m_pchData,s>
 134 CFileException =cause=<m_cause> OS Error=m_lOsError
 135 CMemFile =pos=<m_nPosition> size=<m_nFileSize>
 136 CObject =<,t>
 137 CRuntimeClass =<m_lpszClassName,s>
 138 CStdioFile =FILE*=<m_pStream> name=<m_strFilename.m_pchData,s>
 139 CTimeSpan =time=<m_time>
 140 CTime =time=<m_time>
 141
 142 ; from afxcoll.h
 143 CByteArray =count=<m_nCount>
 144 CStringList =count=<m_nCount>
 145 ; same for all CXXXArray classes
 146 ; same for CXXXList
 147 ; same for CMapXXToXX
 148
 149 ; various string classes from MFC & ATL
 150
 151 _com_error=<m_hresult,hr>
 152 _bstr_t=<m_Data->m_wstr,su> (<m_Data->m_RefCount,u>)
 153 _com_ptr_t<*>=<m_pInterface>
 154 _LARGE_INTEGER=<QuadPart>
 155 _ULARGE_INTEGER=<QuadPart>
 156 ATL::CComPtr<*>=<p>
 157
 158 ATL::CComQIPtr<*>=<p>
 159
 160 tagVARIANT=$BUILTIN(VARIANT)
 161 VARIANT=$BUILTIN(VARIANT)
 162 _GUID=$BUILTIN(GUID)
 163
 164 ; see EEAddIn sample for how to use these
 165 ;_SYSTEMTIME=$ADDIN(EEAddIn.dll,AddIn_SystemTime)
 166 ;_FILETIME=$ADDIN(EEAddIn.dll,AddIn_FileTime)
 167
 168 std::binder1st<*>= op=<op> value=<value>
 169 std::binder2nd<*>= op=<op> value=<value>
 170 std::less<*>=lessthan
 171 std::greater<*>=greaterthan
 172
 173 [Visualizer]
 174 QString|*::QString{
 175     preview         ([$e.d->data,su])
 176     stringview      ([$e.d->data,sub])
 177     children
 178     (
 179         #(
 180             d: $c.d,
 181             [size]: $c.d->size,
 182             [referenced]: $c.d->ref._q_value
 183         )
 184     )
 185 }
 186
 187 QByteArray|*::QByteArray{
 188     preview         ([$e.d->data,s])
 189     stringview      ([$e.d->data,sb])
 190     children
 191     (
 192         #(
 193             d: $c.d,
 194             [size]: $c.d->size,
 195             [referenced]: $c.d->ref._q_value
 196         )
 197     )
 198 }
 199
 200 QFileInfo|*::QFileInfo{
 201     preview
 202     (
 203         #(
 204             "private=", $c.d_ptr
 205         )
 206     )
 207 }
 208
 209 QUrl|*::QUrl{
 210     preview
 211     (
 212         #if ($e.d.stateFlags == 0) (
 213             $e.d
 214         ) #else (
 215             #( $e.d->scheme, $e.d->host, $e.d->path )
 216         )
 217     )
 218     children
 219     (
 220         #(
 221             scheme: $c.d->scheme,
 222             host: $c.d->host,
 223             path: $c.d->path,
 224             username: $c.d->userName,
 225             password: $c.d->password,
 226             encodedOriginal: $c.d->encodedOriginal,
 227             query: $c.d->query,
 228             fragment: $c.d->fragment
 229         )
 230     )
 231 }
 232
 233 QTime|*::QTime{
 234     preview
 235     (
 236         #(
 237             "hour=", [$e.mds / 3600000, d],
 238             ", minute=", [($e.mds % 3600000) / 60000, d],
 239             ", second=", [($e.mds / 1000) % 60, d],
 240             ", millisecond=", [$e.mds % 1000, d]
 241         )
 242     )
 243     children
 244     (
 245         #(
 246             [hour]: [$e.mds / 3600000, d],
 247             [minute]: [($e.mds % 3600000) / 60000, d],
 248             [second]: [($e.mds / 1000) % 60, d],
 249             [millisecond]: [$e.mds % 1000, d]
 250         )
 251     )
 252 }
 253
 254 QVariant{
 255     preview
 256     (
 257         #if ($e.d.type == 1) (
 258             #("bool = ", [$e.d.data.b])
 259         ) #elif ($e.d.type == 2) (
 260             #("int = ", [$e.d.data.i])
 261         ) #elif ($e.d.type == 3) (
 262             #("usigned int = ", [$e.d.data.u])
 263         ) #elif ($e.d.type == 4) (
 264             #("long long = ", [$e.d.data.ll])
 265         ) #elif ($e.d.type == 5) (
 266             #("unsigned long long = ", [$e.d.data.ull])
 267         ) #elif ($e.d.type == 6) (
 268             #("double = ", [$e.d.data.d])
 269         ) #elif ($e.d.type == 7) (
 270             #("char = ", [$e.d.data.c])
 271         ) #elif ($e.d.type == 8) (
 272             #("QMap = ", [(QMap) $e.d.data.ptr])
 273         ) #elif ($e.d.type == 10) (
 274             #("QString = ", [(QString) $e.d.data.ptr])
 275         ) #elif ($e.d.type == 11) (
 276             #("QStringList = ", [(QStringList) $e.d.data.ptr])
 277         ) #elif ($e.d.type == 17) (
 278             #("QUrl = ", [(QUrl) $e.d.data.ptr])
 279         ) #else (
 280             #("type = ", [$e.d.type])
 281         )
 282     )
 283     children
 284     (
 285         #if ($e.d.type == 1) (
 286             $c.d.data.b
 287         ) #elif ($e.d.type == 2) (
 288             $c.d.data.i
 289         ) #elif ($e.d.type == 3) (
 290             $c.d.data.u
 291         ) #elif ($e.d.type == 4) (
 292             $c.d.data.ll
 293         ) #elif ($e.d.type == 5) (
 294             $c.d.data.ull
 295         ) #elif ($e.d.type == 6) (
 296             $c.d.data.d
 297         ) #elif ($e.d.type == 7) (
 298             $c.d.data.c
 299         ) #elif ($e.d.type == 8) (
 300         ) #elif ($e.d.type == 10) (
 301             #(
 302                 [size]: ((QString) $c.d.data.ptr).d->size
 303             )
 304         ) #elif ($e.d.type == 11) (
 305             #if ((((QStringList) $e.d.data.ptr).d->end - ((QStringList) $e.d.data.ptr).d->begin) <= 10) (
 306                #array
 307                (
 308                     expr: (QString)((((QStringList) $e.d.data.ptr).d->array + ((QStringList) $e.d.data.ptr).d->begin)[$i]),
 309                     size: ((QStringList) $e.d.data.ptr).d->end-((QStringList) $e.d.data.ptr).d->begin
 310                 )
 311             ) #else (
 312                 #array
 313                 (
 314                     expr: (QString)((((QStringList) $e.d.data.ptr).d->array + ((QStringList) $e.d.data.ptr).d->begin)[$i]),
 315                     size: 10
 316                 )
 317             )
 318         ) #elif ($e.d.type == 17) (
 319             #(
 320                 scheme: ((QUrl) $e.d.data.ptr).d->scheme,
 321                 host: ((QUrl) $e.d.data.ptr).d->host,
 322                 path: ((QUrl) $e.d.data.ptr).d->path,
 323                 username: ((QUrl) $e.d.data.ptr).d->userName,
 324                 password: ((QUrl) $e.d.data.ptr).d->password,
 325                 encodedOriginal: ((QUrl) $e.d.data.ptr).d->encodedOriginal,
 326                 query: ((QUrl) $e.d.data.ptr).d->query,
 327                 fragment: ((QUrl) $e.d.data.ptr).d->fragment
 328             )
 329         ) #else (
 330             #("type = ", [$e.d.type])
 331         )
 332     )
 333 }
 334
 335 *::QVariant{
 336     preview
 337     (
 338         #if ($e.d.type == 1) (
 339             #("bool = ", [$e.d.data.b])
 340         ) #elif ($e.d.type == 2) (
 341             #("int = ", [$e.d.data.i])
 342         ) #elif ($e.d.type == 3) (
 343             #("usigned int = ", [$e.d.data.u])
 344         ) #elif ($e.d.type == 4) (
 345             #("long long = ", [$e.d.data.ll])
 346         ) #elif ($e.d.type == 5) (
 347             #("unsigned long long = ", [$e.d.data.ull])
 348         ) #elif ($e.d.type == 6) (
 349             #("double = ", [$e.d.data.d])
 350         ) #elif ($e.d.type == 7) (
 351             #("char = ", [$e.d.data.c])
 352         ) #elif ($e.d.type == 8) (
 353             #("QMap = ", [($T1::QMap) $e.d.data.ptr])
 354         ) #elif ($e.d.type == 10) (
 355             #("QString = ", [($T1::QString) $e.d.data.ptr])
 356         ) #elif ($e.d.type == 11) (
 357             #("QStringList = ", [($T1::QStringList) $e.d.data.ptr])
 358         ) #elif ($e.d.type == 17) (
 359             #("QUrl = ", [($T1::QUrl) $e.d.data.ptr])
 360         ) #else (
 361             #("type = ", [$e.d.type])
 362         )
 363     )
 364     children
 365     (
 366         #if ($e.d.type == 1) (
 367             $c.d.data.b
 368         ) #elif ($e.d.type == 2) (
 369             $c.d.data.i
 370         ) #elif ($e.d.type == 3) (
 371             $c.d.data.u
 372         ) #elif ($e.d.type == 4) (
 373             $c.d.data.ll
 374         ) #elif ($e.d.type == 5) (
 375             $c.d.data.ull
 376         ) #elif ($e.d.type == 6) (
 377             $c.d.data.d
 378         ) #elif ($e.d.type == 7) (
 379             $c.d.data.c
 380         ) #elif ($e.d.type == 8) (
 381         ) #elif ($e.d.type == 10) (
 382             #(
 383                 [size]: (($T1::QString) $c.d.data.ptr).d->size
 384             )
 385         ) #elif ($e.d.type == 11) (
 386             #if (((($T1::QStringList) $e.d.data.ptr).d->end - (($T1::QStringList) $e.d.data.ptr).d->begin) <= 10) (
 387                #array
 388                (
 389                     expr: ($T1::QString)(((($T1::QStringList) $e.d.data.ptr).d->array + (($T1::QStringList) $e.d.data.ptr).d->begin)[$i]),
 390                     size: (($T1::QStringList) $e.d.data.ptr).d->end-(($T1::QStringList) $e.d.data.ptr).d->begin
 391                 )
 392             ) #else (
 393                 #array
 394                 (
 395                     expr: ($T1::QString)(((($T1::QStringList) $e.d.data.ptr).d->array + (($T1::QStringList) $e.d.data.ptr).d->begin)[$i]),
 396                     size: 10
 397                 )
 398             )
 399         ) #elif ($e.d.type == 17) (
 400             #(
 401                 scheme: (($T1::QUrl) $e.d.data.ptr).d->scheme,
 402                 host: (($T1::QUrl) $e.d.data.ptr).d->host,
 403                 path: (($T1::QUrl) $e.d.data.ptr).d->path,
 404                 username: (($T1::QUrl) $e.d.data.ptr).d->userName,
 405                 password: (($T1::QUrl) $e.d.data.ptr).d->password,
 406                 encodedOriginal: (($T1::QUrl) $e.d.data.ptr).d->encodedOriginal,
 407                 query: (($T1::QUrl) $e.d.data.ptr).d->query,
 408                 fragment: (($T1::QUrl) $e.d.data.ptr).d->fragment
 409             )
 410         ) #else (
 411             #("type = ", [$e.d.type])
 412         )
 413     )
 414 }
 415
 416 ;------------------------------------------------------------------------------
 417 ; QStringList
 418 ;------------------------------------------------------------------------------
 419 QStringList{
 420     preview
 421     (
 422         #if (($c.d->end - $c.d->begin) <= 10) (
 423             #(
 424                 "[", $c.d->end - $c.d->begin, "](",
 425                 #array
 426                 (
 427                     expr: (QString)(($c.d->array + $c.d->begin)[$i]),
 428                     size: $c.d->end-$c.d->begin
 429                 ), ")"
 430             )
 431         ) #else (
 432             #(
 433                 "[", $c.d->end - $c.d->begin, "](",
 434                 #array
 435                 (
 436                     expr: (QString)(($c.d->array + $c.d->begin)[$i]),
 437                     size: 10
 438                 ), ", ...)"
 439             )
 440         )
 441     )
 442 }
 443
 444 *::QStringList{
 445     preview
 446     (
 447         #if (($c.d->end - $c.d->begin) <= 10) (
 448             #(
 449                 "[", $c.d->end - $c.d->begin, "](",
 450                 #array
 451                 (
 452                     expr: ($T1::QString)(($c.d->array + $c.d->begin)[$i]),
 453                     size: $c.d->end-$c.d->begin
 454                 ), ")"
 455             )
 456         ) #else (
 457             #(
 458                 "[", $c.d->end - $c.d->begin, "](",
 459                 #array
 460                 (
 461                     expr: ($T1::QString)(($c.d->array + $c.d->begin)[$i]),
 462                     size: 10
 463                 ), ", ...)"
 464             )
 465         )
 466     )
 467 }
 468
 469 ;------------------------------------------------------------------------------
 470 ; QList, QQueue
 471 ;------------------------------------------------------------------------------
 472 QList<*>|QQueue<*>{
 473     preview
 474     (
 475         #if (int(sizeof($T1)) <= int(sizeof(void*))) (
 476             #if (($c.d->end - $c.d->begin) <= 10) (
 477                 #(
 478                     "[", $c.d->end - $c.d->begin, "](",
 479                     #array
 480                     (
 481                         expr: ($T1)(($c.d->array + $c.d->begin)[$i]),
 482                         size: $c.d->end-$c.d->begin
 483                     ), ")"
 484                 )
 485             ) #else (
 486                 #(
 487                     "[", $c.d->end - $c.d->begin, "](",
 488                     #array
 489                     (
 490                         expr: ($T1)(($c.d->array + $c.d->begin)[$i]),
 491                         size: 10
 492                     ), ", ...)"
 493                 )
 494             )
 495         ) #else (
 496             #if (($c.d->end - $c.d->begin) <= 10) (
 497                 #(
 498                     "[", $c.d->end - $c.d->begin, "](",
 499                     #array
 500                     (
 501                         expr: *($T1*)(($c.d->array + $c.d->begin)[$i]),
 502                         size: $c.d->end-$c.d->begin
 503                     ), ")"
 504                 )
 505             ) #else (
 506                 #(
 507                     "[", $c.d->end - $c.d->begin, "](",
 508                     #array
 509                     (
 510                         expr: *($T1*)(($c.d->array + $c.d->begin)[$i]),
 511                         size: 10
 512                     ), ", ...)"
 513                 )
 514             )
 515         )
 516     )
 517     children
 518     (
 519         #if (int(sizeof($T1)) <= int(sizeof(void*))) (
 520             #array (
 521                 expr: ($T1)(($c.d->array + $c.d->begin)[$i]),
 522                 size: $c.d->end - $c.d->begin
 523             )
 524         ) #else (
 525             #array (
 526                 expr: *($T1*)(($c.d->array + $c.d->begin)[$i]),
 527                 size: $c.d->end - $c.d->begin
 528             )
 529         )
 530     )
 531 }
 532
 533 *::QList<*>|*::QQueue<*>{
 534     preview
 535     (
 536         #if (int(sizeof($T2)) <= int(sizeof(void*))) (
 537             #if (($c.d->end - $c.d->begin) <= 10) (
 538                 #(
 539                     "[", $c.d->end - $c.d->begin, "](",
 540                     #array
 541                     (
 542                         expr: ($T2)(($c.d->array + $c.d->begin)[$i]),
 543                         size: $c.d->end-$c.d->begin
 544                     ), ")"
 545                 )
 546             ) #else (
 547                 #(
 548                     "[", $c.d->end - $c.d->begin, "](",
 549                     #array
 550                     (
 551                         expr: ($T2)(($c.d->array + $c.d->begin)[$i]),
 552                         size: 10
 553                     ), ", ...)"
 554                 )
 555             )
 556         ) #else (
 557             #if (($c.d->end - $c.d->begin) <= 10) (
 558                 #(
 559                     "[", $c.d->end - $c.d->begin, "](",
 560                     #array
 561                     (
 562                         expr: *($T2*)(($c.d->array + $c.d->begin)[$i]),
 563                         size: $c.d->end-$c.d->begin
 564                     ), ")"
 565                 )
 566             ) #else (
 567                 #(
 568                     "[", $c.d->end - $c.d->begin, "](",
 569                     #array
 570                     (
 571                         expr: *($T2*)(($c.d->array + $c.d->begin)[$i]),
 572                         size: 10
 573                     ), ", ...)"
 574                 )
 575             )
 576         )
 577     )
 578     children
 579     (
 580         #if (int(sizeof($T2)) <= int(sizeof(void*))) (
 581             #array (
 582                 expr: ($T2)(($c.d->array + $c.d->begin)[$i]),
 583                 size: $c.d->end - $c.d->begin
 584             )
 585         ) #else (
 586             #array (
 587                 expr: *($T2*)(($c.d->array + $c.d->begin)[$i]),
 588                 size: $c.d->end - $c.d->begin
 589             )
 590         )
 591     )
 592 }
 593
 594 ;------------------------------------------------------------------------------
 595 ; QList::iterator, QQueue::iterator
 596 ;------------------------------------------------------------------------------
 597 QList<*>::iterator|QList<*>::const_iterator|QQueue<*>::iterator|QQueue<*>::const_iterator{
 598     preview
 599     (
 600         #(
 601             ($T1*)$c.ptr
 602         )
 603     )
 604     children
 605     (
 606         #(
 607             ptr: ($T1)$c.ptr
 608         )
 609     )
 610 }
 611
 612 *::QList<*>::iterator|*::QList<*>::const_iterator|*::QQueue<*>::iterator|*::QQueue<*>::const_iterator{
 613     preview
 614     (
 615         #(
 616             ($T2)$c.i->v
 617         )
 618     )
 619     children
 620     (
 621         #(
 622             ptr: ($T2)$c.i->v
 623         )
 624     )
 625 }
 626
 627 ;------------------------------------------------------------------------------
 628 ; QListIterator
 629 ;------------------------------------------------------------------------------
 630 QListIterator<*>|QMutableListIterator<*>{
 631     preview
 632     (
 633         #(
 634             *($T1*)($c.i.i->v)
 635         )
 636     )
 637     children
 638     (
 639         #(
 640             Value: *($T1*)($c.i.i->v)
 641         )
 642     )
 643 }
 644
 645 *::QListIterator<*>|*::QMutableListIterator<*>{
 646     preview
 647     (
 648         #(
 649             *($T2*)($c.i.i->v)
 650         )
 651     )
 652     children
 653     (
 654         #(
 655             Value: *($T2*)($c.i.i->v)
 656         )
 657     )
 658 }
 659
 660 ;------------------------------------------------------------------------------
 661 ; QLinkedList
 662 ;------------------------------------------------------------------------------
 663 QLinkedList<*>{
 664     preview
 665     (
 666         #if ($e.d->size >= 10) (
 667             #(
 668                 "[", $e.d->size, "](",
 669                 #list
 670                 (
 671                     head: $c.d->n,
 672                     size: 10,
 673                     next: n
 674                 ) : ( (*(QLinkedListNode<$T1>*)&$e).t ), ", ...)"
 675             )
 676         ) #else (
 677             #(
 678                 "[", $e.d->size, "](",
 679                 #list
 680                 (
 681                     head: $c.d->n,
 682                     size: $c.d->size,
 683                     next: n
 684                 ) : ( (*(QLinkedListNode<$T1>*)&$e).t ), ")"
 685             )
 686         )
 687     )
 688     children
 689     (
 690         #(
 691             #list
 692             (
 693                 head: $c.d->n,
 694                 size: $c.d->size,
 695                 next: n
 696             ) : (*(QLinkedListNode<$T1>*)&$e).t
 697         )
 698     )
 699 }
 700
 701 *::QLinkedList<*>{
 702     preview
 703     (
 704         #if ($e.d->size >= 10) (
 705             #(
 706                 "[", $e.d->size, "](",
 707                 #list
 708                 (
 709                     head: $c.d->n,
 710                     size: 10,
 711                     next: n
 712                 ) : ( (*($T1::QLinkedListNode<$T2>*)&$e).t ), ", ...)"
 713             )
 714         ) #else (
 715             #(
 716                 "[", $e.d->size, "](",
 717                 #list
 718                 (
 719                     head: $c.d->n,
 720                     size: $c.d->size,
 721                     next: n
 722                 ) : ( (*($T1::QLinkedListNode<$T2>*)&$e).t ), ")"
 723             )
 724         )
 725     )
 726     children
 727     (
 728         #(
 729             #list
 730             (
 731                 head: $c.d->n,
 732                 size: $c.d->size,
 733                 next: n
 734             ) : (*($T1::QLinkedListNode<$T2>*)&$e).t
 735         )
 736     )
 737 }
 738
 739 ;------------------------------------------------------------------------------
 740 ; QLinkedList::iterator
 741 ;------------------------------------------------------------------------------
 742 QLinkedList<*>::iterator|*::QLinkedList<*>::iterator|QLinkedList<*>::const_iterator|*::QLinkedList<*>::const_iterator{
 743     preview
 744     (
 745         #(
 746             $e.i->t
 747         )
 748     )
 749     children
 750     (
 751         #(
 752             ptr: $e.i->t
 753         )
 754     )
 755 }
 756
 757 QLinkedListIterator<*>|*::QLinkedListIterator<*>{
 758     preview
 759     (
 760         #(
 761             $c.i
 762         )
 763     )
 764     children
 765     (
 766         #(
 767             value: $c.i
 768         )
 769     )
 770 }
 771
 772 ;------------------------------------------------------------------------------
 773 ; QVector, QStack
 774 ;
 775 ; By default, this visualizer supports only Qt 4.6.x. If you're going to use
 776 ; Qt 4.5.x code, then you may want to replace all expr lines with this:
 777 ;    expr: (((size_t)($c.d) + (size_t)(sizeof(QVectorData)) ))[$i],
 778 ;
 779 ; This will allow this visualizer to display Qt 4.5.x and Qt 4.6.x QVector
 780 ; objects. But be aware of some limitations. For example enum types can't be
 781 ; displayed properly this way.
 782 ;
 783 ; Qt 4.5.x:
 784 ;     QVector::d is QVectorTypedData<T>
 785 ;     QVector::p is QVectorData
 786 ;     expr: $c.d->array[$i]
 787 ;
 788 ; Qt 4.6.x:
 789 ;     QVector::d is QVectorData
 790 ;     QVector::p is QVectorTypedData<T>
 791 ;     expr: $c.p->array[$i]
 792 ;
 793 ;------------------------------------------------------------------------------
 794 QVector<*>|*::QVector<*>|QStack<*>|*::QStack<*>{
 795     preview
 796     (
 797         #if ($c.d->size <= 10) (
 798             #(
 799                 "[", $c.d->size, "](",
 800                 #array
 801                 (
 802                     expr: $c.p->array[$i],
 803                     size: $c.d->size
 804                 ), ")"
 805             )
 806         ) #else (
 807             #(
 808                 "[", $c.d->size, "](",
 809                 #array
 810                 (
 811                     expr: $c.p->array[$i],
 812                     size: 10
 813                 ), ", ...)"
 814             )
 815         )
 816     )
 817     children
 818     (
 819         #array
 820         (
 821             expr: $c.p->array[$i],
 822             size: $c.d->size
 823         )
 824     )
 825 }
 826
 827 ;------------------------------------------------------------------------------
 828 ; QMap
 829 ;------------------------------------------------------------------------------
 830 QMapNode<*,*>{
 831     preview
 832     (
 833         #(
 834             "(",
 835             $e.key,
 836             "; ",
 837             $e.value,
 838             ")"
 839         )
 840     )
 841
 842     children
 843     (
 844         #(
 845             key: $e.key,
 846             value: $e.value
 847         )
 848     )
 849 }
 850
 851 QMap<*>{
 852     children
 853     (
 854         #(
 855             raw data: [$c,!],
 856             #tree
 857             (
 858                 head : $c.d->forward[0],
 859                 skip : $c.d,
 860                 size : $c.d->size,
 861                 left : backward,
 862                 right : forward
 863             ) : ( (QMapNode<$T1>*)((char*)&$e - (sizeof(QMapPayloadNode<$T1>) - sizeof(QMapData::Node*))) )
 864         )
 865     )
 866
 867     preview
 868     (
 869         #(
 870             "[",
 871             $e.d->size,
 872             "](",
 873                 #tree
 874                 (
 875                     head : $c.d->forward[0],
 876                     size : $c.d->size,
 877                     left : backward,
 878                     right : forward
 879                 ) : $e,
 880             ")"
 881         )
 882     )
 883 }
 884
 885 ;------------------------------------------------------------------------------
 886 ; QHash
 887 ;------------------------------------------------------------------------------
 888 QHash<*>{
 889     preview
 890     (
 891         #(
 892             "[", $e.d->size, "] (...)"
 893         )
 894     )
 895     children
 896     (
 897         #if ($e.d->size <= 255) (
 898             #(
 899                 #array (
 900                     expr: (QHashNode<$T1>*)$c.d->buckets[$i],
 901                     size: $c.d->numBuckets
 902                 ) : #list (
 903                     head: $e,
 904                     next: next
 905                 ) : #switch ($e.next != 0) #case 1 (
 906                     $e
 907                 )
 908             )
 909         ) #else (
 910             #(
 911                 #array (
 912                     expr: (QHashNode<$T1>*)$c.d->buckets[$i],
 913                     size: 255
 914                 ) : #list (
 915                     head: $e,
 916                     next: next
 917                 ) : #switch ($e.next != 0) #case 1 (
 918                     $e
 919                 )
 920             )
 921         )
 922     )
 923 }
 924
 925 *::QHash<*>{
 926     preview
 927     (
 928         #(
 929              "[", $e.d->size, "] (...)"
 930         )
 931     )
 932     children
 933     (
 934         #if ($e.d->size <= 255) (
 935             #(
 936                 #array (
 937                     expr: ($T1::QHashNode<$T2> *)$c.d->buckets[$i],
 938                     size: $c.d->numBuckets
 939                 ) : #list (
 940                     head: $e,
 941                     next: next
 942                 ) : #switch ($e.next != 0) #case 1 (
 943                     $e
 944                 )
 945             )
 946         ) #else (
 947             #(
 948                 #array (
 949                     expr: ($T1::QHashNode<$T2> *)$c.d->buckets[$i],
 950                     size: 255
 951                 ) : #list (
 952                     head: $e,
 953                     next: next
 954                 ) : #switch ($e.next != 0) #case 1 (
 955                     $e
 956                 )
 957             )
 958         )
 959     )
 960 }
 961
 962 ;------------------------------------------------------------------------------
 963 ; QMultiHash
 964 ;------------------------------------------------------------------------------
 965 QMultiHash<*>{
 966     preview
 967     (
 968         (*(QHash<$T1>*)(&$c))
 969     )
 970 }
 971
 972 *::QMultiHash<*>{
 973     preview
 974     (
 975         (*($T1::QHash<$T2>*)(&$c))
 976     )
 977 }
 978
 979 ;------------------------------------------------------------------------------
 980 ; QHash::iterator
 981 ;------------------------------------------------------------------------------
 982 QHash<*>::iterator{
 983     preview
 984     (
 985         #(
 986             "(", ((QHashNode<$T1>*)($c.i))->key, ", ", ((QHashNode<$T1>*)($c.i))->value, ")"
 987         )
 988     )
 989     children
 990     (
 991         #(
 992             key: ((QHashNode<$T1>*)($c.i))->key,
 993             value: ((QHashNode<$T1>*)($c.i))->value
 994         )
 995     )
 996 }
 997
 998 *::QHash<*>::iterator{
 999     preview
1000     (
1001         #(
1002             "(", (($T1::QHashNode<$T2>*)($c.i))->key, ", ", (($T1::QHashNode<$T2>*)($c.i))->key, ")"
1003         )
1004     )
1005     children
1006     (
1007         #(
1008             key: (($T1::QHashNode<$T2>*)($c.i))->key,
1009             value: (($T1::QHashNode<$T2>*)($c.i))->value
1010         )
1011     )
1012 }
1013
1014 ;------------------------------------------------------------------------------
1015 ; QHashIterator
1016 ;------------------------------------------------------------------------------
1017 QHashIterator<*>{
1018     preview
1019     (
1020         #(
1021             "(", ((QHashNode<$T1>*)((($c).i).i))->key, ", ", ((QHashNode<$T1>*)((($c).i).i))->key, ")"
1022         )
1023     )
1024     children
1025     (
1026         #(
1027             key: ((QHashNode<$T1>*)((($c).i).i))->key,
1028             value: ((QHashNode<$T1>*)((($c).i).i))->value
1029         )
1030     )
1031 }
1032
1033 *::QHashIterator<*>{
1034     preview
1035     (
1036         #(
1037             "(", (($T1::QHashNode<$T2>*)((($c).i).i))->key, ", ", (($T1::QHashNode<$T2>*)((($c).i).i))->key, ")"
1038         )
1039     )
1040     children
1041     (
1042         #(
1043             key: (($T1::QHashNode<$T2>*)((($c).i).i))->key,
1044             value: (($T1::QHashNode<$T2>*)((($c).i).i))->value
1045         )
1046     )
1047 }
1048
1049 ;------------------------------------------------------------------------------
1050 ; QHashNode
1051 ;------------------------------------------------------------------------------
1052 QHashNode<*>|*::QHashNode<*>{
1053     preview
1054     (
1055         #(
1056             "(key = ", $c.key,"; value = ", $c.value, ")"
1057         )
1058     )
1059     children
1060     (
1061         #(
1062             key: $c.key,
1063             value: $c.value
1064         )
1065     )
1066 }
1067
1068 ;------------------------------------------------------------------------------
1069 ; QSet
1070 ;------------------------------------------------------------------------------
1071 QSet<*>{
1072     preview
1073     (
1074         #(
1075              "[", $e.q_hash.d->size, "] (...)"
1076         )
1077     )
1078     children
1079     (
1080         #if ($e.q_hash.d->size <= 255) (
1081             #(
1082                 #array (
1083                     expr: (QHashNode<$T1,QHashDummyValue> *)$c.q_hash.d->buckets[$i],
1084                     size: $c.q_hash.d->numBuckets
1085                 ) : #list (
1086                     head: $e,
1087                     next: next
1088                 ) : #switch ($e.next != 0) #case 1 (
1089                     $e.key
1090                 )
1091             )
1092         ) #else (
1093             #(
1094                 #array (
1095                     expr: (QHashNode<$T1,QHashDummyValue> *)$c.q_hash.d->buckets[$i],
1096                     size: 255
1097                 ) : #list (
1098                     head: $e,
1099                     next: next
1100                 ) : #switch ($e.next != 0) #case 1 (
1101                     $e.key
1102                 )
1103             )
1104         )
1105     )
1106 }
1107
1108 *::QSet<*>{
1109     preview
1110     (
1111         #(
1112              "[", $e.q_hash.d->size, "] (...)"
1113         )
1114     )
1115     children
1116     (
1117         #if ($e.q_hash.d->size <= 255) (
1118             #(
1119                 #array (
1120                     expr: ($T1::QHashNode<$T2,QHashDummyValue> *)$c.q_hash.d->buckets[$i],
1121                     size: $c.q_hash.d->numBuckets
1122                 ) : #list (
1123                     head: $e,
1124                     next: next
1125                 ) : #switch ($e.next != 0) #case 1 (
1126                     $e.key
1127                 )
1128             )
1129         ) #else (
1130             #(
1131                 #array (
1132                     expr: ($T1::QHashNode<$T2,QHashDummyValue> *)$c.q_hash.d->buckets[$i],
1133                     size: 255
1134                 ) : #list (
1135                     head: $e,
1136                     next: next
1137                 ) : #switch ($e.next != 0) #case 1 (
1138                     $e.key
1139                 )
1140             )
1141         )
1142     )
1143 }
1144
1145 ;------------------------------------------------------------------------------
1146 ; QPalette
1147 ;------------------------------------------------------------------------------
1148 QPalette{
1149     children
1150     (
1151         #(
1152             WindowText_active:
1153                 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+ 0)->d,
1154             Button_active:
1155                 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+ 1)->d,
1156             Light_active:
1157                 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+ 2)->d,
1158             Midlight_active:
1159                 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+ 3)->d,
1160             Dark_active:
1161                 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+ 4)->d,
1162             Mid_active:
1163                 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+ 5)->d,
1164             Text_active:
1165                 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+ 6)->d,
1166             BrightText_active:
1167                 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+ 7)->d,
1168             ButtonText_active:
1169                 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+ 8)->d,
1170             Base_active:
1171                 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+ 9)->d,
1172             Window_active:
1173                 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+10)->d,
1174             Shadow_active:
1175                 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+11)->d,
1176             Highlight_active:
1177                 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+12)->d,
1178             HighlightedText_active:
1179                 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+13)->d,
1180             Link_active:
1181                 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+14)->d,
1182             LinkVisited_active:
1183                 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+15)->d,
1184             AlternateBase_active:
1185                 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+16)->d,
1186             NoRole_active:
1187                 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+17)->d,
1188             ToolTipBase_active:
1189                 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+18)->d,
1190             ToolTipText_active:
1191                 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+19)->d,
1192
1193             WindowText_disabled:
1194                 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+ 0)->d,
1195             Button_disabled:
1196                 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+ 1)->d,
1197             Light_disabled:
1198                 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+ 2)->d,
1199             Midlight_disabled:
1200                 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+ 3)->d,
1201             Dark_disabled:
1202                 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+ 4)->d,
1203             Mid_disabled:
1204                 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+ 5)->d,
1205             Text_disabled:
1206                 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+ 6)->d,
1207             BrightText_disabled:
1208                 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+ 7)->d,
1209             ButtonText_disabled:
1210                 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+ 8)->d,
1211             Base_disabled:
1212                 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+ 9)->d,
1213             Window_disabled:
1214                 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+10)->d,
1215             Shadow_disabled:
1216                 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+11)->d,
1217             Highlight_disabled:
1218                 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+12)->d,
1219             HighlightedText_disabled:
1220                 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+13)->d,
1221             Link_disabled:
1222                 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+14)->d,
1223             LinkVisited_disabled:
1224                 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+15)->d,
1225             AlternateBase_disabled:
1226                 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+16)->d,
1227             NoRole_disabled:
1228                 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+17)->d,
1229             ToolTipBase_disabled:
1230                 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+18)->d,
1231             ToolTipText_disabled:
1232                 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+19)->d,
1233
1234             WindowText_inactive:
1235                 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+ 0)->d,
1236             Button_inactive:
1237                 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+ 1)->d,
1238             Light_inactive:
1239                 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+ 2)->d,
1240             Midlight_inactive:
1241                 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+ 3)->d,
1242             Dark_inactive:
1243                 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+ 4)->d,
1244             Mid_inactive:
1245                 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+ 5)->d,
1246             Text_inactive:
1247                 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+ 6)->d,
1248             BrightText_inactive:
1249                 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+ 7)->d,
1250             ButtonText_inactive:
1251                 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+ 8)->d,
1252             Base_inactive:
1253                 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+ 9)->d,
1254             Window_inactive:
1255                 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+10)->d,
1256             Shadow_inactive:
1257                 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+11)->d,
1258             Highlight_inactive:
1259                 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+12)->d,
1260             HighlightedText_inactive:
1261                 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+13)->d,
1262             Link_inactive:
1263                 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+14)->d,
1264             LinkVisited_inactive:
1265                 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+15)->d,
1266             AlternateBase_inactive:
1267                 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+16)->d,
1268             NoRole_inactive:
1269                 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+17)->d,
1270             ToolTipBase_inactive:
1271                 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+18)->d,
1272             ToolTipText_inactive:
1273                 ((QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+19)->d
1274         )
1275     )
1276 }
1277
1278 *::QPalette{
1279     children
1280     (
1281         #(
1282             WindowText_active:
1283                 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+ 0)->d,
1284             Button_active:
1285                 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+ 1)->d,
1286             Light_active:
1287                 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+ 2)->d,
1288             Midlight_active:
1289                 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+ 3)->d,
1290             Dark_active:
1291                 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+ 4)->d,
1292             Mid_active:
1293                 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+ 5)->d,
1294             Text_active:
1295                 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+ 6)->d,
1296             BrightText_active:
1297                 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+ 7)->d,
1298             ButtonText_active:
1299                 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+ 8)->d,
1300             Base_active:
1301                 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+ 9)->d,
1302             Window_active:
1303                 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+10)->d,
1304             Shadow_active:
1305                 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+11)->d,
1306             Highlight_active:
1307                 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+12)->d,
1308             HighlightedText_active:
1309                 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+13)->d,
1310             Link_active:
1311                 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+14)->d,
1312             LinkVisited_active:
1313                 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+15)->d,
1314             AlternateBase_active:
1315                 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+16)->d,
1316             NoRole_active:
1317                 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+17)->d,
1318             ToolTipBase_active:
1319                 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+18)->d,
1320             ToolTipText_active:
1321                 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+19)->d,
1322
1323             WindowText_disabled:
1324                 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+ 0)->d,
1325             Button_disabled:
1326                 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+ 1)->d,
1327             Light_disabled:
1328                 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+ 2)->d,
1329             Midlight_disabled:
1330                 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+ 3)->d,
1331             Dark_disabled:
1332                 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+ 4)->d,
1333             Mid_disabled:
1334                 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+ 5)->d,
1335             Text_disabled:
1336                 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+ 6)->d,
1337             BrightText_disabled:
1338                 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+ 7)->d,
1339             ButtonText_disabled:
1340                 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+ 8)->d,
1341             Base_disabled:
1342                 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+ 9)->d,
1343             Window_disabled:
1344                 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+10)->d,
1345             Shadow_disabled:
1346                 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+11)->d,
1347             Highlight_disabled:
1348                 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+12)->d,
1349             HighlightedText_disabled:
1350                 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+13)->d,
1351             Link_disabled:
1352                 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+14)->d,
1353             LinkVisited_disabled:
1354                 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+15)->d,
1355             AlternateBase_disabled:
1356                 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+16)->d,
1357             NoRole_disabled:
1358                 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+17)->d,
1359             ToolTipBase_disabled:
1360                 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+18)->d,
1361             ToolTipText_disabled:
1362                 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+20+19)->d,
1363
1364             WindowText_inactive:
1365                 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+ 0)->d,
1366             Button_inactive:
1367                 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+ 1)->d,
1368             Light_inactive:
1369                 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+ 2)->d,
1370             Midlight_inactive:
1371                 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+ 3)->d,
1372             Dark_inactive:
1373                 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+ 4)->d,
1374             Mid_inactive:
1375                 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+ 5)->d,
1376             Text_inactive:
1377                 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+ 6)->d,
1378             BrightText_inactive:
1379                 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+ 7)->d,
1380             ButtonText_inactive:
1381                 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+ 8)->d,
1382             Base_inactive:
1383                 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+ 9)->d,
1384             Window_inactive:
1385                 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+10)->d,
1386             Shadow_inactive:
1387                 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+11)->d,
1388             Highlight_inactive:
1389                 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+12)->d,
1390             HighlightedText_inactive:
1391                 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+13)->d,
1392             Link_inactive:
1393                 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+14)->d,
1394             LinkVisited_inactive:
1395                 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+15)->d,
1396             AlternateBase_inactive:
1397                 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+16)->d,
1398             NoRole_inactive:
1399                 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+17)->d,
1400             ToolTipBase_inactive:
1401                 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+18)->d,
1402             ToolTipText_inactive:
1403                 (($T1::QBrush*)((char*)$c.d+sizeof(QAtomicInt))+40+19)->d
1404         )
1405     )
1406 }
1407
1408 ;------------------------------------------------------------------------------
1409 ; QBrush
1410 ;------------------------------------------------------------------------------
1411 QBrush|*::QBrush{
1412     preview
1413     (
1414         #(
1415             "[", $c.d->style, "] (...)"
1416         )
1417     )
1418     children
1419     (
1420         #(
1421             style: $c.d->style,
1422             color: $c.d->color,
1423             transform: $c.d->transform
1424         )
1425     )
1426 }
1427
1428 QBrushData|*::QBrushData{
1429     preview
1430     (
1431         #(
1432             "[", $c.style, "] (...)"
1433         )
1434     )
1435     children
1436     (
1437         #(
1438             style: $c.style,
1439             color: $c.color,
1440             transform: $c.transform
1441         )
1442     )
1443 }
1444
1445 ;------------------------------------------------------------------------------
1446 ; QColor
1447 ;------------------------------------------------------------------------------
1448 QColor|*::QColor{
1449     preview
1450     (
1451         #(
1452             #if ($c.cspec == 1) (
1453                 #(
1454                     "[", $c.cspec, "] [", "r = ", [$c.ct.argb.red,x],
1455                                           ", g = ", [$c.ct.argb.green,x],
1456                                           ", b = ", [$c.ct.argb.blue,x], "] (...)"
1457                 )
1458             ) #elif ($c.cspec == 2) (
1459                 #(
1460                     "[", $c.cspec, "] [", "h = ", [$c.ct.ahsv.hue,x],
1461                                           ", s = ", [$c.ct.ahsv.saturation,x],
1462                                           ", v = ", [$c.ct.ahsv.value,x], "] (...)"
1463                 )
1464             ) #elif ($c.cspec == 3) (
1465                 #(
1466                     "[", $c.cspec, "] [", "c = ", [$c.ct.acmyk.cyan,x],
1467                                           ", m = ", [$c.ct.acmyk.magenta,x],
1468                                           ", y = ", [$c.ct.acmyk.yellow,x],
1469                                           ", k = ", [$c.ct.acmyk.black,x], "] (...)"
1470                 )
1471             ) #else (
1472                 #(
1473                     "[Invalid]"
1474                 )
1475             )
1476         )
1477     )
1478     children
1479     (
1480         #(
1481             #if ($c.cspec == 1) (
1482                 #(
1483                     red: [$c.ct.argb.red,x],
1484                     green: [$c.ct.argb.green,x],
1485                     blue: [$c.ct.argb.blue,x],
1486                     alpha: [$c.ct.argb.alpha,x],
1487             pad: [$c.ct.argb.pad,x]
1488                 )
1489             ) #elif ($c.cspec == 2) (
1490                 #(
1491                     hue: [$c.ct.ahsv.hue,x],
1492                     saturation: [$c.ct.ahsv.saturation,x],
1493                     value: [$c.ct.ahsv.value,x],
1494                     alpha: [$c.ct.ahsv.alpha,x],
1495             pad: [$c.ct.ahsv.pad,x]
1496                 )
1497             ) #elif ($c.cspec == 3) (
1498                 #(
1499                     cyan: [$c.ct.acmyk.cyan,x],
1500                     magenta: [$c.ct.acmyk.magenta,x],
1501                     yellow: [$c.ct.acmyk.yellow,x],
1502                     black: [$c.ct.acmyk.black,x],
1503                     alpha: [$c.ct.acmyk.alpha,x]
1504                 )
1505             )
1506         )
1507     )
1508 }
1509
1510 ;------------------------------------------------------------------------------
1511 ; QTransform
1512 ;------------------------------------------------------------------------------
1513 QTransform|*::QTransform{
1514     preview
1515     (
1516         #(
1517             "[",[$c.affine._m11,g]," ",[$c.affine._m12,g]," ",[$c.m_13,g],"]",
1518             "[",[$c.affine._m21,g]," ",[$c.affine._m22,g]," ",[$c.m_23,g],"]",
1519             "[",[$c.affine._dx,g]," ",[$c.affine._dy,g]," ",[$c.m_33,g],"]"
1520         )
1521     )
1522     children
1523     (
1524         #(
1525             translation_horizontal_m31_dx: [$c.affine._dx,g],
1526             translation_vertical_m32_dy: [$c.affine._dy,g],
1527             scaling_horizontal_m11: [$c.affine._m11,g],
1528             scaling_vertical_m22: [$c.affine._m22,g],
1529             projection_factor_m33: [$c.m_33,g],
1530             projection_horizontal_m13: [$c.m_13,g],
1531             projection_vertical_m23: [$c.m_23,g],
1532             shearing_horizontal_m21: [$c.affine._m21,g],
1533             shearing_vertical_m12: [$c.affine._m12,g],
1534             type: $c.m_type,
1535             dirty: (bool)$c.m_dirty
1536         )
1537     )
1538 }
1539
1540 ;------------------------------------------------------------------------------
1541 ; QMatrix
1542 ;------------------------------------------------------------------------------
1543 QMatrix|*::QMatrix{
1544     preview
1545     (
1546         #(
1547             "[",[$c._m11,g]," ",[$c._m12,g],"]",
1548             "[",[$c._m21,g]," ",[$c._m22,g],"]",
1549             "[",[$c._dx,g]," ",[$c._dy,g],"]"
1550         )
1551     )
1552     children
1553     (
1554         #(
1555             translation_horizontal_dx: [$c._dx,g],
1556             translation_vertical_dy: [$c._dy,g],
1557             scaling_horizontal_m11: [$c._m11,g],
1558             scaling_vertical_m22: [$c._m22,g],
1559             shearing_horizontal_m21: [$c._m21,g],
1560             shearing_vertical_m12: [$c._m12,g]
1561         )
1562     )
1563 }
1564
1565 ;------------------------------------------------------------------------------
1566 ; QPolygon
1567 ;------------------------------------------------------------------------------
1568 QPolygon{
1569     preview
1570     (
1571         #(
1572              "[", ((QVector<QPoint>*)(&$c))->d->size, "] (...)"
1573         )
1574     )
1575     children
1576     (
1577         #(
1578             #array
1579             (
1580                 expr: ((QPoint*)(((void*)$c.d) + sizeof(QVectorData)))[$i],
1581                 size: ((QVector<QPoint>*)(&$c))->d->size
1582             )
1583         )
1584     )
1585 }
1586 *::QPolygon{
1587     preview
1588     (
1589         #(
1590              "[", (($T1::QVector<$T1::QPoint>*)(&$c))->d->size, "] (...)"
1591         )
1592     )
1593     children
1594     (
1595         #(
1596             #array
1597             (
1598                 expr: (($T1::QPoint*)(((void*)$c.d) + sizeof(QVectorData)))[$i],
1599                 size: (($T1::QVector<$T1::QPoint>*)(&$c))->d->size
1600             )
1601         )
1602     )
1603 }
1604
1605 ;------------------------------------------------------------------------------
1606 ; QPolygonF
1607 ;------------------------------------------------------------------------------
1608 QPolygonF{
1609     preview
1610     (
1611         #(
1612              "[", ((QVector<QPointF>*)(&$c))->d->size, "] (...)"
1613         )
1614     )
1615     children
1616     (
1617         #(
1618             #array
1619             (
1620                 expr: ((QVector<QPointF>*)(&$c))->p->array[$i],
1621                 size: ((QVector<QPointF>*)(&$c))->d->size
1622             )
1623         )
1624     )
1625 }
1626
1627 *::QPolygonF{
1628     preview
1629     (
1630         #(
1631              "[", (($T1::QVector<$T1::QPointF>*)(&$c))->d->size, "] (...)"
1632         )
1633     )
1634     children
1635     (
1636         #(
1637             #array
1638             (
1639                 expr: (($T1::QVector<$T1::QPointF>*)(&$c))->p->array[$i],
1640                 size: (($T1::QVector<$T1::QPointF>*)(&$c))->d->size
1641             )
1642         )
1643     )
1644 }
1645
1646 ;------------------------------------------------------------------------------
1647 ; stlport::basic_string
1648 ;------------------------------------------------------------------------------
1649 stlp_std::basic_string<char,*>|stlpx_std::basic_string<char,*>|stlpmtx_std::basic_string<char,*>|stlpxmtx_std::basic_string<char,*>|stlpd_std::priv::_NonDbg_str<char,*>|stlpdx_std::priv::_NonDbg_str<char,*>|stlpdmtx_std::priv::_NonDbg_str<char,*>|stlpdxmtx_std::priv::_NonDbg_str<char,*>{
1650     preview
1651     (
1652         [$c._M_start_of_storage._M_data, s]
1653     )
1654
1655     stringview
1656     (
1657         [$c._M_start_of_storage._M_data, s]
1658     )
1659
1660     children
1661     (
1662         #(
1663             [raw view]: [$c,!],
1664             buffer: [(unsigned int)$c._M_start_of_storage._M_data, x],
1665             length: $c._M_finish - $c._M_start_of_storage._M_data,
1666             capacity: #if($c._M_start_of_storage._M_data == $c._M_buffers._M_static_buf)
1667                     (
1668                         $c._DEFAULT_SIZE
1669                     )
1670                     #else
1671                     (
1672                         $c._M_buffers._M_end_of_storage - $c._M_start_of_storage._M_data
1673                     ),
1674             #array
1675             (
1676                                 expr: $c._M_start_of_storage._M_data[$i],
1677                                 size: $c._M_finish - $c._M_start_of_storage._M_data
1678                         )
1679         )
1680     )
1681 }
1682
1683 stlp_std::basic_string<unsigned short,*>|stlp_std::basic_string<wchar_t,*>|stlpx_std::basic_string<unsigned short,*>|stlpx_std::basic_string<wchar_t,*>|stlpmtx_std::basic_string<unsigned short,*>|stlpmtx_std::basic_string<wchar_t,*>|stlpxmtx_std::basic_string<unsigned short,*>|stlpxmtx_std::basic_string<wchar_t,*>|stlpd_std::priv::_NonDbg_str<unsigned short,*>|stlpd_std::priv::_NonDbg_str<wchar_t,*>|stlpdx_std::priv::_NonDbg_str<unsigned short,*>|stlpdx_std::priv::_NonDbg_str<wchar_t,*>|stlpdmtx_std::priv::_NonDbg_str<unsigned short,*>|stlpdmtx_std::priv::_NonDbg_str<wchar_t,*>|stlpdxmtx_std::priv::_NonDbg_str<unsigned short,*>|stlpdxmtx_std::priv::_NonDbg_str<wchar_t,*>{
1684     preview
1685     (
1686         [$c._M_start_of_storage._M_data, su]
1687     )
1688
1689     stringview
1690     (
1691         [$c._M_start_of_storage._M_data, su]
1692     )
1693
1694     children
1695     (
1696         #(
1697             [raw view]: [$c,!],
1698             buffer: [(unsigned int)$c._M_start_of_storage._M_data, x],
1699             length: $c._M_finish - $c._M_start_of_storage._M_data,
1700             capacity: #if($c._M_start_of_storage._M_data == $c._M_buffers._M_static_buf)
1701                     (
1702                         $c._DEFAULT_SIZE
1703                     )
1704                     #else
1705                     (
1706                         $c._M_buffers._M_end_of_storage - $c._M_start_of_storage._M_data
1707                     ),
1708             #array
1709             (
1710                                 expr: $c._M_start_of_storage._M_data[$i],
1711                                 size: $c._M_finish - $c._M_start_of_storage._M_data
1712                         )
1713         )
1714     )
1715 }
1716
1717 stlpd_std::basic_string<*>|stlpdx_std::basic_string<*>|stlpdmtx_std::basic_string<*>|stlpdxmtx_std::basic_string<*>{
1718     preview
1719     (
1720                 $c._M_non_dbg_impl
1721         )
1722
1723     stringview
1724     (
1725                 $c._M_non_dbg_impl
1726     )
1727
1728     children
1729     (
1730         #(
1731             [raw view]: [$c,!],
1732             string: $c._M_non_dbg_impl
1733          )
1734     )
1735 }
1736
1737 ;------------------------------------------------------------------------------
1738 ; stlport::vector
1739 ;------------------------------------------------------------------------------
1740 stlp_std::vector<bool,*>|stlpx_std::vector<bool,*>|stlpmtx_std::vector<bool,*>|stlpxmtx_std::vector<bool,*>|stlpd_std::priv::_NonDbg_vector<bool,*>|stlpdx_std::priv::_NonDbg_vector<bool,*>|stlpdmtx_std::priv::_NonDbg_vector<bool,*>|stlpdxmtx_std::priv::_NonDbg_vector<bool,*>{
1741     preview
1742     (
1743         #(
1744                         "[",
1745                         ($c._M_finish._M_p - $c._M_start._M_p) * sizeof(unsigned int) * 8 + $c._M_finish._M_offset,
1746                         "](",
1747                         #array
1748                         (
1749                                 expr : ($c._M_start._M_p[$i / (sizeof(unsigned int) * 8)] >> ($i % (sizeof(unsigned int) * 8))),
1750                                 size : (($c._M_finish._M_p - $c._M_start._M_p) * sizeof(unsigned int) * 8 + $c._M_finish._M_offset)
1751                         )  : (bool)($e & 1),
1752                         ")"
1753                 )
1754         )
1755         children
1756         (
1757                 #(
1758                         [raw view]: [$c,!],
1759                         buffer : [(unsigned int)$c._M_start._M_p, x],
1760                         size : (($c._M_finish._M_p - $c._M_start._M_p) * sizeof(unsigned int) * 8 + $c._M_finish._M_offset),
1761                         #array
1762                         (
1763                                 expr : ($c._M_start._M_p[$i / (sizeof(unsigned int) * 8)] >> ($i % (sizeof(unsigned int) * 8))),
1764                                 size : (($c._M_finish._M_p - $c._M_start._M_p) * sizeof(unsigned int) * 8 + $c._M_finish._M_offset)
1765                         )  : (bool)($e & 1)
1766                 )
1767         )
1768 }
1769
1770 stlp_std::priv::_Bit_iter<*>|stlpx_std::priv::_Bit_iter<*>|stlpmtx_std::priv::_Bit_iter<*>|stlpxmtx_std::priv::_Bit_iter<*>|stlpd_std::priv::_Bit_iter<*>|stlpdx_std::priv::_Bit_iter<*>|stlpdmtx_std::priv::::_Bit_iter<*>|stlpdxmtx_std::priv::_Bit_iter<*>{
1771         preview
1772         (
1773                 #(
1774                         (bool) (((*$c._M_p) >> $c._M_offset) & 1)
1775                 )
1776         )
1777         children
1778         (
1779                 #(
1780                         [raw view]: [$c,!],
1781                         value : (bool) (((*$c._M_p) >> $c._M_offset) & 1)
1782                 )
1783         )
1784 }
1785
1786 stlp_std::vector<*>|stlpx_std::vector<*>|stlpmtx_std::vector<*>|stlpxmtx_std::vector<*>|stlpd_std::priv::_NonDbg_vector<*>|stlpdx_std::priv::_NonDbg_vector<*>|stlpdmtx_std::priv::_NonDbg_vector<*>|stlpdxmtx_std::priv::_NonDbg_vector<*>{
1787     preview
1788     (
1789         #(
1790             "[",
1791             $c._M_finish - $c._M_start,
1792             "/",
1793             $c._M_end_of_storage._M_data - $c._M_start,
1794             "](",
1795             #array
1796             (
1797                 expr :  ($c._M_start)[$i],
1798                 size :  $c._M_finish - $c._M_start
1799             ),
1800             ")"
1801         )
1802     )
1803     children
1804     (
1805         #(
1806             [raw view]: [$c,!],
1807             size : $c._M_finish - $c._M_start,
1808             capacity : $c._M_end_of_storage._M_data - $c._M_start,
1809             #array
1810             (
1811                 expr :  ($c._M_start)[$i],
1812                 size :  $c._M_finish - $c._M_start
1813             )
1814         )
1815     )
1816 }
1817
1818 stlpd_std::vector<*>|stlpdx_std::vector<*>|stlpdmtx_std::vector<*>|stlpdxmtx_std::vector<*>{
1819     preview
1820     (
1821                 $c._M_non_dbg_impl
1822     )
1823     children
1824     (
1825         #(
1826             [raw view] : [$c,!],
1827             vector : $c._M_non_dbg_impl
1828          )
1829     )
1830 }
1831
1832 ;------------------------------------------------------------------------------
1833 ; stlport::deque
1834 ;------------------------------------------------------------------------------
1835 stlp_std::deque<*,*>|stlpx_std::deque<*,*>|stlpmtx_std::deque<*,*>|stlpxmtx_std::deque<*,*>|stlpd_std::priv::_NonDbg_deque<*,*>|stlpdx_std::priv::_NonDbg_deque<*,*>|stlpdmtx_std::priv::_NonDbg_deque<*,*>|stlpdxmtx_std::priv::_NonDbg_deque<*,*>{
1836     preview
1837     (
1838                 #if (((unsigned int)($c._M_start._M_cur + 1) - ((unsigned int)$c._M_start._M_cur)) < _MAX_BYTES)
1839                 (
1840                         #(
1841                                 "[",
1842                                 (($c._M_finish._M_node - $c._M_start._M_node + 1) * (_MAX_BYTES / sizeof($T1))) - ($c._M_start._M_cur - $c._M_start._M_first) - ($c._M_finish._M_last - $c._M_finish._M_cur),
1843                                 "/",
1844                                 ($c._M_finish._M_node - $c._M_start._M_node + 1) * (_MAX_BYTES / sizeof($T1)) - 1,
1845                                 "](",
1846                                 #array
1847                                 (
1848                                         expr : *(*($c._M_start._M_node + (($i + ($c._M_start._M_cur - $c._M_start._M_first)) / (_MAX_BYTES / sizeof($T1)))) + (($i + ($c._M_start._M_cur - $c._M_start._M_first)) % (_MAX_BYTES / sizeof($T1)))),
1849                                         size : (($c._M_finish._M_node - $c._M_start._M_node + 1) * (_MAX_BYTES / sizeof($T1))) - ($c._M_start._M_cur - $c._M_start._M_first) - ($c._M_finish._M_last - $c._M_finish._M_cur)
1850                                 ),
1851                                 ")"
1852                         )
1853                 )
1854                 #else
1855                 (
1856                         #(
1857                                 "[",
1858                                 $c._M_finish._M_node - $c._M_start._M_node,
1859                                 "/",
1860                                 $c._M_finish._M_node - $c._M_start._M_node,
1861                                 "](",
1862                                 #array
1863                                 (
1864                                         expr : **($c._M_start._M_node + $i),
1865                                         size : $c._M_finish._M_node - $c._M_start._M_node
1866                                 ),
1867                                 ")"
1868                         )
1869                 )
1870     )
1871     children
1872     (
1873                 #if (((unsigned int)($c._M_start._M_cur + 1) - ((unsigned int)$c._M_start._M_cur)) < _MAX_BYTES)
1874                 (
1875                         #(
1876                                 [raw view]: [$c,!],
1877                                 size : (($c._M_finish._M_node - $c._M_start._M_node + 1) * (_MAX_BYTES / sizeof($T1))) - ($c._M_start._M_cur - $c._M_start._M_first) - ($c._M_finish._M_last - $c._M_finish._M_cur),
1878                                 capacity : ($c._M_finish._M_node - $c._M_start._M_node + 1) * (_MAX_BYTES / sizeof($T1)) - 1,
1879                                 front free space : $c._M_start._M_cur - $c._M_start._M_first,
1880                                 back free space : $c._M_finish._M_last - $c._M_finish._M_cur - 1,
1881                                 #array
1882                                 (
1883                                         expr : *(*($c._M_start._M_node + (($i + ($c._M_start._M_cur - $c._M_start._M_first)) / (_MAX_BYTES / sizeof($T1)))) + (($i + ($c._M_start._M_cur - $c._M_start._M_first)) % (_MAX_BYTES / sizeof($T1)))),
1884                                         size : (($c._M_finish._M_node - $c._M_start._M_node + 1) * (_MAX_BYTES / sizeof($T1))) - ($c._M_start._M_cur - $c._M_start._M_first) - ($c._M_finish._M_last - $c._M_finish._M_cur)
1885                                 )
1886                         )
1887                 )
1888                 #else
1889                 (
1890                         #(
1891                                 [raw view] : [$c,!],
1892                                 size : $c._M_finish._M_node - $c._M_start._M_node,
1893                                 capacity : $c._M_finish._M_node - $c._M_start._M_node,
1894                                 front free space : $c._M_start._M_cur - $c._M_start._M_first,
1895                                 back free space : $c._M_finish._M_last - $c._M_finish._M_cur - 1,
1896                                 #array
1897                                 (
1898                                         expr : **($c._M_start._M_node + $i),
1899                                         size : $c._M_finish._M_node - $c._M_start._M_node
1900                                 )
1901                         )
1902                 )
1903     )
1904 }
1905
1906 stlp_std::priv::_Deque_iterator<*>|stlpx_std::priv::_Deque_iterator<*>|stlpmtx_std::priv::_Deque_iterator<*>|stlpxmtx_std::priv::_Deque_iterator<*>|stlpd_std::priv::_Deque_iterator<*>|stlpdx_std::priv::_Deque_iterator<*>|stlpdmtx_std::priv::_Deque_iterator<*>|stlpdxmtx_std::priv::_Deque_iterator<*>{
1907         preview
1908         (
1909                 *($c._M_cur)
1910         )
1911     children
1912     (
1913         #(
1914             [raw view] : [$c, !],
1915             ptr : [(unsigned int)($c._M_cur), x],
1916             value : *($c._M_cur)
1917         )
1918     )
1919 }
1920
1921 stlpd_std::deque<*>|stlpdx_std::deque<*>|stlpdmtx_std::deque<*>|stlpdxmtx_std::deque<*>{
1922     preview
1923     (
1924                 $c._M_non_dbg_impl
1925         )
1926     children
1927     (
1928         #(
1929             [raw view] : [$c,!],
1930             deque : $c._M_non_dbg_impl
1931         )
1932     )
1933 }
1934
1935 ;------------------------------------------------------------------------------
1936 ; stlport::list
1937 ;------------------------------------------------------------------------------
1938 stlp_std::list<*,*>|stlpx_std::list<*,*>|stlpmtx_std::list<*,*>|stlpxmtx_std::list<*,*>|stlpd_std::priv::_NonDbg_list<*,*>|stlpdx_std::priv::_NonDbg_list<*,*>|stlpdmtx_std::priv::_NonDbg_list<*,*>|stlpdxmtx_std::priv::_NonDbg_list<*,*>{
1939     preview
1940     (
1941                 #(
1942                         "(",
1943                         #list
1944                         (
1945                                 head : $c._M_node._M_data._M_next,
1946                                 skip : &($c._M_node._M_data),
1947                                 next : _M_next,
1948                         ): #( *($T1*)(&($e) + 1)),
1949                         ")"
1950                 )
1951     )
1952     children
1953     (
1954         #(
1955             [raw view]: [$c,!],
1956             #list
1957             (
1958                 head : $c._M_node._M_data._M_next,
1959                                 skip : &($c._M_node._M_data),
1960                 next : _M_next,
1961             ): #( *($T1*)(&($e) + 1))
1962         )
1963     )
1964 }
1965
1966 stlp_std::priv::_List_iterator<*,*>|stlpx_std::priv::_List_iterator<*,*>|stlpmtx_std::priv::_List_iterator<*,*>|stlpxmtx_std::priv::_List_iterator<*,*>|stlpd_std::priv::_List_iterator<*,*>|stlpdx_std::priv::_List_iterator<*,*>|stlpdmtx_std::priv::_List_iterator<*,*>|stlpdxmtx_std::priv::_List_iterator<*,*>{
1967     preview
1968     (
1969         #(*($T1 *)($c._M_node + 1))
1970     )
1971     children
1972     (
1973         #(
1974             [raw view] : [$c, !],
1975             ptr : [(unsigned int)($c._M_node + 1), x],
1976             value : *($T1 *)($c._M_node + 1)
1977         )
1978     )
1979 }
1980
1981 stlpd_std::list<*,*>|stlpdx_std::list<*,*>|stlpdmtx_std::list<*,*>|stlpdxmtx_std::list<*,*>{
1982     preview
1983     (
1984                 $c._M_non_dbg_impl
1985     )
1986     children
1987     (
1988         #(
1989             [raw view] : [$c,!],
1990             list : $c._M_non_dbg_impl
1991         )
1992     )
1993 }
1994
1995 ;------------------------------------------------------------------------------
1996 ; stlport::slist
1997 ;------------------------------------------------------------------------------
1998 stlp_std::slist<*,*>|stlpx_std::slist<*,*>|stlpmtx_std::slist<*,*>|stlpxmtx_std::slist<*,*>|stlpd_std::priv::_NonDbg_slist<*,*>|stlpdx_std::priv::_NonDbg_slist<*,*>|stlpdmtx_std::priv::_NonDbg_slist<*,*>|stlpdxmtx_std::priv::_NonDbg_slist<*,*>{
1999     preview
2000     (
2001                 #(
2002                         "(",
2003                         #list
2004                         (
2005                                 head : $c._M_head._M_data._M_next,
2006                                 skip : &($c._M_head._M_data),
2007                                 next : _M_next,
2008                         ): #( *($T1*)(&($e) + 1)),
2009                         ")"
2010                 )
2011     )
2012     children
2013     (
2014         #(
2015             [raw view]: [$c,!],
2016             #list
2017             (
2018                 head : $c._M_head._M_data._M_next,
2019                                 skip : &($c._M_head._M_data),
2020                 next : _M_next,
2021             ): #( *($T1*)(&($e) + 1))
2022         )
2023     )
2024 }
2025
2026 stlp_std::priv::_Slist_iterator<*,*>|stlpx_std::priv::_Slist_iterator<*,*>|stlpmtx_std::priv::_Slist_iterator<*,*>|stlpxmtx_std::priv::_Slist_iterator<*,*>|stlpd_std::priv::_Slist_iterator<*,*>|stlpdx_std::priv::_Slist_iterator<*,*>|stlpdmtx_std::priv::_Slist_iterator<*,*>|stlpdxmtx_std::priv::_Slist_iterator<*,*>{
2027     preview
2028     (
2029         #(*($T1 *)($c._M_node + 1))
2030     )
2031     children
2032     (
2033         #(
2034             [raw view] : [$c,!],
2035             ptr : [(unsigned int)($c._M_node + 1), x],
2036             value : *($T1 *)($c._M_node + 1)
2037         )
2038     )
2039 }
2040
2041 stlpd_std::slist<*,*>|stlpdx_std::slist<*,*>|stlpdmtx_std::slist<*,*>|stlpdxmtx_std::slist<*,*>{
2042     preview
2043     (
2044                 $c._M_non_dbg_impl
2045     )
2046     children
2047     (
2048         #(
2049             [raw view] : [$c,!],
2050             [slist] : $c._M_non_dbg_impl
2051         )
2052     )
2053 }
2054
2055 ;------------------------------------------------------------------------------
2056 ; stlport::pair
2057 ;------------------------------------------------------------------------------
2058 stlp_std::pair<*,*>|stlpx_std::pair<*,*>|stlpmtx_std::pair<*,*>|stlpxmtx_std::pair<*,*>|stlpd_std::pair<*,*>|stlpdx_std::pair<*,*>|stlpdmtx_std::pair<*,*>|stlpdxmtx_std::pair<*,*>{
2059     preview
2060     (
2061         #(
2062             "(",
2063             $c.first,
2064             ", ",
2065             $c.second,
2066             ")"
2067         )
2068     )
2069 }
2070
2071 ;------------------------------------------------------------------------------
2072 ; stlport::map, stlport::multimap, stlport::set, stlport::multiset
2073 ;------------------------------------------------------------------------------
2074 stlp_std::map<*>|stlpx_std::map<*>|stlpmtx_std::map<*>|stlpxmtx_std::map<*>|stlp_std::multimap<*>|stlpx_std::multimap<*>|stlpmtx_std::multimap<*>|stlpxmtx_std::multimap<*>|stlp_std::set<*>|stlpx_std::set<*>|stlpmtx_std::set<*>|stlpxmtx_std::set<*>|stlp_std::multiset<*>|stlpx_std::multiset<*>|stlpmtx_std::multiset<*>|stlpxmtx_std::multiset<*>{
2075     preview
2076     (
2077                 #(
2078                         "[",
2079                         $c._M_t._M_node_count,
2080                         "](",
2081                         $c._M_t,
2082                         ")"
2083                 )
2084     )
2085     children
2086     (
2087         #(
2088             [raw view]: [$c,!],
2089             size: [$c._M_t._M_node_count],
2090             tree: $c._M_t
2091         )
2092     )
2093 }
2094
2095 stlpd_std::map<*>|stlpdx_std::map<*>|stlpdmtx_std::map<*>|stlpdxmtx_std::map<*>|stlpd_std::multimap<*>|stlpdx_std::multimap<*>|stlpdmtx_std::multimap<*>|stlpdxmtx_std::multimap<*>|stlpd_std::set<*>|stlpdx_std::set<*>|stlpdmtx_std::set<*>|stlpdxmtx_std::set<*>|stlpd_std::multiset<*>|stlpdx_std::multiset<*>|stlpdmtx_std::multiset<*>|stlpdxmtx_std::multiset<*>{
2096     preview
2097     (
2098                 #(
2099                         "[",
2100                         $c._M_t._M_non_dbg_impl._M_node_count,
2101                         "](",
2102                         $c._M_t._M_non_dbg_impl,
2103                         ")"
2104                 )
2105     )
2106     children
2107     (
2108         #(
2109             [raw view]: [$c,!],
2110             size: $c._M_t._M_non_dbg_impl._M_node_count,
2111             tree: $c._M_t._M_non_dbg_impl
2112         )
2113     )
2114 }
2115
2116 stlp_std::priv::_Rb_tree<*,*,*,*,*>|stlpx_std::priv::_Rb_tree<*,*,*,*,*>|stlpmtx_std::priv::_Rb_tree<*,*,*,*,*>|stlpxmtx_std::priv::_Rb_tree<*,*,*,*,*>|stlpd_std::priv::_NonDbg_Rb_tree<*,*,*,*,*>|stlpdx_std::priv::_NonDbg_Rb_tree<*,*,*,*,*>|stlpdmtx_std::priv::_NonDbg_Rb_tree<*,*,*,*,*>|stlpdxmtx_std::priv::_NonDbg_Rb_tree<*,*,*,*,*>{
2117     preview
2118     (
2119                 #tree
2120                 (
2121                         head : $c._M_header._M_data._M_parent,
2122                         skip : &($c._M_header._M_data),
2123                         size : $c._M_node_count,
2124                         left : _M_left,
2125                         right : _M_right
2126                 ): #(*($T3 *)(&($e) + 1))
2127     )
2128     children
2129     (
2130         #(
2131             [raw view]: [$c,!],
2132             #tree
2133             (
2134                 head : $c._M_header._M_data._M_parent,
2135                                 skip : &($c._M_header._M_data),
2136                                 size : $c._M_node_count,
2137                 left : _M_left,
2138                 right : _M_right
2139             ) : #(*($T3 *)(&($e) + 1))
2140         )
2141     )
2142 }
2143
2144 stlp_std::priv::_Rb_tree_iterator<*,*>|stlpx_std::priv::_Rb_tree_iterator<*,*>|stlpmtx_std::priv::_Rb_tree_iterator<*,*>|stlpxmtx_std::priv::_Rb_tree_iterator<*,*>|stlpd_std::priv::_Rb_tree_iterator<*,*>|stlpdx_std::priv::_Rb_tree_iterator<*,*>|stlpdmtx_std::priv::_Rb_tree_iterator<*,*>|stlpdxmtx_std::priv::_Rb_tree_iterator<*,*>{
2145     preview
2146     (
2147         [*($T1*)($c._M_node + 1)]
2148     )
2149     children
2150     (
2151         #(
2152             [raw view]: [$c,!],
2153             value: [*($T1*)($c._M_node + 1)],
2154             ptr: [(unsigned int)($c._M_node + 1), x]
2155         )
2156     )
2157 }
2158
2159 ;------------------------------------------------------------------------------
2160 ; stlport::hash_map, stlport::hash_multimap, stlport::hash_set, stlport::hash_multiset
2161 ; stlport::unordered_map, stlport::unordered_multimap, stlport::unordered_set, stlport::unordered_multiset
2162 ;------------------------------------------------------------------------------
2163 stlp_std::hash_map<*>|stlpx_std::hash_map<*>|stlpmtx_std::hash_map<*>|stlpxmtx_std::hash_map<*>|stlp_std::hash_multimap<*>|stlpx_std::hash_multimap<*>|stlpmtx_std::hash_multimap<*>|stlpxmtx_std::hash_multimap<*>|stlp_std::hash_set<*>|stlpx_std::hash_set<*>|stlpmtx_std::hash_set<*>|stlpxmtx_std::hash_set<*>|stlp_std::hash_multiset<*>|stlpx_std::hash_multiset<*>|stlpmtx_std::hash_multiset<*>|stlpxmtx_std::hash_multiset<*>|stlp_std::tr1::unordered_map<*>|stlpx_std::tr1::unordered_map<*>|stlpmtx_std::tr1::unordered_map<*>|stlpxmtx_std::tr1::unordered_map<*>|stlp_std::tr1::unordered_multimap<*>|stlpx_std::tr1::unordered_multimap<*>|stlpmtx_std::tr1::unordered_multimap<*>|stlpxmtx_std::tr1::unordered_multimap<*>|stlp_std::tr1::unordered_set<*>|stlpx_std::tr1::unordered_set<*>|stlpmtx_std::tr1::unordered_set<*>|stlpxmtx_std::tr1::unordered_set<*>|stlp_std::tr1::unordered_multiset<*>|stlpx_std::tr1::unordered_multiset<*>|stlpmtx_std::tr1::unordered_multiset<*>|stlpxmtx_std::tr1::unordered_multiset<*>{
2164     preview
2165     (
2166                 #(
2167                         "[",
2168                         $c._M_ht._M_num_elements,
2169                         "]",
2170                         $c._M_ht
2171                 )
2172     )
2173     children
2174     (
2175         #(
2176             [raw view]: [$c,!],
2177             hashtable: $c._M_ht
2178         )
2179     )
2180 }
2181
2182 stlpd_std::hash_map<*>|stlpdx_std::hash_map<*>|stlpdmtx_std::hash_map<*>|stlpdxmtx_std::hash_map<*>|stlpd_std::hash_multimap<*>|stlpdx_std::hash_multimap<*>|stlpdmtx_std::hash_multimap<*>|stlpdxmtx_std::hash_multimap<*>|stlpd_std::hash_set<*>|stlpdx_std::hash_set<*>|stlpdmtx_std::hash_set<*>|stlpdxmtx_std::hash_set<*>|stlpd_std::hash_multiset<*>|stlpdx_std::hash_multiset<*>|stlpdmtx_std::hash_multiset<*>|stlpdxmtx_std::hash_multiset<*>|stlpd_std::tr1::unordered_map<*>|stlpdx_std::tr1::unordered_map<*>|stlpdmtx_std::tr1::unordered_map<*>|stlpdxmtx_std::tr1::unordered_map<*>|stlpd_std::tr1::unordered_multimap<*>|stlpdx_std::tr1::unordered_multimap<*>|stlpdmtx_std::tr1::unordered_multimap<*>|stlpdxmtx_std::tr1::unordered_multimap<*>|stlpd_std::tr1::unordered_set<*>|stlpdx_std::tr1::unordered_set<*>|stlpdmtx_std::tr1::unordered_set<*>|stlpdxmtx_std::tr1::unordered_set<*>|stlpd_std::tr1::unordered_multiset<*>|stlpdx_std::tr1::unordered_multiset<*>|stlpdmtx_std::tr1::unordered_multiset<*>|stlpdxmtx_std::tr1::unordered_multiset<*>{
2183     preview
2184     (
2185                 #(
2186                         "[",
2187                         $c._M_ht._M_non_dbg_impl._M_num_elements,
2188                         "]",
2189                         $c._M_ht._M_non_dbg_impl
2190                 )
2191     )
2192     children
2193     (
2194         #(
2195             [raw view]: [$c,!],
2196             hashtable: $c._M_ht._M_non_dbg_impl
2197         )
2198     )
2199 }
2200
2201 stlp_std::hashtable<*,*>|stlpx_std::hashtable<*,*>|stlpmtx_std::hashtable<*,*>|stlpxmtx_std::hashtable<*,*>|stlpd_std::priv::_NonDbg_hashtable<*,*>|stlpdx_std::priv::_NonDbg_hashtable<*,*>|stlpdmtx_std::priv::_NonDbg_hashtable<*,*>|stlpdxmtx_std::priv::_NonDbg_hashtable<*,*>{
2202     preview
2203     (
2204                 $c._M_elems
2205     )
2206     children
2207     (
2208         #(
2209             [raw view]: [$c,!],
2210             size : $c._M_num_elements,
2211             load factor : (float)$c._M_num_elements / ($c._M_buckets._M_finish - $c._M_buckets._M_start),
2212             max load factor: $c._M_max_load_factor,
2213             buckets : $c._M_buckets,
2214             elements : $c._M_elems
2215         )
2216     )
2217 }
2218
2219 ;------------------------------------------------------------------------------
2220 ; stlport::queue, stlport::priority_queue, stlport::stack
2221 ;------------------------------------------------------------------------------
2222 stlp_std::queue<*>|stlpx_std::queue<*>|stlpmtx_std::queue<*>|stlpxmtx_std::queue<*>|stlpd_std::queue<*>|stlpdx_std::queue<*>|stlpdmtx_std::queue<*>|stlpdxmtx_std::queue<*>|stlp_std::priority_queue<*>|stlpx_std::priority_queue<*>|stlpmtx_std::priority_queue<*>|stlpxmtx_std::priority_queue<*>|stlpd_std::priority_queue<*>|stlpdx_std::priority_queue<*>|stlpdmtx_std::priority_queue<*>|stlpdxmtx_std::priority_queue<*>|stlp_std::stack<*>|stlpx_std::stack<*>|stlpmtx_std::stack<*>|stlpxmtx_std::stack<*>|stlpd_std::stack<*>|stlpdx_std::stack<*>|stlpdmtx_std::stack<*>|stlpdxmtx_std::stack<*>{
2223         preview
2224         (
2225                 $c.c
2226         )
2227         children
2228         (
2229                 #(
2230                         [raw view] : [$c,!],
2231                         container : $c.c
2232                 )
2233         )
2234 }
2235
2236 ;------------------------------------------------------------------------------
2237 ; stlport debug iterator
2238 ;------------------------------------------------------------------------------
2239 stlp_std::priv::_DBG_iter<*>|stlpx_std::priv::_DBG_iter<*>|stlpmtx_std::priv::_DBG_iter<*>|stlpxmtx_std::priv::_DBG_iter<*>|stlpd_std::priv::_DBG_iter<*>|stlpdx_std::priv::_DBG_iter<*>|stlpdmtx_std::priv::_DBG_iter<*>|stlpdxmtx_std::priv::_DBG_iter<*>{
2240         preview
2241         (
2242                 #if($c._M_owner != 0)
2243                 (
2244                         $c._M_iterator
2245                 )
2246                 #else
2247                 (
2248                         "undefined"
2249                 )
2250         )
2251         children
2252         (
2253                 #(
2254                         #if($c._M_owner != 0)
2255                         (
2256                                 #(
2257                                         [raw view] : [$c,!],
2258                                         [iterator] : $c._M_iterator,
2259                                         [valid] : [true]
2260                                 )
2261                         )
2262                         #else
2263                         (
2264                                 #(
2265                                         [raw view] : [$c,!],
2266                                         [valid] : [false]
2267                                 )
2268                         )
2269                 )
2270         )
2271 }
2272
2273 ;------------------------------------------------------------------------------
2274 ; stlport::bitset
2275 ; TODO: Fix it, it doesn't work as expected even when adding an enum to the bitset
2276 ; class to get access to the bitset static size rather than using $T1.
2277 ;------------------------------------------------------------------------------
2278 stdp_std::bitset<*,*>|stdpx_std::bitset<*,*>|stdpmtx_std::bitset<*,*>|stdpxmtx_std::bitset<*,*>|stdpd_std::bitset<*>|stdpdx_std::bitset<*>|stdpdmtx_std::bitset<*>|stdpdxmtx_std::bitset<*>{
2279         preview
2280         (
2281                 #(
2282                 "[",
2283                         $T1,
2284                 "](",
2285                 #array
2286                 (
2287                         expr : ($c._M_w[$i / (sizeof(unsigned long) * 8)] >> ($i % (sizeof(unsigned long) * 8))),
2288                         size : $T1
2289                 ) : [($e & 1),d],
2290                 ")"
2291                 )
2292         )
2293         children
2294         (
2295                 #array
2296                 (
2297                         expr :  ($c._M_w[$i / (sizeof(unsigned long) * 8)] >> ($i % (sizeof(unsigned long) * 8))),
2298                         size :  $T1
2299                 ) : (bool)($e & 1)
2300         )
2301 }
2302
2303 stdp_std::bitset<*>::reference|stdpx_std::bitset<*>::reference|stdpmtx_std::bitset<*>::reference|stdpxmtx_std::bitset<*>::reference|stdpd_std::bitset<*>::reference|stdpdx_std::bitset<*>::reference|stdpdmtx_std::bitset<*>::reference|stdpdxmtx_std::bitset<*>{
2304     preview
2305     (
2306                 #(
2307                         "bitset[", $c._M_bpos, "] = ",
2308                         (bool)(*($c._M_wp) >> $c._M_bpos) & 1)
2309                 )
2310     )
2311 }
2312
2313 ;------------------------------------------------------------------------------
2314 ; stlport::auto_ptr
2315 ;------------------------------------------------------------------------------
2316 stlp_std::auto_ptr<*>|stlpx_std::auto_ptr<*>|stlpmtx_std::auto_ptr<*>|stlpxmtx_std::auto_ptr<*>|stlpd_std::auto_ptr<*>|stlpdx_std::auto_ptr<*>|stlpdmtx_std::auto_ptr<*>|stlpdxmtx_std::auto_ptr<*>{
2317     preview
2318     (
2319         #if(($c._M_p) != 0)
2320         (
2321             [*($T1 *)$c._M_p]
2322         )
2323         #else
2324         (
2325             "null"
2326         )
2327     )
2328     children
2329     (
2330         #if(($c._M_p) != 0)
2331         (
2332             #(
2333                 [raw view]: [$c,!],
2334                 ptr: [(unsigned int)$c._M_p, x],
2335                 value: [*($T1 *)$c._M_p]
2336             )
2337         )
2338         #else
2339         (
2340             #(
2341                 [raw view]: [$c,!]
2342             )
2343         )
2344     )
2345 }
2346
2347 ;------------------------------------------------------------------------------
2348 ;  stlport::complex
2349 ;------------------------------------------------------------------------------
2350 stlp_std::complex<*>|stlpx_std::complex<*>|stlpmtx_std::complex<*>|stlpxmtx_std::complex<*>|stlpd_std::complex<*>|stlpdx_std::complex<*>|stlpdmtx_std::complex<*>|stlpdxmtx_std::complex<*>{
2351         children
2352         (
2353                 #(
2354                         real: $e._M_re,
2355                         imaginary: $e._M_im
2356                 )
2357         )
2358         preview
2359         (
2360                 #if($e._M_im != 0)
2361                 (
2362                         #if ($e._M_re != 0)
2363                         (                                                                       ; Real and Imaginary components
2364                                 #if ($e._M_im >= 0)
2365                                 (
2366                                         #($e._M_re,"+i*", $e._M_im)
2367                                 )
2368                                 #else
2369                                 (
2370                                         #($e._M_re,"-i*", -$e._M_im)
2371                                 )
2372                         )
2373                         #else
2374                         (                                                                       ; Purely imaginary
2375                                 #if ($e._M_im >= 0.0)
2376                                 (
2377                                         #("i*", $e._M_im)
2378                                 )
2379                                 #else
2380                                 (
2381                                         #("-i*", -$e._M_im)
2382                                 )
2383                         )
2384                 )
2385                 #else
2386                 (                                                                               ; Purely real
2387                         $e._M_re
2388                 )
2389         )
2390 }
2391
2392 ;------------------------------------------------------------------------------
2393 ;  stlport::valarray
2394 ;------------------------------------------------------------------------------
2395
2396 stlp_std::valarray<*>|stlpx_std::valarray<*>|stlpmtx_std::valarray<*>|stlpxmtx_std::valarray<*>|stlpd_std::valarray<*>|stlpdx_std::valarray<*>|stlpdmtx_std::valarray<*>|stlpdxmtx_std::valarray<*>{
2397     preview
2398     (
2399                 #(
2400                         "[",
2401             $c._M_size ,
2402             "](",
2403             #array
2404             (
2405                                 expr :  ($c._M_first)[$i],
2406                                 size :  $c._M_size
2407                         ),
2408                         ")"
2409                 )
2410         )
2411
2412         children
2413         (
2414                 #array
2415                 (
2416                         expr :  ($c._M_first)[$i],
2417                         size :  $c._M_size
2418                 )
2419         )
2420 }
2421
2422 stlp_std::slice|stlpx_std::slice|stlpmtx_std::slice|stlpxmtx_std::slice|stlpd_std::slice|stlpdx_std::slice|stlpdmtx_std::slice|stlpdxmtx_std::slice{
2423         preview
2424         (
2425                 #(
2426                         "start = ",
2427                         $c._M_start,
2428                         ", size = ",
2429                         $c._M_length,
2430                         ", stride = ",
2431                         $c._M_stride
2432                 )
2433         )
2434         children
2435         (
2436                 #(
2437                         [raw view] : [$c,!],
2438                         start : $c._M_start,
2439                         size : $c._M_length,
2440                         stride : $c._M_stride
2441                 )
2442         )
2443 }
2444
2445 stlp_std::gslice|stlpx_std::gslice|stlpmtx_std::gslice|stlpxmtx_std::gslice|stlpd_std::gslice|stlpdx_std::gslice|stlpdmtx_std::gslice|stlpdxmtx_std::gslice{
2446         preview
2447         (
2448                 #(
2449                         "start = ",
2450                         $c._M_start,
2451                         ", sizes = ",
2452                         $c._M_lengths,
2453                         ", strides = ",
2454                         $c._M_strides
2455                 )
2456         )
2457         children
2458         (
2459                 #(
2460                         [raw view] : [$c,!],
2461                         start : $c._M_start,
2462                         sizes : $c._M_lengths,
2463                         strides : $c._M_strides
2464                 )
2465         )
2466 }
2467
2468 ; This section contains visualizers for STL and ATL containers
2469 ; DO NOT MODIFY
2470 ATL::CStringT<char,*>|CSimpleStringT<char,*>|ATL::CSimpleStringT<char,*>{
2471                 preview                 ([$e.m_pszData,s])
2472                 stringview              ([$e.m_pszData,sb])
2473 }
2474 ATL::CStringT<wchar_t,*>|CSimpleStringT<wchar_t,*>|ATL::CSimpleStringT<wchar_t,*>|ATL::CStringT<unsigned short,*>|CSimpleStringT<unsigned short,*>|ATL::CSimpleStringT<unsigned short,*>{
2475                 preview                 ([$e.m_pszData,su])
2476                 stringview              ([$e.m_pszData,sub])
2477 }
2478 ATL::CComBSTR{
2479                 preview                 ([$e.m_str,su])
2480                 stringview              ([$e.m_str,sub])
2481 }
2482
2483 ; Many TR1 visualizers use nested #()s.
2484 ; Why not use #(foo, bar) instead of #(#(foo), #(bar))?
2485 ; The former alphabetically sorts its fields, while the latter does not.
2486 ;------------------------------------------------------------------------------
2487 ;  std::tr1::reference_wrapper
2488 ;------------------------------------------------------------------------------
2489 std::tr1::reference_wrapper<*>{
2490         preview (
2491                 #if ($e._Callee._EEN_INDIRECT == 1) (
2492                         ; For ordinary T, reference_wrapper<T> stores a T * _Callee._Ptr
2493                         ; which is non-null. Actual references are previewed with what they
2494                         ; refer to, so reference_wrapper<T> is previewed with dereferencing its
2495                         ; stored pointer.
2496                         *$e._Callee._Ptr
2497                 ) #else (
2498                         ; When T is a pointer to function, pointer to member function,
2499                         ; or pointer to data member type, reference_wrapper<T> stores a
2500                         ; T _Callee._Object directly.
2501                         $e._Callee._Object
2502                 )
2503         )
2504
2505         children (
2506                 #if ($e._Callee._EEN_INDIRECT == 1) (
2507                         ; Actual references have the same children as what they refer to.
2508                         ; Unfortunately, there appears to be no way to imitate this exactly.
2509                         ; Therefore, we make reference_wrapper<T> appear to have a single
2510                         ; child, its stored pointer, with a fake name of [ptr].
2511                         #([ptr] : $e._Callee._Ptr)
2512                 ) #else (
2513                         ; When T is a pointer to function, pointer to member function,
2514                         ; or pointer to data member type, T has no children, so we make
2515                         ; reference_wrapper<T> appear to have no children.
2516                         #array(expr: 0, size: 0)
2517                 )
2518         )
2519 }
2520 ;------------------------------------------------------------------------------
2521 ;  std::tr1::shared_ptr
2522 ;------------------------------------------------------------------------------
2523 std::tr1::shared_ptr<*>{
2524         preview (
2525                 ; shared_ptr<T> stores a T * _Ptr .
2526                 #if ($e._Ptr == 0) (
2527                         ; A default-constructed shared_ptr has a null _Ptr and a null _Rep,
2528                         ; and is formally said to be empty.
2529                         ; A shared_ptr constructed from a null pointer has a null _Ptr
2530                         ; and a NON-null _Rep . It is formally said to own the null pointer.
2531                         ; We preview both with "empty".
2532                         "empty"
2533                 ) #else (
2534                         ; Raw pointers are previewed with "<pointer value> <object>".
2535                         ; auto_ptr is previewed with "auto_ptr <object>".
2536                         ; Following these examples, shared_ptr is previewed with
2537                         ; "shared_ptr <object> [N strong refs, M weak refs]".
2538                         #(
2539                                 "shared_ptr ",
2540                                 *$e._Ptr,
2541                                 " [",
2542                                 $e._Rep->_Uses,
2543                                 #if ($e._Rep->_Uses == 1) (" strong ref") #else (" strong refs"),
2544                                 #if ($e._Rep->_Weaks - 1 > 0) (
2545                                         #(
2546                                                 ", ",
2547                                                 $e._Rep->_Weaks - 1,
2548                                                 #if ($e._Rep->_Weaks - 1 == 1) (" weak ref") #else (" weak refs")
2549                                         )
2550                                 ),
2551                                 "]"
2552                         )
2553                         ; Note: _Rep->_Uses counts how many shared_ptrs share ownership of the object,
2554                         ; so we directly display it as the strong reference count.
2555                         ; _Rep->_Weaks counts how many shared_ptrs and weak_ptrs share ownership of
2556                         ; the "representation object" (or "control block"). All of the shared_ptrs are
2557                         ; counted as a single owner. That is, _Weaks is initialized to 1, and when
2558                         ; _Uses falls to 0, _Weaks is decremented. This avoids incrementing and decrementing
2559                         ; _Weaks every time that a shared_ptr gains or loses ownership. Therefore,
2560                         ; _Weaks - 1 is the weak reference count, the number of weak_ptrs that are observing
2561                         ; the shared object.
2562                 )
2563         )
2564
2565         children (
2566                 #if ($e._Ptr == 0) (
2567                         ; We make empty shared_ptrs (and shared_ptrs that own
2568                         ; the null pointer) appear to have no children.
2569                         #array(expr: 0, size: 0)
2570                 ) #else (
2571                         #(
2572                                 ; We make shared_ptr appear to have a single child,
2573                                 ; its stored pointer, with a fake name of [ptr].
2574                                 #([ptr] : $e._Ptr),
2575
2576                                 ; Visualizers can't determine whether a shared_ptr has a custom deleter.
2577                                 ; Therefore, we also show the actual members.
2578                                 ; Look at what std::tr1::shared_ptr<T> > [actual members] > std::tr1::_Ptr_base<T> > _Rep points to.
2579                                 ; Default deleter: std::tr1::_Ref_count<T>
2580                                 ;  Custom deleter: std::tr1::_Ref_count_d<T, D> > _Dtor
2581                                 #([actual members] : [$e,!])
2582                         )
2583                 )
2584         )
2585 }
2586 ;------------------------------------------------------------------------------
2587 ;  std::tr1::weak_ptr
2588 ;------------------------------------------------------------------------------
2589 std::tr1::weak_ptr<*>{
2590         preview (
2591                 #if ($e._Ptr == 0) (
2592                         "empty"
2593                 ) #elif ($e._Rep->_Uses == 0) (
2594                         ; weak_ptr is just like shared_ptr, except that a weak_ptr can be expired.
2595                         "expired"
2596                 ) #else (
2597                         #(
2598                                 "weak_ptr ",
2599                                 *$e._Ptr,
2600                                 " [",
2601                                 $e._Rep->_Uses,
2602                                 #if ($e._Rep->_Uses == 1) (" strong ref") #else (" strong refs"),
2603                                 #if ($e._Rep->_Weaks - 1 > 0) (
2604                                         #(
2605                                                 ", ",
2606                                                 $e._Rep->_Weaks - 1,
2607                                                 #if ($e._Rep->_Weaks - 1 == 1) (" weak ref") #else (" weak refs")
2608                                         )
2609                                 ),
2610                                 "]"
2611                         )
2612                 )
2613         )
2614
2615         children (
2616                 #if ($e._Ptr == 0) (
2617                         #array(expr: 0, size: 0)
2618                 ) #elif ($e._Rep->_Uses == 0) (
2619                         ; When a weak_ptr is expired, we make it appear to have no children.
2620                         #array(expr: 0, size: 0)
2621                 ) #else (
2622                         #(
2623                                 #([ptr] : $e._Ptr),
2624                                 #([actual members] : [$e,!])
2625                         )
2626                 )
2627         )
2628 }
2629 ;------------------------------------------------------------------------------
2630 ;  std::tr1::tuple
2631 ;------------------------------------------------------------------------------
2632 ; tuple is visualized like pair, except that we have to give fake names to tuple's children.
2633 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>{
2634         preview (
2635                 "()"
2636         )
2637
2638         children (
2639                 #array(expr: 0, size: 0)
2640         )
2641 }
2642 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>{
2643         preview (
2644                 #(
2645                         "(", $e._Impl._Value,
2646                         ")"
2647                 )
2648         )
2649
2650         children (
2651                 #(
2652                         [0] : $e._Impl._Value
2653                 )
2654         )
2655 }
2656 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>{
2657         preview (
2658                 #(
2659                         "(", $e._Impl._Value,
2660                         ",", $e._Impl._Tail._Value,
2661                         ")"
2662                 )
2663         )
2664
2665         children (
2666                 #(
2667                         [0] : $e._Impl._Value,
2668                         [1] : $e._Impl._Tail._Value
2669                 )
2670         )
2671 }
2672 std::tr1::tuple<*,*,*,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil>{
2673         preview (
2674                 #(
2675                         "(", $e._Impl._Value,
2676                         ",", $e._Impl._Tail._Value,
2677                         ",", $e._Impl._Tail._Tail._Value,
2678                         ")"
2679                 )
2680         )
2681
2682         children (
2683                 #(
2684                         [0] : $e._Impl._Value,
2685                         [1] : $e._Impl._Tail._Value,
2686                         [2] : $e._Impl._Tail._Tail._Value
2687                 )
2688         )
2689 }
2690 std::tr1::tuple<*,*,*,*,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil>{
2691         preview (
2692                 #(
2693                         "(", $e._Impl._Value,
2694                         ",", $e._Impl._Tail._Value,
2695                         ",", $e._Impl._Tail._Tail._Value,
2696                         ",", $e._Impl._Tail._Tail._Tail._Value,
2697                         ")"
2698                 )
2699         )
2700
2701         children (
2702                 #(
2703                         [0] : $e._Impl._Value,
2704                         [1] : $e._Impl._Tail._Value,
2705                         [2] : $e._Impl._Tail._Tail._Value,
2706                         [3] : $e._Impl._Tail._Tail._Tail._Value
2707                 )
2708         )
2709 }
2710 std::tr1::tuple<*,*,*,*,*,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil>{
2711         preview (
2712                 #(
2713                         "(", $e._Impl._Value,
2714                         ",", $e._Impl._Tail._Value,
2715                         ",", $e._Impl._Tail._Tail._Value,
2716                         ",", $e._Impl._Tail._Tail._Tail._Value,
2717                         ",", $e._Impl._Tail._Tail._Tail._Tail._Value,
2718                         ")"
2719                 )
2720         )
2721
2722         children (
2723                 #(
2724                         [0] : $e._Impl._Value,
2725                         [1] : $e._Impl._Tail._Value,
2726                         [2] : $e._Impl._Tail._Tail._Value,
2727                         [3] : $e._Impl._Tail._Tail._Tail._Value,
2728                         [4] : $e._Impl._Tail._Tail._Tail._Tail._Value
2729                 )
2730         )
2731 }
2732 std::tr1::tuple<*,*,*,*,*,*,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil>{
2733         preview (
2734                 #(
2735                         "(", $e._Impl._Value,
2736                         ",", $e._Impl._Tail._Value,
2737                         ",", $e._Impl._Tail._Tail._Value,
2738                         ",", $e._Impl._Tail._Tail._Tail._Value,
2739                         ",", $e._Impl._Tail._Tail._Tail._Tail._Value,
2740                         ",", $e._Impl._Tail._Tail._Tail._Tail._Tail._Value,
2741                         ")"
2742                 )
2743         )
2744
2745         children (
2746                 #(
2747                         [0] : $e._Impl._Value,
2748                         [1] : $e._Impl._Tail._Value,
2749                         [2] : $e._Impl._Tail._Tail._Value,
2750                         [3] : $e._Impl._Tail._Tail._Tail._Value,
2751                         [4] : $e._Impl._Tail._Tail._Tail._Tail._Value,
2752                         [5] : $e._Impl._Tail._Tail._Tail._Tail._Tail._Value
2753                 )
2754         )
2755 }
2756 std::tr1::tuple<*,*,*,*,*,*,*,std::tr1::_Nil,std::tr1::_Nil,std::tr1::_Nil>{
2757         preview (
2758                 #(
2759                         "(", $e._Impl._Value,
2760                         ",", $e._Impl._Tail._Value,
2761                         ",", $e._Impl._Tail._Tail._Value,
2762                         ",", $e._Impl._Tail._Tail._Tail._Value,
2763                         ",", $e._Impl._Tail._Tail._Tail._Tail._Value,
2764                         ",", $e._Impl._Tail._Tail._Tail._Tail._Tail._Value,
2765                         ",", $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Value,
2766                         ")"
2767                 )
2768         )
2769
2770         children (
2771                 #(
2772                         [0] : $e._Impl._Value,
2773                         [1] : $e._Impl._Tail._Value,
2774                         [2] : $e._Impl._Tail._Tail._Value,
2775                         [3] : $e._Impl._Tail._Tail._Tail._Value,
2776                         [4] : $e._Impl._Tail._Tail._Tail._Tail._Value,
2777                         [5] : $e._Impl._Tail._Tail._Tail._Tail._Tail._Value,
2778                         [6] : $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Value
2779                 )
2780         )
2781 }
2782 std::tr1::tuple<*,*,*,*,*,*,*,*,std::tr1::_Nil,std::tr1::_Nil>{
2783         preview (
2784                 #(
2785                         "(", $e._Impl._Value,
2786                         ",", $e._Impl._Tail._Value,
2787                         ",", $e._Impl._Tail._Tail._Value,
2788                         ",", $e._Impl._Tail._Tail._Tail._Value,
2789                         ",", $e._Impl._Tail._Tail._Tail._Tail._Value,
2790                         ",", $e._Impl._Tail._Tail._Tail._Tail._Tail._Value,
2791                         ",", $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Value,
2792                         ",", $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Value,
2793                         ")"
2794                 )
2795         )
2796
2797         children (
2798                 #(
2799                         [0] : $e._Impl._Value,
2800                         [1] : $e._Impl._Tail._Value,
2801                         [2] : $e._Impl._Tail._Tail._Value,
2802                         [3] : $e._Impl._Tail._Tail._Tail._Value,
2803                         [4] : $e._Impl._Tail._Tail._Tail._Tail._Value,
2804                         [5] : $e._Impl._Tail._Tail._Tail._Tail._Tail._Value,
2805                         [6] : $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Value,
2806                         [7] : $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Value
2807                 )
2808         )
2809 }
2810 std::tr1::tuple<*,*,*,*,*,*,*,*,*,std::tr1::_Nil>{
2811         preview (
2812                 #(
2813                         "(", $e._Impl._Value,
2814                         ",", $e._Impl._Tail._Value,
2815                         ",", $e._Impl._Tail._Tail._Value,
2816                         ",", $e._Impl._Tail._Tail._Tail._Value,
2817                         ",", $e._Impl._Tail._Tail._Tail._Tail._Value,
2818                         ",", $e._Impl._Tail._Tail._Tail._Tail._Tail._Value,
2819                         ",", $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Value,
2820                         ",", $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Value,
2821                         ",", $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Value,
2822                         ")"
2823                 )
2824         )
2825
2826         children (
2827                 #(
2828                         [0] : $e._Impl._Value,
2829                         [1] : $e._Impl._Tail._Value,
2830                         [2] : $e._Impl._Tail._Tail._Value,
2831                         [3] : $e._Impl._Tail._Tail._Tail._Value,
2832                         [4] : $e._Impl._Tail._Tail._Tail._Tail._Value,
2833                         [5] : $e._Impl._Tail._Tail._Tail._Tail._Tail._Value,
2834                         [6] : $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Value,
2835                         [7] : $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Value,
2836                         [8] : $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Value
2837                 )
2838         )
2839 }
2840 std::tr1::tuple<*,*,*,*,*,*,*,*,*,*>{
2841         preview (
2842                 #(
2843                         "(", $e._Impl._Value,
2844                         ",", $e._Impl._Tail._Value,
2845                         ",", $e._Impl._Tail._Tail._Value,
2846                         ",", $e._Impl._Tail._Tail._Tail._Value,
2847                         ",", $e._Impl._Tail._Tail._Tail._Tail._Value,
2848                         ",", $e._Impl._Tail._Tail._Tail._Tail._Tail._Value,
2849                         ",", $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Value,
2850                         ",", $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Value,
2851                         ",", $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Value,
2852                         ",", $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Value,
2853                         ")"
2854                 )
2855         )
2856
2857         children (
2858                 #(
2859                         [0] : $e._Impl._Value,
2860                         [1] : $e._Impl._Tail._Value,
2861                         [2] : $e._Impl._Tail._Tail._Value,
2862                         [3] : $e._Impl._Tail._Tail._Tail._Value,
2863                         [4] : $e._Impl._Tail._Tail._Tail._Tail._Value,
2864                         [5] : $e._Impl._Tail._Tail._Tail._Tail._Tail._Value,
2865                         [6] : $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Value,
2866                         [7] : $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Value,
2867                         [8] : $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Value,
2868                         [9] : $e._Impl._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Value
2869                 )
2870         )
2871 }
2872 ;------------------------------------------------------------------------------
2873 ;  std::tr1::array
2874 ;------------------------------------------------------------------------------
2875 std::tr1::array<*>{
2876         preview (
2877                 ; An actual array is previewed with its address.
2878                 ; array<T, N> is previewed like vector<T>.
2879                 #(
2880                         "[",
2881                         $e._EEN_SIZE,
2882                         "](",
2883                         #array(expr: $e._Elems[$i], size: $e._EEN_SIZE),
2884                         ")"
2885                 )
2886         )
2887
2888         children (
2889                 ; Just like an actual array.
2890                 #array(expr: $e._Elems[$i], size: $e._EEN_SIZE)
2891         )
2892 }
2893 std::tr1::_Array_iterator<*>|std::tr1::_Array_const_iterator<*>{
2894         preview (
2895                 #if ($e._Idx == $e._EEN_SIZE) (
2896                         ; array iterators are represented by _Ptr + _Idx,
2897                         ; and they know how large their parent arrays are. Therefore, detecting
2898                         ; end iterators is trivial.
2899                         "end"
2900                 ) #else (
2901                         ; Like vector iterators, array iterators are previewed with what they point to.
2902                         $e._Ptr[$e._Idx]
2903                 )
2904         )
2905
2906         children (
2907                 #if ($e._Idx == $e._EEN_SIZE) (
2908                         ; We make end iterators appear to have no children.
2909                         #array(expr: 0, size: 0)
2910                 ) #else (
2911                         ; An array iterator is conceptually a pointer, so we make it appear to store one.
2912                         #([ptr] : $e._Ptr + $e._Idx)
2913                 )
2914         )
2915 }
2916 ;------------------------------------------------------------------------------
2917 ;  std::tr1::function
2918 ;------------------------------------------------------------------------------
2919 std::tr1::function<*>{
2920         preview (
2921                 #if ($e._Impl == 0) (
2922                         ; Detecting empty functions is trivial.
2923                         "empty"
2924                 ) #else (
2925                         ; The only thing that we can preview non-empty
2926                         ; functions with is the fact that they are non-empty.
2927                         "full"
2928                 )
2929         )
2930
2931         children (
2932                 #if ($e._Impl == 0) (
2933                         ; We make empty functions appear to have no children.
2934                         #array(expr: 0, size: 0)
2935                 ) #else (
2936                         ; The callee is stored in (vaguely speaking) $e._Impl->_Callee._Object,
2937                         ; but visualizers can't show this. Therefore, we show the actual members.
2938                         #([actual members] : [$e,!])
2939                 )
2940         )
2941 }
2942 ;------------------------------------------------------------------------------
2943 ;  std::tr1::unordered_set
2944 ;  std::tr1::unordered_multiset
2945 ;  std::tr1::unordered_map
2946 ;  std::tr1::unordered_multimap
2947 ;------------------------------------------------------------------------------
2948 ; See the stdext::hash_set visualizer.
2949 ;------------------------------------------------------------------------------
2950 ;  std::tr1::basic_regex
2951 ;------------------------------------------------------------------------------
2952 std::tr1::basic_regex<*>{
2953         preview (
2954                 #if ($e._Rep == 0) (
2955                         ; Default construction creates an empty basic_regex.
2956                         "empty"
2957                 ) #elif ($e._EEN_VIS == 1) (
2958                         ; By default, _ENHANCED_REGEX_VISUALIZER is defined to be 1 in debug and 0 in ship.
2959                         ; When it is 1, basic_regex stores the string from which it was constructed.
2960                         ; When it is 0, basic_regex stores only the resulting finite state machine.
2961                         $e._Visualization
2962                 ) #else (
2963                         ; basic_regex contains many static const flags, which would be shown in the preview by default.
2964                         ; Its actual members are _Rep and _Traits. _Rep holds the finite state machine, so we
2965                         ; use it to preview basic_regex. (It does contain some human-readable information.)
2966                         *$e._Rep
2967                 )
2968         )
2969
2970         children (
2971                 #if ($e._Rep == 0) (
2972                         ; We make empty basic_regexes appear to have no children.
2973                         #array(expr: 0, size: 0)
2974                 ) #elif ($e._EEN_VIS == 1) (
2975                         ; We want to hide those static const flags.
2976                         ; We also want to give _Visualization a fake name.
2977                         #(
2978                                 #([str] : $e._Visualization),
2979                                 #(_Rep : $e._Rep),
2980                                 #(_Traits : $e._Traits)
2981                         )
2982                 ) #else (
2983                         ; We want to hide those static const flags.
2984                         #(
2985                                 _Rep : $e._Rep,
2986                                 _Traits : $e._Traits
2987                         )
2988                 )
2989         )
2990 }
2991 ;------------------------------------------------------------------------------
2992 ;  std::tr1::sub_match
2993 ;------------------------------------------------------------------------------
2994 std::tr1::sub_match<char const *>|std::tr1::sub_match<wchar_t const *>|std::tr1::sub_match<unsigned short const *>{
2995         preview (
2996                 ; It would be nice if we could preview sub_match with its str().
2997                 ; However, visualizers cannot handle strings represented by pointer pairs.
2998                 ; Therefore, our preview contains more limited information.
2999                 #if ($e.matched) (
3000                         ; If this sub_match participated in a match,
3001                         ; we preview it with its length().
3002                         $e.second - $e.first
3003                 ) #else (
3004                         ; Otherwise, we preview it with its matched bool (i.e. "false").
3005                         ; (Why not length() (i.e. "0")? It's meaningful to have
3006                         ; matched == true and length() == 0.
3007                         "false"
3008                 )
3009         )
3010
3011         children (
3012                 #(
3013                         ; sub_match's three data members are public, but we list them here
3014                         ; (a) to display matched before first and second, and
3015                         ; (b) to gloss over the fact that sub_match derives from std::pair.
3016                         #(matched : $e.matched),
3017                         #(first : $e.first),
3018                         #(second : $e.second)
3019                 )
3020         )
3021 }
3022 std::tr1::sub_match<std::_String_const_iterator<*> >{
3023         preview (
3024                 #if ($e.matched) (
3025                         ; We visualize ssub_match and wssub_match just like csub_match and wcsub_match,
3026                         ; except that when determining the length(), we can't subtract iterators.
3027                         ; We have to subtract their stored pointers.
3028                         $e.second._Myptr - $e.first._Myptr
3029                 ) #else (
3030                         "false"
3031                 )
3032         )
3033
3034         children (
3035                 #(
3036                         #(matched : $e.matched),
3037                         #(first : $e.first),
3038                         #(second : $e.second)
3039                 )
3040         )
3041 }
3042 ;------------------------------------------------------------------------------
3043 ;  std::tr1::match_results
3044 ;------------------------------------------------------------------------------
3045 std::tr1::match_results<*>{
3046         preview (
3047                 ; A match_results object is empty iff its vector _Matches is empty.
3048                 #if ($e._Matches._Myfirst == $e._Matches._Mylast) (
3049                         "empty"
3050                 ) #else (
3051                         ; We preview a non-empty match_results object with its vector.
3052                         $e._Matches
3053                 )
3054         )
3055
3056         children (
3057                 #if ($e._Matches._Myfirst == $e._Matches._Mylast) (
3058                         ; We make empty match_results appear to have no children.
3059                         #array(expr: 0, size: 0)
3060                 ) #else (
3061                         ; As match_results has operator[](), prefix(), and suffix() member functions,
3062                         ; we make it appear to directly contain [0], [1], [2], etc. elements,
3063                         ; as well as [prefix] and [suffix] elements.
3064                         #(
3065                                 #array(expr: $e._Matches._Myfirst[$i], size: $e._Matches._Mylast - $e._Matches._Myfirst),
3066                                 #([prefix] : $e._Prefix),
3067                                 #([suffix] : $e._Suffix)
3068                         )
3069                 )
3070         )
3071 }
3072 ;------------------------------------------------------------------------------
3073 ;  std::tr1::mem_fn()
3074 ;------------------------------------------------------------------------------
3075 ; Note that when mem_fn() is given a data member pointer, it returns a _Call_wrapper<_Callable_pmd<*> > .
3076 ; Data member pointers themselves don't have useful previews, so we don't attempt to visualize this.
3077 ; When mem_fn() is given a member function pointer, it returns a _Mem_fn[N], which we can visualize.
3078 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<*>{
3079         preview (
3080                 ; We preview the functor returned by mem_fn() with its stored member function pointer.
3081                 $e._Callee._Object
3082         )
3083
3084         children (
3085                 ; Member function pointers have no children.
3086                 #array(expr: 0, size: 0)
3087         )
3088 }
3089 ;------------------------------------------------------------------------------
3090 ;  std::tr1::regex_iterator
3091 ;------------------------------------------------------------------------------
3092 std::tr1::regex_iterator<*>{
3093         preview (
3094                 #if ($e._MyRe == 0) (
3095                         ; We represent end-of-sequence regex_iterators with null regex pointers.
3096                         "end"
3097                 ) #else (
3098                         ; Dereferenceable regex_iterators return match_results when dereferenced,
3099                         ; so we'll preview them with that.
3100                         $e._MyVal
3101                 )
3102         )
3103
3104         children (
3105                 #if ($e._MyRe == 0) (
3106                         ; We make end-of-sequence regex_iterators appear to have no children.
3107                         #array(expr: 0, size: 0)
3108                 ) #else (
3109                         ; For ease of understanding, we make dereferenceable regex_iterators
3110                         ; appear to have data members with the "for exposition only" names from TR1.
3111                         #(
3112                                 #([begin] : $e._Begin),
3113                                 #([end] : $e._End),
3114                                 #([pregex] : $e._MyRe),
3115                                 #([flags] : $e._Flags),
3116                                 #([match] : $e._MyVal)
3117                         )
3118                 )
3119         )
3120 }
3121 ;------------------------------------------------------------------------------
3122 ;  std::tr1::regex_token_iterator
3123 ;------------------------------------------------------------------------------
3124 std::tr1::regex_token_iterator<*>{
3125         preview (
3126                 #if ($e._Res == 0) (
3127                         ; We represent end-of-sequence regex_token_iterators with null result pointers.
3128                         "end"
3129                 ) #else (
3130                         ; Dereferenceable regex_token_iterators return *result when dereferenced,
3131                         ; so we'll preview them with that.
3132                         *$e._Res
3133                 )
3134         )
3135
3136         children (
3137                 #if ($e._Res == 0) (
3138                         ; We make end-of-sequence regex_token_iterators appear to have no children.
3139                         #array(expr: 0, size: 0)
3140                 ) #else (
3141                         ; For ease of understanding, we make dereferenceable regex_token_iterators
3142                         ; appear to have data members with the "for exposition only" names from TR1.
3143                         #(
3144                                 #([position] : $e._Pos),
3145                                 #([result] : $e._Res),
3146                                 #([suffix] : $e._Suffix),
3147                                 #([N] : $e._Cur),
3148                                 #([subs] : $e._Subs)
3149                         )
3150                 )
3151         )
3152 }
3153
3154 ;------------------------------------------------------------------------------
3155 ;  std::tr1::bind()
3156 ;------------------------------------------------------------------------------
3157
3158 ; STL functors are previewed with their names.
3159 ; They have no state, so they have no children.
3160 std::plus<*>{
3161         preview ( "plus" )
3162         children ( #array(expr: 0, size: 0) )
3163 }
3164 std::minus<*>{
3165         preview ( "minus" )
3166         children ( #array(expr: 0, size: 0) )
3167 }
3168 std::multiplies<*>{
3169         preview ( "multiplies" )
3170         children ( #array(expr: 0, size: 0) )
3171 }
3172 std::divides<*>{
3173         preview ( "divides" )
3174         children ( #array(expr: 0, size: 0) )
3175 }
3176 std::modulus<*>{
3177         preview ( "modulus" )
3178         children ( #array(expr: 0, size: 0) )
3179 }
3180 std::negate<*>{
3181         preview ( "negate" )
3182         children ( #array(expr: 0, size: 0) )
3183 }
3184 std::equal_to<*>{
3185         preview ( "equal_to" )
3186         children ( #array(expr: 0, size: 0) )
3187 }
3188 std::not_equal_to<*>{
3189         preview ( "not_equal_to" )
3190         children ( #array(expr: 0, size: 0) )
3191 }
3192 std::greater<*>{
3193         preview ( "greater" )
3194         children ( #array(expr: 0, size: 0) )
3195 }
3196 std::less<*>{
3197         preview ( "less" )
3198         children ( #array(expr: 0, size: 0) )
3199 }
3200 std::greater_equal<*>{
3201         preview ( "greater_equal" )
3202         children ( #array(expr: 0, size: 0) )
3203 }
3204 std::less_equal<*>{
3205         preview ( "less_equal" )
3206         children ( #array(expr: 0, size: 0) )
3207 }
3208 std::logical_and<*>{
3209         preview ( "logical_and" )
3210         children ( #array(expr: 0, size: 0) )
3211 }
3212 std::logical_or<*>{
3213         preview ( "logical_or" )
3214         children ( #array(expr: 0, size: 0) )
3215 }
3216 std::logical_not<*>{
3217         preview ( "logical_not" )
3218         children ( #array(expr: 0, size: 0) )
3219 }
3220
3221 ; STL function pointer adaptors are previewed with "ptr_fun(<stored function pointer>)".
3222 ; Function pointers have no children, so the adaptors have no children.
3223 std::pointer_to_unary_function<*>|std::pointer_to_binary_function<*>{
3224         preview (
3225                 #(
3226                         "ptr_fun(",
3227                         $e._Pfun,
3228                         ")"
3229                 )
3230         )
3231
3232         children ( #array(expr: 0, size: 0) )
3233 }
3234
3235 ; STL negators are previewed with "not[12](<stored functor>)".
3236 ; They have a child with the fake name of [pred], so that the
3237 ; stored functor can be inspected.
3238 std::unary_negate<*>{
3239         preview (
3240                 #(
3241                         "not1(",
3242                         $e._Functor,
3243                         ")"
3244                 )
3245         )
3246
3247         children (
3248                 #([pred] : $e._Functor)
3249         )
3250 }
3251 std::binary_negate<*>{
3252         preview (
3253                 #(
3254                         "not2(",
3255                         $e._Functor,
3256                         ")"
3257                 )
3258         )
3259
3260         children (
3261                 #([pred] : $e._Functor)
3262         )
3263 }
3264
3265 ; bind() placeholders are previewed with their names.
3266 ; They have no state, so they have no children.
3267 std::tr1::_Ph<1>{
3268         preview ( "_1" )
3269         children ( #array(expr: 0, size: 0) )
3270 }
3271 std::tr1::_Ph<2>{
3272         preview ( "_2" )
3273         children ( #array(expr: 0, size: 0) )
3274 }
3275 std::tr1::_Ph<3>{
3276         preview ( "_3" )
3277         children ( #array(expr: 0, size: 0) )
3278 }
3279 std::tr1::_Ph<4>{
3280         preview ( "_4" )
3281         children ( #array(expr: 0, size: 0) )
3282 }
3283 std::tr1::_Ph<5>{
3284         preview ( "_5" )
3285         children ( #array(expr: 0, size: 0) )
3286 }
3287 std::tr1::_Ph<6>{
3288         preview ( "_6" )
3289         children ( #array(expr: 0, size: 0) )
3290 }
3291 std::tr1::_Ph<7>{
3292         preview ( "_7" )
3293         children ( #array(expr: 0, size: 0) )
3294 }
3295 std::tr1::_Ph<8>{
3296         preview ( "_8" )
3297         children ( #array(expr: 0, size: 0) )
3298 }
3299 std::tr1::_Ph<9>{
3300         preview ( "_9" )
3301         children ( #array(expr: 0, size: 0) )
3302 }
3303 std::tr1::_Ph<10>{
3304         preview ( "_10" )
3305         children ( #array(expr: 0, size: 0) )
3306 }
3307
3308 ; The functor returned by bind(f, t1, t2) is previewed with "bind(f, t1, t2)".
3309 ; It has children with the fake names of [f], [t1], [t2], etc.
3310 std::tr1::_Bind<std::tr1::_Notforced,std::tr1::_Bind0<*> >{
3311         preview (
3312                 #(
3313                         "bind(", $e._Bx._Callee._Object,
3314                         ")"
3315                 )
3316         )
3317
3318         children (
3319                 #(
3320                         #([f] : $e._Bx._Callee._Object)
3321                 )
3322         )
3323 }
3324 std::tr1::_Bind<std::tr1::_Notforced,std::tr1::_Bind1<*> >{
3325         preview (
3326                 #(
3327                         "bind(", $e._Bx._Callee._Object,
3328                         ", ", $e._Bx._Vx0,
3329                         ")"
3330                 )
3331         )
3332
3333         children (
3334                 #(
3335                         #([f] : $e._Bx._Callee._Object),
3336                         #([t1] : $e._Bx._Vx0)
3337                 )
3338         )
3339 }
3340 std::tr1::_Bind<std::tr1::_Notforced,std::tr1::_Bind2<*> >{
3341         preview (
3342                 #(
3343                         "bind(", $e._Bx._Callee._Object,
3344                         ", ", $e._Bx._Vx0,
3345                         ", ", $e._Bx._Vx1,
3346                         ")"
3347                 )
3348         )
3349
3350         children (
3351                 #(
3352                         #([f] : $e._Bx._Callee._Object),
3353                         #([t1] : $e._Bx._Vx0),
3354                         #([t2] : $e._Bx._Vx1)
3355                 )
3356         )
3357 }
3358 std::tr1::_Bind<std::tr1::_Notforced,std::tr1::_Bind3<*> >{
3359         preview (
3360                 #(
3361                         "bind(", $e._Bx._Callee._Object,
3362                         ", ", $e._Bx._Vx0,
3363                         ", ", $e._Bx._Vx1,
3364                         ", ", $e._Bx._Vx2,
3365                         ")"
3366                 )
3367         )
3368
3369         children (
3370                 #(
3371                         #([f] : $e._Bx._Callee._Object),
3372                         #([t1] : $e._Bx._Vx0),
3373                         #([t2] : $e._Bx._Vx1),
3374                         #([t3] : $e._Bx._Vx2)
3375                 )
3376         )
3377 }
3378 std::tr1::_Bind<std::tr1::_Notforced,std::tr1::_Bind4<*> >{
3379         preview (
3380                 #(
3381                         "bind(", $e._Bx._Callee._Object,
3382                         ", ", $e._Bx._Vx0,
3383                         ", ", $e._Bx._Vx1,
3384                         ", ", $e._Bx._Vx2,
3385                         ", ", $e._Bx._Vx3,
3386                         ")"
3387                 )
3388         )
3389
3390         children (
3391                 #(
3392                         #([f] : $e._Bx._Callee._Object),
3393                         #([t1] : $e._Bx._Vx0),
3394                         #([t2] : $e._Bx._Vx1),
3395                         #([t3] : $e._Bx._Vx2),
3396                         #([t4] : $e._Bx._Vx3)
3397                 )
3398         )
3399 }
3400 std::tr1::_Bind<std::tr1::_Notforced,std::tr1::_Bind5<*> >{
3401         preview (
3402                 #(
3403                         "bind(", $e._Bx._Callee._Object,
3404                         ", ", $e._Bx._Vx0,
3405                         ", ", $e._Bx._Vx1,
3406                         ", ", $e._Bx._Vx2,
3407                         ", ", $e._Bx._Vx3,
3408                         ", ", $e._Bx._Vx4,
3409                         ")"
3410                 )
3411         )
3412
3413         children (
3414                 #(
3415                         #([f] : $e._Bx._Callee._Object),
3416                         #([t1] : $e._Bx._Vx0),
3417                         #([t2] : $e._Bx._Vx1),
3418                         #([t3] : $e._Bx._Vx2),
3419                         #([t4] : $e._Bx._Vx3),
3420                         #([t5] : $e._Bx._Vx4)
3421                 )
3422         )
3423 }
3424 std::tr1::_Bind<std::tr1::_Notforced,std::tr1::_Bind6<*> >{
3425         preview (
3426                 #(
3427                         "bind(", $e._Bx._Callee._Object,
3428                         ", ", $e._Bx._Vx0,
3429                         ", ", $e._Bx._Vx1,
3430                         ", ", $e._Bx._Vx2,
3431                         ", ", $e._Bx._Vx3,
3432                         ", ", $e._Bx._Vx4,
3433                         ", ", $e._Bx._Vx5,
3434                         ")"
3435                 )
3436         )
3437
3438         children (
3439                 #(
3440                         #([f] : $e._Bx._Callee._Object),
3441                         #([t1] : $e._Bx._Vx0),
3442                         #([t2] : $e._Bx._Vx1),
3443                         #([t3] : $e._Bx._Vx2),
3444                         #([t4] : $e._Bx._Vx3),
3445                         #([t5] : $e._Bx._Vx4),
3446                         #([t6] : $e._Bx._Vx5)
3447                 )
3448         )
3449 }
3450 std::tr1::_Bind<std::tr1::_Notforced,std::tr1::_Bind7<*> >{
3451         preview (
3452                 #(
3453                         "bind(", $e._Bx._Callee._Object,
3454                         ", ", $e._Bx._Vx0,
3455                         ", ", $e._Bx._Vx1,
3456                         ", ", $e._Bx._Vx2,
3457                         ", ", $e._Bx._Vx3,
3458                         ", ", $e._Bx._Vx4,
3459                         ", ", $e._Bx._Vx5,
3460                         ", ", $e._Bx._Vx6,
3461                         ")"
3462                 )
3463         )
3464
3465         children (
3466                 #(
3467                         #([f] : $e._Bx._Callee._Object),
3468                         #([t1] : $e._Bx._Vx0),
3469                         #([t2] : $e._Bx._Vx1),
3470                         #([t3] : $e._Bx._Vx2),
3471                         #([t4] : $e._Bx._Vx3),
3472                         #([t5] : $e._Bx._Vx4),
3473                         #([t6] : $e._Bx._Vx5),
3474                         #([t7] : $e._Bx._Vx6)
3475                 )
3476         )
3477 }
3478 std::tr1::_Bind<std::tr1::_Notforced,std::tr1::_Bind8<*> >{
3479         preview (
3480                 #(
3481                         "bind(", $e._Bx._Callee._Object,
3482                         ", ", $e._Bx._Vx0,
3483                         ", ", $e._Bx._Vx1,
3484                         ", ", $e._Bx._Vx2,
3485                         ", ", $e._Bx._Vx3,
3486                         ", ", $e._Bx._Vx4,
3487                         ", ", $e._Bx._Vx5,
3488                         ", ", $e._Bx._Vx6,
3489                         ", ", $e._Bx._Vx7,
3490                         ")"
3491                 )
3492         )
3493
3494         children (
3495                 #(
3496                         #([f] : $e._Bx._Callee._Object),
3497                         #([t1] : $e._Bx._Vx0),
3498                         #([t2] : $e._Bx._Vx1),
3499                         #([t3] : $e._Bx._Vx2),
3500                         #([t4] : $e._Bx._Vx3),
3501                         #([t5] : $e._Bx._Vx4),
3502                         #([t6] : $e._Bx._Vx5),
3503                         #([t7] : $e._Bx._Vx6),
3504                         #([t8] : $e._Bx._Vx7)
3505                 )
3506         )
3507 }
3508 std::tr1::_Bind<std::tr1::_Notforced,std::tr1::_Bind9<*> >{
3509         preview (
3510                 #(
3511                         "bind(", $e._Bx._Callee._Object,
3512                         ", ", $e._Bx._Vx0,
3513                         ", ", $e._Bx._Vx1,
3514                         ", ", $e._Bx._Vx2,
3515                         ", ", $e._Bx._Vx3,
3516                         ", ", $e._Bx._Vx4,
3517                         ", ", $e._Bx._Vx5,
3518                         ", ", $e._Bx._Vx6,
3519                         ", ", $e._Bx._Vx7,
3520                         ", ", $e._Bx._Vx8,
3521                         ")"
3522                 )
3523         )
3524
3525         children (
3526                 #(
3527                         #([f] : $e._Bx._Callee._Object),
3528                         #([t1] : $e._Bx._Vx0),
3529                         #([t2] : $e._Bx._Vx1),
3530                         #([t3] : $e._Bx._Vx2),
3531                         #([t4] : $e._Bx._Vx3),
3532                         #([t5] : $e._Bx._Vx4),
3533                         #([t6] : $e._Bx._Vx5),
3534                         #([t7] : $e._Bx._Vx6),
3535                         #([t8] : $e._Bx._Vx7),
3536                         #([t9] : $e._Bx._Vx8)
3537                 )
3538         )
3539 }
3540 std::tr1::_Bind<std::tr1::_Notforced,std::tr1::_Bind10<*> >{
3541         preview (
3542                 #(
3543                         "bind(", $e._Bx._Callee._Object,
3544                         ", ", $e._Bx._Vx0,
3545                         ", ", $e._Bx._Vx1,
3546                         ", ", $e._Bx._Vx2,
3547                         ", ", $e._Bx._Vx3,
3548                         ", ", $e._Bx._Vx4,
3549                         ", ", $e._Bx._Vx5,
3550                         ", ", $e._Bx._Vx6,
3551                         ", ", $e._Bx._Vx7,
3552                         ", ", $e._Bx._Vx8,
3553                         ", ", $e._Bx._Vx9,
3554                         ")"
3555                 )
3556         )
3557
3558         children (
3559                 #(
3560                         #([f] : $e._Bx._Callee._Object),
3561                         #([t1] : $e._Bx._Vx0),
3562                         #([t2] : $e._Bx._Vx1),
3563                         #([t3] : $e._Bx._Vx2),
3564                         #([t4] : $e._Bx._Vx3),
3565                         #([t5] : $e._Bx._Vx4),
3566                         #([t6] : $e._Bx._Vx5),
3567                         #([t7] : $e._Bx._Vx6),
3568                         #([t8] : $e._Bx._Vx7),
3569                         #([t9] : $e._Bx._Vx8),
3570                         #([t10] : $e._Bx._Vx9)
3571                 )
3572         )
3573 }
3574
3575 ; The functor returned by bind<RetType>(f, t1, t2) is previewed with "bind<R>(f, t1, t2)",
3576 ; because we cannot stringify a type name into the preview.
3577 ; Its first child has the fake name of [R *] and is a null pointer of type RetType *.
3578 ; This allows RetType to be found easily, instead of digging through the bound functor's type.
3579 ; This is followed by children with the fake names of [f], [t1], [t2], etc.
3580 std::tr1::_Bind<*,std::tr1::_Bind0<*> >{
3581         preview (
3582                 #(
3583                         "bind<R>(", $e._Bx._Callee._Object,
3584                         ")"
3585                 )
3586         )
3587
3588         children (
3589                 #(
3590                         #([R *] : ($T1 *) 0),
3591                         #([f] : $e._Bx._Callee._Object)
3592                 )
3593         )
3594 }
3595 std::tr1::_Bind<*,std::tr1::_Bind1<*> >{
3596         preview (
3597                 #(
3598                         "bind<R>(", $e._Bx._Callee._Object,
3599                         ", ", $e._Bx._Vx0,
3600                         ")"
3601                 )
3602         )
3603
3604         children (
3605                 #(
3606                         #([R *] : ($T1 *) 0),
3607                         #([f] : $e._Bx._Callee._Object),
3608                         #([t1] : $e._Bx._Vx0)
3609                 )
3610         )
3611 }
3612 std::tr1::_Bind<*,std::tr1::_Bind2<*> >{
3613         preview (
3614                 #(
3615                         "bind<R>(", $e._Bx._Callee._Object,
3616                         ", ", $e._Bx._Vx0,
3617                         ", ", $e._Bx._Vx1,
3618                         ")"
3619                 )
3620         )
3621
3622         children (
3623                 #(
3624                         #([R *] : ($T1 *) 0),
3625                         #([f] : $e._Bx._Callee._Object),
3626                         #([t1] : $e._Bx._Vx0),
3627                         #([t2] : $e._Bx._Vx1)
3628                 )
3629         )
3630 }
3631 std::tr1::_Bind<*,std::tr1::_Bind3<*> >{
3632         preview (
3633                 #(
3634                         "bind<R>(", $e._Bx._Callee._Object,
3635                         ", ", $e._Bx._Vx0,
3636                         ", ", $e._Bx._Vx1,
3637                         ", ", $e._Bx._Vx2,
3638                         ")"
3639                 )
3640         )
3641
3642         children (
3643                 #(
3644                         #([R *] : ($T1 *) 0),
3645                         #([f] : $e._Bx._Callee._Object),
3646                         #([t1] : $e._Bx._Vx0),
3647                         #([t2] : $e._Bx._Vx1),
3648                         #([t3] : $e._Bx._Vx2)
3649                 )
3650         )
3651 }
3652 std::tr1::_Bind<*,std::tr1::_Bind4<*> >{
3653         preview (
3654                 #(
3655                         "bind<R>(", $e._Bx._Callee._Object,
3656                         ", ", $e._Bx._Vx0,
3657                         ", ", $e._Bx._Vx1,
3658                         ", ", $e._Bx._Vx2,
3659                         ", ", $e._Bx._Vx3,
3660                         ")"
3661                 )
3662         )
3663
3664         children (
3665                 #(
3666                         #([R *] : ($T1 *) 0),
3667                         #([f] : $e._Bx._Callee._Object),
3668                         #([t1] : $e._Bx._Vx0),
3669                         #([t2] : $e._Bx._Vx1),
3670                         #([t3] : $e._Bx._Vx2),
3671                         #([t4] : $e._Bx._Vx3)
3672                 )
3673         )
3674 }
3675 std::tr1::_Bind<*,std::tr1::_Bind5<*> >{
3676         preview (
3677                 #(
3678                         "bind<R>(", $e._Bx._Callee._Object,
3679                         ", ", $e._Bx._Vx0,
3680                         ", ", $e._Bx._Vx1,
3681                         ", ", $e._Bx._Vx2,
3682                         ", ", $e._Bx._Vx3,
3683                         ", ", $e._Bx._Vx4,
3684                         ")"
3685                 )
3686         )
3687
3688         children (
3689                 #(
3690                         #([R *] : ($T1 *) 0),
3691                         #([f] : $e._Bx._Callee._Object),
3692                         #([t1] : $e._Bx._Vx0),
3693                         #([t2] : $e._Bx._Vx1),
3694                         #([t3] : $e._Bx._Vx2),
3695                         #([t4] : $e._Bx._Vx3),
3696                         #([t5] : $e._Bx._Vx4)
3697                 )
3698         )
3699 }
3700 std::tr1::_Bind<*,std::tr1::_Bind6<*> >{
3701         preview (
3702                 #(
3703                         "bind<R>(", $e._Bx._Callee._Object,
3704                         ", ", $e._Bx._Vx0,
3705                         ", ", $e._Bx._Vx1,
3706                         ", ", $e._Bx._Vx2,
3707                         ", ", $e._Bx._Vx3,
3708                         ", ", $e._Bx._Vx4,
3709                         ", ", $e._Bx._Vx5,
3710                         ")"
3711                 )
3712         )
3713
3714         children (
3715                 #(
3716                         #([R *] : ($T1 *) 0),
3717                         #([f] : $e._Bx._Callee._Object),
3718                         #([t1] : $e._Bx._Vx0),
3719                         #([t2] : $e._Bx._Vx1),
3720                         #([t3] : $e._Bx._Vx2),
3721                         #([t4] : $e._Bx._Vx3),
3722                         #([t5] : $e._Bx._Vx4),
3723                         #([t6] : $e._Bx._Vx5)
3724                 )
3725         )
3726 }
3727 std::tr1::_Bind<*,std::tr1::_Bind7<*> >{
3728         preview (
3729                 #(
3730                         "bind<R>(", $e._Bx._Callee._Object,
3731                         ", ", $e._Bx._Vx0,
3732                         ", ", $e._Bx._Vx1,
3733                         ", ", $e._Bx._Vx2,
3734                         ", ", $e._Bx._Vx3,
3735                         ", ", $e._Bx._Vx4,
3736                         ", ", $e._Bx._Vx5,
3737                         ", ", $e._Bx._Vx6,
3738                         ")"
3739                 )
3740         )
3741
3742         children (
3743                 #(
3744                         #([R *] : ($T1 *) 0),
3745                         #([f] : $e._Bx._Callee._Object),
3746                         #([t1] : $e._Bx._Vx0),
3747                         #([t2] : $e._Bx._Vx1),
3748                         #([t3] : $e._Bx._Vx2),
3749                         #([t4] : $e._Bx._Vx3),
3750                         #([t5] : $e._Bx._Vx4),
3751                         #([t6] : $e._Bx._Vx5),
3752                         #([t7] : $e._Bx._Vx6)
3753                 )
3754         )
3755 }
3756 std::tr1::_Bind<*,std::tr1::_Bind8<*> >{
3757         preview (
3758                 #(
3759                         "bind<R>(", $e._Bx._Callee._Object,
3760                         ", ", $e._Bx._Vx0,
3761                         ", ", $e._Bx._Vx1,
3762                         ", ", $e._Bx._Vx2,
3763                         ", ", $e._Bx._Vx3,
3764                         ", ", $e._Bx._Vx4,
3765                         ", ", $e._Bx._Vx5,
3766                         ", ", $e._Bx._Vx6,
3767                         ", ", $e._Bx._Vx7,
3768                         ")"
3769                 )
3770         )
3771
3772         children (
3773                 #(
3774                         #([R *] : ($T1 *) 0),
3775                         #([f] : $e._Bx._Callee._Object),
3776                         #([t1] : $e._Bx._Vx0),
3777                         #([t2] : $e._Bx._Vx1),
3778                         #([t3] : $e._Bx._Vx2),
3779                         #([t4] : $e._Bx._Vx3),
3780                         #([t5] : $e._Bx._Vx4),
3781                         #([t6] : $e._Bx._Vx5),
3782                         #([t7] : $e._Bx._Vx6),
3783                         #([t8] : $e._Bx._Vx7)
3784                 )
3785         )
3786 }
3787 std::tr1::_Bind<*,std::tr1::_Bind9<*> >{
3788         preview (
3789                 #(
3790                         "bind<R>(", $e._Bx._Callee._Object,
3791                         ", ", $e._Bx._Vx0,
3792                         ", ", $e._Bx._Vx1,
3793                         ", ", $e._Bx._Vx2,
3794                         ", ", $e._Bx._Vx3,
3795                         ", ", $e._Bx._Vx4,
3796                         ", ", $e._Bx._Vx5,
3797                         ", ", $e._Bx._Vx6,
3798                         ", ", $e._Bx._Vx7,
3799                         ", ", $e._Bx._Vx8,
3800                         ")"
3801                 )
3802         )
3803
3804         children (
3805                 #(
3806                         #([R *] : ($T1 *) 0),
3807                         #([f] : $e._Bx._Callee._Object),
3808                         #([t1] : $e._Bx._Vx0),
3809                         #([t2] : $e._Bx._Vx1),
3810                         #([t3] : $e._Bx._Vx2),
3811                         #([t4] : $e._Bx._Vx3),
3812                         #([t5] : $e._Bx._Vx4),
3813                         #([t6] : $e._Bx._Vx5),
3814                         #([t7] : $e._Bx._Vx6),
3815                         #([t8] : $e._Bx._Vx7),
3816                         #([t9] : $e._Bx._Vx8)
3817                 )
3818         )
3819 }
3820 std::tr1::_Bind<*,std::tr1::_Bind10<*> >{
3821         preview (
3822                 #(
3823                         "bind<R>(", $e._Bx._Callee._Object,
3824                         ", ", $e._Bx._Vx0,
3825                         ", ", $e._Bx._Vx1,
3826                         ", ", $e._Bx._Vx2,
3827                         ", ", $e._Bx._Vx3,
3828                         ", ", $e._Bx._Vx4,
3829                         ", ", $e._Bx._Vx5,
3830                         ", ", $e._Bx._Vx6,
3831                         ", ", $e._Bx._Vx7,
3832                         ", ", $e._Bx._Vx8,
3833                         ", ", $e._Bx._Vx9,
3834                         ")"
3835                 )
3836         )
3837
3838         children (
3839                 #(
3840                         #([R *] : ($T1 *) 0),
3841                         #([f] : $e._Bx._Callee._Object),
3842                         #([t1] : $e._Bx._Vx0),
3843                         #([t2] : $e._Bx._Vx1),
3844                         #([t3] : $e._Bx._Vx2),
3845                         #([t4] : $e._Bx._Vx3),
3846                         #([t5] : $e._Bx._Vx4),
3847                         #([t6] : $e._Bx._Vx5),
3848                         #([t7] : $e._Bx._Vx6),
3849                         #([t8] : $e._Bx._Vx7),
3850                         #([t9] : $e._Bx._Vx8),
3851                         #([t10] : $e._Bx._Vx9)
3852                 )
3853         )
3854 }
3855
3856 ;------------------------------------------------------------------------------
3857 ;  std::vector<bool,*> specialization
3858 ;------------------------------------------------------------------------------
3859 std::vector<bool,*>{
3860         children
3861         (
3862                 #array
3863                 (
3864                         expr : ($e._Myvec._Myfirst[$i / _VBITS] >> ($i % _VBITS)),
3865                         size : ($e._Mysize)
3866                 )  : (bool)($e & 1)
3867         )
3868         preview
3869         (
3870                 #(
3871                         "[", $e._Mysize , "](",
3872                         #array
3873                         (
3874                                 expr : ($e._Myvec._Myfirst[$i / _VBITS] >> ($i % _VBITS)),
3875                                 size : ($e._Mysize)
3876                         )  : (bool)($e & 1),
3877                         ")"
3878                 )
3879         )
3880 }
3881 std::vector<bool,*>::iterator|std::vector<bool,*>::const_iterator|std::_Vb_iterator<*>|std::_Vb_const_iterator<*>{
3882         preview         ( #( (bool) (((*$e._Myptr) >> $e._Myoff) & 1)))
3883         children        ( #( ptr: (bool) (((*$e._Myptr) >> $e._Myoff) & 1)))
3884 }
3885 ;------------------------------------------------------------------------------
3886 ;  std::vector
3887 ;------------------------------------------------------------------------------
3888 std::vector<*>{
3889         children
3890         (
3891                 #array
3892                 (
3893                         expr :          ($e._Myfirst)[$i],
3894                         size :          $e._Mylast-$e._Myfirst
3895                 )
3896         )
3897         preview
3898         (
3899                 #(
3900                         "[", $e._Mylast - $e._Myfirst , "](",
3901                         #array
3902                         (
3903                                 expr :  ($e._Myfirst)[$i],
3904                                 size :  $e._Mylast-$e._Myfirst
3905                         ),
3906                         ")"
3907                 )
3908         )
3909 }
3910 std::_Vector_iterator<*>|std::_Vector_const_iterator<*>{
3911         preview         ( #(*$e._Myptr))
3912         children        ( #(ptr: *$e._Myptr))
3913 }
3914 ;------------------------------------------------------------------------------
3915 ;  std::string/basic_string
3916 ;------------------------------------------------------------------------------
3917 std::basic_string<char,*>{
3918         preview         ( #if(($e._Myres) < ($e._BUF_SIZE)) ( [$e._Bx._Buf,s]) #else ( [$e._Bx._Ptr,s]))
3919         stringview      ( #if(($e._Myres) < ($e._BUF_SIZE)) ( [$e._Bx._Buf,sb]) #else ( [$e._Bx._Ptr,sb]))
3920         children
3921         (
3922                 #if(($e._Myres) < ($e._BUF_SIZE))
3923                 (
3924                         #([actual members]: [$e,!] , #array( expr: $e._Bx._Buf[$i], size: $e._Mysize))
3925                 )
3926                 #else
3927                 (
3928                         #([actual members]: [$e,!],  #array( expr: $e._Bx._Ptr[$i], size: $e._Mysize))
3929                 )
3930         )
3931 }
3932 std::basic_string<unsigned short,*>|std::basic_string<wchar_t,*>{
3933         preview
3934         (
3935                 #if(($e._Myres) < ($e._BUF_SIZE)) ( [$e._Bx._Buf,su] )
3936                 #else ( [$e._Bx._Ptr,su] )
3937         )
3938         stringview
3939         (
3940                 #if(($e._Myres) < ($e._BUF_SIZE)) ( [$e._Bx._Buf,sub] )
3941                 #else ( [$e._Bx._Ptr,sub] )
3942         )
3943         children
3944         (
3945                 #if(($e._Myres) < ($e._BUF_SIZE))
3946                 (
3947                         #(
3948                                 [actual members]: [$e,!] ,
3949                                 #array( expr: $e._Bx._Buf[$i], size: $e._Mysize)
3950                         )
3951                 )
3952                 #else
3953                 (
3954                         #(
3955                                 [actual members]: [$e,!],
3956                                 #array( expr: $e._Bx._Ptr[$i], size: $e._Mysize)
3957                         )
3958                 )
3959         )
3960 }
3961 std::basic_string<*>::iterator|std::basic_string<*>::const_iterator|std::_String_iterator<*>|std::_String_const_iterator<*>{
3962                 preview ( #( $e._Myptr ))
3963                 children ( #( ptr: $e._Myptr ))
3964 }
3965 std::pair<*>{
3966         preview ( #( "(", $e.first, ",", $e.second , ")"))
3967 }
3968 ;------------------------------------------------------------------------------
3969 ;  std::auto_ptr
3970 ;------------------------------------------------------------------------------
3971 std::auto_ptr<*>{
3972         preview
3973         (
3974                 #(
3975                         "auto_ptr ",
3976                         (*(($T1 *)$e._Myptr))
3977                  )
3978         )
3979         children
3980         (
3981                 #(
3982                         ptr: (*(($T1 *)$e._Myptr))
3983                 )
3984         )
3985 }
3986 ;------------------------------------------------------------------------------
3987 ;  std::map
3988 ;------------------------------------------------------------------------------
3989 std::map<*>{
3990         children
3991         (
3992                 #tree
3993                 (
3994                         head : $e._Myhead->_Parent,
3995                         skip : $e._Myhead,
3996                         size : $e._Mysize,
3997                         left : _Left,
3998                         right : _Right
3999                 ) : $e._Myval
4000         )
4001         preview
4002         (
4003                 #(
4004                         "[", $e._Mysize, "](",
4005                         #tree
4006                         (
4007                                 head : $e._Myhead->_Parent,
4008                                 skip : $e._Myhead,
4009                                 size : $e._Mysize,
4010                                 left : _Left,
4011                                 right : _Right
4012                         ) : $e._Myval,
4013                         ")"
4014                 )
4015         )
4016 }
4017 ;------------------------------------------------------------------------------
4018 ;  std::multi_map
4019 ;------------------------------------------------------------------------------
4020 std::multimap<*>{
4021         children
4022         (
4023                 #tree
4024                 (
4025                         head : $e._Myhead->_Parent,
4026                         skip : $e._Myhead,
4027                         size : $e._Mysize,
4028                         left : _Left,
4029                         right : _Right
4030                 ) : $e._Myval
4031         )
4032         preview
4033         (
4034                 #(
4035                         "[", $e._Mysize, "](",
4036                         #tree
4037                         (
4038                                 head : $e._Myhead->_Parent,
4039                                 skip : $e._Myhead,
4040                                 size : $e._Mysize,
4041                                 left : _Left,
4042                                 right : _Right
4043                         ) : $e._Myval,
4044                         ")"
4045                 )
4046         )
4047 }
4048 ;------------------------------------------------------------------------------
4049 ;  std::list
4050 ;------------------------------------------------------------------------------
4051 std::list<*>{
4052         children
4053         (
4054                 #list
4055                 (
4056                         head : $e._Myhead->_Next,
4057                         size : $e._Mysize,
4058                         next : _Next
4059                 ) : $e._Myval
4060         )
4061         preview
4062         (
4063                 #(
4064                         "[", $e._Mysize, "](",
4065                         #list
4066                         (
4067                                 head : $e._Myhead->_Next,
4068                                 size : $e._Mysize,
4069                                 next : _Next
4070                         ) : $e._Myval,
4071                         ")"
4072                 )
4073         )
4074 }
4075 std::list<*>::iterator|std::list<*>::const_iterator|std::list<*>::_Iterator<1>|std::list<*>::_Const_iterator<1>{
4076         preview ( #($e._Ptr->_Myval))
4077         children ( #(ptr: $e._Ptr->_Myval))
4078 }
4079 ;------------------------------------------------------------------------------
4080 ;  std::bitset  <bitset>
4081 ;------------------------------------------------------------------------------
4082 std::bitset<*>{
4083         preview
4084         (
4085                 #(
4086                         "[", $e.digits, "](",
4087                         #array
4088                         (
4089                                 expr :  ($e._Array[$i / $e._Bitsperword] >> ($i % $e._Bitsperword)),
4090                                 size :  $e.digits
4091                         ) : [($e & 1),d],
4092                         ")"
4093                 )
4094         )
4095         children
4096         (
4097                 #array
4098                 (
4099                         expr :  ($e._Array[$i / $e._Bitsperword] >> ($i % $e._Bitsperword)),
4100                         size :  $e.digits
4101                 ) : (bool)($e & 1)
4102         )
4103 }
4104 std::bitset<*>::reference{
4105         preview
4106         (
4107                 #(
4108                         "bitset[", $e._Mypos, "] = ",
4109                         (bool)(($e._Pbitset->_Array[$i / _Bitsperword] >> ($e._Mypos % _Bitsperword)) & 1)
4110                 )
4111         )
4112 }
4113 ;------------------------------------------------------------------------------
4114 ;  std::deque
4115 ;------------------------------------------------------------------------------
4116 std::deque<*>{
4117         children
4118         (
4119                 #array
4120                 (
4121                         expr : $e._Map[ (($i + $e._Myoff) / $e._EEN_DS) % $e._Mapsize][($i + $e._Myoff) % $e._EEN_DS],
4122                         size : $e._Mysize
4123                 )
4124         )
4125         preview
4126         (
4127                 #(
4128                         "[", $e._Mysize, "](",
4129                         #array
4130                         (
4131                                 expr : $e._Map[ (($i + $e._Myoff) / $e._EEN_DS) % $e._Mapsize][($i + $e._Myoff) % $e._EEN_DS],
4132                                 size : $e._Mysize
4133                         ),
4134                         ")"
4135                 )
4136         )
4137 }
4138 std::deque<*,*>::iterator|std::_Deque_iterator<*,*,*>|std::_Deque_const_iterator<*,*,*>{
4139         preview
4140         (
4141                 #if( $e._EEN_HID == 0 )
4142                 (
4143                         #if( $e._Myoff >= ((std::deque<$T1,$T2 > *)($e._Myaux->_Mycontainer))->_Myoff + ((std::deque<$T1,$T2 > *)($e._Myaux->_Mycontainer))->_Mysize)
4144                         (
4145                                 #("<end>")
4146                         )
4147                         #else
4148                         (
4149                                 #(
4150                                         "deque[",
4151                                         $e._Myoff - ((std::deque<$T1,$T2 > *)($e._Myaux->_Mycontainer))->_Myoff,
4152                                         "] = ",
4153                                         ((std::deque<$T1,$T2 > *)($e._Myaux->_Mycontainer))->_Map[ (($e._Myoff) / ((std::deque<$T1,$T2 > *)($e._Myaux->_Mycontainer))->_EEN_DS) % ((std::deque<$T1,$T2 > *)$e._Myaux->_Mycontainer)->_Mapsize][$e._Myoff % ((std::deque<$T1,$T2 > *)($e._Myaux->_Mycontainer))->_EEN_DS]
4154                                 )
4155                         )
4156                 )
4157                 #else
4158                 (
4159                         #if( $e._Myoff >= ((std::deque<$T1,$T2 > *)$e._Mycont)->_Myoff + ((std::deque<$T1,$T2 > *)$e._Mycont)->_Mysize)
4160                         (
4161                                 #("<end>")
4162                         )
4163                         #else
4164                         (
4165                                 #(
4166                                         "deque[",
4167                                         $e._Myoff - ((std::deque<$T1,$T2 > *)$e._Mycont)->_Myoff,
4168                                         "] = ",
4169                                         ((std::deque<$T1,$T2 > *)$e._Mycont)->_Map[ (($e._Myoff) / ((std::deque<$T1,$T2 > *)$e._Mycont)->_EEN_DS) % ((std::deque<$T1,$T2 > *)$e._Mycont)->_Mapsize][$e._Myoff % ((std::deque<$T1,$T2 > *)$e._Mycont)->_EEN_DS]
4170                                 )
4171                         )
4172                 )
4173         )
4174         children
4175         (
4176                 #if( $e._EEN_HID == 0 )
4177                 (
4178                         #if( ((std::deque<$T1,$T2 > *)($e._Myaux->_Mycontainer))->_Myoff + ((std::deque<$T1,$T2 > *)($e._Myaux->_Mycontainer))->_Mysize > $e._Myoff)
4179                         (
4180                                 #(
4181                                         ptr: ((std::deque<$T1,$T2 > *)($e._Myaux->_Mycontainer))->_Map[ ($e._Myoff / ((std::deque<$T1,$T2 > *)($e._Myaux->_Mycontainer))->_EEN_DS) % ((std::deque<$T1,$T2 > *)($e._Myaux->_Mycontainer))->_Mapsize][$e._Myoff % ((std::deque<$T1,$T2 > *)($e._Myaux->_Mycontainer))->_EEN_DS]
4182                                 )
4183                         )
4184                 )
4185                 #else
4186                 (
4187                         #if( ((std::deque<$T1,$T2 > *)$e._Mycont)->_Myoff + ((std::deque<$T1,$T2 > *)$e._Mycont)->_Mysize > $e._Myoff)
4188                         (
4189                                 #(
4190                                         ptr: ((std::deque<$T1,$T2 > *)$e._Mycont)->_Map[ ($e._Myoff / ((std::deque<$T1,$T2 > *)$e._Mycont)->_EEN_DS) % ((std::deque<$T1,$T2 > *)$e._Mycont)->_Mapsize][$e._Myoff % ((std::deque<$T1,$T2 > *)$e._Mycont)->_EEN_DS]
4191                                 )
4192                         )
4193                 )
4194         )
4195 }
4196 ;------------------------------------------------------------------------------
4197 ;  std::queue
4198 ;------------------------------------------------------------------------------
4199 std::queue<*>{
4200         children
4201         (
4202                 #array
4203                 (
4204                         expr : $e.c._Map[ (($i + $e.c._Myoff) / $e.c._EEN_DS) % $e.c._Mapsize][($i + $e.c._Myoff) % $e.c._EEN_DS],
4205                         size : $e.c._Mysize
4206                 )
4207         )
4208         preview
4209         (
4210                 #(
4211                         "[", $e.c._Mysize, "](",
4212                         #array
4213                         (
4214                                 expr : $e.c._Map[ (($i + $e.c._Myoff) / $e.c._EEN_DS) % $e.c._Mapsize][($i + $e.c._Myoff) % $e.c._EEN_DS],
4215                                 size : $e.c._Mysize
4216                         ),
4217                         ")"
4218                 )
4219         )
4220 }
4221 ;------------------------------------------------------------------------------
4222 ;  std::priority_queue
4223 ;------------------------------------------------------------------------------
4224 std::priority_queue<*>{
4225         preview ( $e.c)
4226 }
4227 ;------------------------------------------------------------------------------
4228 ;  std::set
4229 ;------------------------------------------------------------------------------
4230 std::set<*>{
4231         preview
4232         (
4233                 #(
4234                         "[", $e._Mysize , "](",
4235                         #tree
4236                         (
4237                                 head : $e._Myhead->_Parent,
4238                                 skip : $e._Myhead,
4239                                 left : _Left,
4240                                 right : _Right,
4241                                 size  : $e._Mysize
4242                         ) : $e._Myval,
4243                         ")"
4244                 )
4245         )
4246         children
4247         (
4248                 #tree
4249                 (
4250                         head : $e._Myhead->_Parent,
4251                         skip : $e._Myhead,
4252                         left : _Left,
4253                         right : _Right,
4254                         size  : $e._Mysize
4255                 ) : $e._Myval
4256         )
4257 }
4258 ;------------------------------------------------------------------------------
4259 ;  std::multi_set
4260 ;------------------------------------------------------------------------------
4261 std::multiset<*>{
4262         preview
4263         (
4264                 #(
4265                         "[", $e._Mysize , "](",
4266                         #tree
4267                         (
4268                                 head : $e._Myhead->_Parent,
4269                                 skip : $e._Myhead,
4270                                 left : _Left,
4271                                 right : _Right,
4272                                 size  : $e._Mysize
4273                         ) : $e._Myval,
4274                         ")"
4275                 )
4276         )
4277         children
4278         (
4279                 #tree
4280                 (
4281                         head : $e._Myhead->_Parent,
4282                         skip : $e._Myhead,
4283                         left : _Left,
4284                         right : _Right,
4285                         size  : $e._Mysize
4286                 ) : $e._Myval
4287         )
4288 }
4289 ;------------------------------------------------------------------------------
4290 ;  std::_Tree (shared my map/multimap/set/multiset)
4291 ;------------------------------------------------------------------------------
4292 std::_Tree<*>::iterator|std::_Tree<*>::const_iterator{
4293         preview         ( #($e._Ptr->_Myval))
4294         children        ( #(ptr: $e._Ptr->_Myval))
4295 }
4296 ;------------------------------------------------------------------------------
4297 ;  std::stack
4298 ;------------------------------------------------------------------------------
4299 std::stack<*>{
4300         children
4301         (
4302                 #array
4303                 (
4304                         expr : $e.c._Map[ (($i + $e.c._Myoff) / $e.c._EEN_DS) % $e.c._Mapsize][($i + $e.c._Myoff) % $e.c._EEN_DS],
4305                         size : $e.c._Mysize
4306                         )
4307         )
4308         preview
4309         (
4310                 #(
4311                         "[", $e.c._Mysize , "](",
4312                         #array
4313                         (
4314                                 expr : $e.c._Map[ (($i + $e.c._Myoff) / $e.c._EEN_DS) % $e.c._Mapsize][($i + $e.c._Myoff) % $e.c._EEN_DS],
4315                                 size : $e.c._Mysize
4316                         ),
4317                         ")"
4318                 )
4319         )
4320 }
4321 ;------------------------------------------------------------------------------
4322 ;  stdext::hash_map
4323 ;  stdext::hash_multimap
4324 ;  stdext::hash_set
4325 ;  stdext::hash_multiset
4326 ;  std::tr1::unordered_set
4327 ;  std::tr1::unordered_multiset
4328 ;  std::tr1::unordered_map
4329 ;  std::tr1::unordered_multimap
4330 ;------------------------------------------------------------------------------
4331 stdext::hash_map<*>|stdext::hash_multimap<*>|stdext::hash_set<*>|stdext::hash_multiset<*>|std::tr1::unordered_set<*>|std::tr1::unordered_multiset<*>|std::tr1::unordered_map<*>|std::tr1::unordered_multimap<*>{
4332         preview
4333         (
4334                 #(
4335                         "[", $e._List._Mysize, "](",
4336                         #list
4337                         (
4338                                 head : $e._List._Myhead->_Next,
4339                                 size : $e._List._Mysize,
4340                                 next : _Next
4341                         ) : $e._Myval,
4342                         ")"
4343                 )
4344         )
4345         children
4346         (
4347                 #list
4348                 (
4349                         head : $e._List._Myhead->_Next,
4350                         size : $e._List._Mysize,
4351                         next : _Next
4352                 ) : $e._Myval
4353         )
4354 }
4355 ;------------------------------------------------------------------------------
4356 ;  std::complex
4357 ;------------------------------------------------------------------------------
4358 std::complex<*>{
4359         children
4360         (
4361                 #(
4362                         real: $e._Val[0],
4363                         imaginary: $e._Val[1]
4364                 )
4365         )
4366         preview
4367         (
4368                 #if($e._Val[1] != 0)
4369                 (
4370                         #if ($e._Val[0] != 0)
4371                         (       ; Real and Imaginary components
4372                                 #if ($e._Val[1] >= 0)
4373                                         ( #($e._Val[0],"+i*", $e._Val[1]))
4374                                 #else
4375                                         ( #($e._Val[0],"-i*", -$e._Val[1]))
4376                         )
4377                         #else
4378                         (       ; Purely imaginary
4379                                 #if ($e._Val[1] >= 0.0)
4380                                 ( #("i*", $e._Val[1]))
4381                                 #else
4382                                 ( #("-i*", -$e._Val[1]))
4383                         )
4384                 )
4385                 #else
4386                 (               ; Purely real
4387                         $e._Val[0]
4388                 )
4389         )
4390 }
4391 ;------------------------------------------------------------------------------
4392 ;  std::valarray
4393 ;------------------------------------------------------------------------------
4394 std::valarray<*>{
4395         preview
4396         (
4397                 #(
4398                         "[", $e._Mysize , "](",
4399                         #array
4400                         (
4401                                 expr :  ($e._Myptr)[$i],
4402                                 size :  $e._Mysize
4403                         ),
4404                         ")"
4405                 )
4406         )
4407         children
4408         (
4409                 #array
4410                 (
4411                         expr :  ($e._Myptr)[$i],
4412                         size :  $e._Mysize
4413                 )
4414         )
4415 }
4416 ;------------------------------------------------------------------------------
4417 ;  PROPVARIANT
4418 ;------------------------------------------------------------------------------
4419 ; Visualizers for VT_VECTOR C arrays
4420 tagCAC|tagCAUB|tagCAI|tagCAUI|tagCAL|tagCAUL|tagCAFLT|tagCADBL|tagCACY|tagCADATE|tagCABSTR|tagCABSTRBLOB|tagCABOOL|tagCASCODE|tagCAPROPVARIANT|tagCAH|tagCAUH|tagCALPSTR|tagCALPWSTR|tagCAFILETIME|tagCACLIPDATA|tagCACLSID{
4421         preview(
4422                 #(
4423                         "[", $e.cElems , "](",
4424                         #array
4425                         (
4426                                 expr :  ($e.pElems)[$i],
4427                                 size :  $e.cElems
4428                         ),
4429                         ")"
4430                 )
4431         )
4432         children
4433         (
4434                 #array
4435                 (
4436                         expr :  ($e.pElems)[$i],
4437                         size :  $e.cElems
4438                 )
4439         )
4440 }
4441 ; Visualizers for SAFE ARRAY
4442 tagSAFEARRAY|SAFEARRAY{
4443         preview(
4444                 #if ($e.fFeatures & 0x0080)             ; FADF_HAVEVARTYPE
4445                 (
4446                         ; Switch on the variant type field - which is stored 4 bytes
4447                         ; before the beginning of the SAFEARRAY type
4448                         #switch( ((unsigned *)&($e))[-1] )
4449                         #case 0x2               ; VT_I2 | VT_ARRAY
4450                         (
4451                                 #(
4452                                         "safearray of I2 = [",
4453                                         ; output the rank array
4454                                         #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
4455                                         "](",
4456                                         ; output the data elements
4457                                         #array(
4458                                                 expr: ((signed short *)$e.pvData)[$i],
4459                                                 size: $e.rgsabound[$r].cElements,
4460                                                 rank: $e.cDims,
4461                                                 base: $e.rgsabound[$r].lLbound
4462                                         ),
4463                                         ")"
4464                                 )
4465                         )
4466                         #case 0x3               ; VT_I4 | VT_ARRAY
4467                         (
4468                                 #(
4469                                         "safearray of I4 = [",
4470                                         ; output the rank array
4471                                         #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
4472                                         "](",
4473                                         ; output the data elements
4474                                         #array(
4475                                                 expr: ((signed int *)$e.pvData)[$i],
4476                                                 size: $e.rgsabound[$r].cElements,
4477                                                 rank: $e.cDims,
4478                                                 base: $e.rgsabound[$r].lLbound
4479                                         ),
4480                                         ")"
4481                                 )
4482                         )
4483                         #case 0x4               ; VT_R4 | VT_ARRAY
4484                         (
4485                                 #(
4486                                         "safearray of R4 = [",
4487                                         ; output the rank array
4488                                         #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
4489                                         "](",
4490                                         ; output the data elements
4491                                         #array(
4492                                                 expr: ((float *)$e.pvData)[$i],
4493                                                 size: $e.rgsabound[$r].cElements,
4494                                                 rank: $e.cDims,
4495                                                 base: $e.rgsabound[$r].lLbound
4496                                         ),
4497                                         ")"
4498                                 )
4499                         )
4500                         #case 0x5               ; VT_R8 | VT_ARRAY
4501                         (
4502                                 #(
4503                                         "safearray of R8 = [",
4504                                         ; output the rank array
4505                                         #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
4506                                         "](",
4507                                         ; output the data elements
4508                                         #array(
4509                                                 expr: ((double *)$e.pvData)[$i],
4510                                                 size: $e.rgsabound[$r].cElements,
4511                                                 rank: $e.cDims,
4512                                                 base: $e.rgsabound[$r].lLbound
4513                                         ),
4514                                         ")"
4515                                  )
4516                         )
4517                         #case 0x6               ; VT_CY | VT_ARRAY
4518                         (
4519                                 #(
4520                                         "safearray of CY = [",
4521                                         ; output the rank array
4522                                         #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
4523                                         "](",
4524                                         ; output the data elements
4525                                         #array(
4526                                                 expr: ((CY *)$e.pvData)[$i],
4527                                                 size: $e.rgsabound[$r].cElements,
4528                                                 rank: $e.cDims,
4529                                                 base: $e.rgsabound[$r].lLbound
4530                                         ),
4531                                         ")"
4532                                 )
4533                         )
4534                         #case 0x7               ; VT_DATE | VT_ARRAY
4535                         (
4536                                 #(
4537                                         "safearray of DATE = [",
4538                                         ; output the rank array
4539                                         #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
4540                                         "](",
4541                                         ; output the data elements
4542                                         #array(
4543                                                 expr: ((DATE *)$e.pvData)[$i],
4544                                                 size: $e.rgsabound[$r].cElements,
4545                                                 rank: $e.cDims,
4546                                                 base: $e.rgsabound[$r].lLbound
4547                                         ),
4548                                         ")"
4549                                 )
4550                         )
4551                         #case 0x8               ; VT_BSTR | VT_ARRAY
4552                         (
4553                                 #(
4554                                         "safearray of BSTR = [",
4555                                         ; output the rank array
4556                                         #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
4557                                         "](",
4558                                         ; output the data elements
4559                                         #array(
4560                                                 expr: ((wchar_t **)$e.pvData)[$i],
4561                                                 size: $e.rgsabound[$r].cElements,
4562                                                 rank: $e.cDims,
4563                                                 base: $e.rgsabound[$r].lLbound
4564                                         ),
4565                                         ")"
4566                                 )
4567                         )
4568                         #case 0xa               ; VT_ERROR | VT_ARRAY
4569                         (
4570                                 #(
4571                                         "safearray of ERROR = [",
4572                                         ; output the rank array
4573                                         #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
4574                                         "](",
4575                                         ; output the data elements
4576                                         #array(
4577                                                 expr: ((long *)$e.pvData)[$i],
4578                                                 size: $e.rgsabound[$r].cElements,
4579                                                 rank: $e.cDims,
4580                                                 base: $e.rgsabound[$r].lLbound
4581                                         ),
4582                                         ")"
4583                                 )
4584                         )
4585                         #case 0xb               ; VT_BOOL | VT_ARRAY
4586                         (
4587                                 #(
4588                                         "safearray of BOOL = [",
4589                                         ; output the rank array
4590                                         #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
4591                                         "](",
4592                                         ; output the data elements
4593                                         #array(
4594                                                 expr: ((short *)$e.pvData)[$i],
4595                                                 size: $e.rgsabound[$r].cElements,
4596                                                 rank: $e.cDims,
4597                                                 base: $e.rgsabound[$r].lLbound
4598                                         ),
4599                                         ")"
4600                                 )
4601                         )
4602                         #case 0xc               ; VT_VARIANT | VT_ARRAY
4603                         (
4604                                 #(
4605                                         "safearray of VARIANT = [",
4606                                         ; output the rank array
4607                                         #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
4608                                         "](",
4609                                         ; output the data elements
4610                                         #array(
4611                                                 expr: ((tagVARIANT *)$e.pvData)[$i],
4612                                                 size: $e.rgsabound[$r].cElements,
4613                                                 rank: $e.cDims,
4614                                                 base: $e.rgsabound[$r].lLbound
4615                                         ),
4616                                         ")"
4617                                 )
4618                         )
4619                         #case 0x10              ; VT_I1 | VT_ARRAY
4620                         (
4621                                 #(
4622                                         "safearray of I1 = [",
4623                                         ; output the rank array
4624                                         #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
4625                                         "](",
4626                                         ; output the data elements
4627                                         #array(
4628                                                 expr: ((signed char *)$e.pvData)[$i],
4629                                                 size: $e.rgsabound[$r].cElements,
4630                                                 rank: $e.cDims,
4631                                                 base: $e.rgsabound[$r].lLbound
4632                                         ),
4633                                         ")"
4634                                 )
4635                         )
4636                         #case 0x11              ; VT_UI1 | VT_ARRAY
4637                         (
4638                                 #(
4639                                         "safearray of UI1 = [",
4640                                         ; output the rank array
4641                                         #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
4642                                         "](",
4643                                         ; output the data elements
4644                                         #array(
4645                                                 expr: ((unsigned char *)$e.pvData)[$i],
4646                                                 size: $e.rgsabound[$r].cElements,
4647                                                 rank: $e.cDims,
4648                                                 base: $e.rgsabound[$r].lLbound
4649                                         ),
4650                                         ")"
4651                                 )
4652                         )
4653                         #case 0x12              ; VT_UI2 | VT_ARRAY
4654                         (
4655                                 #(
4656                                         "safearray of UI2 = [",
4657                                         ; output the rank array
4658                                         #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
4659                                         "](",
4660                                         ; output the data elements
4661                                         #array(
4662                                                 expr: ((unsigned short *)$e.pvData)[$i],
4663                                                 size: $e.rgsabound[$r].cElements,
4664                                                 rank: $e.cDims,
4665                                                 base: $e.rgsabound[$r].lLbound
4666                                           ),
4667                                 ")"
4668                                 )
4669                         )
4670                         #case 0x13              ; VT_UI4 | VT_ARRAY
4671                         (
4672                                 #(
4673                                         "safearray of UI4 = [",
4674                                         ; output the rank array
4675                                         #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
4676                                         "](",
4677                                         ; output the data elements
4678                                         #array(
4679                                                 expr: ((unsigned int *)$e.pvData)[$i],
4680                                                 size: $e.rgsabound[$r].cElements,
4681                                                 rank: $e.cDims,
4682                                                 base: $e.rgsabound[$r].lLbound
4683                                         ),
4684                                         ")"
4685                                 )
4686                         )
4687                         #case 0x14              ; VT_I8 | VT_ARRAY
4688                         (
4689                                 #(
4690                                         "safearray of I8 = [",
4691                                         ; output the rank array
4692                                         #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
4693                                         "](",
4694                                         ; output the data elements
4695                                         #array(
4696                                                 expr: ((signed __int64 *)$e.pvData)[$i],
4697                                                 size: $e.rgsabound[$r].cElements,
4698                                                 rank: $e.cDims,
4699                                                 base: $e.rgsabound[$r].lLbound
4700                                         ),
4701                                         ")"
4702                                 )
4703                         )
4704                         #case 0x15              ; VT_UI8 | VT_ARRAY
4705                         (
4706                                 #(
4707                                         "safearray of UI8 = [",
4708                                         ; output the rank array
4709                                         #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
4710                                         "](",
4711                                         ; output the data elements
4712                                         #array(
4713                                                 expr: ((unsigned __int64 *)$e.pvData)[$i],
4714                                                 size: $e.rgsabound[$r].cElements,
4715                                                 rank: $e.cDims,
4716                                                 base: $e.rgsabound[$r].lLbound
4717                                         ),
4718                                         ")"
4719                                 )
4720                         )
4721                         #case 0x16              ; VT_INT | VT_ARRAY
4722                         (
4723                                 #(
4724                                         "safearray of INT = [",
4725                                         ; output the rank array
4726                                         #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
4727                                         "](",
4728                                         ; output the data elements
4729                                         #array(
4730                                                 expr: ((int *)$e.pvData)[$i],
4731                                                 size: $e.rgsabound[$r].cElements,
4732                                                 rank: $e.cDims,
4733                                                 base: $e.rgsabound[$r].lLbound
4734                                         ),
4735                                         ")"
4736                                 )
4737                         )
4738                         #case 0x17              ; VT_UINT | VT_ARRAY
4739                         (
4740                                 #(
4741                                         "safearray of UINT = [",
4742                                         ; output the rank array
4743                                         #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
4744                                         "](",
4745                                         ; output the data elements
4746                                         #array(
4747                                                 expr: ((unsigned *)$e.pvData)[$i],
4748                                                 size: $e.rgsabound[$r].cElements,
4749                                                 rank: $e.cDims,
4750                                                 base: $e.rgsabound[$r].lLbound
4751                                         ),
4752                                         ")"
4753                                 )
4754                         )
4755                         #case 0x1e              ; VT_LPSTR | VT_ARRAY
4756                         (
4757                                 #(
4758                                         "safearray of LPSTR = [",
4759                                         ; output the rank array
4760                                         #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
4761                                         "](",
4762                                         ; output the data elements
4763                                         #array(
4764                                                 expr: ((char **)$e.pvData)[$i],
4765                                                 size: $e.rgsabound[$r].cElements,
4766                                                 rank: $e.cDims,
4767                                                 base: $e.rgsabound[$r].lLbound
4768                                         ),
4769                                         ")"
4770                                 )
4771                         )
4772                         #case 0x1f              ; VT_LPWSTR | VT_ARRAY
4773                         (
4774                                 #(
4775                                         "safearray of LPWSTR = [",
4776                                         ; output the rank array
4777                                         #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
4778                                         "](",
4779                                         ; output the data elements
4780                                         #array(
4781                                                 expr: ((wchar_t **)$e.pvData)[$i],
4782                                                 size: $e.rgsabound[$r].cElements,
4783                                                 rank: $e.cDims,
4784                                                 base: $e.rgsabound[$r].lLbound
4785                                         ),
4786                                         ")"
4787                                 )
4788                         )
4789                         #case 0x40              ; VT_FILETIME | VT_ARRAY
4790                         (
4791                                 #(
4792                                         "safearray of FILETIME = [",
4793                                         ; output the rank array
4794                                         #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
4795                                         "](",
4796                                         ; output the data elements
4797                                         #array(
4798                                                 expr: ((FILETIME *)$e.pvData)[$i],
4799                                                 size: $e.rgsabound[$r].cElements,
4800                                                 rank: $e.cDims,
4801                                                 base: $e.rgsabound[$r].lLbound
4802                                         ),
4803                                         ")"
4804                                 )
4805                         )
4806                         #case 0x47              ; VT_CLIPDATA | VT_ARRAY
4807                         (
4808                                 #(
4809                                         "safearray of CLIPDATA = [",
4810                                         ; output the rank array
4811                                         #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
4812                                         "](",
4813                                         ; output the data elements
4814                                         #array(
4815                                                 expr: ((CLIPDATA *)$e.pvData)[$i],
4816                                                 size: $e.rgsabound[$r].cElements,
4817                                                 rank: $e.cDims,
4818                                                 base: $e.rgsabound[$r].lLbound
4819                                         ),
4820                                         ")"
4821                                 )
4822                         )
4823                         #case 0x48              ; VT_CLSID | VT_ARRAY
4824                         (
4825                                 #(
4826                                         "safearray of CLSID = [",
4827                                         ; output the rank array
4828                                         #array( expr: $e.rgsabound[$i].cElements, size: $e.cDims),
4829                                         "](",
4830                                         ; output the data elements
4831                                         #array(
4832                                                 expr: ((CLSID *)$e.pvData)[$i],
4833                                                 size: $e.rgsabound[$r].cElements,
4834                                                 rank: $e.cDims,
4835                                                 base: $e.rgsabound[$r].lLbound
4836                                         ),
4837                                         ")"
4838                                 )
4839                         )
4840                 )
4841                 #elif ($e.fFeatures & 0x0100)   ; FADF_BSTR
4842                 (
4843                         #("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 ), ")")
4844                 )
4845                 #elif ($e.fFeatures & 0x0200)   ; FADF_UNKNOWN
4846                 (
4847                                 #("safearray of IUnknown* = ",#array(expr: $e.rgsabound[$i].cElements, size: $e.cDims) : #("[",$e,"]"), "(", #array(expr: ((IUnknown *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound ), ")")
4848                 )
4849                 #elif ($e.fFeatures & 0x0400)   ; FADF_DISPATCH
4850                 (
4851                                 #("safearray of IDispatch* = ",#array(expr: $e.rgsabound[$i].cElements, size: $e.cDims) : #("[",$e,"]"), "(", #array(expr: ((IDispatch*)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound ), ")")
4852                 )
4853                 #elif ($e.fFeatures & 0x0800)   ; FADF_VARIANT
4854                 (
4855                                 #("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 ), ")")
4856                 )
4857         )
4858         children
4859         (
4860                 #(              ;[actual members]: [$e,!],
4861                         #if ($e.fFeatures & 0x0080)             ; FADF_HAVEVARTYPE
4862                         (
4863                                 #switch( ((unsigned *)&($e))[-1] )              ; for some reason the VT field is before the SAFEARRAY struct
4864                                 #case 2 ; VT_I2|VT_ARRAY
4865                                 (
4866                                         #array(
4867                                                 expr: ((signed short *)$e.pvData)[$i],
4868                                                 size: $e.rgsabound[$r].cElements,
4869                                                 rank: $e.cDims,
4870                                                 base: $e.rgsabound[$r].lLbound
4871                                         )
4872                                 )
4873                                 #case 3 ; VT_I4|VT_ARRAY
4874                                 (
4875                                         #array(
4876                                                 expr: ((signed int       *)$e.pvData)[$i],
4877                                                 size: $e.rgsabound[$r].cElements,
4878                                                 rank: $e.cDims,
4879                                                 base: $e.rgsabound[$r].lLbound
4880                                         )
4881                                 )
4882                                 #case 4 ; VT_R4|VT_ARRAY
4883                                 (
4884                                         #array(
4885                                                 expr: ((float *)$e.pvData)[$i],
4886                                                 size: $e.rgsabound[$r].cElements,
4887                                                 rank: $e.cDims,
4888                                                 base: $e.rgsabound[$r].lLbound
4889                                         )
4890                                 )
4891                                 #case 5 ; VT_R8|VT_ARRAY
4892                                 (
4893                                         #array(
4894                                                 expr: ((double  *)$e.pvData)[$i],
4895                                                 size: $e.rgsabound[$r].cElements,
4896                                                 rank: $e.cDims,
4897                                                 base: $e.rgsabound[$r].lLbound
4898                                         )
4899                                 )
4900                                 #case 0x10              ; VT_I1|VT_ARRAY
4901                                 (
4902                                         #array(
4903                                                 expr: ((signed char *)$e.pvData)[$i],
4904                                                 size: $e.rgsabound[$r].cElements,
4905                                                 rank: $e.cDims,
4906                                                 base: $e.rgsabound[$r].lLbound
4907                                         )
4908                                 )
4909                                 #case 0x11              ; VT_UI1|VT_ARRAY
4910                                 (
4911                                         #array(
4912                                                 expr: ((unsigned char *)$e.pvData)[$i],
4913                                                 size: $e.rgsabound[$r].cElements,
4914                                                 rank: $e.cDims,
4915                                                 base: $e.rgsabound[$r].lLbound
4916                                         )
4917                                 )
4918                                 #case 0x12              ; VT_UI2|VT_ARRAY
4919                                 (
4920                                         #array(
4921                                                 expr: ((unsigned short *)$e.pvData)[$i],
4922                                                 size: $e.rgsabound[$r].cElements,
4923                                                 rank: $e.cDims,
4924                                                 base: $e.rgsabound[$r].lLbound
4925                                         )
4926                                 )
4927                                 #case 0x13              ; VT_UI4|VT_ARRAY
4928                                 (
4929                                         #array(
4930                                                 expr: ((unsigned int *)$e.pvData)[$i],
4931                                                 size: $e.rgsabound[$r].cElements,
4932                                                 rank: $e.cDims,
4933                                                 base: $e.rgsabound[$r].lLbound
4934                                         )
4935                                 )
4936                                 #case 0x14              ; VT_I8|VT_ARRAY
4937                                 (
4938                                         #array(
4939                                                 expr: ((signed __int64 *)$e.pvData)[$i],
4940                                                 size: $e.rgsabound[$r].cElements,
4941                                                 rank: $e.cDims,
4942                                                 base: $e.rgsabound[$r].lLbound
4943                                         )
4944                                 )
4945                                 #case 0x15              ; VT_UI8|VT_ARRAY
4946                                 (
4947                                         #array(
4948                                                 expr: ((unsigned __int64 *)$e.pvData)[$i],
4949                                                 size: $e.rgsabound[$r].cElements,
4950                                                 rank: $e.cDims,
4951                                                 base: $e.rgsabound[$r].lLbound
4952                                         )
4953                                 )
4954                                 #case 0x1e              ; VT_LPSTR|VT_ARRAY
4955                                 (
4956                                         #array(
4957                                                 expr: ((char * *)$e.pvData)[$i],
4958                                                 size: $e.rgsabound[$r].cElements,
4959                                                 rank: $e.cDims,
4960                                                 base: $e.rgsabound[$r].lLbound
4961                                         )
4962                                 )
4963                                 #case 0x1f              ; VT_LPWSTR|VT_ARRAY
4964                                 (
4965                                         #array(
4966                                                 expr: ((wchar_t **)$e.pvData)[$i],
4967                                                 size: $e.rgsabound[$r].cElements,
4968                                                 rank: $e.cDims,
4969                                                 base: $e.rgsabound[$r].lLbound
4970                                         )
4971                                 )
4972                                 #case 0xc               ; VT_VARIANT|VT_ARRAY
4973                                 (
4974                                         #array(
4975                                                 expr: ((tagVARIANT *)$e.pvData)[$i],
4976                                                 size: $e.rgsabound[$r].cElements,
4977                                                 rank: $e.cDims,
4978                                                 base: $e.rgsabound[$r].lLbound
4979                                         )
4980                                 )
4981                                 #case 0xb               ; VT_BOOL|VT_ARRAY
4982                                 (
4983                                         #array(
4984                                                 expr: ((short *)$e.pvData)[$i],
4985                                                 size: $e.rgsabound[$r].cElements,
4986                                                 rank: $e.cDims,
4987                                                 base: $e.rgsabound[$r].lLbound
4988                                         )
4989                                 )
4990                                 #case 0xa               ; VT_ERROR|VT_ARRAY
4991                                 (
4992                                         #array(
4993                                                 expr: ((long *)$e.pvData)[$i],
4994                                                 size: $e.rgsabound[$r].cElements,
4995                                                 rank: $e.cDims,
4996                                                 base: $e.rgsabound[$r].lLbound
4997                                         )
4998                                 )
4999                                 #case 6 ; VT_CY|VT_ARRAY
5000                                 (
5001                                         #array(
5002                                                 expr: ((CY *)$e.pvData)[$i],
5003                                                 size: $e.rgsabound[$r].cElements,
5004                                                 rank: $e.cDims,
5005                                                 base: $e.rgsabound[$r].lLbound
5006                                         )
5007                                 )
5008                                 #case 7 ; VT_DATE|VT_ARRAY
5009                                 (
5010                                         #array(
5011                                                 expr: ((DATE *)$e.pvData)[$i],
5012                                                 size: $e.rgsabound[$r].cElements,
5013                                                 rank: $e.cDims,
5014                                                 base: $e.rgsabound[$r].lLbound
5015                                         )
5016                                 )
5017                                 #case 0x40              ; VT_FILETIME|VT_ARRAY
5018                                 (
5019                                         #array(
5020                                                 expr: ((FILETIME *)$e.pvData)[$i],
5021                                                 size: $e.rgsabound[$r].cElements,
5022                                                 rank: $e.cDims,
5023                                                 base: $e.rgsabound[$r].lLbound
5024                                         )
5025                                 )
5026                                 #case 0x48              ; VT_CLSID|VT_ARRAY
5027                                 (
5028                                         #array(
5029                                                 expr: ((CLSID *)$e.pvData)[$i],
5030                                                 size: $e.rgsabound[$r].cElements,
5031                                                 rank: $e.cDims,
5032                                                 base: $e.rgsabound[$r].lLbound
5033                                         )
5034                                 )
5035                                 #case 0x47              ; VT_CF|VT_ARRAY
5036                                 (
5037                                         #array(
5038                                                 expr: ((CLIPDATA *)$e.pvData)[$i],
5039                                                 size: $e.rgsabound[$r].cElements,
5040                                                 rank: $e.cDims,
5041                                                 base: $e.rgsabound[$r].lLbound
5042                                         )
5043                                 )
5044                                 #case 8 ; VT_BSTR|VT_ARRAY
5045                                 (
5046                                         #array(
5047                                                 expr: ((wchar_t * *)$e.pvData)[$i],
5048                                                 size: $e.rgsabound[$r].cElements,
5049                                                 rank: $e.cDims,
5050                                                 base: $e.rgsabound[$r].lLbound
5051                                         )
5052                                 )
5053                                 #case 0x16              ; VT_INT|VT_ARRAY
5054                                 (
5055                                         #array(
5056                                                 expr: ((int *)$e.pvData)[$i],
5057                                                 size: $e.rgsabound[$r].cElements,
5058                                                 rank: $e.cDims,
5059                                                 base: $e.rgsabound[$r].lLbound
5060                                         )
5061                                 )
5062                                 #case 0x17              ; VT_UINT|VT_ARRAY
5063                                 (
5064                                         #array(
5065                                                 expr: ((unsigned int*)$e.pvData)[$i],
5066                                                 size: $e.rgsabound[$r].cElements,
5067                                                 rank: $e.cDims,
5068                                                 base: $e.rgsabound[$r].lLbound
5069                                         )
5070                                 )
5071                                 #default
5072                                 (
5073                                                 #([actual members]: [$e,!])
5074                                 )
5075                                 #except
5076                                 (
5077                                                 #([actual members]: [$e,!])
5078                                 )
5079                         )
5080                         #elif ($e.fFeatures & 0x0100)   ; FADF_BSTR
5081                         (
5082                                         #array(expr: ((wchar_t * *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound )
5083                         )
5084                         #elif ($e.fFeatures & 0x0200)   ; FADF_UNKNOWN
5085                         (
5086                                         #array(expr: ((IUnknown *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound )
5087                         )
5088                         #elif ($e.fFeatures & 0x0400)   ; FADF_DISPATCH
5089                         (
5090                                         #array(expr: ((IDispatch *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound )
5091                         )
5092                         #elif ($e.fFeatures & 0x0800)   ; FADF_VARIANT
5093                         (
5094                                         #array(expr: ((tagVARIANT *)$e.pvData)[$i], size: $e.rgsabound[$r].cElements, rank: $e.cDims, base: $e.rgsabound[$r].lLbound )
5095                         )
5096                 )
5097         )
5098 }
5099 tagPROPVARIANT|tagVARIANT|PROPVARIANT|VARIANT{
5100         preview(
5101                 #switch ($e.vt)
5102                 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
5103                 ;;              Base Types              ;;
5104                 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
5105                 #case 0 ( #("Empty") )  ; VT_EMPTY
5106                 #case 1 ( #("NULL") )   ; VT_NULL
5107                 #case 2 ( #("I2 = ", $e.iVal) ) ; VT_I2
5108                 #case 3 ( #("I4 = ", $e.lVal) ) ; VT_I4
5109                 #case 4 ( #("R4 = ", $e.fltVal) )               ; VT_R4
5110                 #case 5 ( #("R8 = ", $e.dblVal) )               ; VT_R8
5111                 #case 6 ( #("CY = ", $e.cyVal) )                ; VT_CY
5112                 #case 7 ( #("DATE =  ", $e.date) )              ; VT_DATE
5113                 #case 8 ( #("BSTR = ", $e.bstrVal) )    ; VT_BSTR
5114                 #case 9 ( #("DISPATCH =  ", $e.pdispVal) )              ; VT_DISPATCH
5115                 #case 10 ( #("ERROR =  ", $e.scode) )   ; VT_ERROR
5116                 #case 0xB ( #("BOOL =  ", $e.boolVal) ) ; VT_BOOL
5117                 #case 0xC ( #("VARIANT ") )             ; VT_VARIANT
5118                 #case 0xD ( #("UNKNOWN =  ", $e.punkVal) )              ; VT_UNKOWN
5119                 #case 0xE ( #("DECIMAL = ", $e.decVal) )                ; VT_DECIMAL
5120                 #case 0x10 ( #("I1 =  ", $e.cVal) )             ; VT_I1
5121                 #case 0x11 ( #("UI1 =  ", $e.bVal) )    ; VT_UI1
5122                 #case 0x12 ( #("UI2 =  ", $e.uiVal) )   ; VT_UI2
5123                 #case 0x13 ( #("UI4 =  ", $e.ulVal) )   ; VT_UI4
5124                 #case 0x14 ( #("I8 =  ", *(__int64*)&$e.dblVal) )       ; VT_I8
5125                 #case 0x15 ( #("UI8 =  ", *(unsigned __int64*)&$e.dblVal) )     ; VT_UI8
5126                 #case 0x16 ( #("INT =  ", $e.intVal) )  ; VT_INT
5127                 #case 0x17 ( #("UINT = ", $e.uintVal) ) ; VT_UINT
5128                 #case 0x18 ( #("VOID ") )               ; VT_VOID
5129                 #case 0x19 ( #("HRESULT ") )    ; VT_HRESULT
5130                 #case 0x1A ( #("PTR ") )                ; VT_PTR
5131                 #case 0x1B ( #("SAFEARRAY ") )  ; VT_SAFEARRAY
5132                 #case 0x1C ( #("CARRAY ") )             ; VT_CARRAY
5133                 #case 0x1D ( #("USERDEFINED ") )                ; VT_USERDEFINED
5134                 #case 0x1E ( #("LPSTR =  ", $e.pszVal) )                ; VT_LPSTR
5135                 #case 0x1F ( #("LPWSTR =  ", $e.pwszVal) )              ; VT_LPWSTR
5136                 #case 0x24 ( #("RECORD  ") )    ; VT_RECORD
5137                 #case 0x26 ( #("UINT_PTR ") )   ; VT_UINT_PTR
5138                 #case 0x40 ( #("FILETIME =      ", $e.filetime) )       ; VT_FILETIME
5139                 #case 0x42 ( #("STREAM =  ", $e.pStream) )              ; VT_STREAM
5140                 #case 0x43 ( #("STORAGE = ", $e.pStorage) )             ; VT_STORAGE
5141                 #case 0x44 ( #("STREAMED_OBJECT =  ", $e.pStream) )             ; VT_STREAMED_OBJECT
5142                 #case 0x45 ( #("STORED_OBJECT =  ", $e.pStorage) )              ; VT_STORED_OBJECT
5143                 #case 0x46 ( #("BLOB_OBJECT = ", $e.blob ) )    ; VT_BLOB_OBJECT
5144                 #case 0x47 ( #("CF =  ", $e.pclipdata) )                ; VT_CF
5145                 #case 0x48 ( #("CLSID = ", $e.puuid) )  ; VT_CLSID
5146                 #case 0x49 ( #("VERSIONED_STREAM = ", $e.pVersionedStream) )    ; VT_VERSIONED_STREAM
5147                 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
5148                 ;;       Vector types           ;;
5149                 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
5150                 #case 0x1002 ( #("vector of I2 = ", $e.cai) )   ; VT_I2|VT_VECTOR
5151                 #case 0x1003 ( #("vector of I4 = ", $e.cal) )   ; VT_I4|VT_VECTOR
5152                 #case 0x1004 ( #("vector of R4 = ", $e.caflt) ) ; VT_R4|VT_VECTOR
5153                 #case 0x1005 ( #("vector of R8 = ", $e.cadbl) ) ; VT_R8|VT_VECTOR
5154                 #case 0x1010 ( #("vector of I1 =  ", $e.cac) )  ; VT_I1|VT_VECTOR
5155                 #case 0x1011 ( #("vector of UI1 =  ", $e.caub) )                ; VT_UI1|VT_VECTOR
5156                 #case 0x1012 ( #("vector of UI2 =  ", $e.caui) )                ; VT_UI2|VT_VECTOR
5157                 #case 0x1013 ( #("vector of UI4 =  ", $e.caul) )                ; VT_UI4|VT_VECTOR
5158                 #case 0x1014 ( #("vector of I8 =  ", $e.cah) )  ; VT_I8|VT_VECTOR
5159                 #case 0x1015 ( #("vector of UI8 =  ", $e.cauh) )                ; VT_UI8|VT_VECTOR
5160                 #case 0x101E ( #("vector of LPSTR =  ", $e.calpstr) )   ; VT_LPSTR|VT_VECTOR
5161                 #case 0x101F ( #("vector of LPWSTR =  ", $e.calpwstr) ) ; VT_LPWSTR|VT_VECTOR
5162                 #case 0x100C ( #("vector of VARIANT ", $e.capropvar) )  ; VT_VARIANT|VT_VECTOR
5163                 #case 0x100B ( #("vector of BOOL =      ", $e.cabool) )         ; VT_BOOL|VT_VECTOR
5164                 #case 0x100A ( #("vector of ERROR =  ", $e.cascode) )   ; VT_ERROR|VT_VECTOR
5165                 #case 0x1006 ( #("vector of CY = ", $e.cacy) )  ; VT_CY|VT_VECTOR
5166                 #case 0x1007 ( #("vector of DATE =      ", $e.cadate) )         ; VT_DATE|VT_VECTOR
5167                 #case 0x1040 ( #("vector of FILETIME =  ", $e.cafiletime) )             ; VT_FILETIME|VT_VECTOR
5168                 #case 0x1048 ( #("vector of CLSID = ", $e.cauuid) )             ; VT_CLSID|VT_VECTOR
5169                 #case 0x1047 ( #("vector of CF =  ", $e.caclipdata) )   ; VT_CF|VT_VECTOR
5170                 #case 0x1008 ( #("vector of BSTR = ", $e.cabstr) )              ; VT_BSTR|VT_VECTOR
5171                 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
5172                 ;;       Byref Types            ;;
5173                 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
5174                 #case 0x4016 ( #("byref of INT =  ", $e.pintVal) )              ; VT_INT|VT_BYREF
5175                 #case 0x4017 ( #("byref of UINT = ", $e.puintVal) )             ; VT_UINT|VT_BYREF
5176                 #case 0x4002 ( #("byref of I2 = ", $e.piVal) )  ; VT_I2|VT_BYREF
5177                 #case 0x4003 ( #("byref of I4 = ", $e.plVal) )  ; VT_I4|VT_BYREF
5178                 #case 0x4004 ( #("byref of R4 = ", $e.pfltVal) )                ; VT_R4|VT_BYREF
5179                 #case 0x4005 ( #("byref of R8 = ", $e.pdblVal) )                ; VT_R8|VT_BYREF
5180                 #case 0x4010 ( #("byref of I1 =  ", $e.pcVal) ) ; VT_I1|VT_BYREF
5181                 #case 0x4011 ( #("byref of UI1 =  ", $e.pbVal) )                ; VT_UI1|VT_BYREF
5182                 #case 0x4012 ( #("byref of UI2 =  ", $e.puiVal) )               ; VT_UI2|VT_BYREF
5183                 #case 0x4013 ( #("byref of UI4 =  ", $e.pulVal) )               ; VT_UI4|VT_BYREF
5184                 #case 0x4014 ( #("byref of I8 =  ", (__int64*)$e.pdblVal) )             ; VT_I8|VT_BYREF
5185                 #case 0x4015 ( #("byref of UI8 =  ", (unsigned __int64*)$e.pudblVal) )          ; VT_UI8|VT_BYREF
5186                 #case 0x400C ( #("byref of VARIANT ", $e.pvarVal) )             ; VT_VARIANT|VT_BYREF
5187                 #case 0x400B ( #("byref of BOOL =  ", $e.pboolVal) )    ; VT_BOOL|VT_BYREF
5188                 #case 0x400A ( #("byref of ERROR =      ", $e.pscode) )         ; VT_ERROR|VT_BYREF
5189                 #case 0x4006 ( #("byref of CY = ", $e.pcyVal) ) ; VT_CY|VT_BYREF
5190                 #case 0x4007 ( #("byref of DATE =  ", $e.pdate) )               ; VT_DATE|VT_BYREF
5191                 #case 0x4008 ( #("byref of BSTR = ", $e.pbstrVal) )             ; VT_BSTR|VT_BYREF
5192                 #case 0x400E ( #("byref of DECIMAL = ", $e.pdecVal) )   ; VT_DECIMAL|VT_BYREF
5193                 #case 0x400D ( #("byref of UNKNOWN =  ", $e.ppunkVal) ) ; VT_UNKOWN|VT_BYREF
5194                 #case 0x4009 ( #("byref of DISPATCH =  ", $e.ppdispVal) )               ; VT_DISPATCH|VT_BYREF
5195                 #case 0x6000 ( #("byref of ARRAY =      ", $e.pparray) )        ; VT_ARRAY|VT_BYREF
5196                 #default
5197                 (
5198                         #if ($e.vt & 0x2000) ( $e.parray)
5199                         #else ( #("Unknown vt type = ", $e.vt))
5200                 )
5201         )
5202         children(
5203                 #(
5204                         vt: $e.vt,
5205                         #switch ($e.vt)
5206                         ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
5207                         ;;              Base Types              ;;
5208                         ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
5209                         #case 0x2 ( #(I2  : $e.iVal) )  ; VT_I2
5210                         #case 0x3 ( #(I4  : $e.lVal) )  ; VT_I4
5211                         #case 0x4 ( #(R4  : $e.fltVal) )                ; VT_R4
5212                         #case 0x5 ( #(R8  : $e.dblVal) )                ; VT_R8
5213                         #case 0x6 ( #(CY  : $e.cyVal) ) ; VT_CY
5214                         #case 0x7 ( #(DATE       : $e.date) )           ; VT_DATE
5215                         #case 0x8 ( #(BSTR      : $e.bstrVal) )         ; VT_BSTR
5216                         #case 0x9 ( #(DISPATCH   : $e.pdispVal) )               ; VT_DISPATCH
5217                         #case 0xA ( #(ERROR   : $e.scode) )             ; VT_ERROR
5218                         #case 0xB ( #(BOOL       : $e.boolVal) )        ; VT_BOOL
5219                         #case 0xD ( #(UNKNOWN   : $e.punkVal) ) ; VT_UNKOWN
5220                         #case 0xE ( #(DECIMAL  : $e.decVal) )   ; VT_DECIMAL
5221                         #case 0x10 ( #(I1       : $e.cVal) )            ; VT_I1
5222                         #case 0x11 ( #(UI1       : $e.bVal) )           ; VT_UI1
5223                         #case 0x12 ( #(UI2       : $e.uiVal) )          ; VT_UI2
5224                         #case 0x13 ( #(UI4       : $e.ulVal) )          ; VT_UI4
5225                         #case 0x14 ( #(I8       : *(__int64*)&$e.dblVal) )              ; VT_I8
5226                         #case 0x15 ( #(UI8       : *(unsigned __int64*)&$e.dblVal) )            ; VT_UI8
5227                         #case 0x16 ( #(INT       : $e.intVal) )         ; VT_INT
5228                         #case 0x17 ( #(UINT  : $e.uintVal) )    ; VT_UINT
5229                         #case 0x1E ( #(LPSTR   : $e.pszVal) )   ; VT_LPSTR
5230                         #case 0x1F ( #(LPWSTR   : $e.pwszVal) ) ; VT_LPWSTR
5231                         #case 0x40 ( #(FILETIME   : $e.filetime) )              ; VT_FILETIME
5232                         #case 0x42 ( #(STREAM   : $e.pStream) ) ; VT_STREAM
5233                         #case 0x43 ( #(STORAGE  : $e.pStorage) )                ; VT_STORAGE
5234                         #case 0x44 ( #(STREAMED_OBJECT   : $e.pStream) )                ; VT_STREAMED_OBJECT
5235                         #case 0x45 ( #(STORED_OBJECT   : $e.pStorage) ) ; VT_STORED_OBJECT
5236                         #case 0x46 ( #(BLOB_OBJECT      : $e.blob ) )           ; VT_BLOB_OBJECT
5237                         #case 0x47 ( #(CF       : $e.pclipdata) )       ; VT_CF
5238                         #case 0x48 ( #(CLSID  : $e.puuid) )             ; VT_CLSID
5239                         #case 0x49 ( #(VERSIONED_STREAM  : $e.pVersionedStream) )               ; VT_VERSIONED_STREAM
5240                         ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
5241                         ;;       Vector types           ;;
5242                         ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
5243                         #case 0x1002 ( #(vector of I2  : $e.cai) )              ; VT_I2|VT_VECTOR
5244                         #case 0x1003 ( #(vector of I4  : $e.cal) )              ; VT_I4|VT_VECTOR
5245                         #case 0x1004 ( #(vector of R4  : $e.caflt) )    ; VT_R4|VT_VECTOR
5246                         #case 0x1005 ( #(vector of R8  : $e.cadbl) )    ; VT_R8|VT_VECTOR
5247                         #case 0x1010 ( #(vector of I1   : $e.cac) )             ; VT_I1|VT_VECTOR
5248                         #case 0x1011 ( #(vector of UI1   : $e.caub) )   ; VT_UI1|VT_VECTOR
5249                         #case 0x1012 ( #(vector of UI2   : $e.caui) )   ; VT_UI2|VT_VECTOR
5250                         #case 0x1013 ( #(vector of UI4   : $e.caul) )   ; VT_UI4|VT_VECTOR
5251                         #case 0x1014 ( #(vector of I8   : $e.cah) )             ; VT_I8|VT_VECTOR
5252                         #case 0x1015 ( #(vector of UI8   : $e.cauh) )   ; VT_UI8|VT_VECTOR
5253                         #case 0x101E ( #(vector of LPSTR   : $e.calpstr) )              ; VT_LPSTR|VT_VECTOR
5254                         #case 0x101F ( #(vector of LPWSTR       : $e.calpwstr) )        ; VT_LPWSTR|VT_VECTOR
5255                         #case 0x100C ( #(vector of VARIANT : $e.capropvar) )    ; VT_VARIANT|VT_VECTOR
5256                         #case 0x100B ( #(vector of BOOL   : $e.cabool) )                ; VT_BOOL|VT_VECTOR
5257                         #case 0x100A ( #(vector of ERROR   : $e.cascode) )              ; VT_ERROR|VT_VECTOR
5258                         #case 0x1006 ( #(vector of CY  : $e.cacy) )             ; VT_CY|VT_VECTOR
5259                         #case 0x1007 ( #(vector of DATE   : $e.cadate) )                ; VT_DATE|VT_VECTOR
5260                         #case 0x1040 ( #(vector of FILETIME   : $e.cafiletime) )                ; VT_FILETIME|VT_VECTOR
5261                         #case 0x1048 ( #(vector of CLSID  : $e.cauuid) )                ; VT_CLSID|VT_VECTOR
5262                         #case 0x1047 ( #(vector of CF   : $e.caclipdata) )              ; VT_CF|VT_VECTOR
5263                         #case 0x1008 ( #(vector of BSTR  : $e.cabstr) ) ; VT_BSTR|VT_VECTOR
5264                         ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
5265                         ;;       Byref Types            ;;
5266                         ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
5267                         #case 0x4016 ( #(byref of INT   : $e.pintVal) ) ; VT_INT|VT_BYREF
5268                         #case 0x4017 ( #(byref of UINT  : $e.puintVal) )                ; VT_UINT|VT_BYREF
5269                         #case 0x4002 ( #(byref of I2  : $e.piVal) )             ; VT_I2|VT_BYREF
5270                         #case 0x4003 ( #(byref of I4  : $e.plVal) )             ; VT_I4|VT_BYREF
5271                         #case 0x4004 ( #(byref of R4  : $e.pfltVal) )   ; VT_R4|VT_BYREF
5272                         #case 0x4005 ( #(byref of R8  : $e.pdblVal) )   ; VT_R8|VT_BYREF
5273                         #case 0x4010 ( #(byref of I1   : $e.pcVal) )    ; VT_I1|VT_BYREF
5274                         #case 0x4011 ( #(byref of UI1   : $e.pbVal) )   ; VT_UI1|VT_BYREF
5275                         #case 0x4012 ( #(byref of UI2   : $e.puiVal) )  ; VT_UI2|VT_BYREF
5276                         #case 0x4013 ( #(byref of UI4   : $e.pulVal) )  ; VT_UI4|VT_BYREF
5277                         #case 0x4014 ( #(byref of I8    : (__int64*)$e.pdblVal) )       ; VT_I8|VT_BYREF
5278                         #case 0x4015 ( #(byref of UI8   : (unsigned __int64*)$e.pdblVal) ) ; VT_UI8|VT_BYREF
5279                         #case 0x400C ( #(byref of VARIANT : $e.pvarVal) )               ; VT_VARIANT|VT_BYREF
5280                         #case 0x400B ( #(byref of BOOL   : $e.pboolVal) )               ; VT_BOOL|VT_BYREF
5281                         #case 0x400A ( #(byref of ERROR   : $e.pscode) )                ; VT_ERROR|VT_BYREF
5282                         #case 0x4006 ( #(byref of CY  : $e.pcyVal) )    ; VT_CY|VT_BYREF
5283                         #case 0x4007 ( #(byref of DATE   : $e.pdate) )  ; VT_DATE|VT_BYREF
5284                         #case 0x4008 ( #(byref of BSTR  : $e.pbstrVal) )                ; VT_BSTR|VT_BYREF
5285                         #case 0x400E ( #(byref of DECIMAL  : $e.pdecVal) )              ; VT_DECIMAL|VT_BYREF
5286                         #case 0x400D ( #(byref of UNKNOWN       : $e.ppunkVal) )        ; VT_UNKOWN|VT_BYREF
5287                         #case 0x4009 ( #(byref of DISPATCH       : $e.ppdispVal) )      ; VT_DISPATCH|VT_BYREF
5288                         #case 0x6000 ( #(byref of ARRAY   : $e.pparray) )               ; VT_ARRAY|VT_BYREF
5289
5290                         ; the following are either empty or invalid vt values for a variant
5291                         ; #case 0 ( #(Empty :) )                ; VT_EMPTY
5292                         ; #case 0x1 ( #(NULL :) )               ; VT_NULL
5293                         ; #case 0xC ( #(VARIANT :) )    ; VT_VARIANT
5294                         ; #case 0x18 ( #(VOID :) )              ; VT_VOID
5295                         ; #case 0x19 ( #(HRESULT :) )   ; VT_HRESULT
5296                         ; #case 0x1A ( #(PTR :) )               ; VT_PTR
5297                         ; #case 0x1B ( #(SAFEARRAY :) ) ; VT_SAFEARRAY
5298                         ; #case 0x1C ( #(CARRAY :) )    ; VT_CARRAY
5299                         ; #case 0x1D ( #(USERDEFINED :) )               ; VT_USERDEFINED
5300                         ; #case 0x24 ( #(RECORD  :) )   ; VT_RECORD
5301                         ; #case 0x26 ( #(UINT_PTR :) )  ; VT_UINT_PTR
5302                         #default
5303                         (
5304                                 #if ($e.vt & 0x2000 )
5305                                         ( #(safearray: $e.parray))
5306                                 #else
5307                                 (
5308                                         #(
5309                                                 [raw members]: [$e,!]   ; unformatted data members
5310                                          )
5311                                  )
5312                         )
5313                         #except
5314                         (
5315                                 #(
5316                                         [raw members]: [$e,!]   ; unformatted data members
5317                                  )
5318                         )
5319                 )
5320         )
5321 }
5322 ; This section lets you define your own errors for the HRESULT display.
5323 ; You need to list the error code in unsigned decimal, followed by the message.
5324 ; Changes will take effect the next time you redisplay the variable.
5325
5326 [hresult]
5327 ;1234=my custom error code
5328