git.oblomov.eu Git - wine/blob - dlls/shell32/iconcache.c

   1 /*
   2  *      shell icon cache (SIC)
   3  *
   4  * Copyright 1998, 1999 Juergen Schmied
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include "config.h"
  22
  23 #include <stdarg.h>
  24 #include <string.h>
  25 #include <sys/types.h>
  26 #ifdef HAVE_UNISTD_H
  27 # include <unistd.h>
  28 #endif
  29 #include "windef.h"
  30 #include "winbase.h"
  31 #include "wingdi.h"
  32 #include "winuser.h"
  33 #include "winreg.h"
  34 #include "wine/winuser16.h"
  35 #include "wine/winbase16.h"
  36 #include "heap.h"
  37 #include "wine/debug.h"
  38
  39 #include "shellapi.h"
  40 #include "objbase.h"
  41 #include "shlguid.h"
  42 #include "pidl.h"
  43 #include "shell32_main.h"
  44 #include "undocshell.h"
  45 #include "shlwapi.h"
  46
  47 WINE_DEFAULT_DEBUG_CHANNEL(shell);
  48
  49 /********************** THE ICON CACHE ********************************/
  50
  51 #define INVALID_INDEX -1
  52
  53 typedef struct
  54 {
  55         LPSTR sSourceFile;      /* file (not path!) containing the icon */
  56         DWORD dwSourceIndex;    /* index within the file, if it is a resoure ID it will be negated */
  57         DWORD dwListIndex;      /* index within the iconlist */
  58         DWORD dwFlags;          /* GIL_* flags */
  59         DWORD dwAccessTime;
  60 } SIC_ENTRY, * LPSIC_ENTRY;
  61
  62 static HDPA             sic_hdpa = 0;
  63
  64 static CRITICAL_SECTION SHELL32_SicCS;
  65 static CRITICAL_SECTION_DEBUG critsect_debug =
  66 {
  67     0, 0, &SHELL32_SicCS,
  68     { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
  69       0, 0, { 0, (DWORD)(__FILE__ ": SHELL32_SicCS") }
  70 };
  71 static CRITICAL_SECTION SHELL32_SicCS = { &critsect_debug, -1, 0, 0, 0, 0 };
  72
  73 /*****************************************************************************
  74  * SIC_CompareEntries
  75  *
  76  * NOTES
  77  *  Callback for DPA_Search
  78  */
  79 static INT CALLBACK SIC_CompareEntries( LPVOID p1, LPVOID p2, LPARAM lparam)
  80 {       TRACE("%p %p %8lx\n", p1, p2, lparam);
  81
  82         if (((LPSIC_ENTRY)p1)->dwSourceIndex != ((LPSIC_ENTRY)p2)->dwSourceIndex) /* first the faster one*/
  83           return 1;
  84
  85         if (strcasecmp(((LPSIC_ENTRY)p1)->sSourceFile,((LPSIC_ENTRY)p2)->sSourceFile))
  86           return 1;
  87
  88         return 0;
  89 }
  90 /*****************************************************************************
  91  * SIC_IconAppend                       [internal]
  92  *
  93  * NOTES
  94  *  appends a icon pair to the end of the cache
  95  */
  96 static INT SIC_IconAppend (LPCSTR sSourceFile, INT dwSourceIndex, HICON hSmallIcon, HICON hBigIcon)
  97 {       LPSIC_ENTRY lpsice;
  98         INT ret, index, index1;
  99         char *path;
 100         TRACE("%s %i %p %p\n", sSourceFile, dwSourceIndex, hSmallIcon ,hBigIcon);
 101
 102         lpsice = (LPSIC_ENTRY) SHAlloc (sizeof (SIC_ENTRY));
 103
 104         path = PathFindFileNameA(sSourceFile);
 105         lpsice->sSourceFile = HeapAlloc( GetProcessHeap(), 0, strlen(path)+1 );
 106         strcpy( lpsice->sSourceFile, path );
 107
 108         lpsice->dwSourceIndex = dwSourceIndex;
 109
 110         EnterCriticalSection(&SHELL32_SicCS);
 111
 112         index = DPA_InsertPtr(sic_hdpa, 0x7fff, lpsice);
 113         if ( INVALID_INDEX == index )
 114         {
 115           SHFree(lpsice);
 116           ret = INVALID_INDEX;
 117         }
 118         else
 119         {
 120           index = ImageList_AddIcon (ShellSmallIconList, hSmallIcon);
 121           index1= ImageList_AddIcon (ShellBigIconList, hBigIcon);
 122
 123           if (index!=index1)
 124           {
 125             FIXME("iconlists out of sync 0x%x 0x%x\n", index, index1);
 126           }
 127           lpsice->dwListIndex = index;
 128           ret = lpsice->dwListIndex;
 129         }
 130
 131         LeaveCriticalSection(&SHELL32_SicCS);
 132         return ret;
 133 }
 134 /****************************************************************************
 135  * SIC_LoadIcon                         [internal]
 136  *
 137  * NOTES
 138  *  gets small/big icon by number from a file
 139  */
 140 static INT SIC_LoadIcon (LPCSTR sSourceFile, INT dwSourceIndex)
 141 {       HICON   hiconLarge=0;
 142         HICON   hiconSmall=0;
 143
 144         PrivateExtractIconsA( sSourceFile, dwSourceIndex, 32, 32, &hiconLarge, 0, 1, 0 );
 145         PrivateExtractIconsA( sSourceFile, dwSourceIndex, 16, 16, &hiconSmall, 0, 1, 0 );
 146
 147         if ( !hiconLarge ||  !hiconSmall)
 148         {
 149           WARN("failure loading icon %i from %s (%p %p)\n", dwSourceIndex, sSourceFile, hiconLarge, hiconSmall);
 150           return -1;
 151         }
 152         return SIC_IconAppend (sSourceFile, dwSourceIndex, hiconSmall, hiconLarge);
 153 }
 154 /*****************************************************************************
 155  * SIC_GetIconIndex                     [internal]
 156  *
 157  * Parameters
 158  *      sSourceFile     [IN]    filename of file containing the icon
 159  *      index           [IN]    index/resID (negated) in this file
 160  *
 161  * NOTES
 162  *  look in the cache for a proper icon. if not available the icon is taken
 163  *  from the file and cached
 164  */
 165 INT SIC_GetIconIndex (LPCSTR sSourceFile, INT dwSourceIndex )
 166 {       SIC_ENTRY sice;
 167         INT ret, index = INVALID_INDEX;
 168
 169         TRACE("%s %i\n", sSourceFile, dwSourceIndex);
 170
 171         sice.sSourceFile = PathFindFileNameA(sSourceFile);
 172         sice.dwSourceIndex = dwSourceIndex;
 173
 174         EnterCriticalSection(&SHELL32_SicCS);
 175
 176         if (NULL != DPA_GetPtr (sic_hdpa, 0))
 177         {
 178           /* search linear from position 0*/
 179           index = DPA_Search (sic_hdpa, &sice, 0, SIC_CompareEntries, 0, 0);
 180         }
 181
 182         if ( INVALID_INDEX == index )
 183         {
 184           ret = SIC_LoadIcon (sSourceFile, dwSourceIndex);
 185         }
 186         else
 187         {
 188           TRACE("-- found\n");
 189           ret = ((LPSIC_ENTRY)DPA_GetPtr(sic_hdpa, index))->dwListIndex;
 190         }
 191
 192         LeaveCriticalSection(&SHELL32_SicCS);
 193         return ret;
 194 }
 195 /****************************************************************************
 196  * SIC_GetIcon                          [internal]
 197  *
 198  * NOTES
 199  *  retrieves the specified icon from the iconcache. if not found tries to load the icon
 200  */
 201 static HICON WINE_UNUSED SIC_GetIcon (LPCSTR sSourceFile, INT dwSourceIndex, BOOL bSmallIcon )
 202 {       INT index;
 203
 204         TRACE("%s %i\n", sSourceFile, dwSourceIndex);
 205
 206         index = SIC_GetIconIndex(sSourceFile, dwSourceIndex);
 207
 208         if (INVALID_INDEX == index)
 209         {
 210           return (HICON)INVALID_INDEX;
 211         }
 212
 213         if (bSmallIcon)
 214           return ImageList_GetIcon(ShellSmallIconList, index, ILD_NORMAL);
 215         return ImageList_GetIcon(ShellBigIconList, index, ILD_NORMAL);
 216
 217 }
 218 /*****************************************************************************
 219  * SIC_Initialize                       [internal]
 220  *
 221  * NOTES
 222  *  hack to load the resources from the shell32.dll under a different dll name
 223  *  will be removed when the resource-compiler is ready
 224  */
 225 BOOL SIC_Initialize(void)
 226 {
 227         HICON           hSm, hLg;
 228         UINT            index;
 229
 230         TRACE("\n");
 231
 232         if (sic_hdpa)   /* already initialized?*/
 233           return TRUE;
 234
 235         sic_hdpa = DPA_Create(16);
 236
 237         if (!sic_hdpa)
 238         {
 239           return(FALSE);
 240         }
 241
 242         ShellSmallIconList = ImageList_Create(16,16,ILC_COLORDDB | ILC_MASK,0,0x20);
 243         ShellBigIconList = ImageList_Create(32,32,ILC_COLORDDB | ILC_MASK,0,0x20);
 244
 245         ImageList_SetBkColor(ShellSmallIconList, GetSysColor(COLOR_WINDOW));
 246         ImageList_SetBkColor(ShellBigIconList, GetSysColor(COLOR_WINDOW));
 247
 248         for (index=1; index<39; index++)
 249         {
 250           hSm = LoadImageA(shell32_hInstance, MAKEINTRESOURCEA(index), IMAGE_ICON, 16, 16,LR_SHARED);
 251           hLg = LoadImageA(shell32_hInstance, MAKEINTRESOURCEA(index), IMAGE_ICON, 32, 32,LR_SHARED);
 252
 253           if(!hSm)
 254           {
 255             hSm = LoadImageA(shell32_hInstance, MAKEINTRESOURCEA(0), IMAGE_ICON, 16, 16,LR_SHARED);
 256             hLg = LoadImageA(shell32_hInstance, MAKEINTRESOURCEA(0), IMAGE_ICON, 32, 32,LR_SHARED);
 257           }
 258           SIC_IconAppend ("shell32.dll", index, hSm, hLg);
 259         }
 260
 261         TRACE("hIconSmall=%p hIconBig=%p\n",ShellSmallIconList, ShellBigIconList);
 262
 263         return TRUE;
 264 }
 265 /*************************************************************************
 266  * SIC_Destroy
 267  *
 268  * frees the cache
 269  */
 270 static INT CALLBACK sic_free( LPVOID ptr, LPVOID lparam )
 271 {
 272     SHFree(ptr);
 273     return TRUE;
 274 }
 275
 276 void SIC_Destroy(void)
 277 {
 278         TRACE("\n");
 279
 280         EnterCriticalSection(&SHELL32_SicCS);
 281
 282         if (sic_hdpa) DPA_DestroyCallback(sic_hdpa, sic_free, NULL );
 283
 284         sic_hdpa = NULL;
 285
 286         LeaveCriticalSection(&SHELL32_SicCS);
 287         DeleteCriticalSection(&SHELL32_SicCS);
 288 }
 289 /*************************************************************************
 290  * Shell_GetImageList                   [SHELL32.71]
 291  *
 292  * PARAMETERS
 293  *  imglist[1|2] [OUT] pointer which recive imagelist handles
 294  *
 295  */
 296 BOOL WINAPI Shell_GetImageList(HIMAGELIST * lpBigList, HIMAGELIST * lpSmallList)
 297 {       TRACE("(%p,%p)\n",lpBigList,lpSmallList);
 298         if (lpBigList)
 299         { *lpBigList = ShellBigIconList;
 300         }
 301         if (lpSmallList)
 302         { *lpSmallList = ShellSmallIconList;
 303         }
 304
 305         return TRUE;
 306 }
 307 /*************************************************************************
 308  * PidlToSicIndex                       [INTERNAL]
 309  *
 310  * PARAMETERS
 311  *      sh      [IN]    IShellFolder
 312  *      pidl    [IN]
 313  *      bBigIcon [IN]
 314  *      uFlags  [IN]    GIL_*
 315  *      pIndex  [OUT]   index within the SIC
 316  *
 317  */
 318 BOOL PidlToSicIndex (
 319         IShellFolder * sh,
 320         LPCITEMIDLIST pidl,
 321         BOOL bBigIcon,
 322         UINT uFlags,
 323         UINT * pIndex)
 324 {
 325         IExtractIconA   *ei;
 326         char            szIconFile[MAX_PATH];   /* file containing the icon */
 327         INT             iSourceIndex;           /* index or resID(negated) in this file */
 328         BOOL            ret = FALSE;
 329         UINT            dwFlags = 0;
 330
 331         TRACE("sf=%p pidl=%p %s\n", sh, pidl, bBigIcon?"Big":"Small");
 332
 333         if (SUCCEEDED (IShellFolder_GetUIObjectOf(sh, 0, 1, &pidl, &IID_IExtractIconA, 0, (void **)&ei)))
 334         {
 335           if (SUCCEEDED(IExtractIconA_GetIconLocation(ei, uFlags, szIconFile, MAX_PATH, &iSourceIndex, &dwFlags)))
 336           {
 337             *pIndex = SIC_GetIconIndex(szIconFile, iSourceIndex);
 338             ret = TRUE;
 339           }
 340           IExtractIconA_Release(ei);
 341         }
 342
 343         if (INVALID_INDEX == *pIndex)   /* default icon when failed */
 344           *pIndex = 1;
 345
 346         return ret;
 347
 348 }
 349
 350 /*************************************************************************
 351  * SHMapPIDLToSystemImageListIndex      [SHELL32.77]
 352  *
 353  * PARAMETERS
 354  *      sh      [IN]            pointer to an instance of IShellFolder
 355  *      pidl    [IN]
 356  *      pIndex  [OUT][OPTIONAL] SIC index for big icon
 357  *
 358  */
 359 int WINAPI SHMapPIDLToSystemImageListIndex(
 360         LPSHELLFOLDER sh,
 361         LPCITEMIDLIST pidl,
 362         UINT * pIndex)
 363 {
 364         UINT    Index;
 365
 366         TRACE("(SF=%p,pidl=%p,%p)\n",sh,pidl,pIndex);
 367         pdump(pidl);
 368
 369         if (pIndex)
 370           PidlToSicIndex ( sh, pidl, 1, 0, pIndex);
 371         PidlToSicIndex ( sh, pidl, 0, 0, &Index);
 372         return Index;
 373 }
 374
 375 /*************************************************************************
 376  * Shell_GetCachedImageIndex            [SHELL32.72]
 377  *
 378  */
 379 INT WINAPI Shell_GetCachedImageIndexA(LPCSTR szPath, INT nIndex, BOOL bSimulateDoc)
 380 {
 381         WARN("(%s,%08x,%08x) semi-stub.\n",debugstr_a(szPath), nIndex, bSimulateDoc);
 382         return SIC_GetIconIndex(szPath, nIndex);
 383 }
 384
 385 INT WINAPI Shell_GetCachedImageIndexW(LPCWSTR szPath, INT nIndex, BOOL bSimulateDoc)
 386 {       INT ret;
 387         LPSTR sTemp = HEAP_strdupWtoA (GetProcessHeap(),0,szPath);
 388
 389         WARN("(%s,%08x,%08x) semi-stub.\n",debugstr_w(szPath), nIndex, bSimulateDoc);
 390
 391         ret = SIC_GetIconIndex(sTemp, nIndex);
 392         HeapFree(GetProcessHeap(),0,sTemp);
 393         return ret;
 394 }
 395
 396 INT WINAPI Shell_GetCachedImageIndexAW(LPCVOID szPath, INT nIndex, BOOL bSimulateDoc)
 397 {       if( SHELL_OsIsUnicode())
 398           return Shell_GetCachedImageIndexW(szPath, nIndex, bSimulateDoc);
 399         return Shell_GetCachedImageIndexA(szPath, nIndex, bSimulateDoc);
 400 }
 401
 402 /*************************************************************************
 403  * ExtractIconEx                        [SHELL32.@]
 404  */
 405 UINT WINAPI ExtractIconExAW(LPCVOID lpszFile, INT nIconIndex, HICON * phiconLarge, HICON * phiconSmall, UINT nIcons)
 406 {       if (SHELL_OsIsUnicode())
 407           return ExtractIconExW ( lpszFile, nIconIndex, phiconLarge, phiconSmall, nIcons);
 408         return ExtractIconExA ( lpszFile, nIconIndex, phiconLarge, phiconSmall, nIcons);
 409 }
 410
 411 /*************************************************************************
 412  * ExtractIconExW                       [SHELL32.@]
 413  * RETURNS:
 414  *  0 no icon found
 415  *  -1 file is not valid
 416  *  or number of icons extracted
 417  */
 418 UINT WINAPI ExtractIconExW(LPCWSTR lpszFile, INT nIconIndex, HICON * phiconLarge, HICON * phiconSmall, UINT nIcons)
 419 {
 420         TRACE("%s %i %p %p %i\n", debugstr_w(lpszFile), nIconIndex, phiconLarge, phiconSmall, nIcons);
 421
 422         return PrivateExtractIconExW(lpszFile, nIconIndex, phiconLarge, phiconSmall, nIcons);
 423 }
 424
 425 /*************************************************************************
 426  * ExtractIconExA                       [SHELL32.@]
 427  */
 428 UINT WINAPI ExtractIconExA(LPCSTR lpszFile, INT nIconIndex, HICON * phiconLarge, HICON * phiconSmall, UINT nIcons)
 429 {
 430     UINT ret;
 431     INT len = MultiByteToWideChar(CP_ACP, 0, lpszFile, -1, NULL, 0);
 432     LPWSTR lpwstrFile = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 433
 434     TRACE("%s %i %p %p %i\n", lpszFile, nIconIndex, phiconLarge, phiconSmall, nIcons);
 435
 436     MultiByteToWideChar(CP_ACP, 0, lpszFile, -1, lpwstrFile, len);
 437     ret = ExtractIconExW (lpwstrFile, nIconIndex, phiconLarge, phiconSmall, nIcons);
 438     HeapFree(GetProcessHeap(), 0, lpwstrFile);
 439     return ret;
 440 }
 441
 442 /*************************************************************************
 443  *                              ExtractAssociatedIconA (SHELL32.@)
 444  *
 445  * Return icon for given file (either from file itself or from associated
 446  * executable) and patch parameters if needed.
 447  */
 448 HICON WINAPI ExtractAssociatedIconA(HINSTANCE hInst, LPSTR lpIconPath, LPWORD lpiIcon)
 449 {
 450         HICON hIcon;
 451         WORD wDummyIcon = 0;
 452
 453         TRACE("\n");
 454
 455         if(lpiIcon == NULL)
 456             lpiIcon = &wDummyIcon;
 457
 458         hIcon = ExtractIconA(hInst, lpIconPath, *lpiIcon);
 459
 460         if( hIcon < (HICON)2 )
 461         { if( hIcon == (HICON)1 ) /* no icons found in given file */
 462           { char  tempPath[0x80];
 463             HINSTANCE uRet = FindExecutableA(lpIconPath,NULL,tempPath);
 464
 465             if( uRet > (HINSTANCE)32 && tempPath[0] )
 466             { strcpy(lpIconPath,tempPath);
 467               hIcon = ExtractIconA(hInst, lpIconPath, *lpiIcon);
 468               if( hIcon > (HICON)2 )
 469                 return hIcon;
 470             }
 471             else hIcon = 0;
 472           }
 473
 474           if( hIcon == (HICON)1 )
 475             *lpiIcon = 2;   /* MSDOS icon - we found .exe but no icons in it */
 476           else
 477             *lpiIcon = 6;   /* generic icon - found nothing */
 478
 479           GetModuleFileNameA(hInst, lpIconPath, 0x80);
 480           hIcon = LoadIconA( hInst, MAKEINTRESOURCEA(*lpiIcon));
 481         }
 482         return hIcon;
 483 }
 484
 485 /*************************************************************************
 486  *                              ExtractAssociatedIconExW (SHELL32.@)
 487  *
 488  * Return icon for given file (either from file itself or from associated
 489  * executable) and patch parameters if needed.
 490  */
 491 HICON WINAPI ExtractAssociatedIconExW(HINSTANCE hInst, LPWSTR lpIconPath, LPWORD lpiIconIdx, LPWORD lpiIconId)
 492 {
 493   FIXME("%p %s %p %p): stub\n", hInst, debugstr_w(lpIconPath), lpiIconIdx, lpiIconId);
 494   return 0;
 495 }
 496
 497 /*************************************************************************
 498  *                              ExtractAssociatedIconExA (SHELL32.@)
 499  *
 500  * Return icon for given file (either from file itself or from associated
 501  * executable) and patch parameters if needed.
 502  */
 503 HICON WINAPI ExtractAssociatedIconExA(HINSTANCE hInst, LPSTR lpIconPath, LPWORD lpiIconIdx, LPWORD lpiIconId)
 504 {
 505   HICON ret;
 506   INT len = MultiByteToWideChar( CP_ACP, 0, lpIconPath, -1, NULL, 0 );
 507   LPWSTR lpwstrFile = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
 508
 509   TRACE("%p %s %p %p)\n", hInst, lpIconPath, lpiIconIdx, lpiIconId);
 510
 511   MultiByteToWideChar( CP_ACP, 0, lpIconPath, -1, lpwstrFile, len );
 512   ret = ExtractAssociatedIconExW(hInst, lpwstrFile, lpiIconIdx, lpiIconId);
 513   HeapFree(GetProcessHeap(), 0, lpwstrFile);
 514   return ret;
 515 }
 516
 517
 518 /****************************************************************************
 519  * SHDefExtractIconW            [SHELL32.@]
 520  */
 521 HRESULT WINAPI SHDefExtractIconW(LPCWSTR pszIconFile, int iIndex, UINT uFlags,
 522                                  HICON* phiconLarge, HICON* phiconSmall, UINT nIconSize)
 523 {
 524         UINT ret;
 525         HICON hIcons[2];
 526         WARN("%s %d 0x%08x %p %p %d, semi-stub\n", debugstr_w(pszIconFile), iIndex, uFlags, phiconLarge, phiconSmall, nIconSize);
 527
 528         ret = PrivateExtractIconsW(pszIconFile, iIndex, nIconSize, nIconSize, hIcons, NULL, 2, LR_DEFAULTCOLOR);
 529         /* FIXME: deal with uFlags parameter which contains GIL_ flags */
 530         if (ret == 0xFFFFFFFF)
 531           return E_FAIL;
 532         if (ret > 0) {
 533           *phiconLarge = hIcons[0];
 534           *phiconSmall = hIcons[1];
 535           return S_OK;
 536         }
 537         return S_FALSE;
 538 }
 539
 540 /****************************************************************************
 541  * SHDefExtractIconA            [SHELL32.@]
 542  */
 543 HRESULT WINAPI SHDefExtractIconA(LPCSTR pszIconFile, int iIndex, UINT uFlags,
 544                                  HICON* phiconLarge, HICON* phiconSmall, UINT nIconSize)
 545 {
 546   HRESULT ret;
 547   INT len = MultiByteToWideChar(CP_ACP, 0, pszIconFile, -1, NULL, 0);
 548   LPWSTR lpwstrFile = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 549
 550   TRACE("%s %d 0x%08x %p %p %d\n", pszIconFile, iIndex, uFlags, phiconLarge, phiconSmall, nIconSize);
 551
 552   MultiByteToWideChar(CP_ACP, 0, pszIconFile, -1, lpwstrFile, len);
 553   ret = SHDefExtractIconW(lpwstrFile, iIndex, uFlags, phiconLarge, phiconSmall, nIconSize);
 554   HeapFree(GetProcessHeap(), 0, lpwstrFile);
 555   return ret;
 556 }