Changeset 6608 for trunk/src


Ignore:
Timestamp:
Aug 30, 2001, 9:19:59 PM (24 years ago)
Author:
phaller
Message:

SHLWAPI update

Location:
trunk/src/shlwapi
Files:
10 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/shlwapi/ordinal.c

    r5753 r6608  
    6868 */
    6969DWORD WINAPI SHLWAPI_1 (
    70         LPSTR lpStr,
    71         LPVOID x)
    72 {
    73         FIXME("(%p %s %p %s)\n",lpStr, debugstr_a(lpStr),x, debugstr_a(x));
    74         return 0;
     70        LPSTR lpString1,
     71        LPSTR lpString2)
     72{
     73  if (lpString1 == NULL)
     74    return 0;
     75 
     76  if (lpString2 == NULL)
     77    return 0;
     78 
     79  FIXME("(%p %s %p %s)\n",lpStr, debugstr_a(lpStr),x, debugstr_a(x));
     80  return 0;
    7581}
    7682

  • trunk/src/shlwapi/reg.c

    r5753 r6608  
    1515
    1616#ifdef __WIN32OS2__
     17
     18#include "shlwapi_odin.h"
     19
    1720#undef FIXME
    1821#ifdef DEBUG
    … …  
    7275 */
    7376LONG WINAPI SHRegOpenUSKeyA(
    74         LPCSTR Path,
    75         REGSAM AccessType,
    76         HKEY hRelativeUSKey,
    77         HKEY hNewUSKey,
     77        LPCSTR lpszPath,
     78        DWORD  dwAccessType,
     79        HUSKEY hRelativeUSKey,
     80        PHUSKEY phNewUSKey,
    7881        BOOL fIgnoreHKCU)
    7982{
    … …  
    8891 */
    8992LONG WINAPI SHRegOpenUSKeyW(
    90         LPCSTR Path,
    91         REGSAM AccessType,
    92         HKEY hRelativeUSKey,
    93         HKEY hNewUSKey,
     93        LPCSTR lpszPath,
     94        DWORD  dwAccessType,
     95        HUSKEY hRelativeUSKey,
     96        HUSKEY hNewUSKey,
    9497        BOOL fIgnoreHKCU)
    9598{
    … …  
    130133 */
    131134LONG WINAPI SHRegQueryUSValueA(
    132         HKEY hUSKey,             /* [in] FIXME: HUSKEY */
     135        HUSKEY hUSKey,             /* [in] FIXME: HUSKEY */
    133136        LPCSTR pszValue,
    134137        LPDWORD pdwType,
    135         void *pvData,
     138        LPVOID pvData,
    136139        LPDWORD pcbData,
    137140        BOOL fIgnoreHKCU,
    138         void *pvDefaultData,
     141        LPVOID pvDefaultData,
    139142        DWORD dwDefaultDataSize)
    140143{
    … …  
    147150 */
    148151LONG WINAPI SHRegQueryUSValueW(
    149         HKEY hUSKey,             /* [in] FIXME: HUSKEY */
     152        HUSKEY hUSKey,             /* [in] FIXME: HUSKEY */
    150153        LPCSTR pszValue,
    151154        LPDWORD pdwType,

  • trunk/src/shlwapi/reg_odin.cpp

    r4081 r6608  
    1 /* $Id: reg_odin.cpp,v 1.1 2000-08-24 09:32:43 sandervl Exp $ */
     1/* $Id: reg_odin.cpp,v 1.2 2001-08-30 19:19:57 phaller Exp $ */
    22
    33/*
    … …  
    5252ODINFUNCTION5(DWORD,  SHRegCreateUSKeyA,
    5353              LPSTR,  lpszKeyName,
    54               DWORD,  arg1,
    55               DWORD,  arg2,
    56               DWORD,  arg3,
    57               DWORD,  arg4)
     54              REGSAM,  AccessType,
     55              HUSKEY,  hRelativeUSKey,
     56              PHUSKEY, phNewUSKey,
     57              DWORD,   dwFlags)
    5858{
    5959  dprintf(("not implemented\n"));
    … …  
    7474 *****************************************************************************/
    7575
    76 ODINFUNCTION5(DWORD,  SHRegCreateUSKeyW,
    77               LPWSTR, lpszKeyName,
    78               DWORD,  arg1,
    79               DWORD,  arg2,
    80               DWORD,  arg3,
    81               DWORD,  arg4)
     76ODINFUNCTION5(DWORD,   SHRegCreateUSKeyW,
     77              LPWSTR,  lpszKeyName,
     78              REGSAM,  AccessType,
     79              HUSKEY,  hRelativeUSKey,
     80              PHUSKEY, phNewUSKey,
     81              DWORD,   dwFlags)
    8282{
    8383  char szBuffer[256];
    … …  
    9595
    9696  return SHRegCreateUSKeyA(szBuffer,
    97                          arg1,
    98                          arg2,
    99                          arg3,
    100                          arg4);
     97                         AccessType,
     98                         hRelativeUSKey,
     99                         phNewUSKey,
     100                         dwFlags);
    101101}
    102102
    … …  
    212212
    213213ODINFUNCTION6(LONG,    SHRegSetUSValueA,
     214              LPCSTR,  lpszSubKeyName,
     215              LPCSTR,  lpszValueName,
     216              DWORD,   dwValueType,
     217              LPVOID,  lpValue,
     218              DWORD,   dwValueSize,
     219              DWORD,   dwFlags)
     220{
     221  dprintf(("not yet implemented"));
     222 
     223  LONG rc = 0;
     224  return rc;
     225}
     226
     227
     228
     229
     230/*****************************************************************************
     231 * Name      : DWORD SHRegSetUSValueW
     232 * Purpose   :
     233 * Parameters:
     234 * Variables :
     235 * Result    :
     236 * Remark    : SHLWAPI.SHRegSetUSValueW SHLWAPI.616
     237 * Status    : STUB UNTESTED
     238 *
     239 * Author    : Patrick Haller [Wed, 1999/12/29 23:02]
     240 *****************************************************************************/
     241
     242ODINFUNCTION6(LONG,    SHRegSetUSValueW,
     243              LPCWSTR, lpszSubKeyName,
     244              LPCWSTR, lpszValueName,
     245              DWORD,   dwValueType,
     246              LPVOID,  lpValue,
     247              DWORD,   dwValueSize,
     248              DWORD,   dwFlags)
     249{
     250  dprintf(("not yet implemented"));
     251 
     252  LONG rc = 0;
     253  return rc;
     254}
     255
     256
     257/*****************************************************************************
     258 * Name      : LONG SHRegCloseUSKey
     259 * Purpose   :
     260 * Parameters:
     261 * Variables :
     262 * Result    :
     263 * Remark    :
     264 * Status    : STUB UNTESTED
     265 *
     266 * Author    : Patrick Haller [2001-08-30]
     267 *****************************************************************************/
     268
     269ODINFUNCTION1(LONG,    SHRegCloseUSKey,
     270              HUSKEY,  hUSKey)
     271{
     272  dprintf(("not implemented\n"));
     273 
     274  LONG rc = RegCloseKey(hUSKey);
     275  return rc;
     276}
     277
     278
     279/*****************************************************************************
     280 * Name      : LONG SHRegDeleteUSValueA
     281 * Purpose   :
     282 * Parameters:
     283 * Variables :
     284 * Result    :
     285 * Remark    :
     286 * Status    : STUB UNTESTED
     287 *
     288 * Author    : Patrick Haller [2001-08-30]
     289 *****************************************************************************/
     290
     291ODINFUNCTION3(LONG,    SHRegDeleteUSValueA,
     292              HUSKEY,  hUSKey,
     293              LPSTR,   lpValue,
     294              DWORD,   dwFlags)
     295{
     296  dprintf(("not implemented\n"));
     297 
     298  LONG rc = RegDeleteValueA(hUSKey,
     299                            lpValue);
     300  return rc;
     301}
     302
     303
     304/*****************************************************************************
     305 * Name      : LONG SHRegDeleteUSValueW
     306 * Purpose   :
     307 * Parameters:
     308 * Variables :
     309 * Result    :
     310 * Remark    :
     311 * Status    : STUB UNTESTED
     312 *
     313 * Author    : Patrick Haller [2001-08-30]
     314 *****************************************************************************/
     315
     316ODINFUNCTION3(LONG,    SHRegDeleteUSValueW,
    214317              HKEY,    hKey,
    215               DWORD,   arg2,
    216               DWORD,   arg3,
    217               DWORD,   arg4,
    218               DWORD,   arg5,
    219               DWORD,   arg6)
    220 {
    221   LONG rc;
    222 
    223 #if 0
    224   rc = SHRegCreateUSKeyA(hKey,
    225                          3,
    226                          0,
    227                          &hKey);
    228   if (rc == ERROR_SUCCESS)
    229   {
    230     rc = SHRegWriteUSValueA(hKey,
    231                             arg2,
    232                             arg3,
    233                             arg4,
    234                             arg5,
    235                             arg6);
    236     SHRegCloseUSKey(hKey);
    237   }
    238 #endif
    239 
     318              LPWSTR,  lpValue,
     319              DWORD,   dwFlags)
     320{
     321  dprintf(("not implemented\n"));
     322 
     323  LONG rc = RegDeleteValueW(hKey,
     324                            lpValue);
    240325  return rc;
    241326}
    242327
    243328
    244 
    245 
    246 /*****************************************************************************
    247  * Name      : DWORD SHRegSetUSValueW
    248  * Purpose   :
    249  * Parameters:
    250  * Variables :
    251  * Result    :
    252  * Remark    : SHLWAPI.SHRegSetUSValueW SHLWAPI.616
    253  * Status    : STUB UNTESTED
    254  *
    255  * Author    : Patrick Haller [Wed, 1999/12/29 23:02]
    256  *****************************************************************************/
    257 
    258 ODINFUNCTION6(LONG,    SHRegSetUSValueW,
     329/*****************************************************************************
     330 * Name      : LONG SHDeleteOrphanKeyA
     331 * Purpose   :
     332 * Parameters:
     333 * Variables :
     334 * Result    :
     335 * Remark    :
     336 * Status    : STUB UNTESTED
     337 *
     338 * Author    : Patrick Haller [2001-08-30]
     339 *****************************************************************************/
     340
     341ODINFUNCTION2(LONG,    SHDeleteOrphanKeyA,
    259342              HKEY,    hKey,
    260               DWORD,   arg2,
    261               DWORD,   arg3,
    262               DWORD,   arg4,
    263               DWORD,   arg5,
    264               DWORD,   arg6)
    265 {
    266   LONG rc;
    267 
    268 #if 0
    269   rc = SHRegCreateUSKeyW(hKey,
    270                          3,
    271                          0,
    272                          &hKey);
    273   if (rc == ERROR_SUCCESS)
    274   {
    275     rc = SHRegWriteUSValueW(hKey,
    276                             arg2,
    277                             arg3,
    278                             arg4,
    279                             arg5,
    280                             arg6);
    281     SHRegCloseUSKey(hKey);
    282   }
    283 #endif
    284 
     343              LPCSTR,  lpszSubkey)
     344{
     345  dprintf(("not implemented\n"));
     346 
     347  LONG rc = RegDeleteKeyA(hKey,
     348                          lpszSubkey);
    285349  return rc;
    286350}
    287351
    288352
     353/*****************************************************************************
     354 * Name      : LONG SHDeleteOrphanKeyW
     355 * Purpose   :
     356 * Parameters:
     357 * Variables :
     358 * Result    :
     359 * Remark    :
     360 * Status    : STUB UNTESTED
     361 *
     362 * Author    : Patrick Haller [2001-08-30]
     363 *****************************************************************************/
     364
     365ODINFUNCTION2(LONG,    SHDeleteOrphanKeyW,
     366              HKEY,    hKey,
     367              LPWSTR,  lpszSubkey)
     368{
     369  dprintf(("not implemented\n"));
     370 
     371  LONG rc = RegDeleteKeyW(hKey,
     372                          lpszSubkey);
     373  return rc;
     374}
     375
     376
     377/*****************************************************************************
     378 * Name      : LONG SHRegDeleteEmptyUSKeyA
     379 * Purpose   :
     380 * Parameters:
     381 * Variables :
     382 * Result    :
     383 * Remark    :
     384 * Status    : STUB UNTESTED
     385 *
     386 * Author    : Patrick Haller [2001-08-30]
     387 *****************************************************************************/
     388
     389ODINFUNCTION3(LONG,    SHRegDeleteEmptyUSKeyA,
     390              HUSKEY,  hUSKey,
     391              LPSTR,   lpszSubkey,
     392              DWORD,   dwFlags)
     393{
     394  dprintf(("not yet implemented"));
     395  return 0;
     396}
     397
     398
     399/*****************************************************************************
     400 * Name      : LONG SHRegDeleteEmptyUSKeyW
     401 * Purpose   :
     402 * Parameters:
     403 * Variables :
     404 * Result    :
     405 * Remark    :
     406 * Status    : STUB UNTESTED
     407 *
     408 * Author    : Patrick Haller [2001-08-30]
     409 *****************************************************************************/
     410
     411ODINFUNCTION3(LONG,    SHRegDeleteEmptyUSKeyW,
     412              HUSKEY,  hUSKey,
     413              LPWSTR,  lpszSubkey,
     414              DWORD,   dwFlags)
     415{
     416  dprintf(("not yet implemented"));
     417  return 0;
     418}
     419
     420
     421/*****************************************************************************
     422 * Name      : LONG SHRegDeleteUSKeyA
     423 * Purpose   :
     424 * Parameters:
     425 * Variables :
     426 * Result    :
     427 * Remark    :
     428 * Status    : STUB UNTESTED
     429 *
     430 * Author    : Patrick Haller [2001-08-30]
     431 *****************************************************************************/
     432
     433ODINFUNCTION3(LONG,    SHRegDeleteUSKeyA,
     434              HUSKEY,  hUSKey,
     435              LPSTR,   lpszSubkey,
     436              DWORD,   dwFlags)
     437{
     438  dprintf(("not yet implemented"));
     439  return 0;
     440}
     441
     442
     443/*****************************************************************************
     444 * Name      : LONG SHRegDeleteUSKeyW
     445 * Purpose   :
     446 * Parameters:
     447 * Variables :
     448 * Result    :
     449 * Remark    :
     450 * Status    : STUB UNTESTED
     451 *
     452 * Author    : Patrick Haller [2001-08-30]
     453 *****************************************************************************/
     454
     455ODINFUNCTION3(LONG,    SHRegDeleteUSKeyW,
     456              HUSKEY,  hUSKey,
     457              LPWSTR,  lpszSubkey,
     458              DWORD,   dwFlags)
     459{
     460  dprintf(("not yet implemented"));
     461  return 0;
     462}
     463
     464
     465/*****************************************************************************
     466 * Name      : LONG SHRegEnumUSKeyA
     467 * Purpose   :
     468 * Parameters:
     469 * Variables :
     470 * Result    :
     471 * Remark    :
     472 * Status    : STUB UNTESTED
     473 *
     474 * Author    : Patrick Haller [2001-08-30]
     475 *****************************************************************************/
     476
     477ODINFUNCTION5(LONG,    SHRegEnumUSKeyA,
     478              HUSKEY,  hUSKey,
     479              DWORD,   dwIndex,
     480              LPSTR,   lpszKeyName,
     481              LPDWORD, lpdwKeyNameSize,
     482              SHREGENUM_FLAGS, dwFlags)
     483{
     484  dprintf(("not yet implemented"));
     485  return 0;
     486}
     487
     488
     489/*****************************************************************************
     490 * Name      : LONG SHRegEnumUSKeyW
     491 * Purpose   :
     492 * Parameters:
     493 * Variables :
     494 * Result    :
     495 * Remark    :
     496 * Status    : STUB UNTESTED
     497 *
     498 * Author    : Patrick Haller [2001-08-30]
     499 *****************************************************************************/
     500
     501ODINFUNCTION5(LONG,    SHRegEnumUSKeyW,
     502              HUSKEY,  hUSKey,
     503              DWORD,   dwIndex,
     504              LPWSTR,  lpszKeyName,
     505              LPDWORD, lpdwKeyNameSize,
     506              SHREGENUM_FLAGS, dwFlags)
     507{
     508  dprintf(("not yet implemented"));
     509  return 0;
     510}
     511
     512
     513/*****************************************************************************
     514 * Name      : LONG SHRegEnumUSValueA
     515 * Purpose   :
     516 * Parameters:
     517 * Variables :
     518 * Result    :
     519 * Remark    :
     520 * Status    : STUB UNTESTED
     521 *
     522 * Author    : Patrick Haller [2001-08-30]
     523 *****************************************************************************/
     524
     525ODINFUNCTION8(LONG,    SHRegEnumUSValueA,
     526              HUSKEY,  hUSKey,
     527              DWORD,   dwIndex,
     528              LPSTR,   lpszValueName,
     529              LPDWORD, lpdwValueNameSize,
     530              LPDWORD, lpdwValueType,
     531              LPVOID,  lpValue,
     532              LPDWORD, lpdwValueSize,
     533              SHREGENUM_FLAGS, dwFlags)
     534{
     535  dprintf(("not yet implemented"));
     536  return 0;
     537}
     538
     539
     540/*****************************************************************************
     541 * Name      : LONG SHRegEnumUSValueW
     542 * Purpose   :
     543 * Parameters:
     544 * Variables :
     545 * Result    :
     546 * Remark    :
     547 * Status    : STUB UNTESTED
     548 *
     549 * Author    : Patrick Haller [2001-08-30]
     550 *****************************************************************************/
     551
     552ODINFUNCTION8(LONG,    SHRegEnumUSValueW,
     553              HUSKEY,  hUSKey,
     554              DWORD,   dwIndex,
     555              LPWSTR,  lpszValueName,
     556              LPDWORD, lpdwValueNameSize,
     557              LPDWORD, lpdwValueType,
     558              LPVOID,  lpValue,
     559              LPDWORD, lpdwValueSize,
     560              SHREGENUM_FLAGS, dwFlags)
     561{
     562  dprintf(("not yet implemented"));
     563  return 0;
     564}
     565
     566
     567/*****************************************************************************
     568 * Name      : LONG SHRegQueryInfoUSKeyA
     569 * Purpose   :
     570 * Parameters:
     571 * Variables :
     572 * Result    :
     573 * Remark    :
     574 * Status    : STUB UNTESTED
     575 *
     576 * Author    : Patrick Haller [2001-08-30]
     577 *****************************************************************************/
     578
     579ODINFUNCTION5(LONG,    SHRegQueryInfoUSKeyA,
     580              LPDWORD,  lpdwSubKeyNum,
     581              LPDWORD,  lpdwMaxSubKeyNameSize,
     582              LPDWORD,  lpdwValueNum,
     583              LPDWORD,  lpdwMaxValueNameSize,
     584              SHREGENUM_FLAGS, dwFlags)
     585{
     586  dprintf(("not yet implemented"));
     587  return 0;
     588}
     589
     590
     591/*****************************************************************************
     592 * Name      : LONG SHRegQueryInfoUSKeyW
     593 * Purpose   :
     594 * Parameters:
     595 * Variables :
     596 * Result    :
     597 * Remark    :
     598 * Status    : STUB UNTESTED
     599 *
     600 * Author    : Patrick Haller [2001-08-30]
     601 *****************************************************************************/
     602
     603ODINFUNCTION5(LONG,    SHRegQueryInfoUSKeyW,
     604              LPDWORD,  lpdwSubKeyNum,
     605              LPDWORD,  lpdwMaxSubKeyNameSize,
     606              LPDWORD,  lpdwValueNum,
     607              LPDWORD,  lpdwMaxValueNameSize,
     608              SHREGENUM_FLAGS, dwFlags)
     609{
     610  dprintf(("not yet implemented"));
     611  return 0;
     612}
     613
     614
     615/*****************************************************************************
     616 * Name      : LONG SHRegWriteUSValueA
     617 * Purpose   :
     618 * Parameters:
     619 * Variables :
     620 * Result    :
     621 * Remark    :
     622 * Status    : STUB UNTESTED
     623 *
     624 * Author    : Patrick Haller [2001-08-30]
     625 *****************************************************************************/
     626
     627ODINFUNCTION6(LONG,     SHRegWriteUSValueA,
     628              HUSKEY,   hUSKey,
     629              LPCSTR,   lpszValueName,
     630              DWORD,    dwValueType,
     631              LPVOID,   lpValue,
     632              DWORD,    dwValueSize,
     633              DWORD,    dwFlags)
     634{
     635  dprintf(("not yet implemented"));
     636  return 0;
     637}
     638
     639
     640/*****************************************************************************
     641 * Name      : LONG SHRegWriteUSValueW
     642 * Purpose   :
     643 * Parameters:
     644 * Variables :
     645 * Result    :
     646 * Remark    :
     647 * Status    : STUB UNTESTED
     648 *
     649 * Author    : Patrick Haller [2001-08-30]
     650 *****************************************************************************/
     651
     652ODINFUNCTION6(LONG,     SHRegWriteUSValueW,
     653              HUSKEY,   hUSKey,
     654              LPCWSTR,  lpszValueName,
     655              DWORD,    dwValueType,
     656              LPVOID,   lpValue,
     657              DWORD,    dwValueSize,
     658              DWORD,    dwFlags)
     659{
     660  dprintf(("not yet implemented"));
     661  return 0;
     662}

  • trunk/src/shlwapi/shlstub.cpp

    r3562 r6608  
    1 /* $Id: shlstub.cpp,v 1.1 2000-05-19 12:10:04 sandervl Exp $ */
     1/* $Id: shlstub.cpp,v 1.2 2001-08-30 19:19:58 phaller Exp $ */
    22
    33/*
    … …  
    3939
    4040
     41/*****************************************************************************
     42 * Name      : StrFromTimeIntervalA
     43 * Purpose   :
     44 * Parameters:
     45 * Variables :
     46 * Result    :
     47 * Remark    :
     48 * Status    : UNTESTED
     49 *
     50 * Author    :
     51 *****************************************************************************/
     52
     53ODINFUNCTION2(LPSTR,    StrFromTimeIntervalA,
     54              LPVOID, lp1,
     55              LPVOID, lp2)
     56{
     57  dprintf(("not yet implemented"));
     58 
     59  return NULL;
     60}
     61
     62
     63/*****************************************************************************
     64 * Name      : StrFromTimeIntervalW
     65 * Purpose   :
     66 * Parameters:
     67 * Variables :
     68 * Result    :
     69 * Remark    :
     70 * Status    : UNTESTED
     71 *
     72 * Author    :
     73 *****************************************************************************/
     74
     75ODINFUNCTION2(LPWSTR,    StrFromTimeIntervalW,
     76              LPVOID, lp1,
     77              LPVOID, lp2)
     78{
     79  dprintf(("not yet implemented"));
     80 
     81  return NULL;
     82}

  • trunk/src/shlwapi/shlwapi.def

    r5753 r6608  
    1 ; $Id: shlwapi.def,v 1.24 2001-05-19 13:17:33 sandervl Exp $
     1; $Id: shlwapi.def,v 1.25 2001-08-30 19:19:58 phaller Exp $
    22
    33; updated export ordinals to NT4 SP6 version of SHLWAPI.DLL
    … …  
    167167                             _SHLWAPI_156@8                       @156 NONAME
    168168                             _SHLWAPI_158@8                       @158 NONAME
    169                              _CompareStringW@24                   @159 NONAME
     169; @@@PH dupe                 _CompareStringW@24                   @159 NONAME
    170170                             _SHLWAPI_160@8                       @160 NONAME
    171171                             _SHLWAPI_162@8                       @162 NONAME
    … …  
    202202
    203203                             _DrawTextExW@24                      @301 NONAME
    204                              _GetMenuItemInfoW@16                 @302 NONAME ; FIXME CreateFontW
     204; @@@PH dupe                 _GetMenuItemInfoW@16                 @302 NONAME ; FIXME CreateFontW
    205205                             _InsertMenuItemW@16                  @303 NONAME
    206206                             _CreateMetaFileW@4                   @304 NONAME
    … …  
    409409  ; SHCreateStreamWrapper  = _SHCreateStreamWrapper@?             @565
    410410
    411   ; SHDeleteEmptyKeyA      = _SHDeleteEmptyKeyA@?                 @567
    412   ; SHDeleteEmptyKeyW      = _SHDeleteEmptyKeyW@?                 @568
     411    SHDeleteEmptyKeyA      = _SHDeleteEmptyKeyA@8                 @567
     412    SHDeleteEmptyKeyW      = _SHDeleteEmptyKeyW@8                 @568
    413413    SHDeleteKeyA           = _SHDeleteKeyA@8                      @569
    414414    SHDeleteKeyW           = _SHDeleteKeyW@8                      @570
    415   ; SHDeleteOrphanKeyA     = _SHDeleteOrphanKeyA@?                @571
    416   ; SHDeleteOrphanKeyW     = _SHDeleteOrphanKeyW@?                @572
     415    SHDeleteOrphanKeyA     = _SHDeleteOrphanKeyA@8                @571
     416    SHDeleteOrphanKeyW     = _SHDeleteOrphanKeyW@8                @572
    417417    SHDeleteValueA         = _SHDeleteValueA@12                   @573
    418418    SHDeleteValueW         = _SHDeleteValueW@12                   @574
    … …  
    435435    SHQueryValueExA        = _SHQueryValueExA@24                  @591
    436436    SHQueryValueExW        = _SHQueryValueExW@24                  @592
    437   ; SHRegCloseUSKey        = _SHRegCloseUSKey@?                   @593
     437    SHRegCloseUSKey        = _SHRegCloseUSKey@4                   @593
    438438    SHRegCreateUSKeyA      = _SHRegCreateUSKeyA@20                @594
    439439    SHRegCreateUSKeyW      = _SHRegCreateUSKeyW@20                @595
    440   ; SHRegDeleteEmptyUSKeyA = _SHRegDeleteEmptyUSKeyA@?            @596
    441   ; SHRegDeleteEmptyUSKeyW = _SHRegDeleteEmptyUSKeyW@?            @597
    442   ; SHRegDeleteUSKeyA      = _SHRegDeleteUSKeyA@?                 @598
    443   ; SHRegDeleteUSKeyW      = _SHRegDeleteUSKeyW@?                 @599
     440    SHRegDeleteEmptyUSKeyA = _SHRegDeleteEmptyUSKeyA@12           @596
     441    SHRegDeleteEmptyUSKeyW = _SHRegDeleteEmptyUSKeyW@12           @597
     442    SHRegDeleteUSKeyA      = _SHRegDeleteUSKeyA@12                @598
     443    SHRegDeleteUSKeyW      = _SHRegDeleteUSKeyW@12                @599
    444444  ; SHRegDuplicateHKey     = _SHRegDuplicateHKey@?                @600
    445   ; SHRegEnumUSKeyA        = _SHRegEnumUSKeyA@?                   @601
    446   ; SHRegEnumUSKeyW        = _SHRegEnumUSKeyW@?                   @602
    447   ; SHRegEnumUSValueA      = _SHRegEnumUSValueA@?                 @603
    448   ; SHRegEnumUSValueA      = _SHRegEnumUSValueW@?                 @604
     445    SHRegEnumUSKeyA        = _SHRegEnumUSKeyA@20                  @601
     446    SHRegEnumUSKeyW        = _SHRegEnumUSKeyW@20                  @602
     447    SHRegEnumUSValueA      = _SHRegEnumUSValueA@32                @603
     448    SHRegEnumUSValueW      = _SHRegEnumUSValueW@32                @604
    449449    SHRegGetBoolUSValueA   = _SHRegGetBoolUSValueA@16             @605
    450450    SHRegGetBoolUSValueW   = _SHRegGetBoolUSValueW@16             @606
    … …  
    459459    SHRegSetUSValueA       = _SHRegSetUSValueA@24                 @615
    460460    SHRegSetUSValueW       = _SHRegSetUSValueW@24                 @616
    461 ;   SHRegWriteUSValueA     = _SHRegWriteUSValueA@?                @617
    462 ;   SHRegWriteUSValueW     = _SHRegWriteUSValueW@?                @618
     461    SHRegWriteUSValueA     = _SHRegWriteUSValueA@24               @617
     462    SHRegWriteUSValueW     = _SHRegWriteUSValueW@24               @618
    463463;   SHSetSetThreadRef      = _SHSetThreadRef@?                    @619
    464464    SHSetValueA            = _SHSetValueA@24                      @620
    … …  
    495495;   StrFormatKBSizeA       = _StrFormatKBSizeA@16                 @649
    496496;   StrFormatKBSizeW       = _StrFormatKBSizeW@16                 @650
    497   ; StrFromTimeIntervalA   = _StrFromTimeIntervalA@?              @651
    498   ; StrFromTimeIntervalW   = _StrFromTimeIntervalW@?              @652
     497    StrFromTimeIntervalA   = _StrFromTimeIntervalA@8              @651
     498    StrFromTimeIntervalW   = _StrFromTimeIntervalW@8              @652
    499499  ; IntlStrEqWorkerA       = _StrIsIntlEqualA@16                  @653
    500500  ; StrIsIntlEqualW        = _StrIsIntlEqualW@?                   @654
    501501    StrNCatA               = _StrNCatA@12                         @655
    502502    StrNCatW               = _StrNCatW@12                         @656
    503   ; StrPBrkA               = _StrPBrkA@?                          @657
    504   ; StrPBrkW               = _StrPBrkW@?                          @658
     503    StrPBrkA               = _StrPBrkA@8                          @657
     504    StrPBrkW               = _StrPBrkW@8                          @658
    505505    StrRChrA               = _StrRChrA@12                         @659
    506506  ; StrRChrIA              = _StrRChrIA@12                        @660
    507507  ; StrRChrIW              = _StrRChrIW@12                        @661
    508508    StrRChrW               = _StrRChrW@12                         @662
    509   ; StrRStrIA              = _StrRStrIA@?                         @663
    510   ; StrRStrIW              = _StrRStrIW@?                         @664
     509    StrRStrIA              = _StrRStrIA@8                         @663
     510    StrRStrIW              = _StrRStrIW@8                         @664
    511511    StrRetToBufA           = _StrRetToBufA@16                     @665
    512512    StrRetToBufW           = _StrRetToBufW@16                     @666
    513513;   StrRetToStrA           = _StrRetToStrA@12                     @667
    514514;   StrRetToStrW           = _StrRetToStrW@12                     @668
    515   ; StrSpnA                = _StrSpnA@?                           @669
    516   ; StrSpnW                = _StrSpnW@?                           @670
     515    StrSpnA                = _StrSpnA@8                           @669
     516    StrSpnW                = _StrSpnW@8                           @670
    517517    StrStrA                = _StrStrA@8                           @671
    518518    StrStrIA               = _StrStrIA@8                          @672
    … …  
    523523    StrToIntExW            = _StrToIntExW@12                      @677
    524524    StrToIntW              = _StrToIntW@4                         @678
    525   ; StrTrimA               = _StrTrimA@?                          @679
     525    StrTrimA               = _StrTrimA@8                          @679
    526526  ; StrTrimW               = _StrTrimW@?                          @680
    527527    UrlApplySchemeA        = _UrlApplySchemeA@16                  @681
    … …  
    558558    SHRegGetPathA          = _SHRegGetPathA@20                    @802
    559559    SHRegGetPathW          = _SHRegGetPathW@20                    @803
     560    SHRegDeleteUSValueA    = _SHRegDeleteUSValueA@12
     561    SHRegDeleteUSValueW    = _SHRegDeleteUSValueW@12

  • trunk/src/shlwapi/shlwapi_odin.h

    r4081 r6608  
    1 /* $Id: shlwapi_odin.h,v 1.1 2000-08-24 09:32:44 sandervl Exp $ */
     1/* $Id: shlwapi_odin.h,v 1.2 2001-08-30 19:19:58 phaller Exp $ */
    22
    33/*
    … …  
    2525  extern "C" {
    2626#endif /* defined(__cplusplus) */
     27   
     28   
    2729
     30typedef HKEY HUSKEY;
     31typedef HUSKEY *PHUSKEY;
     32
     33typedef DWORD SHREGDEL_FLAGS;
     34#define SHREGDEL_BOTH
     35
     36typedef DWORD SHREGENUM_FLAGS;
     37#define SHREGENUM_HKCU   
     38#define SHREGENUM_DEFAULT
     39#define SHREGENUM_HKLM
     40
     41typedef DWORD SHREGSET_FLAGS;
     42#define SHREGSET_HKLM
     43#define SHREGSET_DEFAULT
     44   
     45   
    2846   
    2947/*****************************************************************************

  • trunk/src/shlwapi/string.c

    r5753 r6608  
    530530
    531531/*************************************************************************
     532 *      StrTrimA        [SHLWAPI.@]
     533 */
     534BOOL WINAPI StrTrimA(LPSTR pszSource, LPCSTR pszTrimChars)
     535{
     536    BOOL trimmed = FALSE;
     537    LPSTR pSrc;
     538    LPCSTR pTrim;
     539
     540    TRACE("('%s', '%s');\n", pszSource, pszTrimChars);
     541    for (pTrim = pszTrimChars; *pTrim; pTrim++)
     542    {
     543         for (pSrc = pszSource; *pSrc; pSrc++)
     544             if (*pSrc == *pTrim)
     545             {
     546                 /* match -> remove this char.
     547                  * strlen(pSrc) equiv. to the correct strlen(pSrc+1)+1 */
     548                 memmove(pSrc, pSrc+1, strlen(pSrc));
     549                 trimmed = TRUE;
     550             }
     551    }
     552    TRACE("<- '%s'\n", pszSource);
     553    return trimmed;
     554}
     555
     556/*************************************************************************
    532557 *      wnsprintfA      [SHLWAPI]
    533558 */

  • trunk/src/shlwapi/string_odin.cpp

    r6375 r6608  
    1  /* $Id: string_odin.cpp,v 1.3 2001-07-20 15:37:53 sandervl Exp $ */
     1 /* $Id: string_odin.cpp,v 1.4 2001-08-30 19:19:59 phaller Exp $ */
    22
    33/*
    … …  
    271271
    272272
    273 
    274 
     273/*****************************************************************************
     274 * Name      : StrSpnA
     275 * Purpose   : find the first occurence of a character in string1
     276 *             that is not contained in the set of characters specified by
     277 *             string2.
     278 * Parameters:
     279 * Variables :
     280 * Result    :
     281 * Remark    : COMCTL32undoc.StrSpnW, CRTDLL.strspn
     282 * Status    : UNTESTED
     283 *
     284 * Author    :
     285 *****************************************************************************/
     286
     287ODINFUNCTION2(INT,    StrSpnA,
     288              LPCSTR, lpString1,
     289              LPCSTR, lpString2)
     290{
     291  // 2001-08-30 PH
     292  // copied from implementation in COMCTL32
     293  if ( (lpString1 == NULL) ||
     294       (lpString2 == NULL) )
     295    return 0;
     296 
     297  LPSTR lpLoop = (LPSTR)lpString1;
     298 
     299  for (; (*lpLoop != 0); lpLoop++ )
     300    if ( StrChrA( lpString2, *lpLoop ) )
     301      return (INT) (lpLoop - lpString1);
     302 
     303  return (INT) (lpLoop - lpString1);
     304}
     305
     306
     307/*****************************************************************************
     308 * Name      : StrSpnW
     309 * Purpose   : find the first occurence of a character in string1
     310 *             that is not contained in the set of characters specified by
     311 *             string2.
     312 * Parameters:
     313 * Variables :
     314 * Result    :
     315 * Remark    : COMCTL32undoc.StrSpnW, CRTDLL.strspn
     316 * Status    : UNTESTED
     317 *
     318 * Author    :
     319 *****************************************************************************/
     320
     321ODINFUNCTION2(INT,     StrSpnW,
     322              LPCWSTR, lpString1,
     323              LPCWSTR, lpString2)
     324{
     325  // 2001-08-30 PH
     326  // copied from implementation in COMCTL32
     327  if ( (lpString1 == NULL) ||
     328       (lpString2 == NULL) )
     329    return 0;
     330 
     331  LPWSTR lpLoop = (LPWSTR)lpString1;
     332 
     333  for (; (*lpLoop != 0); lpLoop++ )
     334    if ( StrChrW( lpString2, *lpLoop ) )
     335      return (INT) (lpLoop - lpString1);
     336 
     337  return (INT) (lpLoop - lpString1);
     338}
     339
     340
     341/*****************************************************************************
     342 * Name      : StrPBrkA
     343 * Purpose   : find the first occurence in string1 of any character from string2
     344 * Parameters:
     345 * Variables :
     346 * Result    :
     347 * Remark    :
     348 * Status    : UNTESTED
     349 *
     350 * Author    :
     351 *****************************************************************************/
     352
     353ODINFUNCTION2(LPSTR,   StrPBrkA,
     354              LPCSTR,  lpString1,
     355              LPCSTR,  lpString2)
     356{
     357  register LPSTR s1;
     358 
     359  while (*lpString1)
     360  {
     361    for (s1 = (LPSTR)lpString2;
     362         *s1 && *s1 != *lpString1;
     363         s1++)
     364         /* empty */
     365      ;
     366
     367    if (*s1)
     368      return (LPSTR)lpString1;
     369
     370    lpString1++;
     371  }
     372 
     373  return (LPSTR)NULL;
     374}
     375
     376
     377/*****************************************************************************
     378 * Name      : StrPBrkW
     379 * Purpose   : find the first occurence in string1 of any character from string2
     380 * Parameters:
     381 * Variables :
     382 * Result    :
     383 * Remark    :
     384 * Status    : UNTESTED
     385 *
     386 * Author    :
     387 *****************************************************************************/
     388
     389ODINFUNCTION2(LPWSTR,   StrPBrkW,
     390              LPCWSTR,  lpString1,
     391              LPCWSTR,  lpString2)
     392{
     393  register LPWSTR s1;
     394 
     395  while (*lpString1)
     396  {
     397    for (s1 = (LPWSTR)lpString2;
     398         *s1 && *s1 != *lpString1;
     399         s1++)
     400         /* empty */
     401      ;
     402
     403    if (*s1)
     404      return (LPWSTR)lpString1;
     405
     406    lpString1++;
     407  }
     408 
     409  return (LPWSTR)NULL;
     410}
     411
     412
     413/*************************************************************************
     414 * StrRStrIA                                    [SHLWAPI]
     415 */
     416LPSTR WINAPI StrRStrIA(LPCSTR lpFirst, LPCSTR lpSrch)
     417{
     418  INT   iLen = lstrlenA(lpFirst) - lstrlenA(lpSrch);
     419 
     420  // lpSrch cannot fit into lpFirst
     421  if (iLen < 0)
     422    return (LPSTR)NULL;
     423 
     424  LPSTR lpThis = (LPSTR)lpFirst + iLen;
     425 
     426  while (lpThis >= lpFirst)
     427  {
     428    LPCSTR p1 = lpThis, p2 = lpSrch;
     429    while (*p1 && *p2 && toupper(*p1) == toupper(*p2)) { p1++; p2++; }
     430    if (!*p2) return (LPSTR)lpThis;
     431    lpThis--;
     432  }
     433 
     434  return NULL;
     435}
     436
     437
     438/*************************************************************************
     439 * StrRStrIW                                    [SHLWAPI]
     440 */
     441LPWSTR WINAPI StrRStrIW(LPCWSTR lpFirst, LPCWSTR lpSrch)
     442{
     443  INT   iLen = lstrlenW(lpFirst) - lstrlenW(lpSrch);
     444 
     445  // lpSrch cannot fit into lpFirst
     446  if (iLen < 0)
     447    return (LPWSTR)NULL;
     448 
     449  LPWSTR lpThis = (LPWSTR)lpFirst + iLen;
     450 
     451  while (lpThis >= lpFirst)
     452  {
     453    LPCWSTR p1 = lpThis, p2 = lpSrch;
     454    while (*p1 && *p2 && toupperW(*p1) == toupperW(*p2)) { p1++; p2++; }
     455    if (!*p2) return (LPWSTR)lpThis;
     456    lpThis--;
     457  }
     458 
     459  return NULL;
     460}

  • trunk/src/shlwapi/url.c

    r5753 r6608  
    370370}
    371371
     372/*************************************************************************
     373 *      UrlApplySchemeW [SHLWAPI.@]
     374 */
     375HRESULT WINAPI UrlApplySchemeW(LPCWSTR pszIn, LPWSTR pszOut, LPDWORD pcchOut, DWORD dwFlags)
     376{
     377    HRESULT err = NOERROR;
     378    FIXME("(%s %p %p %08lx): stub !\n", debugstr_w(pszIn), pszOut, pcchOut, dwFlags);
     379    lstrcpyW(pszOut, pszIn);
     380    *pcchOut = (err != E_POINTER) ? lstrlenW(pszOut) : 0;
     381    return err;
     382}

  • trunk/src/shlwapi/url_odin.cpp

    r5618 r6608  
    1 /* $Id: url_odin.cpp,v 1.1 2001-04-28 13:32:38 sandervl Exp $ */
     1/* $Id: url_odin.cpp,v 1.2 2001-08-30 19:19:59 phaller Exp $ */
    22
    33/*
    … …  
    159159  return S_OK;
    160160}
    161 
    162 
    163 /**
    164  * @status      partially
    165  */
    166 ODINFUNCTION4(HRESULT, UrlApplySchemeW,
    167               LPCWSTR, pszIn,
    168               LPWSTR,  pszOut,
    169               LPDWORD, pcchOut,
    170               DWORD,   dwFlags)
    171 {
    172   dprintf(("not implemented."));
    173 
    174   wcsncpy((wchar_t*)pszOut,
    175           (wchar_t*)pszIn,
    176           *pcchOut);
    177   *pcchOut = 0;
    178 
    179   return S_OK;
    180 }
    181 
    182 
    183 
    184161
    185162
Note: See TracChangeset for help on using the changeset viewer.