本文整理汇总了C++中AssertCompile函数的典型用法代码示例。如果您正苦于以下问题:C++ AssertCompile函数的具体用法?C++ AssertCompile怎么用?C++ AssertCompile使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了AssertCompile函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: VBOXUSBTOOL_DECL
VBOXUSBTOOL_DECL(NTSTATUS) VBoxUsbToolGetStringDescriptor(PDEVICE_OBJECT pDevObj, char *pszResult, ULONG cbResult,
int iIndex, int LangId, ULONG dwTimeoutMs)
{
char aBuf[MAXIMUM_USB_STRING_LENGTH];
AssertCompile(sizeof (aBuf) <= UINT8_MAX);
UCHAR cbBuf = (UCHAR)sizeof (aBuf);
PUSB_STRING_DESCRIPTOR pDr = (PUSB_STRING_DESCRIPTOR)&aBuf;
Assert(pszResult);
*pszResult = 0;
memset(pDr, 0, cbBuf);
pDr->bLength = cbBuf;
pDr->bDescriptorType = USB_STRING_DESCRIPTOR_TYPE;
NTSTATUS Status = VBoxUsbToolGetDescriptor(pDevObj, pDr, cbBuf, USB_STRING_DESCRIPTOR_TYPE, iIndex, LangId, dwTimeoutMs);
if (NT_SUCCESS(Status))
{
if (pDr->bLength >= sizeof (USB_STRING_DESCRIPTOR))
{
int rc = RTUtf16ToUtf8Ex(pDr->bString, (pDr->bLength - RT_OFFSETOF(USB_STRING_DESCRIPTOR, bString)) / sizeof(RTUTF16),
&pszResult, cbResult, NULL /*pcch*/);
if (RT_SUCCESS(rc))
{
USBLibPurgeEncoding(pszResult);
Status = STATUS_SUCCESS;
}
else
Status = STATUS_UNSUCCESSFUL;
}
else
Status = STATUS_INVALID_PARAMETER;
}
return Status;
}
示例2: RTDECL
/**
* Wrapper around RTNtPathExpand8dot3Path that allocates a buffer instead of
* working on the input buffer.
*
* @returns IPRT status code, see RTNtPathExpand8dot3Path().
* @param pUniStrSrc The path to fix up. MaximumLength is the max buffer
* length.
* @param fPathOnly Whether to only process the path and leave the filename
* as passed in.
* @param pUniStrDst Output string. On success, the caller must use
* RTUtf16Free to free what the Buffer member points to.
* This is all zeros and NULL on failure.
*/
RTDECL(int) RTNtPathExpand8dot3PathA(PCUNICODE_STRING pUniStrSrc, bool fPathOnly, PUNICODE_STRING pUniStrDst)
{
/* Guess a reasonable size for the final version. */
size_t const cbShort = pUniStrSrc->Length;
size_t cbLong = RT_MIN(_64K - 1, cbShort * 8);
if (cbLong < RTPATH_MAX)
cbLong = RTPATH_MAX * 2;
AssertCompile(RTPATH_MAX * 2 < _64K);
pUniStrDst->Buffer = (WCHAR *)RTUtf16Alloc(cbLong);
if (pUniStrDst->Buffer != NULL)
{
/* Copy over the short name and fix it up. */
pUniStrDst->MaximumLength = (uint16_t)cbLong;
pUniStrDst->Length = (uint16_t)cbShort;
memcpy(pUniStrDst->Buffer, pUniStrSrc->Buffer, cbShort);
pUniStrDst->Buffer[cbShort / sizeof(WCHAR)] = '\0';
int rc = RTNtPathExpand8dot3Path(pUniStrDst, fPathOnly);
if (RT_SUCCESS(rc))
return rc;
/* We failed, bail. */
RTUtf16Free(pUniStrDst->Buffer);
pUniStrDst->Buffer = NULL;
}
pUniStrDst->Length = 0;
pUniStrDst->MaximumLength = 0;
return VERR_NO_UTF16_MEMORY;
}
示例3: RTDECL
RTDECL(int) RTSemEventMultiCreateEx(PRTSEMEVENTMULTI phEventMultiSem, uint32_t fFlags, RTLOCKVALCLASS hClass,
const char *pszNameFmt, ...)
{
AssertReturn(!(fFlags & ~RTSEMEVENTMULTI_FLAGS_NO_LOCK_VAL), VERR_INVALID_PARAMETER);
AssertCompile(sizeof(RTSEMEVENTMULTIINTERNAL) > sizeof(void *));
AssertPtrReturn(phEventMultiSem, VERR_INVALID_POINTER);
RT_ASSERT_PREEMPTIBLE();
PRTSEMEVENTMULTIINTERNAL pThis = (PRTSEMEVENTMULTIINTERNAL)RTMemAlloc(sizeof(*pThis));
if (pThis)
{
pThis->u32Magic = RTSEMEVENTMULTI_MAGIC;
pThis->fStateAndGen = RTSEMEVENTMULTIDARWIN_STATE_GEN_INIT;
pThis->cRefs = 1;
pThis->fHaveBlockedThreads = false;
Assert(g_pDarwinLockGroup);
pThis->pSpinlock = lck_spin_alloc_init(g_pDarwinLockGroup, LCK_ATTR_NULL);
if (pThis->pSpinlock)
{
*phEventMultiSem = pThis;
return VINF_SUCCESS;
}
pThis->u32Magic = 0;
RTMemFree(pThis);
}
return VERR_NO_MEMORY;
}
示例4: RTDECL
RTDECL(PRTTIMESPEC) RTTimeNow(PRTTIMESPEC pTime)
{
uint64_t u64;
AssertCompile(sizeof(u64) == sizeof(FILETIME));
GetSystemTimeAsFileTime((LPFILETIME)&u64);
return RTTimeSpecSetNtTime(pTime, u64);
}
示例5: rtZipGzip_CompressIt
/**
* Processes all available input.
*
* @returns IPRT status code.
*
* @param pThis The gzip I/O stream instance data.
* @param fBlocking Whether to block or not.
*/
static int rtZipGzip_CompressIt(PRTZIPGZIPSTREAM pThis, bool fBlocking)
{
/*
* Processes all the intput currently lined up for us.
*/
while (pThis->Zlib.avail_in > 0)
{
/* Make sure there is some space in the output buffer before calling
deflate() so we don't waste time filling up the corners. */
static const size_t s_cbFlushThreshold = 4096;
AssertCompile(sizeof(pThis->abBuffer) >= s_cbFlushThreshold * 4);
if (pThis->Zlib.avail_out < s_cbFlushThreshold)
{
int rc = rtZipGzip_WriteOutputBuffer(pThis, fBlocking);
if (rc != VINF_SUCCESS)
return rc;
Assert(pThis->Zlib.avail_out >= s_cbFlushThreshold);
}
int rcZlib = deflate(&pThis->Zlib, Z_NO_FLUSH);
if (rcZlib != Z_OK)
return rtZipGzipConvertErrFromZlib(pThis, rcZlib);
}
return VINF_SUCCESS;
}
示例6: RTDECL
RTDECL(int) RTSemMutexCreateEx(PRTSEMMUTEX phMutexSem, uint32_t fFlags,
RTLOCKVALCLASS hClass, uint32_t uSubClass, const char *pszNameFmt, ...)
{
AssertReturn(!(fFlags & ~RTSEMMUTEX_FLAGS_NO_LOCK_VAL), VERR_INVALID_PARAMETER);
RT_ASSERT_PREEMPTIBLE();
AssertCompile(sizeof(RTSEMMUTEXINTERNAL) > sizeof(void *));
PRTSEMMUTEXINTERNAL pThis = (PRTSEMMUTEXINTERNAL)RTMemAlloc(sizeof(*pThis));
if (pThis)
{
pThis->u32Magic = RTSEMMUTEX_MAGIC;
pThis->cWaiters = 0;
pThis->cRefs = 1;
pThis->cRecursions = 0;
pThis->hNativeOwner = NIL_RTNATIVETHREAD;
Assert(g_pDarwinLockGroup);
pThis->pSpinlock = lck_spin_alloc_init(g_pDarwinLockGroup, LCK_ATTR_NULL);
if (pThis->pSpinlock)
{
*phMutexSem = pThis;
return VINF_SUCCESS;
}
RTMemFree(pThis);
}
return VERR_NO_MEMORY;
}
示例7: DISDECL
/**
* Returns the value of the specified segment register
*
*/
DISDECL(int) DISFetchRegSeg(PCCPUMCTXCORE pCtx, DIS_SELREG sel, RTSEL *pVal)
{
AssertReturn((unsigned)sel < RT_ELEMENTS(g_aRegSegIndex), VERR_INVALID_PARAMETER);
AssertCompile(sizeof(uint16_t) == sizeof(RTSEL));
*pVal = DIS_READ_REGSEG(pCtx, sel);
return VINF_SUCCESS;
}
示例8: RTDECL
RTDECL(void) RTCrRc4(PRTCRRC4KEY pKey, size_t cbData, void const *pvDataIn, void *pvDataOut)
{
AssertCompile(sizeof(RC4_INT) == 4 ? sizeof(pKey->au64Padding) == sizeof(pKey->Ossl) : sizeof(pKey->au64Padding) >= sizeof(pKey->Ossl));
Assert((int)cbData == (ssize_t)cbData);
AssertPtr(pKey);
RC4(&pKey->Ossl, (int)cbData, (const unsigned char *)pvDataIn, (unsigned char *)pvDataOut);
}
示例9: rtMpSolarisGetCoreId
/**
* Helper for getting the core ID for a given CPU/strand/hyperthread.
*
* @returns The core ID.
* @param idCpu The CPU ID instance.
*/
static inline uint64_t rtMpSolarisGetCoreId(RTCPUID idCpu)
{
kstat_named_t *pStat = (kstat_named_t *)kstat_data_lookup(g_papCpuInfo[idCpu], (char *)"core_id");
Assert(pStat->data_type == KSTAT_DATA_LONG);
Assert(pStat->value.l >= 0);
AssertCompile(sizeof(uint64_t) >= sizeof(long)); /* Paranoia. */
return (uint64_t)pStat->value.l;
}
示例10: VBoxLikesVideoMode
bool VBoxLikesVideoMode(uint32_t display, uint32_t width, uint32_t height, uint32_t bpp)
{
bool bRC = FALSE;
VMMDevVideoModeSupportedRequest2 *req2 = NULL;
int rc = VbglGRAlloc((VMMDevRequestHeader**)&req2, sizeof(VMMDevVideoModeSupportedRequest2), VMMDevReq_VideoModeSupported2);
if (RT_FAILURE(rc))
{
LOG(("ERROR allocating request, rc = %#xrc", rc));
/* Most likely the VBoxGuest driver is not loaded.
* To get at least the video working, report the mode as supported.
*/
bRC = TRUE;
}
else
{
req2->display = display;
req2->width = width;
req2->height = height;
req2->bpp = bpp;
rc = VbglGRPerform(&req2->header);
if (RT_SUCCESS(rc))
{
bRC = req2->fSupported;
}
else
{
/* Retry using old interface. */
AssertCompile(sizeof(VMMDevVideoModeSupportedRequest2) >= sizeof(VMMDevVideoModeSupportedRequest));
VMMDevVideoModeSupportedRequest *req = (VMMDevVideoModeSupportedRequest *)req2;
req->header.size = sizeof(VMMDevVideoModeSupportedRequest);
req->header.version = VMMDEV_REQUEST_HEADER_VERSION;
req->header.requestType = VMMDevReq_VideoModeSupported;
req->header.rc = VERR_GENERAL_FAILURE;
req->header.reserved1 = 0;
req->header.reserved2 = 0;
req->width = width;
req->height = height;
req->bpp = bpp;
rc = VbglGRPerform(&req->header);
if (RT_SUCCESS(rc))
{
bRC = req->fSupported;
}
else
{
WARN(("ERROR querying video mode supported status from VMMDev. rc = %#xrc", rc));
}
}
VbglGRFree(&req2->header);
}
LOG(("width: %d, height: %d, bpp: %d -> %s", width, height, bpp, (bRC == 1) ? "OK" : "FALSE"));
return bRC;
}
示例11: suplibDarwinOpenService
/**
* Opens the IOKit service, instantiating org_virtualbox_SupDrvClient.
*
* @returns VBox status code.
*/
static int suplibDarwinOpenService(PSUPLIBDATA pThis)
{
/*
* Open the IOKit client first - The first step is finding the service.
*/
mach_port_t MasterPort;
kern_return_t kr = IOMasterPort(MACH_PORT_NULL, &MasterPort);
if (kr != kIOReturnSuccess)
{
LogRel(("IOMasterPort -> %d\n", kr));
return VERR_GENERAL_FAILURE;
}
CFDictionaryRef ClassToMatch = IOServiceMatching(IOCLASS_NAME);
if (!ClassToMatch)
{
LogRel(("IOServiceMatching(\"%s\") failed.\n", IOCLASS_NAME));
return VERR_GENERAL_FAILURE;
}
/* Create an io_iterator_t for all instances of our drivers class that exist in the IORegistry. */
io_iterator_t Iterator;
kr = IOServiceGetMatchingServices(MasterPort, ClassToMatch, &Iterator);
if (kr != kIOReturnSuccess)
{
LogRel(("IOServiceGetMatchingServices returned %d\n", kr));
return VERR_GENERAL_FAILURE;
}
/* Get the first item in the iterator and release it. */
io_service_t ServiceObject = IOIteratorNext(Iterator);
IOObjectRelease(Iterator);
if (!ServiceObject)
{
LogRel(("SUP: Couldn't find any matches. The kernel module is probably not loaded.\n"));
return VERR_VM_DRIVER_NOT_INSTALLED;
}
/*
* Open the service.
*
* This will cause the user client class in SUPDrv-darwin.cpp to be
* instantiated and create a session for this process.
*/
io_connect_t Connection = NULL;
kr = IOServiceOpen(ServiceObject, mach_task_self(), SUP_DARWIN_IOSERVICE_COOKIE, &Connection);
IOObjectRelease(ServiceObject);
if (kr != kIOReturnSuccess)
{
LogRel(("SUP: IOServiceOpen returned %d. Driver open failed.\n", kr));
pThis->uConnection = 0;
return VERR_VM_DRIVER_OPEN_ERROR;
}
AssertCompile(sizeof(pThis->uConnection) >= sizeof(Connection));
pThis->uConnection = Connection;
return VINF_SUCCESS;
}
示例12: AssertCompile
HRESULT SystemProperties::getMinGuestRAM(ULONG *minRAM)
{
/* no need to lock, this is const */
AssertCompile(MM_RAM_MIN_IN_MB >= SchemaDefs::MinGuestRAM);
*minRAM = MM_RAM_MIN_IN_MB;
return S_OK;
}
示例13: DISDECL
//*****************************************************************************
//*****************************************************************************
DISDECL(DISSELREG) DISDetectSegReg(PCDISSTATE pDis, PCDISOPPARAM pParam)
{
if (pDis->fPrefix & DISPREFIX_SEG)
/* Use specified SEG: prefix. */
return (DISSELREG)pDis->idxSegPrefix;
/* Guess segment register by parameter type. */
if (pParam->fUse & (DISUSE_REG_GEN32|DISUSE_REG_GEN64|DISUSE_REG_GEN16))
{
AssertCompile(DISGREG_ESP == DISGREG_RSP);
AssertCompile(DISGREG_EBP == DISGREG_RBP);
AssertCompile(DISGREG_ESP == DISGREG_SP);
AssertCompile(DISGREG_EBP == DISGREG_BP);
if (pParam->Base.idxGenReg == DISGREG_ESP || pParam->Base.idxGenReg == DISGREG_EBP)
return DISSELREG_SS;
}
/* Default is use DS: for data access. */
return DISSELREG_DS;
}
示例14: rtThreadNativeMain
/**
* Native thread main function.
*
* @param pvThreadInt The thread structure.
*/
static void rtThreadNativeMain(void *pvThreadInt)
{
PRTTHREADINT pThreadInt = (PRTTHREADINT)pvThreadInt;
AssertCompile(sizeof(kt_did_t) == sizeof(pThreadInt->tid));
uint64_t *pu64ThrId = SOL_THREAD_ID_PTR;
pThreadInt->tid = *pu64ThrId;
rtThreadMain(pThreadInt, RTThreadNativeSelf(), &pThreadInt->szName[0]);
thread_exit();
}
示例15: DECLCALLBACK
/**
* @callback_method_impl{PFNVMMEMTRENDEZVOUS,
* Worker for gimR3KvmEnableWallClock}
*/
static DECLCALLBACK(VBOXSTRICTRC) gimR3KvmEnableWallClockCallback(PVM pVM, PVMCPU pVCpu, void *pvData)
{
Assert(pvData);
PKVMWALLCLOCKINFO pWallClockInfo = (PKVMWALLCLOCKINFO)pvData;
RTGCPHYS GCPhysWallClock = pWallClockInfo->GCPhysWallClock;
/*
* Read the wall-clock version (sequence) from the guest.
*/
uint32_t uVersion;
Assert(PGMPhysIsGCPhysNormal(pVM, GCPhysWallClock));
int rc = PGMPhysSimpleReadGCPhys(pVM, &uVersion, GCPhysWallClock, sizeof(uVersion));
if (RT_FAILURE(rc))
{
LogRel(("GIM: KVM: Failed to read wall-clock struct. version at %#RGp. rc=%Rrc\n", GCPhysWallClock, rc));
return rc;
}
/*
* Ensure the version is incrementally even.
*/
if (!(uVersion & 1))
++uVersion;
++uVersion;
/*
* Update wall-clock guest struct. with UTC information.
*/
RTTIMESPEC TimeSpec;
int32_t iSec;
int32_t iNano;
TMR3UtcNow(pVM, &TimeSpec);
RTTimeSpecGetSecondsAndNano(&TimeSpec, &iSec, &iNano);
GIMKVMWALLCLOCK WallClock;
RT_ZERO(WallClock);
AssertCompile(sizeof(uVersion) == sizeof(WallClock.u32Version));
WallClock.u32Version = uVersion;
WallClock.u32Sec = iSec;
WallClock.u32Nano = iNano;
/*
* Write out the wall-clock struct. to guest memory.
*/
Assert(!(WallClock.u32Version & 1));
rc = PGMPhysSimpleWriteGCPhys(pVM, GCPhysWallClock, &WallClock, sizeof(GIMKVMWALLCLOCK));
if (RT_SUCCESS(rc))
{
LogRel(("GIM: KVM: Enabled wall-clock struct. at %#RGp - u32Sec=%u u32Nano=%u uVersion=%#RU32\n", GCPhysWallClock,
WallClock.u32Sec, WallClock.u32Nano, WallClock.u32Version));
}
else
LogRel(("GIM: KVM: Failed to write wall-clock struct. at %#RGp. rc=%Rrc\n", GCPhysWallClock, rc));
return rc;
}