stg_prop.c File Reference

#include <assert.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "windef.h"
#include "winbase.h"
#include "winnls.h"
#include "winuser.h"
#include "wine/asm.h"
#include "wine/debug.h"
#include "wine/heap.h"
#include "oleauto.h"

Include dependency graph for stg_prop.c:

Go to the source code of this file.

Macros
#define	COBJMACROS
#define	BITS_PER_BYTE   8
#define	CHARMASK   0x1f
#define	BITS_IN_CHARMASK   5
#define	NUM_ALPHA_CHARS   26

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (storage)
HRESULT WINAPI	FmtIdToPropStgName (const FMTID *rfmtid, LPOLESTR str)
HRESULT WINAPI	PropStgNameToFmtId (const LPOLESTR str, FMTID *rfmtid)

Variables
static const WCHAR	szSummaryInfo [] = L"\5SummaryInformation"
static const WCHAR	szDocSummaryInfo [] = L"\5DocumentSummaryInformation"

Macro Definition Documentation

BITS_IN_CHARMASK

#define BITS_IN_CHARMASK   5

Definition at line 66 of file stg_prop.c.

BITS_PER_BYTE

#define BITS_PER_BYTE   8

Definition at line 64 of file stg_prop.c.

CHARMASK

#define CHARMASK   0x1f

Definition at line 65 of file stg_prop.c.

COBJMACROS

#define COBJMACROS

Definition at line 46 of file stg_prop.c.

NUM_ALPHA_CHARS

#define NUM_ALPHA_CHARS   26

Definition at line 67 of file stg_prop.c.

Function Documentation

FmtIdToPropStgName()

HRESULT WINAPI FmtIdToPropStgName	(	const FMTID *	rfmtid,
		LPOLESTR	str
	)

Definition at line 72 of file stg_prop.c.

{
    static const char fmtMap[] = "abcdefghijklmnopqrstuvwxyz012345";
 
    TRACE("%s, %p\n", debugstr_guid(rfmtid), str);
 
    if (!rfmtid) return E_INVALIDARG;
    if (!str) return E_INVALIDARG;
 
    if (IsEqualGUID(&FMTID_SummaryInformation, rfmtid))
        lstrcpyW(str, szSummaryInfo);
    else if (IsEqualGUID(&FMTID_DocSummaryInformation, rfmtid))
        lstrcpyW(str, szDocSummaryInfo);
    else if (IsEqualGUID(&FMTID_UserDefinedProperties, rfmtid))
        lstrcpyW(str, szDocSummaryInfo);
    else
    {
        const BYTE *fmtptr;
        WCHAR *pstr = str;
        ULONG bitsRemaining = BITS_PER_BYTE;
 
        *pstr++ = 5;
        for (fmtptr = (const BYTE *)rfmtid; fmtptr < (const BYTE *)rfmtid + sizeof(FMTID); )
        {
            ULONG i = *fmtptr >> (BITS_PER_BYTE - bitsRemaining);
 
            if (bitsRemaining >= BITS_IN_CHARMASK)
            {
                *pstr = (WCHAR)(fmtMap[i & CHARMASK]);
                if (bitsRemaining == BITS_PER_BYTE && *pstr >= 'a' &&
                 *pstr <= 'z')
                    *pstr += 'A' - 'a';
                pstr++;
                bitsRemaining -= BITS_IN_CHARMASK;
                if (bitsRemaining == 0)
                {
                    fmtptr++;
                    bitsRemaining = BITS_PER_BYTE;
                }
            }
            else
            {
                if (++fmtptr < (const BYTE *)rfmtid + sizeof(FMTID))
                    i |= *fmtptr << bitsRemaining;
                *pstr++ = (WCHAR)(fmtMap[i & CHARMASK]);
                bitsRemaining += BITS_PER_BYTE - BITS_IN_CHARMASK;
            }
        }
        *pstr = 0;
    }
    TRACE("returning %s\n", debugstr_w(str));
    return S_OK;
}

Referenced by IPropertySetStorage_fnCreate(), IPropertySetStorage_fnDelete(), IPropertySetStorage_fnOpen(), and testFmtId().

PropStgNameToFmtId()

HRESULT WINAPI PropStgNameToFmtId	(	const LPOLESTR	str,
		FMTID *	rfmtid
	)

Definition at line 129 of file stg_prop.c.

{
    HRESULT hr = STG_E_INVALIDNAME;
 
    TRACE("%s, %p\n", debugstr_w(str), rfmtid);
 
    if (!rfmtid) return E_INVALIDARG;
    if (!str) return STG_E_INVALIDNAME;
 
    if (!lstrcmpiW(str, szDocSummaryInfo))
    {
        *rfmtid = FMTID_DocSummaryInformation;
        hr = S_OK;
    }
    else if (!lstrcmpiW(str, szSummaryInfo))
    {
        *rfmtid = FMTID_SummaryInformation;
        hr = S_OK;
    }
    else
    {
        ULONG bits;
        BYTE *fmtptr = (BYTE *)rfmtid - 1;
        const WCHAR *pstr = str;
 
        memset(rfmtid, 0, sizeof(*rfmtid));
        for (bits = 0; bits < sizeof(FMTID) * BITS_PER_BYTE;
         bits += BITS_IN_CHARMASK)
        {
            ULONG bitsUsed = bits % BITS_PER_BYTE, bitsStored;
            WCHAR wc;
 
            if (bitsUsed == 0)
                fmtptr++;
            wc = *++pstr - 'A';
            if (wc > NUM_ALPHA_CHARS)
            {
                wc += 'A' - 'a';
                if (wc > NUM_ALPHA_CHARS)
                {
                    wc += 'a' - '0' + NUM_ALPHA_CHARS;
                    if (wc > CHARMASK)
                    {
                        WARN("invalid character (%d)\n", *pstr);
                        goto end;
                    }
                }
            }
            *fmtptr |= wc << bitsUsed;
            bitsStored = min(BITS_PER_BYTE - bitsUsed, BITS_IN_CHARMASK);
            if (bitsStored < BITS_IN_CHARMASK)
            {
                wc >>= BITS_PER_BYTE - bitsUsed;
                if (bits + bitsStored == sizeof(FMTID) * BITS_PER_BYTE)
                {
                    if (wc != 0)
                    {
                        WARN("extra bits\n");
                        goto end;
                    }
                    break;
                }
                fmtptr++;
                *fmtptr |= (BYTE)wc;
            }
        }
        hr = S_OK;
    }
end:
    return hr;
}

Referenced by create_enum_stat_propset_stg(), and testFmtId().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

storage

)

Variable Documentation

szDocSummaryInfo

const WCHAR szDocSummaryInfo[] = L"\5DocumentSummaryInformation"

static

Definition at line 62 of file stg_prop.c.

Referenced by FmtIdToPropStgName(), PropStgNameToFmtId(), and testFmtId().

szSummaryInfo

const WCHAR szSummaryInfo[] = L"\5SummaryInformation"

static

Definition at line 61 of file stg_prop.c.

Referenced by FmtIdToPropStgName(), PropStgNameToFmtId(), testFmtId(), and testPropsHelper().