Changeset 480 for trunk/src


Ignore:
Timestamp:
Aug 11, 1999, 11:20:06 PM (26 years ago)
Author:
phaller
Message:

Add: added support for ODINWRAP to Registry functions

Location:
trunk/src/advapi32
Files:
1 added
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/advapi32/ADVAPI32.CPP

    r103 r480  
    1 /* $Id: ADVAPI32.CPP,v 1.5 1999-06-11 13:19:52 phaller Exp $ */
     1/* $Id: ADVAPI32.CPP,v 1.6 1999-08-11 21:19:49 phaller Exp $ */
    22
    33/*
    … …  
    2525#include <stdarg.h>
    2626#include <string.h>
     27#include <odinwrap.h>
    2728#include "misc.h"
    2829#include "advapi32.h"
    2930#include "unicode.h"
    30 #include <winreg.h>
     31#include "winreg.h"
     32
     33ODINDEBUGCHANNEL(ADVAPI32-ADVAPI32)
     34
    3135
    3236/*****************************************************************************
    … …  
    3741//#define DEBUG_LOCAL 1
    3842
    39 //******************************************************************************
    40 //******************************************************************************
    41 HKEY ConvertKey(HKEY winkey)
    42 {
    43   switch((int)winkey)
    44   {
    45    case HKEY_CLASSES_ROOT:   return HKEY_CLASSES_ROOT_O32;
    46    case HKEY_CURRENT_USER:   return HKEY_CURRENT_USER_O32;
    47    case HKEY_LOCAL_MACHINE:  return HKEY_LOCAL_MACHINE_O32;
    48    case HKEY_USERS:          return HKEY_USERS_O32;
    49   }
    50   return(winkey);
    51 }
    52 
    53 //******************************************************************************
    54 //******************************************************************************
    55 DWORD WIN32API RegCloseKey( HKEY arg1)
    56 {
    57     dprintf(("ADVAPI32: RegCloseKey %X\n", arg1));
    58     return O32_RegCloseKey(ConvertKey(arg1));
    59 }
    60 //******************************************************************************
    61 //******************************************************************************
    62 DWORD WIN32API RegCreateKeyA( HKEY arg1, LPCSTR arg2, PHKEY  arg3)
    63 {
    64   dprintf(("ADVAPI32: RegCreateKey(%08xh,%s,%08xh)\n",
    65            arg1,
    66            arg2,
    67            arg3));
    68 
    69   return O32_RegCreateKey(ConvertKey(arg1),
    70                           arg2,
    71                           arg3);
    72 }
    73 //******************************************************************************
    74 //******************************************************************************
    75 DWORD WIN32API RegCreateKeyW(HKEY arg1, LPCWSTR arg2, PHKEY  arg3)
    76 {
    77   char *astring = UnicodeToAsciiString((LPWSTR)arg2);
    78   LONG  rc;
    79 
    80   dprintf(("ADVAPI32: RegCreateKeyW(%08xh,%s,%08xh)\n",
    81            arg1,
    82            astring,
    83            arg3));
    84 
    85   rc = O32_RegCreateKey(ConvertKey(arg1),
    86                         astring,
    87                         arg3);
    88   FreeAsciiString(astring);
    89   return(rc);
    90 }
    91 //******************************************************************************
    92 //******************************************************************************
    93 DWORD WIN32API RegCreateKeyExA(HKEY   arg1,
    94                                LPCSTR arg2,
    95                                DWORD  arg3,
    96                                LPSTR  arg4,
    97                                DWORD  arg5,
    98                                REGSAM arg6,
    99                                LPSECURITY_ATTRIBUTES arg7,
    100                                PHKEY   arg8,
    101                                LPDWORD arg9)
    102 {
    103   dprintf(("ADVAPI32: RegCreateKeyExA(%08xh,%s,%08xh,%s,%08xh,%08xh,%08xh,%08xh,%08xh)\n",
    104            arg1,
    105            arg2,
    106            arg3,
    107            arg4,
    108            arg5,
    109            arg6,
    110            arg7,
    111            arg8,
    112            arg9));
    113 
    114     return O32_RegCreateKeyEx(ConvertKey(arg1),
    115                               arg2,
    116                               arg3,
    117                               arg4,
    118                               arg5,
    119                               arg6 | KEY_READ,
    120                               arg7,
    121                               arg8,
    122                               arg9);
    123 }
    124 //******************************************************************************
    125 //******************************************************************************
    126 DWORD WIN32API RegCreateKeyExW(HKEY    arg1,
    127                                LPCWSTR arg2,
    128                                DWORD   arg3,
    129                                LPWSTR  arg4,
    130                                DWORD   arg5,
    131                                REGSAM  arg6,
    132                                LPSECURITY_ATTRIBUTES arg7,
    133                                PHKEY   arg8,
    134                                LPDWORD arg9)
    135 {
    136  char *astring1 = UnicodeToAsciiString((LPWSTR)arg2);
    137  char *astring2 = UnicodeToAsciiString(arg4);
    138  LONG  rc;
    139 
    140   dprintf(("ADVAPI32: RegCreateKeyExW(%08xh,%s,%08xh,%s,%08xh,%08xh,%08xh,%08xh,%08xh)\n",
    141            arg1,
    142            astring1,
    143            arg3,
    144            astring2,
    145            arg5,
    146            arg6,
    147            arg7,
    148            arg8,
    149            arg9));
    150 
    151   rc = O32_RegCreateKeyEx(ConvertKey(arg1),
    152                           astring1,
    153                           arg3,
    154                           astring2,
    155                           arg5,
    156                           arg6 | KEY_READ,
    157                           arg7,
    158                           arg8,
    159                           arg9);
    160 
    161   FreeAsciiString(astring1);
    162   FreeAsciiString(astring2);
    163   return(rc);
    164 }
    165 //******************************************************************************
    166 //******************************************************************************
    167 DWORD WIN32API RegDeleteKeyW(HKEY   arg1,
    168                              LPWSTR arg2)
    169 {
    170   char *astring = UnicodeToAsciiString(arg2);
    171   LONG  rc;
    172 
    173   dprintf(("ADVAPI32: RegDeleteKeyW(%08xh,%s)\n",
    174            arg1,
    175            astring));
    176 
    177   rc = O32_RegDeleteKey(ConvertKey(arg1), astring);
    178   FreeAsciiString(astring);
    179   return(rc);
    180 }
    181 //******************************************************************************
    182 //******************************************************************************
    183 DWORD WIN32API RegDeleteKeyA(HKEY   arg1,
    184                              LPCSTR arg2)
    185 {
    186   dprintf(("ADVAPI32: RegDeleteKeyA(%08xh,%s)\n",
    187            arg1,
    188            arg2));
    189 
    190   return O32_RegDeleteKey(ConvertKey(arg1), arg2);
    191 }
    192 //******************************************************************************
    193 //******************************************************************************
    194 DWORD WIN32API RegDeleteValueA(HKEY  arg1,
    195                                LPSTR arg2)
    196 {
    197   dprintf(("ADVAPI32: RegDeleteValueA(%08xh,%s)\n",
    198            arg1,
    199            arg2));
    200 
    201   return O32_RegDeleteValue(ConvertKey(arg1),
    202                             arg2);
    203 }
    204 //******************************************************************************
    205 //******************************************************************************
    206 DWORD WIN32API RegDeleteValueW(HKEY   arg1,
    207                                LPWSTR arg2)
    208 {
    209   char *astring = UnicodeToAsciiString(arg2);
    210   LONG  rc;
    211 
    212   dprintf(("ADVAPI32: RegDeleteValueW(%08xh,%s)\n",
    213            arg1,
    214            astring));
    215 
    216   rc = O32_RegDeleteValue(ConvertKey(arg1),
    217                           astring);
    218   FreeAsciiString(astring);
    219   return(rc);
    220 }
    221 //******************************************************************************
    222 //******************************************************************************
    223 DWORD WIN32API RegEnumKeyA(HKEY  arg1,
    224                            DWORD arg2,
    225                            LPSTR arg3,
    226                            DWORD arg4)
    227 {
    228   dprintf(("ADVAPI32: RegEnumKeyA(%08xh,%08xh,%08xh,%08xh)\n",
    229            arg1,
    230            arg2,
    231            arg3,
    232            arg4));
    233 
    234   return O32_RegEnumKey(ConvertKey(arg1),
    235                         arg2,
    236                         arg3,
    237                         arg4);
    238 }
    239 //******************************************************************************
    240 //******************************************************************************
    241 DWORD WIN32API RegEnumKeyW(HKEY arg1, DWORD arg2, LPWSTR arg3, DWORD  arg4)
    242 {
    243  char *astring;
    244  LONG  rc;
    245 
    246 #ifdef DEBUG
    247     WriteLog("ADVAPI32: RegEnumKeyW\n");
    248 #endif
    249     rc = O32_RegEnumKey(ConvertKey(arg1), arg2, (char *)arg3, arg4);
    250     if(rc == ERROR_SUCCESS) {
    251       astring = (char *)malloc(arg4);
    252       strcpy(astring, (char *)arg3);
    253       AsciiToUnicode(astring, arg3);
    254       free(astring);
    255     }
    256     return(rc);
    257 }
    258 //******************************************************************************
    259 //******************************************************************************
    260 DWORD WIN32API RegEnumKeyExA(HKEY arg1, DWORD arg2, LPSTR arg3, LPDWORD arg4, LPDWORD arg5, LPSTR arg6, LPDWORD arg7, LPFILETIME  arg8)
    261 {
    262 #ifdef DEBUG
    263     WriteLog("ADVAPI32: RegEnumKeyEx\n");
    264 #endif
    265     return O32_RegEnumKeyEx(ConvertKey(arg1), arg2, arg3, arg4, arg5, arg6, arg7, arg8);
    266 }
    267 //******************************************************************************
    268 //******************************************************************************
    269 DWORD WIN32API RegEnumKeyExW(HKEY arg1, DWORD arg2, LPWSTR arg3, LPDWORD arg4, LPDWORD arg5, LPWSTR arg6, LPDWORD arg7, LPFILETIME  arg8)
    270 {
    271  char *astring;
    272  LONG  rc;
    273 
    274 #ifdef DEBUG
    275     WriteLog("ADVAPI32: RegEnumKeyExW\n");
    276 #endif
    277     rc = O32_RegEnumKeyEx(ConvertKey(arg1), arg2, (char *)arg3, arg4, arg5, (char *)arg6, arg7, arg8);
    278     if(rc == ERROR_SUCCESS) {
    279       astring = (char *)malloc(max(*arg4, *arg7));   //class & keyname
    280       strcpy(astring, (char *)arg3);
    281       AsciiToUnicode(astring, arg3);
    282       if(arg6 != NULL) {
    283             strcpy(astring, (char *)arg6);
    284             AsciiToUnicode(astring, arg6);
    285       }
    286       free(astring);
    287     }
    288     return(rc);
    289 }
    290 //******************************************************************************
    291 //******************************************************************************
    292 DWORD WIN32API RegEnumValueA(HKEY arg1, DWORD arg2, LPSTR arg3, LPDWORD arg4, LPDWORD arg5, LPDWORD arg6, LPBYTE arg7, LPDWORD  arg8)
    293 {
    294 #ifdef DEBUG
    295     WriteLog("ADVAPI32: RegEnumValue\n");
    296 #endif
    297     return O32_RegEnumValue(ConvertKey(arg1), arg2, arg3, arg4, arg5, arg6, arg7, arg8);
    298 }
    299 //******************************************************************************
    300 //******************************************************************************
    301 DWORD WIN32API RegEnumValueW(HKEY arg1, DWORD arg2, LPWSTR arg3, LPDWORD arg4, LPDWORD arg5, LPDWORD arg6, LPBYTE arg7, LPDWORD  arg8)
    302 {
    303  char *astring;
    304  LONG  rc;
    305 
    306 #ifdef DEBUG
    307     WriteLog("ADVAPI32: RegEnumValueW\n");
    308 #endif
    309     rc = O32_RegEnumValue(ConvertKey(arg1), arg2, (char *)arg3, arg4, arg5, arg6, arg7, arg8);
    310     if(rc == ERROR_SUCCESS) {
    311       astring = (char *)malloc(*arg4);
    312       strcpy(astring, (char *)arg3);
    313       AsciiToUnicode(astring, arg3);
    314       free(astring);
    315     }
    316     return(rc);
    317 }
    318 //******************************************************************************
    319 //******************************************************************************
    320 DWORD WIN32API RegOpenKeyA(HKEY    arg1,
    321                            LPCSTR arg2,
    322                            PHKEY   arg3)
    323 {
    324  LONG rc;
    325 
    326     rc = O32_RegOpenKey(ConvertKey(arg1), arg2, arg3);
    327     if(rc) {
    328       *arg3 = 0;
    329     }
    330 
    331 #ifdef DEBUG
    332     WriteLog("ADVAPI32: RegOpenKey 0x%x\\%s returned %d (%d)\n", arg1, arg2, *arg3, rc);
    333 #endif
    334     return(rc);
    335 }
    336 //******************************************************************************
    337 //******************************************************************************
    338 DWORD WIN32API RegOpenKeyW(HKEY arg1, LPCWSTR arg2, PHKEY  arg3)
    339 {
    340  char *astring = UnicodeToAsciiString((LPWSTR)arg2);
    341  LONG  rc;
    342 
    343 #ifdef DEBUG
    344     WriteLog("ADVAPI32: RegOpenKeyW\n");
    345 #endif
    346     rc = O32_RegOpenKey(ConvertKey(arg1), astring, arg3);
    347     if(rc) {
    348       *arg3 = 0;
    349     }
    350 
    351     FreeAsciiString(astring);
    352     return(rc);
    353 }
    354 //******************************************************************************
    355 //******************************************************************************
    356 DWORD WIN32API RegOpenKeyExA(HKEY arg1, LPCSTR arg2, DWORD arg3, REGSAM arg4, PHKEY arg5)
    357 {
    358  LONG rc;
    359 
    360     rc = O32_RegOpenKeyEx(ConvertKey(arg1), arg2, arg3, arg4, arg5);
    361 #ifdef DEBUG
    362     WriteLog("ADVAPI32: RegOpenKeyExA %X %s returned %X (%d)\n", arg1, arg2, *arg5, rc);
    363 #endif
    364     //SvL: This fixes crashes in pmwinx.dll. (if an app doesn't check the
    365     //     return value and uses the whatever *arg5 contains)
    366     if(rc) {
    367       *arg5 = 0;
    368     }
    369     return(rc);
    370 }
    371 //******************************************************************************
    372 //******************************************************************************
    373 DWORD WIN32API RegOpenKeyExW(HKEY arg1, LPCWSTR arg2, DWORD arg3, REGSAM arg4, PHKEY arg5)
    374 {
    375  char *astring = UnicodeToAsciiString((LPWSTR)arg2);
    376  LONG  rc;
    377 
    378 #ifdef DEBUG
    379     WriteLog("ADVAPI32: RegOpenKeyExW %X %s\n", arg1, astring);
    380 #endif
    381     rc = O32_RegOpenKeyEx(ConvertKey(arg1), astring, arg3, arg4, arg5);
    382     //SvL: This fixes crashes in pmwinx.dll. (if an app doesn't check the
    383     //     return value and uses the whatever *arg5 contains)
    384     if(rc) {
    385       *arg5 = 0;
    386     }
    387     FreeAsciiString(astring);
    388     return(rc);
    389 }
    390 //******************************************************************************
    391 //******************************************************************************
    392 DWORD WIN32API RegQueryInfoKeyA(HKEY arg1, LPSTR arg2, LPDWORD arg3, LPDWORD arg4, LPDWORD arg5, LPDWORD arg6, LPDWORD arg7, LPDWORD arg8, LPDWORD arg9, LPDWORD arg10, LPDWORD arg11, LPFILETIME  arg12)
    393 {
    394 #ifdef DEBUG
    395     WriteLog("ADVAPI32: RegQueryInfoKey\n");
    396 #endif
    397     return O32_RegQueryInfoKey(ConvertKey(arg1), arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
    398 }
    399 //******************************************************************************
    400 //******************************************************************************
    401 DWORD WIN32API RegQueryInfoKeyW(HKEY arg1, LPWSTR arg2, LPDWORD arg3, LPDWORD arg4, LPDWORD arg5, LPDWORD arg6, LPDWORD arg7, LPDWORD arg8, LPDWORD arg9, LPDWORD arg10, LPDWORD arg11, LPFILETIME  arg12)
    402 {
    403  char *astring;
    404  LONG  rc;
    405 
    406 #ifdef DEBUG
    407     WriteLog("ADVAPI32: RegQueryInfoKeyW\n");
    408 #endif
    409     rc = O32_RegQueryInfoKey(ConvertKey(arg1), (char *)arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
    410     if(rc == ERROR_SUCCESS) {
    411       astring = (char *)malloc(*arg3);
    412    strcpy(astring, (char *)arg2);
    413    AsciiToUnicode(astring, arg2);
    414    free(astring);
    415     }
    416     return(rc);
    417 }
    418 //******************************************************************************
    419 //******************************************************************************
    420 DWORD WIN32API RegQueryValueA(HKEY arg1, LPCSTR arg2, LPSTR arg3, PLONG  arg4)
    421 {
    422 #ifdef DEBUG
    423     WriteLog("ADVAPI32: RegQueryValue\n");
    424 #endif
    425     return O32_RegQueryValue(ConvertKey(arg1), arg2, arg3, arg4);
    426 }
    427 //******************************************************************************
    428 //******************************************************************************
    429 DWORD WIN32API RegQueryValueW(HKEY hkey, LPCWSTR lpszSubKey, LPWSTR lpszValue, PLONG pcbValue)
    430 {
    431  char *astring1 = UnicodeToAsciiString((LPWSTR)lpszSubKey);
    432  char *astring2;
    433  LONG  rc;
    434 
    435 #ifdef DEBUG
    436     WriteLog("ADVAPI32: RegQueryValueW\n");
    437 #endif
    438     rc = O32_RegQueryValue(ConvertKey(hkey), astring1, (char *)lpszValue, pcbValue);
    439     if(rc == ERROR_SUCCESS) {
    440    astring2 = (char *)malloc(*pcbValue);
    441    strcpy(astring2, (char *)lpszValue);
    442    AsciiToUnicode(astring2, lpszValue);
    443    free(astring2);
    444     }
    445     return(rc);
    446 }
    447 //******************************************************************************
    448 //******************************************************************************
    449 DWORD WIN32API RegQueryValueExA(HKEY arg1, LPSTR arg2, LPDWORD arg3, LPDWORD arg4, LPBYTE arg5, LPDWORD  arg6)
    450 {
    451 #ifdef DEBUG
    452     WriteLog("ADVAPI32: RegQueryValueEx %s\n", arg2);
    453 #endif
    454     return O32_RegQueryValueEx(ConvertKey(arg1), arg2, arg3, arg4, arg5, arg6);
    455 }
    456 //******************************************************************************
    457 //TODO: DOESN'T WORK FOR STRING DATA!!
    458 //******************************************************************************
    459 DWORD WIN32API RegQueryValueExW(HKEY arg1, LPWSTR arg2, LPDWORD arg3, LPDWORD arg4, LPBYTE arg5, LPDWORD  arg6)
    460 {
    461  char *astring = UnicodeToAsciiString(arg2);
    462  LONG  rc;
    463 
    464 #ifdef DEBUG
    465     WriteLog("ADVAPI32: RegQueryValueExW %s\n", astring);
    466 #endif
    467     rc = O32_RegQueryValueEx(ConvertKey(arg1), astring, arg3, arg4, arg5, arg6);
    468     FreeAsciiString(astring);
    469     return(rc);
    470 }
    471 //******************************************************************************
    472 //******************************************************************************
    473 DWORD WIN32API RegSetValueA(HKEY   hkey,
    474                             LPCSTR lpSubKey,
    475                             DWORD  dwType,
    476                             LPCSTR lpData,
    477                             DWORD  cbData)
    478 {
    479   dprintf(("ADVAPI32: RegSetValueA(%08xh,%s,%08xh,%s,%08xh)\n",
    480            hkey,
    481            lpSubKey,
    482            dwType,
    483            lpData,
    484            cbData));
    485 
    486 
    487   //SvL: 8-11-'97: Bugfix: crash in pmwinx if size == 0 and string is large
    488   if(cbData == 0)
    489     cbData = strlen(lpData);
    490 
    491   return(O32_RegSetValue(ConvertKey(hkey),
    492                          lpSubKey,
    493                          dwType,
    494                          lpData,
    495                          cbData));
    496 }
    497 //******************************************************************************
    498 //******************************************************************************
    499 DWORD WIN32API RegSetValueW(HKEY    hkey,
    500                             LPCWSTR lpSubKey,
    501                             DWORD   dwType,
    502                             LPCWSTR lpData,
    503                             DWORD   cbData)
    504 {
    505   char *astring1 = UnicodeToAsciiString((LPWSTR)lpSubKey);
    506   char *astring2 = UnicodeToAsciiString((LPWSTR)lpData);
    507   LONG  rc;
    508 
    509   dprintf(("ADVAPI32: RegSetValueW(%08xh,%s,%08xh,%s,%08xh)\n",
    510            hkey,
    511            astring1,
    512            dwType,
    513            astring2,
    514            cbData));
    515 
    516   //SvL: 8-11-'97: Bugfix: crash in pmwinx if size == 0 and string is large
    517   if(cbData == 0)
    518     cbData = strlen(astring2);
    519 
    520   rc = O32_RegSetValue(ConvertKey(hkey),
    521                        astring1,
    522                        dwType,
    523                        astring2,
    524                        cbData);
    525 
    526   FreeAsciiString(astring1);
    527   FreeAsciiString(astring2);
    528   return(rc);
    529 }
    530 //******************************************************************************
    531 //TODO:Check for string length here too?
    532 //******************************************************************************
    533 DWORD WIN32API RegSetValueExA(HKEY   arg1,
    534                               LPSTR  arg2,
    535                               DWORD  arg3,
    536                               DWORD  arg4,
    537                               BYTE  *arg5,
    538                               DWORD  arg6)
    539 {
    540   dprintf(("ADVAPI32: RegSetValueExA(%08xh,%s,%08xh,%08xh,%08xh,%08xh)\n",
    541            arg1,
    542            arg2,
    543            arg3,
    544            arg4,
    545            arg5,
    546            arg6));
    547 
    548   return O32_RegSetValueEx(ConvertKey(arg1),
    549                            arg2,
    550                            arg3,
    551                            arg4,
    552                            arg5,
    553                            arg6);
    554 }
    555 //******************************************************************************
    556 //TODO:Check for string length here too?
    557 //******************************************************************************
    558 DWORD WIN32API RegSetValueExW(HKEY   arg1,
    559                               LPWSTR arg2,
    560                               DWORD  arg3,
    561                               DWORD  arg4,
    562                               BYTE   *arg5,
    563                               DWORD  arg6)
    564 {
    565   char *astring = UnicodeToAsciiString(arg2);
    566   LONG  rc;
    567 
    568   dprintf(("ADVAPI32: RegSetValueExW(%08xh,%s,%08xh,%08xh,%08xh,%08xh)\n",
    569            arg1,
    570            astring,
    571            arg3,
    572            arg4,
    573            arg5,
    574            arg6));
    575 
    576   rc = O32_RegSetValueEx(ConvertKey(arg1),
    577                          astring,
    578                          arg3,
    579                          arg4,
    580                          arg5,
    581                          arg6);
    582   FreeAsciiString(astring);
    583   return(rc);
    584 }
    585 //******************************************************************************
    586 //******************************************************************************
    587 DWORD WIN32API RegFlushKey(HKEY hkey)
    588 {
    589 #ifdef DEBUG
    590     WriteLog("OS2RegFlushKey, not implemented\n");
    591 #endif
    592     return(ERROR_SUCCESS);
    593 }
     43
    59444//******************************************************************************
    59545//******************************************************************************
    … …  
    802252
    803253
    804 //******************************************************************************
    805 /* Stubs added to get up office97 */
    806 //******************************************************************************
    807 /*KSO Thu 21.05.1998*/
    808 LONG WIN32API RegNotifyChangeKeyValue (
    809    HKEY hKey,
    810    BOOL bWatchSubtree,
    811    DWORD dwNotifyFilter,
    812    HANDLE hEvent,
    813    BOOL fAsynchronus
    814                         )
    815 {
    816    dprintf(("ADVAPI32: RegNotifyChangeKeyValue() NIY\n"));
    817    return FALSE;
    818 }
    819254//******************************************************************************
    820255//******************************************************************************
    … …  
    46124047
    46134048
    4614 
    4615 /*****************************************************************************
    4616  * Name      : O32_RegConnectRegistryA
    4617  * Purpose   : The RegConnectRegistry function establishes a connection to a
    4618  *             predefined registry handle on another computer.
    4619  * Parameters: LPTSTR lpszComputerName address of name of remote computer
    4620  *             HKEY   hKey             predefined registry handle
    4621  *             PHKEY  phkResult        address of buffer for remote registry handle
    4622  * Variables :
    4623  * Result    :
    4624  * Remark    :
    4625  * Status    : UNTESTED STUB
    4626  *
    4627  * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
    4628  *****************************************************************************/
    4629 
    4630 LONG WIN32API RegConnectRegistryA(LPCSTR lpszComputerName,
    4631                                      HKEY   hKey,
    4632                                      PHKEY  phkResult)
    4633 {
    4634   dprintf(("ADVAPI32: RegConnectRegistryA(%s,%08xh,%08xh) not implemented.\n",
    4635            lpszComputerName,
    4636            hKey,
    4637            phkResult));
    4638 
    4639   if (lpszComputerName == NULL) /* local registry ? */
    4640   {
    4641     /* @@@PH experimental !!! */
    4642     *phkResult = hKey;
    4643 
    4644     return (NO_ERROR);
    4645   }
    4646 
    4647 #if 0
    4648   return (ERROR_ACCESS_DENIED); /* signal failure */
    4649 #else
    4650   // @@@PH 1999/06/09 always fake this API
    4651   *phkResult = hKey;
    4652   return (NO_ERROR);
    4653 #endif
    4654 }
    4655 
    4656 
    4657 /*****************************************************************************
    4658  * Name      : RegConnectRegistryW
    4659  * Purpose   : The RegConnectRegistry function establishes a connection to a
    4660  *             predefined registry handle on another computer.
    4661  * Parameters: LPWSTR lpszComputerName address of name of remote computer
    4662  *             HKEY   hKey             predefined registry handle
    4663  *             PHKEY  phkResult        address of buffer for remote registry handle
    4664  * Variables :
    4665  * Result    :
    4666  * Remark    :
    4667  * Status    : UNTESTED STUB
    4668  *
    4669  * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
    4670  *****************************************************************************/
    4671 
    4672 LONG WIN32API RegConnectRegistryW(LPCWSTR lpszComputerName,
    4673                                      HKEY   hKey,
    4674                                      PHKEY  phkResult)
    4675 {
    4676                                                /* corresponding ascii string */
    4677   LPSTR pszAscii;
    4678   LONG rc;         /* returncode from call to ascii version of this function */
    4679 
    4680   if (lpszComputerName != NULL)
    4681     pszAscii = UnicodeToAsciiString((LPWSTR)lpszComputerName);
    4682   else
    4683     pszAscii = NULL;
    4684 
    4685   dprintf(("ADVAPI32: RegConnectRegistryW(%s,%08xh,%08xh) not implemented.\n",
    4686            pszAscii,
    4687            hKey,
    4688            phkResult));
    4689 
    4690   rc = RegConnectRegistryA(pszAscii,
    4691                            hKey,
    4692                            phkResult);
    4693 
    4694   if (pszAscii != NULL)
    4695     FreeAsciiString(pszAscii);
    4696 
    4697   return (rc);                                                         /* OK */
    4698 }
    4699 
    4700 
    4701 /*****************************************************************************
    4702  * Name      : RegGetKeySecurity
    4703  * Purpose   : The RegGetKeySecurity function retrieves a copy of the security
    4704  *             descriptor protecting the specified open registry key.
    4705  * Parameters: HKEY                 hKey        open handle of key to set
    4706  *             SECURITY_INFORMATION SecInf      descriptor contents
    4707  *             PSECURITY_DESCRIPTOR pSecDesc    address of descriptor for key
    4708  *             LPDWORD              lpcbSecDesc address of size of buffer and descriptor
    4709  * Variables :
    4710  * Result    :
    4711  * Remark    :
    4712  * Status    : UNTESTED STUB
    4713  *
    4714  * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
    4715  *****************************************************************************/
    4716 
    4717 LONG WIN32API RegGetKeySecurity(HKEY                 hKey,
    4718                                    SECURITY_INFORMATION SecInf,
    4719                                    PSECURITY_DESCRIPTOR pSecDesc,
    4720                                    LPDWORD              lpcbSecDesc)
    4721 {
    4722   dprintf(("ADVAPI32: RegGetKeySecurity(%08xh,%08xh,%08xh,%08xh) not implemented.\n",
    4723            hKey,
    4724            SecInf,
    4725            pSecDesc,
    4726            lpcbSecDesc));
    4727 
    4728   return (ERROR_ACCESS_DENIED); /* signal failure */
    4729 }
    4730 
    4731 
    4732 /*****************************************************************************
    4733  * Name      : RegLoadKeyA
    4734  * Purpose   : The RegLoadKey function creates a subkey under HKEY_USER or
    4735  *             HKEY_LOCAL_MACHINE and stores registration information from a
    4736  *             specified file into that subkey. This registration information
    4737  *             is in the form of a hive. A hive is a discrete body of keys,
    4738  *             subkeys, and values that is rooted at the top of the registry
    4739  *             hierarchy. A hive is backed by a single file and .LOG file.
    4740  * Parameters: HKEY    hKey       handle of open key
    4741  *             LPCSTR lpszSubKey address of name of subkey
    4742  *             LPCSTR lpszFile   address of filename for registry information
    4743  * Variables :
    4744  * Result    :
    4745  * Remark    :
    4746  * Status    : UNTESTED STUB
    4747  *
    4748  * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
    4749  *****************************************************************************/
    4750 
    4751 LONG WIN32API RegLoadKeyA(HKEY    hKey,
    4752                              LPCSTR lpszSubKey,
    4753                              LPCSTR lpszFile)
    4754 {
    4755   dprintf(("ADVAPI32: RegLoadKeyA(%08xh,%s,%s) not implemented.\n",
    4756            hKey,
    4757            lpszSubKey,
    4758            lpszFile));
    4759 
    4760   return (ERROR_ACCESS_DENIED); /* signal failure */
    4761 }
    4762 
    4763 
    4764 /*****************************************************************************
    4765  * Name      : RegLoadKeyW
    4766  * Purpose   : The RegLoadKey function creates a subkey under HKEY_USER or
    4767  *             HKEY_LOCAL_MACHINE and stores registration information from a
    4768  *             specified file into that subkey. This registration information
    4769  *             is in the form of a hive. A hive is a discrete body of keys,
    4770  *             subkeys, and values that is rooted at the top of the registry
    4771  *             hierarchy. A hive is backed by a single file and .LOG file.
    4772  * Parameters: HKEY    hKey       handle of open key
    4773  *             LPCWSTR lpszSubKey address of name of subkey
    4774  *             LPCWSTR lpszFile   address of filename for registry information
    4775  * Variables :
    4776  * Result    :
    4777  * Remark    :
    4778  * Status    : UNTESTED STUB
    4779  *
    4780  * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
    4781  *****************************************************************************/
    4782 
    4783 LONG WIN32API RegLoadKeyW(HKEY    hKey,
    4784                              LPCWSTR lpszSubKey,
    4785                              LPCWSTR lpszFile)
    4786 {
    4787   dprintf(("ADVAPI32: RegLoadKeyW(%08xh,%s,%s) not implemented.\n",
    4788            hKey,
    4789            lpszSubKey,
    4790            lpszFile));
    4791 
    4792   return (ERROR_ACCESS_DENIED); /* signal failure */
    4793 }
    4794 
    4795 
    4796 /*****************************************************************************
    4797  * Name      : RegQueryMultipleValuesA
    4798  * Purpose   : The RegQueryMultipleValues function retrieves the type and data
    4799  *             for a list of value names associated with an open registry key.
    4800  * Parameters: HKEY    hKey        handle of key to query
    4801  *             PVALENT val_list    address of array of value entry structures
    4802  *             DWORD   num_vals    size of array of value entry structures
    4803  *             LPTSTR  lpValueBuf  address of buffer for value information
    4804  *             LPDWORD ldwTotsize  address of size of value buffer
    4805  * Variables :
    4806  * Result    :
    4807  * Remark    :
    4808  * Status    : UNTESTED STUB
    4809  *
    4810  * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
    4811  *****************************************************************************/
    4812 
    4813 #define PVALENT LPVOID
    4814 LONG WIN32API RegQueryMultipleValuesA(HKEY    hKey,
    4815                                          PVALENT val_list,
    4816                                          DWORD   num_vals,
    4817                                          LPTSTR  lpValueBuf,
    4818                                          LPDWORD ldwTotsize)
    4819 {
    4820   dprintf(("ADVAPI32: RegQueryMultipleValuesA(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
    4821            hKey,
    4822            val_list,
    4823            num_vals,
    4824            lpValueBuf,
    4825            ldwTotsize));
    4826 
    4827   return (ERROR_ACCESS_DENIED); /* signal failure */
    4828 }
    4829 
    4830 
    4831 /*****************************************************************************
    4832  * Name      : RegQueryMultipleValuesW
    4833  * Purpose   : The RegQueryMultipleValues function retrieves the type and data
    4834  *             for a list of value names associated with an open registry key.
    4835  * Parameters: HKEY    hKey        handle of key to query
    4836  *             PVALENT val_list    address of array of value entry structures
    4837  *             DWORD   num_vals    size of array of value entry structures
    4838  *             LPWSTR  lpValueBuf  address of buffer for value information
    4839  *             LPDWORD ldwTotsize  address of size of value buffer
    4840  * Variables :
    4841  * Result    :
    4842  * Remark    :
    4843  * Status    : UNTESTED STUB
    4844  *
    4845  * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
    4846  *****************************************************************************/
    4847 
    4848 LONG WIN32API RegQueryMultipleValuesW(HKEY    hKey,
    4849                                          PVALENT val_list,
    4850                                          DWORD   num_vals,
    4851                                          LPWSTR  lpValueBuf,
    4852                                          LPDWORD ldwTotsize)
    4853 {
    4854   dprintf(("ADVAPI32: RegQueryMultipleValuesW(%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
    4855            hKey,
    4856            val_list,
    4857            num_vals,
    4858            lpValueBuf,
    4859            ldwTotsize));
    4860 
    4861   return (ERROR_ACCESS_DENIED); /* signal failure */
    4862 }
    4863 
    4864 
    4865 /*****************************************************************************
    4866  * Name      : RegRemapPreDefKey
    4867  * Purpose   :
    4868  * Parameters:
    4869  * Variables :
    4870  * Result    :
    4871  * Remark    :
    4872  * Status    : UNTESTED STUB
    4873  *
    4874  * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
    4875  *****************************************************************************/
    4876 
    4877 #if 0
    4878 LONG WIN32API RegRemapPreDefKey(HKEY hKey)
    4879 {
    4880   dprintf(("ADVAPI32: RegRemapPreDefKey(%08xh) not implemented.\n",
    4881            hKey));
    4882 
    4883   return (ERROR_ACCESS_DENIED); /* signal failure */
    4884 }
    4885 #endif
    4886 
    4887 
    4888 /*****************************************************************************
    4889  * Name      : RegReplaceKeyA
    4890  * Purpose   : The RegReplaceKey function replaces the file backing a key and
    4891  *             all its subkeys with another file, so that when the system is
    4892  *             next started, the key and subkeys will have the values stored in the new file.
    4893  * Parameters: HKEY    hKey      handle of open key
    4894  *             LPCSTR lpSubKey  address of name of subkey
    4895  *             LPCSTR lpNewFile address of filename for file with new data
    4896  *             LPCSTR lpOldFile address of filename for backup file
    4897  * Variables :
    4898  * Result    :
    4899  * Remark    :
    4900  * Status    : UNTESTED STUB
    4901  *
    4902  * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
    4903  *****************************************************************************/
    4904 
    4905 LONG WIN32API RegReplaceKeyA(HKEY    hKey,
    4906                                 LPCSTR lpSubKey,
    4907                                 LPCSTR lpNewFile,
    4908                                 LPCSTR lpOldFile)
    4909 {
    4910   dprintf(("ADVAPI32: RegReplaceKeyA(%08xh,%s,%s,%s) not implemented.\n",
    4911            hKey,
    4912            lpSubKey,
    4913            lpNewFile,
    4914            lpOldFile));
    4915 
    4916   return (ERROR_ACCESS_DENIED); /* signal failure */
    4917 }
    4918 
    4919 
    4920 /*****************************************************************************
    4921  * Name      : RegReplaceKeyW
    4922  * Purpose   : The RegReplaceKey function replaces the file backing a key and
    4923  *             all its subkeys with another file, so that when the system is
    4924  *             next started, the key and subkeys will have the values stored in the new file.
    4925  * Parameters: HKEY    hKey      handle of open key
    4926  *             LPCWSTR lpSubKey  address of name of subkey
    4927  *             LPCWSTR lpNewFile address of filename for file with new data
    4928  *             LPCWSTR lpOldFile address of filename for backup file
    4929  * Variables :
    4930  * Result    :
    4931  * Remark    :
    4932  * Status    : UNTESTED STUB
    4933  *
    4934  * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
    4935  *****************************************************************************/
    4936 
    4937 LONG WIN32API RegReplaceKeyW(HKEY    hKey,
    4938                                 LPCWSTR lpSubKey,
    4939                                 LPCWSTR lpNewFile,
    4940                                 LPCWSTR lpOldFile)
    4941 {
    4942   dprintf(("ADVAPI32: RegReplaceKeyW(%08xh,%s,%s,%s) not implemented.\n",
    4943            hKey,
    4944            lpSubKey,
    4945            lpNewFile,
    4946            lpOldFile));
    4947 
    4948   return (ERROR_ACCESS_DENIED); /* signal failure */
    4949 }
    4950 
    4951 
    4952 /*****************************************************************************
    4953  * Name      : RegRestoreKeyA
    4954  * Purpose   : The RegRestoreKey function reads the registry information in a
    4955  *             specified file and copies it over the specified key. This
    4956  *             registry information may be in the form of a key and multiple
    4957  *             levels of subkeys.
    4958  * Parameters: HKEY    hKey      handle of key where restore begins
    4959  *             LPCSTR lpszFile  address of filename containing saved tree
    4960  *             DWORD   fdw       optional flags
    4961  * Variables :
    4962  * Result    :
    4963  * Remark    :
    4964  * Status    : UNTESTED STUB
    4965  *
    4966  * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
    4967  *****************************************************************************/
    4968 
    4969 LONG WIN32API RegRestoreKeyA(HKEY    hKey,
    4970                                 LPCSTR lpszFile,
    4971                                 DWORD   fdw)
    4972 {
    4973   dprintf(("ADVAPI32: RegRestoreKeyA(%08xh,%s,%08xh) not implemented.\n",
    4974            hKey,
    4975            lpszFile,
    4976            fdw));
    4977 
    4978   return (ERROR_ACCESS_DENIED); /* signal failure */
    4979 }
    4980 
    4981 
    4982 /*****************************************************************************
    4983  * Name      : RegRestoreKeyW
    4984  * Purpose   : The RegRestoreKey function reads the registry information in a
    4985  *             specified file and copies it over the specified key. This
    4986  *             registry information may be in the form of a key and multiple
    4987  *             levels of subkeys.
    4988  * Parameters: HKEY    hKey      handle of key where restore begins
    4989  *             LPCWSTR lpszFile  address of filename containing saved tree
    4990  *             DWORD   fdw       optional flags
    4991  * Variables :
    4992  * Result    :
    4993  * Remark    :
    4994  * Status    : UNTESTED STUB
    4995  *
    4996  * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
    4997  *****************************************************************************/
    4998 
    4999 LONG WIN32API RegRestoreKeyW(HKEY    hKey,
    5000                                 LPCWSTR lpszFile,
    5001                                 DWORD   fdw)
    5002 {
    5003   dprintf(("ADVAPI32: RegRestoreKeyW(%08xh,%s,%08xh) not implemented.\n",
    5004            hKey,
    5005            lpszFile,
    5006            fdw));
    5007 
    5008   return (ERROR_ACCESS_DENIED); /* signal failure */
    5009 }
    5010 
    5011 
    5012 /*****************************************************************************
    5013  * Name      : RegSaveKeyA
    5014  * Purpose   : The RegSaveKey function saves the specified key and all of its
    5015  *             subkeys and values to a new file.
    5016  * Parameters: HKEY                  hKey      handle of key where save begins
    5017  *             LPCSTR               lpszFile  address of filename to save to
    5018  *             LPSECURITY_ATTRIBUTES lpsa      address of security structure
    5019  * Variables :
    5020  * Result    :
    5021  * Remark    :
    5022  * Status    : UNTESTED STUB
    5023  *
    5024  * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
    5025  *****************************************************************************/
    5026 
    5027 LONG WIN32API RegSaveKeyA(HKEY                  hKey,
    5028                              LPCSTR               lpszFile,
    5029                              LPSECURITY_ATTRIBUTES lpsa)
    5030 {
    5031   dprintf(("ADVAPI32: RegSaveKeyA(%08xh,%s,%08xh) not implemented.\n",
    5032            hKey,
    5033            lpszFile,
    5034            lpsa));
    5035 
    5036   return (ERROR_ACCESS_DENIED); /* signal failure */
    5037 }
    5038 
    5039 
    5040 /*****************************************************************************
    5041  * Name      : RegSaveKeyW
    5042  * Purpose   : The RegSaveKey function saves the specified key and all of its
    5043  *             subkeys and values to a new file.
    5044  * Parameters: HKEY                  hKey      handle of key where save begins
    5045  *             LPCWSTR               lpszFile  address of filename to save to
    5046  *             LPSECURITY_ATTRIBUTES lpsa      address of security structure
    5047  * Variables :
    5048  * Result    :
    5049  * Remark    :
    5050  * Status    : UNTESTED STUB
    5051  *
    5052  * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
    5053  *****************************************************************************/
    5054 
    5055 LONG WIN32API RegSaveKeyW(HKEY                  hKey,
    5056                              LPCWSTR               lpszFile,
    5057                              LPSECURITY_ATTRIBUTES lpsa)
    5058 {
    5059   dprintf(("ADVAPI32: RegSaveKeyW(%08xh,%s,%08xh) not implemented.\n",
    5060            hKey,
    5061            lpszFile,
    5062            lpsa));
    5063 
    5064   return (ERROR_ACCESS_DENIED); /* signal failure */
    5065 }
    5066 
    5067 
    5068 /*****************************************************************************
    5069  * Name      : RegSetKeySecurity
    5070  * Purpose   : The RegSetKeySecurity function sets the security of an open registry key.
    5071  * Parameters: HKEY                 hKey open handle of key to set
    5072  *             SECURITY_INFORMATION si   descriptor contents
    5073  *             PSECURITY_DESCRIPTOR psd  address of descriptor for key
    5074  * Variables :
    5075  * Result    :
    5076  * Remark    :
    5077  * Status    : UNTESTED STUB
    5078  *
    5079  * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
    5080  *****************************************************************************/
    5081 
    5082 LONG WIN32API RegSetKeySecurity(HKEY                 hKey,
    5083                                    SECURITY_INFORMATION si,
    5084                                    PSECURITY_DESCRIPTOR psd)
    5085 {
    5086   dprintf(("ADVAPI32: RegSetKeySecurity(%08xh,%08xh,%08xh) not implemented.\n",
    5087            hKey,
    5088            si,
    5089            psd));
    5090 
    5091   return (ERROR_ACCESS_DENIED); /* signal failure */
    5092 }
    5093 
    5094 
    5095 /*****************************************************************************
    5096  * Name      : RegUnLoadKeyA
    5097  * Purpose   : The RegUnLoadKey function unloads the specified key and subkeys from the registry.
    5098  * Parameters: HKEY    hKey       handle of open key
    5099  *             LPCSTR lpszSubKey address of name of subkey to unload
    5100  * Variables :
    5101  * Result    :
    5102  * Remark    :
    5103  * Status    : UNTESTED STUB
    5104  *
    5105  * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
    5106  *****************************************************************************/
    5107 
    5108 LONG WIN32API RegUnLoadKeyA(HKEY    hKey,
    5109                                LPCSTR lpszSubKey)
    5110 {
    5111   dprintf(("ADVAPI32: RegUnLoadKeyA(%08xh,%s) not implemented.\n",
    5112            hKey,
    5113            lpszSubKey));
    5114 
    5115   return (ERROR_ACCESS_DENIED); /* signal failure */
    5116 }
    5117 
    5118 
    5119 /*****************************************************************************
    5120  * Name      : RegUnLoadKeyW
    5121  * Purpose   : The RegUnLoadKey function unloads the specified key and subkeys from the registry.
    5122  * Parameters: HKEY    hKey       handle of open key
    5123  *             LPCWSTR lpszSubKey address of name of subkey to unload
    5124  * Variables :
    5125  * Result    :
    5126  * Remark    :
    5127  * Status    : UNTESTED STUB
    5128  *
    5129  * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
    5130  *****************************************************************************/
    5131 
    5132 LONG WIN32API RegUnLoadKeyW(HKEY    hKey,
    5133                                LPCWSTR lpszSubKey)
    5134 {
    5135   dprintf(("ADVAPI32: RegUnLoadKeyW(%08xh,%s) not implemented.\n",
    5136            hKey,
    5137            lpszSubKey));
    5138 
    5139   return (ERROR_ACCESS_DENIED); /* signal failure */
    5140 }
    5141 
    5142 
    51434049/*****************************************************************************
    51444050 * Name      : RegisterServiceCtrlHandlerA

  • trunk/src/advapi32/ADVAPI32.DEF

    r91 r480  
    1 ; $Id: ADVAPI32.DEF,v 1.2 1999-06-10 14:23:33 phaller Exp $
     1; $Id: ADVAPI32.DEF,v 1.3 1999-08-11 21:19:49 phaller Exp $
    22
    33;Created by BLAST for IBM's compiler
    … …  
    132132     ReadEventLogA              = _ReadEventLogA@28                  @125
    133133     ReadEventLogW              = _ReadEventLogW@28                  @126
    134      RegCloseKey                = _RegCloseKey@4                     @127
    135      RegConnectRegistryA        = _RegConnectRegistryA@12            @128
    136      RegConnectRegistryW        = _RegConnectRegistryW@12            @129
    137      RegCreateKeyA              = _RegCreateKeyA@12                  @130
    138      RegCreateKeyExA            = _RegCreateKeyExA@36                @131
    139      RegCreateKeyExW            = _RegCreateKeyExW@36                @132
    140      RegCreateKeyW              = _RegCreateKeyW@12                  @133
    141      RegDeleteKeyA              = _RegDeleteKeyA@8                   @134
    142      RegDeleteKeyW              = _RegDeleteKeyW@8                   @135
    143      RegDeleteValueA            = _RegDeleteValueA@8                 @136
    144      RegDeleteValueW            = _RegDeleteValueW@8                 @137
    145      RegEnumKeyA                = _RegEnumKeyA@16                    @138
    146      RegEnumKeyExA              = _RegEnumKeyExA@32                  @139
    147      RegEnumKeyExW              = _RegEnumKeyExW@32                  @140
    148      RegEnumKeyW                = _RegEnumKeyW@16                    @141
    149      RegEnumValueA              = _RegEnumValueA@32                  @142
    150      RegEnumValueW              = _RegEnumValueW@32                  @143
    151      RegFlushKey                = _RegFlushKey@4                     @144
    152      RegGetKeySecurity          = _RegGetKeySecurity@16              @145
    153      RegLoadKeyA                = _RegLoadKeyA@12                    @146
    154      RegLoadKeyW                = _RegLoadKeyW@12                    @147
    155      RegNotifyChangeKeyValue    = _RegNotifyChangeKeyValue@20        @148
    156      RegOpenKeyA                = _RegOpenKeyA@12                    @149
    157      RegOpenKeyExA              = _RegOpenKeyExA@20                  @150
    158      RegOpenKeyExW              = _RegOpenKeyExW@20                  @151
    159      RegOpenKeyW                = _RegOpenKeyW@12                    @152
    160      RegQueryInfoKeyA           = _RegQueryInfoKeyA@48               @153
    161      RegQueryInfoKeyW           = _RegQueryInfoKeyW@48               @154
    162      RegQueryMultipleValuesA    = _RegQueryMultipleValuesA@20        @155
    163      RegQueryMultipleValuesW    = _RegQueryMultipleValuesW@20        @156
    164      RegQueryValueA             = _RegQueryValueA@16                 @157
    165      RegQueryValueExA           = _RegQueryValueExA@24               @158
    166      RegQueryValueExW           = _RegQueryValueExW@24               @159
    167      RegQueryValueW             = _RegQueryValueW@16                 @160
    168 ;    RegRemapPreDefKey          = _RegRemapPreDefKey@4               @161
    169      RegReplaceKeyA             = _RegReplaceKeyA@16                 @162
    170      RegReplaceKeyW             = _RegReplaceKeyW@16                 @163
    171      RegRestoreKeyA             = _RegRestoreKeyA@12                 @164
    172      RegRestoreKeyW             = _RegRestoreKeyW@12                 @165
    173      RegSaveKeyA                = _RegSaveKeyA@12                    @166
    174      RegSaveKeyW                = _RegSaveKeyW@12                    @167
    175      RegSetKeySecurity          = _RegSetKeySecurity@12              @168
    176      RegSetValueA               = _RegSetValueA@20                   @169
    177      RegSetValueExA             = _RegSetValueExA@24                 @170
    178      RegSetValueExW             = _RegSetValueExW@24                 @171
    179      RegSetValueW               = _RegSetValueW@20                   @172
    180      RegUnLoadKeyA              = _RegUnLoadKeyA@8                   @173
    181      RegUnLoadKeyW              = _RegUnLoadKeyW@8                   @174
     134     RegCloseKey                = _ODIN_RegCloseKey@4                     @127
     135     RegConnectRegistryA        = _ODIN_RegConnectRegistryA@12            @128
     136     RegConnectRegistryW        = _ODIN_RegConnectRegistryW@12            @129
     137     RegCreateKeyA              = _ODIN_RegCreateKeyA@12                  @130
     138     RegCreateKeyExA            = _ODIN_RegCreateKeyExA@36                @131
     139     RegCreateKeyExW            = _ODIN_RegCreateKeyExW@36                @132
     140     RegCreateKeyW              = _ODIN_RegCreateKeyW@12                  @133
     141     RegDeleteKeyA              = _ODIN_RegDeleteKeyA@8                   @134
     142     RegDeleteKeyW              = _ODIN_RegDeleteKeyW@8                   @135
     143     RegDeleteValueA            = _ODIN_RegDeleteValueA@8                 @136
     144     RegDeleteValueW            = _ODIN_RegDeleteValueW@8                 @137
     145     RegEnumKeyA                = _ODIN_RegEnumKeyA@16                    @138
     146     RegEnumKeyExA              = _ODIN_RegEnumKeyExA@32                  @139
     147     RegEnumKeyExW              = _ODIN_RegEnumKeyExW@32                  @140
     148     RegEnumKeyW                = _ODIN_RegEnumKeyW@16                    @141
     149     RegEnumValueA              = _ODIN_RegEnumValueA@32                  @142
     150     RegEnumValueW              = _ODIN_RegEnumValueW@32                  @143
     151     RegFlushKey                = _ODIN_RegFlushKey@4                     @144
     152     RegGetKeySecurity          = _ODIN_RegGetKeySecurity@16              @145
     153     RegLoadKeyA                = _ODIN_RegLoadKeyA@12                    @146
     154     RegLoadKeyW                = _ODIN_RegLoadKeyW@12                    @147
     155     RegNotifyChangeKeyValue    = _ODIN_RegNotifyChangeKeyValue@20        @148
     156     RegOpenKeyA                = _ODIN_RegOpenKeyA@12                    @149
     157     RegOpenKeyExA              = _ODIN_RegOpenKeyExA@20                  @150
     158     RegOpenKeyExW              = _ODIN_RegOpenKeyExW@20                  @151
     159     RegOpenKeyW                = _ODIN_RegOpenKeyW@12                    @152
     160     RegQueryInfoKeyA           = _ODIN_RegQueryInfoKeyA@48               @153
     161     RegQueryInfoKeyW           = _ODIN_RegQueryInfoKeyW@48               @154
     162     RegQueryMultipleValuesA    = _ODIN_RegQueryMultipleValuesA@20        @155
     163     RegQueryMultipleValuesW    = _ODIN_RegQueryMultipleValuesW@20        @156
     164     RegQueryValueA             = _ODIN_RegQueryValueA@16                 @157
     165     RegQueryValueExA           = _ODIN_RegQueryValueExA@24               @158
     166     RegQueryValueExW           = _ODIN_RegQueryValueExW@24               @159
     167     RegQueryValueW             = _ODIN_RegQueryValueW@16                 @160
     168;    RegRemapPreDefKey          = _ODIN_RegRemapPreDefKey@4               @161
     169     RegReplaceKeyA             = _ODIN_RegReplaceKeyA@16                 @162
     170     RegReplaceKeyW             = _ODIN_RegReplaceKeyW@16                 @163
     171     RegRestoreKeyA             = _ODIN_RegRestoreKeyA@12                 @164
     172     RegRestoreKeyW             = _ODIN_RegRestoreKeyW@12                 @165
     173     RegSaveKeyA                = _ODIN_RegSaveKeyA@12                    @166
     174     RegSaveKeyW                = _ODIN_RegSaveKeyW@12                    @167
     175     RegSetKeySecurity          = _ODIN_RegSetKeySecurity@12              @168
     176     RegSetValueA               = _ODIN_RegSetValueA@20                   @169
     177     RegSetValueExA             = _ODIN_RegSetValueExA@24                 @170
     178     RegSetValueExW             = _ODIN_RegSetValueExW@24                 @171
     179     RegSetValueW               = _ODIN_RegSetValueW@20                   @172
     180     RegUnLoadKeyA              = _ODIN_RegUnLoadKeyA@8                   @173
     181     RegUnLoadKeyW              = _ODIN_RegUnLoadKeyW@8                   @174
    182182     RegisterEventSourceA       = _RegisterEventSourceA@8            @175
    183183     RegisterEventSourceW       = _RegisterEventSourceW@8            @176

  • trunk/src/advapi32/makefile

    r447 r480  
    1 # $Id: makefile,v 1.5 1999-08-09 18:30:44 achimha Exp $
     1# $Id: makefile,v 1.6 1999-08-11 21:19:50 phaller Exp $
    22
    33#
    … …  
    2020TARGET = advapi32
    2121
    22 OBJS =  advapi32.obj initterm.obj
     22OBJS =  advapi32.obj initterm.obj registry.obj
    2323
    2424
    … …  
    3939
    4040advapi32.obj: advapi32.cpp advapi32.h
     41registry.obj: registry.cpp
    4142initterm.obj: initterm.cpp
    4243
Note: See TracChangeset for help on using the changeset viewer.