/******************************************************************************
* HGLOBAL_UserSize [OLE32.@]
*/
unsigned long __RPC_USER HGLOBAL_UserSize(unsigned long *pFlags, unsigned long StartingSize, HGLOBAL *phGlobal)
{
unsigned long size = StartingSize;
TRACE("("); dump_user_flags(pFlags); TRACE(", %ld, %p\n", StartingSize, phGlobal);
ALIGN_LENGTH(size, 3);
size += sizeof(ULONG);
if (LOWORD(*pFlags == MSHCTX_INPROC))
size += sizeof(HGLOBAL);
else
{
size += sizeof(ULONG);
if (*phGlobal)
{
SIZE_T ret;
size += 3 * sizeof(ULONG);
ret = GlobalSize(*phGlobal);
size += (unsigned long)ret;
}
}
return size;
}
unsigned long WINAPI BSTR_UserSize(unsigned long *pFlags, unsigned long Start, BSTR *pstr)
{
TRACE("(%lx,%ld,%p) => %p\n", *pFlags, Start, pstr, *pstr);
if (*pstr) TRACE("string=%s\n", debugstr_w(*pstr));
ALIGN_LENGTH(Start, 3);
Start += sizeof(bstr_wire_t) + ((SysStringByteLen(*pstr) + 1) & ~1);
TRACE("returning %ld\n", Start);
return Start;
}
unsigned long WINAPI VARIANT_UserSize(unsigned long *pFlags, unsigned long Start, VARIANT *pvar)
{
int align;
TRACE("(%lx,%ld,%p)\n", *pFlags, Start, pvar);
TRACE("vt=%04x\n", V_VT(pvar));
ALIGN_LENGTH(Start, 7);
Start += sizeof(variant_wire_t);
if(V_VT(pvar) & VT_BYREF)
Start += 4;
align = get_type_alignment(pFlags, pvar);
ALIGN_LENGTH(Start, align);
if(V_VT(pvar) == (VT_VARIANT | VT_BYREF))
Start += 4;
else
Start += get_type_size(pFlags, pvar);
Start = wire_extra_user_size(pFlags, Start, pvar);
TRACE("returning %ld\n", Start);
return Start;
}
unsigned long __RPC_USER STGMEDIUM_UserSize(unsigned long *pFlags, unsigned long StartingSize, STGMEDIUM *pStgMedium)
{
unsigned long size = StartingSize;
TRACE("("); dump_user_flags(pFlags); TRACE(", %ld, %p\n", StartingSize, pStgMedium);
ALIGN_LENGTH(size, 3);
size += 2 * sizeof(DWORD);
if (pStgMedium->tymed != TYMED_NULL)
size += sizeof(DWORD);
switch (pStgMedium->tymed)
{
case TYMED_NULL:
TRACE("TYMED_NULL\n");
break;
case TYMED_HGLOBAL:
TRACE("TYMED_HGLOBAL\n");
size = HGLOBAL_UserSize(pFlags, size, &pStgMedium->u.hGlobal);
break;
case TYMED_FILE:
FIXME("TYMED_FILE\n");
break;
case TYMED_ISTREAM:
FIXME("TYMED_ISTREAM\n");
break;
case TYMED_ISTORAGE:
FIXME("TYMED_ISTORAGE\n");
break;
case TYMED_GDI:
FIXME("TYMED_GDI\n");
break;
case TYMED_MFPICT:
FIXME("TYMED_MFPICT\n");
break;
case TYMED_ENHMF:
TRACE("TYMED_ENHMF\n");
size = HENHMETAFILE_UserSize(pFlags, size, &pStgMedium->u.hEnhMetaFile);
break;
default:
RaiseException(DV_E_TYMED, 0, 0, NULL);
}
if (pStgMedium->pUnkForRelease)
FIXME("buffer size pUnkForRelease\n");
return size;
}
EFI_STATUS
WriteFirstFreeSpiProtect (
IN CONST UINT32 PchRootComplexBar,
IN CONST UINT32 DirectValue,
IN CONST UINT32 BaseAddress,
IN CONST UINT32 Length,
OUT UINT32 *OffsetPtr
)
{
UINT32 RegVal;
UINT32 Offset;
UINT32 StepLen;
ASSERT (PchRootComplexBar > 0);
Offset = 0;
if (OffsetPtr != NULL) {
*OffsetPtr = Offset;
}
if (MmioRead32 (PchRootComplexBar + R_QNC_RCRB_SPIPBR0) == 0) {
Offset = R_QNC_RCRB_SPIPBR0;
} else {
if (MmioRead32 (PchRootComplexBar + R_QNC_RCRB_SPIPBR1) == 0) {
Offset = R_QNC_RCRB_SPIPBR1;
} else {
if (MmioRead32 (PchRootComplexBar + R_QNC_RCRB_SPIPBR2) == 0) {
Offset = R_QNC_RCRB_SPIPBR2;
}
}
}
if (Offset != 0) {
if (DirectValue == 0) {
StepLen = ALIGN_LENGTH (Length,0x1000); // Bring up to 4K boundary.
RegVal = BaseAddress + StepLen - 1;
RegVal &= 0x00FFF000; // Set EDS Protected Range Limit (PRL).
RegVal |= ((BaseAddress >> 12) & 0xfff); // or in EDS Protected Range Base (PRB).
} else {
unsigned long WINAPI CLEANLOCALSTORAGE_UserSize(unsigned long *pFlags, unsigned long Start, CLEANLOCALSTORAGE *pstg)
{
ALIGN_LENGTH(Start, 3);
return Start + sizeof(DWORD);
}
unsigned long WINAPI LPSAFEARRAY_UserSize(unsigned long *pFlags, unsigned long StartingSize, LPSAFEARRAY *ppsa)
{
unsigned long size = StartingSize;
TRACE("("); dump_user_flags(pFlags); TRACE(", %ld, %p\n", StartingSize, *ppsa);
ALIGN_LENGTH(size, 3);
size += sizeof(ULONG_PTR);
if (*ppsa)
{
SAFEARRAY *psa = *ppsa;
ULONG ulCellCount = SAFEARRAY_GetCellCount(psa);
SF_TYPE sftype;
HRESULT hr;
size += sizeof(ULONG);
size += FIELD_OFFSET(struct _wireSAFEARRAY, uArrayStructs);
sftype = SAFEARRAY_GetUnionType(psa);
size += sizeof(ULONG);
size += sizeof(ULONG);
size += sizeof(ULONG_PTR);
if (sftype == SF_HAVEIID)
size += sizeof(IID);
size += sizeof(psa->rgsabound[0]) * psa->cDims;
size += sizeof(ULONG);
switch (sftype)
{
case SF_BSTR:
{
BSTR* lpBstr;
for (lpBstr = (BSTR*)psa->pvData; ulCellCount; ulCellCount--, lpBstr++)
size = BSTR_UserSize(pFlags, size, lpBstr);
break;
}
case SF_DISPATCH:
case SF_UNKNOWN:
case SF_HAVEIID:
FIXME("size interfaces\n");
break;
case SF_VARIANT:
{
VARIANT* lpVariant;
for (lpVariant = (VARIANT*)psa->pvData; ulCellCount; ulCellCount--, lpVariant++)
size = VARIANT_UserSize(pFlags, size, lpVariant);
break;
}
case SF_RECORD:
{
IRecordInfo* pRecInfo = NULL;
hr = SafeArrayGetRecordInfo(psa, &pRecInfo);
if (FAILED(hr))
RpcRaiseException(hr);
if (pRecInfo)
{
FIXME("size record info %p\n", pRecInfo);
IRecordInfo_Release(pRecInfo);
}
break;
}
case SF_I8:
ALIGN_LENGTH(size, 7);
/* fallthrough */
case SF_I1:
case SF_I2:
case SF_I4:
size += ulCellCount * psa->cbElements;
break;
default:
break;
}
}
return size;
}
#ifndef _MZ_SHARE_HEAPALLOCATOR_HPP_
#define _MZ_SHARE_HEAPALLOCATOR_HPP_
#include "Define.hpp"
#include "Type.hpp"
template<int UNITLENGTH = DEFAULT_ALIGNMENT>
class HeapAllocator {
DISALLOW_COPY_AND_ASSIGN(HeapAllocator)
enum { ALIGNLENGTH = ALIGN_LENGTH(UNITLENGTH, DEFAULT_ALIGNMENT) };
public:
template<int OTHERLENGTH>
using Rebind = HeapAllocator<OTHERLENGTH>;
public:
HeapAllocator() {}
~HeapAllocator() {}
public:
void Initialize() {}
void Finalize() {}
void* Alloc() {
return ::malloc(ALIGNLENGTH);
}
void Free(void* memory) {