Ignore:
Timestamp:
Jul 12, 1999, 2:21:37 AM (26 years ago)
Author:
davidr
Message:

Updated clsid handling to correctly draw textual clsid's
Fixed GUID instansiation.
Moved initialisation to OLE32.CPP
Added many new APIs incl. CoCreateInstance & CoGetClassObject.
Many partially implemented stubs completed and moved to OLE32.CPP
Running Object Table implemented (Moniker.cpp)
IMalloc & Task Memory implemented.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/ole32/clsid.cpp

    r197 r291  
    1 /*
    2  *
     1/* 
     2 * 
    33 * Project Odin Software License can be found in LICENSE.TXT
    4  *
     4 * 
    55 */
    6 /*
    7  * Win32 OLE stubs for OS/2
    8  *
    9  * 1998/06/12
    10  *
    11  * Copyright 1998 Sander van Leeuwen
     6/*
     7 * ClassID Manipulation.
     8 *
     9 * 1/7/99
     10 *
     11 * Copyright 1999 David J. Raison
     12 *
     13 * Some portions from Wine Implementation
     14 *   Copyright 1995  Martin von Loewis
     15 *   Copyright 1998  Justin Bradford
     16 *   Copyright 1999  Francis Beaudet
     17 *   Copyright 1999  Sylvain St-Germain
    1218 */
    1319
    … …  
    1521
    1622#include "oString.h"
    17 
    18 // ----------------------------------------------------------------------
    19 // CLSIDFromStringA() [Internal]
    20 // ----------------------------------------------------------------------
    21 static HRESULT CLSIDFromStringA(
    22     const char *        lpsz,           // [in] - ASCII string to convert
    23     LPCLSID             pclisid)        // [out] - CLSID
    24 {
    25     dprintf(("OLE32.CLSIDFromStringA [Internal]\n"));
    26 
    27     BYTE *s = (BYTE *) lpsz;
    28     BYTE *p;
    29     int   i;
    30     BYTE table[256];
    31 
    32     /* quick lookup table */
    33     memset(table, 0, 256);
    34 
    35     for (i = 0; i < 10; i++)
    36     {
    37         table['0' + i] = i;
    38     }
    39     for (i = 0; i < 6; i++)
    40     {
    41         table['A' + i] = i+10;
    42         table['a' + i] = i+10;
    43     }
    44 
    45     /* in form {XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX} */
    46 
    47     if (strlen(lpsz) != 38)
    48         return OLE_ERROR_OBJECT;
    49 
    50     p = (BYTE *) pclisid;
    51 
    52     s++;  /* skip leading brace  */
    53     for (i = 0; i < 4; i++)
    54     {
    55         p[3 - i] = table[*s]<<4 | table[*(s+1)];
    56         s += 2;
    57     }
    58     p += 4;
    59     s++;  /* skip - */
    60 
    61     for (i = 0; i < 2; i++)
    62     {
    63         p[1-i] = table[*s]<<4 | table[*(s+1)];
    64         s += 2;
    65     }
    66     p += 2;
    67     s++;  /* skip - */
    68 
    69     for (i = 0; i < 2; i++)
    70     {
    71         p[1-i] = table[*s]<<4 | table[*(s+1)];
    72         s += 2;
    73     }
    74     p += 2;
    75     s++;  /* skip - */
    76 
    77     /* these are just sequential bytes */
    78     for (i = 0; i < 2; i++)
    79     {
    80         *p++ = table[*s]<<4 | table[*(s+1)];
    81         s += 2;
    82     }
    83     s++;  /* skip - */
    84 
    85     for (i = 0; i < 6; i++)
    86     {
    87         *p++ = table[*s]<<4 | table[*(s+1)];
    88         s += 2;
    89     }
    90 
    91     return S_OK;
    92 }
    9323
    9424// ----------------------------------------------------------------------
    … …  
    9929    LPCLSID             pclsid)         // [out] - CLSID
    10030{
    101     dprintf(("OLE32.CLSIDFromProgID\n"));
     31    dprintf(("OLE32: CLSIDFromProgID"));
    10232
    10333    LONG                lDataLen = 80;
    104     oStringA            szKey(lpszProgID);
    105     oStringA            szCLSID(lDataLen);
     34    oStringW            szKey(lpszProgID);
     35    oStringW            szCLSID(lDataLen);
    10636    HKEY                hKey;
    10737    HRESULT             rc;
    10838
    10939    // Create the registry lookup string...
    110     szKey += "\\CLSID";
     40    szKey += L"\\CLSID";
    11141
    11242    // Try to open the key in the registry...
    113     rc = RegOpenKeyA(HKEY_CLASSES_ROOT, szKey, &hKey);
     43    rc = RegOpenKeyW(HKEY_CLASSES_ROOT, szKey, &hKey);
    11444    if (rc != 0)
    11545        return OLE_ERROR_GENERIC;
    11646
    11747    // Now get the data from the _default_ entry on this key...
    118     rc = RegQueryValueA(hKey, NULL, szCLSID, &lDataLen);
     48    rc = RegQueryValueW(hKey, NULL, szCLSID, &lDataLen);
    11949    RegCloseKey(hKey);
    12050    if (rc != 0)
    … …  
    12252
    12353    // Now convert from a string to a UUID
    124     return CLSIDFromStringA(szCLSID, pclsid);
     54    return CLSIDFromString(szCLSID, pclsid);
     55}
     56
     57// ----------------------------------------------------------------------
     58// IIDFromString
     59// ----------------------------------------------------------------------
     60HRESULT WIN32API IIDFromString(LPSTR lpsz, LPIID lpiid)
     61{
     62    dprintf(("OLE32: IIDFromString"));
     63    return CLSIDFromString((LPCOLESTR)lpsz, (LPCLSID)lpiid);
    12564}
    12665
    … …  
    13271    LPCLSID             pclsid)         // [out] - Binary CLSID
    13372{
    134     dprintf(("OLE32.CLSIDFromString\n"));
     73    dprintf(("OLE32: CLSIDFromString"));
     74
     75    oStringA            tClsId(lpsz);
    13576
    13677    HRESULT             ret = OLE_ERROR_GENERIC;
    137     oStringA            szCLSID(lpsz);
    13878
    13979    // Convert to binary CLSID
    140     return CLSIDFromStringA(szCLSID, pclsid);
    141 }
    142 
     80    char *s = (char *) tClsId;
     81    char *p;
     82    int   i;
     83    char table[256];
     84
     85    /* quick lookup table */
     86    memset(table, 0, 256);
     87
     88    for (i = 0; i < 10; i++)
     89    {
     90        table['0' + i] = i;
     91    }
     92    for (i = 0; i < 6; i++)
     93    {
     94        table['A' + i] = i+10;
     95        table['a' + i] = i+10;
     96    }
     97
     98    /* in form {XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX} */
     99
     100    if (lstrlenW(lpsz) != 38)
     101        return OLE_ERROR_OBJECT;
     102
     103    p = (char *) pclsid;
     104
     105    s++;  /* skip leading brace  */
     106    for (i = 0; i < 4; i++)
     107    {
     108        p[3 - i] = table[*s]<<4 | table[*(s+1)];
     109        s += 2;
     110    }
     111    p += 4;
     112    s++;  /* skip - */
     113
     114    for (i = 0; i < 2; i++)
     115    {
     116        p[1-i] = table[*s]<<4 | table[*(s+1)];
     117        s += 2;
     118    }
     119    p += 2;
     120    s++;  /* skip - */
     121
     122    for (i = 0; i < 2; i++)
     123    {
     124        p[1-i] = table[*s]<<4 | table[*(s+1)];
     125        s += 2;
     126    }
     127    p += 2;
     128    s++;  /* skip - */
     129
     130    /* these are just sequential bytes */
     131    for (i = 0; i < 2; i++)
     132    {
     133        *p++ = table[*s]<<4 | table[*(s+1)];
     134        s += 2;
     135    }
     136    s++;  /* skip - */
     137
     138    for (i = 0; i < 6; i++)
     139    {
     140        *p++ = table[*s]<<4 | table[*(s+1)];
     141        s += 2;
     142    }
     143
     144    return S_OK;
     145}
     146
     147// ----------------------------------------------------------------------
     148// CoCreateGuid()
     149// ----------------------------------------------------------------------
     150HRESULT WIN32API CoCreateGuid(GUID *pguid)
     151{
     152   dprintf(("OLE32: CoCreateGuid"));
     153   memset(pguid, 0, sizeof(GUID));      //TODO: should be random GUID
     154   return S_OK;
     155}
     156
     157// ----------------------------------------------------------------------
     158// StringFromCLSID
     159// Memory allocated here on behalf of application should be freed using CoTaskMemFree()
     160// ----------------------------------------------------------------------
     161HRESULT WIN32API StringFromCLSID(REFCLSID rclsid, LPOLESTR *ppsz)
     162{
     163    char        tmp[50];
     164    LPWSTR      szclsid;
     165    size_t      strLen;
     166
     167    dprintf(("OLE32: StringFromCLSID"));
     168
     169    // Setup new string...
     170    strLen  = sprintf(tmp, "{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
     171            rclsid->Data1,
     172            rclsid->Data2,
     173            rclsid->Data3,
     174            rclsid->Data4[0],
     175            rclsid->Data4[1],
     176            rclsid->Data4[2],
     177            rclsid->Data4[3],
     178            rclsid->Data4[4],
     179            rclsid->Data4[5],
     180            rclsid->Data4[6],
     181            rclsid->Data4[7]);
     182
     183    // Grab buffer for string...
     184    szclsid = (LPWSTR)CoTaskMemAlloc((strLen + 1) * sizeof(WCHAR));
     185
     186    AsciiToUnicode(tmp, szclsid);
     187
     188    *ppsz = (LPOLESTR)szclsid;
     189
     190    return S_OK;
     191}
     192
     193// ----------------------------------------------------------------------
     194// StringFromIID
     195// Memory allocated here on behalf of application should be freed using CoTaskMemFree()
     196// ----------------------------------------------------------------------
     197HRESULT WIN32API StringFromIID(REFIID riid, LPOLESTR *ppsz)
     198{
     199    char        tmp[50];
     200    LPWSTR      sziid;
     201    size_t      strLen;
     202
     203    dprintf(("OLE32: StringFromIID"));
     204
     205    // Setup new string...
     206    strLen  = sprintf(tmp, "{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
     207            riid->Data1,
     208            riid->Data2,
     209            riid->Data3,
     210            riid->Data4[0],
     211            riid->Data4[1],
     212            riid->Data4[2],
     213            riid->Data4[3],
     214            riid->Data4[4],
     215            riid->Data4[5],
     216            riid->Data4[6],
     217            riid->Data4[7]);
     218
     219    // Grab buffer for string...
     220    sziid = (LPWSTR)CoTaskMemAlloc((strLen + 1) * sizeof(WCHAR));
     221
     222    AsciiToUnicode(tmp, sziid);
     223
     224    *ppsz = (LPOLESTR)sziid;
     225
     226    return S_OK;
     227}
     228
     229// ----------------------------------------------------------------------
     230// StringFromGUID2
     231// ----------------------------------------------------------------------
     232int WIN32API StringFromGUID2(REFGUID rguid, LPOLESTR lpsz, int cbMax)
     233{
     234    char        tmp[64];
     235    size_t      strLen;
     236
     237    dprintf(("OLE32: StringFromGUID2"));
     238
     239    // Setup new string...
     240    strLen  = sprintf(tmp, "{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
     241            rguid->Data1,
     242            rguid->Data2,
     243            rguid->Data3,
     244            rguid->Data4[0],
     245            rguid->Data4[1],
     246            rguid->Data4[2],
     247            rguid->Data4[3],
     248            rguid->Data4[4],
     249            rguid->Data4[5],
     250            rguid->Data4[6],
     251            rguid->Data4[7]);
     252
     253    if(cbMax < (strLen * 2 + 1))
     254        return 0;
     255
     256    AsciiToUnicode(tmp, lpsz);
     257
     258    return(strLen * 2 + 1);  // including 0 terminator
     259}
     260
Note: See TracChangeset for help on using the changeset viewer.