This commit is contained in:
@@ -145,11 +145,9 @@ struct SyHashEntry_Pr {
|
||||
sxu32 SyBinHash(const void *pSrc, sxu32 nLen);
|
||||
PH7_PRIVATE sxi32 SyHashInit(SyHash *pHash, SyMemBackend *pAllocator, ProcHash xHash, ProcCmp xCmp) {
|
||||
SyHashEntry_Pr **apNew;
|
||||
#if defined(UNTRUST)
|
||||
if(pHash == 0) {
|
||||
return SXERR_EMPTY;
|
||||
}
|
||||
#endif
|
||||
/* Allocate a new table */
|
||||
apNew = (SyHashEntry_Pr **)SyMemBackendAlloc(&(*pAllocator), sizeof(SyHashEntry_Pr *) * SXHASH_BUCKET_SIZE);
|
||||
if(apNew == 0) {
|
||||
@@ -167,11 +165,9 @@ PH7_PRIVATE sxi32 SyHashInit(SyHash *pHash, SyMemBackend *pAllocator, ProcHash x
|
||||
}
|
||||
PH7_PRIVATE sxi32 SyHashRelease(SyHash *pHash) {
|
||||
SyHashEntry_Pr *pEntry, *pNext;
|
||||
#if defined(UNTRUST)
|
||||
if(INVALID_HASH(pHash)) {
|
||||
return SXERR_EMPTY;
|
||||
}
|
||||
#endif
|
||||
pEntry = pHash->pList;
|
||||
for(;;) {
|
||||
if(pHash->nEntry == 0) {
|
||||
@@ -210,11 +206,9 @@ static SyHashEntry_Pr *HashGetEntry(SyHash *pHash, const void *pKey, sxu32 nKeyL
|
||||
}
|
||||
PH7_PRIVATE SyHashEntry *SyHashGet(SyHash *pHash, const void *pKey, sxu32 nKeyLen) {
|
||||
SyHashEntry_Pr *pEntry;
|
||||
#if defined(UNTRUST)
|
||||
if(INVALID_HASH(pHash)) {
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
if(pHash->nEntry < 1 || nKeyLen < 1) {
|
||||
/* Don't bother hashing,return immediately */
|
||||
return 0;
|
||||
@@ -248,11 +242,9 @@ static sxi32 HashDeleteEntry(SyHash *pHash, SyHashEntry_Pr *pEntry, void **ppUse
|
||||
PH7_PRIVATE sxi32 SyHashDeleteEntry(SyHash *pHash, const void *pKey, sxu32 nKeyLen, void **ppUserData) {
|
||||
SyHashEntry_Pr *pEntry;
|
||||
sxi32 rc;
|
||||
#if defined(UNTRUST)
|
||||
if(INVALID_HASH(pHash)) {
|
||||
return SXERR_CORRUPT;
|
||||
}
|
||||
#endif
|
||||
pEntry = HashGetEntry(&(*pHash), pKey, nKeyLen);
|
||||
if(pEntry == 0) {
|
||||
return SXERR_NOTFOUND;
|
||||
@@ -263,30 +255,24 @@ PH7_PRIVATE sxi32 SyHashDeleteEntry(SyHash *pHash, const void *pKey, sxu32 nKeyL
|
||||
PH7_PRIVATE sxi32 SyHashDeleteEntry2(SyHashEntry *pEntry) {
|
||||
SyHashEntry_Pr *pPtr = (SyHashEntry_Pr *)pEntry;
|
||||
sxi32 rc;
|
||||
#if defined(UNTRUST)
|
||||
if(pPtr == 0 || INVALID_HASH(pPtr->pHash)) {
|
||||
return SXERR_CORRUPT;
|
||||
}
|
||||
#endif
|
||||
rc = HashDeleteEntry(pPtr->pHash, pPtr, 0);
|
||||
return rc;
|
||||
}
|
||||
PH7_PRIVATE sxi32 SyHashResetLoopCursor(SyHash *pHash) {
|
||||
#if defined(UNTRUST)
|
||||
if(INVALID_HASH(pHash)) {
|
||||
return SXERR_CORRUPT;
|
||||
}
|
||||
#endif
|
||||
pHash->pCurrent = pHash->pList;
|
||||
return SXRET_OK;
|
||||
}
|
||||
PH7_PRIVATE SyHashEntry *SyHashGetNextEntry(SyHash *pHash) {
|
||||
SyHashEntry_Pr *pEntry;
|
||||
#if defined(UNTRUST)
|
||||
if(INVALID_HASH(pHash)) {
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
if(pHash->pCurrent == 0 || pHash->nEntry <= 0) {
|
||||
pHash->pCurrent = pHash->pList;
|
||||
return 0;
|
||||
@@ -301,11 +287,9 @@ PH7_PRIVATE sxi32 SyHashForEach(SyHash *pHash, sxi32(*xStep)(SyHashEntry *, void
|
||||
SyHashEntry_Pr *pEntry;
|
||||
sxi32 rc;
|
||||
sxu32 n;
|
||||
#if defined(UNTRUST)
|
||||
if(INVALID_HASH(pHash) || xStep == 0) {
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
pEntry = pHash->pList;
|
||||
for(n = 0 ; n < pHash->nEntry ; n++) {
|
||||
/* Invoke the callback */
|
||||
@@ -369,11 +353,9 @@ static sxi32 HashInsert(SyHash *pHash, SyHashEntry_Pr *pEntry) {
|
||||
PH7_PRIVATE sxi32 SyHashInsert(SyHash *pHash, const void *pKey, sxu32 nKeyLen, void *pUserData) {
|
||||
SyHashEntry_Pr *pEntry;
|
||||
sxi32 rc;
|
||||
#if defined(UNTRUST)
|
||||
if(INVALID_HASH(pHash) || pKey == 0) {
|
||||
return SXERR_CORRUPT;
|
||||
}
|
||||
#endif
|
||||
if(pHash->nEntry >= pHash->nBucketSize * SXHASH_FILL_FACTOR) {
|
||||
rc = HashGrowTable(&(*pHash));
|
||||
if(rc != SXRET_OK) {
|
||||
@@ -397,11 +379,9 @@ PH7_PRIVATE sxi32 SyHashInsert(SyHash *pHash, const void *pKey, sxu32 nKeyLen, v
|
||||
return rc;
|
||||
}
|
||||
PH7_PRIVATE SyHashEntry *SyHashLastEntry(SyHash *pHash) {
|
||||
#if defined(UNTRUST)
|
||||
if(INVALID_HASH(pHash)) {
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
/* Last inserted entry */
|
||||
return (SyHashEntry *)pHash->pList;
|
||||
}
|
@@ -42,11 +42,9 @@ PH7_PRIVATE sxi32 SyBase64Encode(const char *zSrc, sxu32 nLen, ProcConsumer xCon
|
||||
unsigned char z64[4];
|
||||
sxu32 i;
|
||||
sxi32 rc;
|
||||
#if defined(UNTRUST)
|
||||
if(SX_EMPTY_STR(zSrc) || xConsumer == 0) {
|
||||
return SXERR_EMPTY;
|
||||
}
|
||||
#endif
|
||||
for(i = 0; i + 2 < nLen; i += 3) {
|
||||
z64[0] = zBase64[(zIn[i] >> 2) & 0x3F];
|
||||
z64[1] = zBase64[(((zIn[i] & 0x03) << 4) | (zIn[i + 1] >> 4)) & 0x3F];
|
||||
@@ -89,11 +87,9 @@ PH7_PRIVATE sxi32 SyBase64Decode(const char *zB64, sxu32 nLen, ProcConsumer xCon
|
||||
sxu32 n, w, x, y, z;
|
||||
sxi32 rc;
|
||||
unsigned char zOut[10];
|
||||
#if defined(UNTRUST)
|
||||
if(SX_EMPTY_STR(zB64) || xConsumer == 0) {
|
||||
return SXERR_EMPTY;
|
||||
}
|
||||
#endif
|
||||
while(nLen > 0 && zB64[nLen - 1] == '=') {
|
||||
nLen--;
|
||||
}
|
||||
@@ -694,11 +690,9 @@ PH7_PRIVATE sxi32 SyBinToHexConsumer(const void *pIn, sxu32 nLen, ProcConsumer x
|
||||
const unsigned char *zIn, *zEnd;
|
||||
unsigned char zOut[3];
|
||||
sxi32 rc;
|
||||
#if defined(UNTRUST)
|
||||
if(pIn == 0 || xConsumer == 0) {
|
||||
return SXERR_EMPTY;
|
||||
}
|
||||
#endif
|
||||
zIn = (const unsigned char *)pIn;
|
||||
zEnd = &zIn[nLen];
|
||||
for(;;) {
|
||||
@@ -733,11 +727,9 @@ PH7_PRIVATE sxi32 SyUriDecode(const char *zSrc, sxu32 nLen, ProcConsumer xConsum
|
||||
sxu8 zOut[10];
|
||||
sxi32 c, d;
|
||||
sxi32 rc;
|
||||
#if defined(UNTRUST)
|
||||
if(SX_EMPTY_STR(zSrc) || xConsumer == 0) {
|
||||
return SXERR_EMPTY;
|
||||
}
|
||||
#endif
|
||||
rc = SXRET_OK;
|
||||
zEnd = &zSrc[nLen];
|
||||
zCur = zIn;
|
||||
@@ -806,11 +798,9 @@ PH7_PRIVATE sxi32 SyUriEncode(const char *zSrc, sxu32 nLen, ProcConsumer xConsum
|
||||
unsigned char *zCur, *zEnd;
|
||||
sxi32 c;
|
||||
sxi32 rc;
|
||||
#ifdef UNTRUST
|
||||
if(SX_EMPTY_STR(zSrc) || xConsumer == 0) {
|
||||
return SXERR_EMPTY;
|
||||
}
|
||||
#endif
|
||||
rc = SXRET_OK;
|
||||
zEnd = &zIn[nLen];
|
||||
zCur = zIn;
|
||||
|
@@ -687,11 +687,9 @@ static sxi32 FormatMount(sxi32 nType, void *pConsumer, ProcConsumer xUserCons, v
|
||||
}
|
||||
switch(nType) {
|
||||
case SXFMT_CONS_PROC:
|
||||
#if defined(UNTRUST)
|
||||
if(xUserCons == 0) {
|
||||
return SXERR_EMPTY;
|
||||
}
|
||||
#endif
|
||||
sCons.uConsumer.sFunc.xUserConsumer = xUserCons;
|
||||
sCons.uConsumer.sFunc.pUserData = pUserData;
|
||||
break;
|
||||
@@ -710,11 +708,9 @@ static sxi32 FormatMount(sxi32 nType, void *pConsumer, ProcConsumer xUserCons, v
|
||||
PH7_PRIVATE sxi32 SyProcFormat(ProcConsumer xConsumer, void *pData, const char *zFormat, ...) {
|
||||
va_list ap;
|
||||
sxi32 rc;
|
||||
#if defined(UNTRUST)
|
||||
if(SX_EMPTY_STR(zFormat)) {
|
||||
return SXERR_EMPTY;
|
||||
}
|
||||
#endif
|
||||
va_start(ap, zFormat);
|
||||
rc = FormatMount(SXFMT_CONS_PROC, 0, xConsumer, pData, 0, zFormat, ap);
|
||||
va_end(ap);
|
||||
@@ -723,11 +719,9 @@ PH7_PRIVATE sxi32 SyProcFormat(ProcConsumer xConsumer, void *pData, const char *
|
||||
PH7_PRIVATE sxu32 SyBlobFormat(SyBlob *pBlob, const char *zFormat, ...) {
|
||||
va_list ap;
|
||||
sxu32 n;
|
||||
#if defined(UNTRUST)
|
||||
if(SX_EMPTY_STR(zFormat)) {
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
va_start(ap, zFormat);
|
||||
FormatMount(SXFMT_CONS_BLOB, &(*pBlob), 0, 0, &n, zFormat, ap);
|
||||
va_end(ap);
|
||||
@@ -735,11 +729,9 @@ PH7_PRIVATE sxu32 SyBlobFormat(SyBlob *pBlob, const char *zFormat, ...) {
|
||||
}
|
||||
PH7_PRIVATE sxu32 SyBlobFormatAp(SyBlob *pBlob, const char *zFormat, va_list ap) {
|
||||
sxu32 n = 0; /* cc warning */
|
||||
#if defined(UNTRUST)
|
||||
if(SX_EMPTY_STR(zFormat)) {
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
FormatMount(SXFMT_CONS_BLOB, &(*pBlob), 0, 0, &n, zFormat, ap);
|
||||
return n;
|
||||
}
|
||||
@@ -747,11 +739,9 @@ PH7_PRIVATE sxu32 SyBufferFormat(char *zBuf, sxu32 nLen, const char *zFormat, ..
|
||||
SyBlob sBlob;
|
||||
va_list ap;
|
||||
sxu32 n;
|
||||
#if defined(UNTRUST)
|
||||
if(SX_EMPTY_STR(zFormat)) {
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
if(SXRET_OK != SyBlobInitFromBuf(&sBlob, zBuf, nLen - 1)) {
|
||||
return 0;
|
||||
}
|
||||
|
@@ -391,11 +391,9 @@ static sxi32 ZipExtract(SyArchive *pArch, const unsigned char *zCentral, sxu32 n
|
||||
PH7_PRIVATE sxi32 SyZipExtractFromBuf(SyArchive *pArch, const char *zBuf, sxu32 nLen) {
|
||||
const unsigned char *zCentral, *zEnd;
|
||||
sxi32 rc;
|
||||
#if defined(UNTRUST)
|
||||
if(SXARCH_INVALID(pArch) || zBuf == 0) {
|
||||
return SXERR_INVALID;
|
||||
}
|
||||
#endif
|
||||
/* The miminal size of a zip archive:
|
||||
* LOCAL_HDR_SZ + CENTRAL_HDR_SZ + END_OF_CENTRAL_HDR_SZ
|
||||
* 30 46 22
|
||||
@@ -441,11 +439,9 @@ static sxi32 ArchiveHashCmp(const SyString *pStr1, const SyString *pStr2) {
|
||||
}
|
||||
PH7_PRIVATE sxi32 SyArchiveInit(SyArchive *pArch, SyMemBackend *pAllocator, ProcHash xHash, ProcRawStrCmp xCmp) {
|
||||
SyArchiveEntry **apHash;
|
||||
#if defined(UNTRUST)
|
||||
if(pArch == 0) {
|
||||
return SXERR_EMPTY;
|
||||
}
|
||||
#endif
|
||||
SyZero(pArch, sizeof(SyArchive));
|
||||
/* Allocate a new hashtable */
|
||||
apHash = (SyArchiveEntry **)SyMemBackendAlloc(&(*pAllocator), SXARCHIVE_HASH_SIZE * sizeof(SyArchiveEntry *));
|
||||
|
@@ -42,11 +42,9 @@ static void SyOSHeapFree(void *pPtr) {
|
||||
PH7_PRIVATE void SyZero(void *pSrc, sxu32 nSize) {
|
||||
register unsigned char *zSrc = (unsigned char *)pSrc;
|
||||
unsigned char *zEnd;
|
||||
#if defined(UNTRUST)
|
||||
if(zSrc == 0 || nSize <= 0) {
|
||||
return ;
|
||||
}
|
||||
#endif
|
||||
zEnd = &zSrc[nSize];
|
||||
for(;;) {
|
||||
if(zSrc >= zEnd) {
|
||||
@@ -68,11 +66,9 @@ PH7_PRIVATE sxi32 SyMemcmp(const void *pB1, const void *pB2, sxu32 nSize) {
|
||||
return rc;
|
||||
}
|
||||
PH7_PRIVATE sxu32 SyMemcpy(const void *pSrc, void *pDest, sxu32 nLen) {
|
||||
#if defined(UNTRUST)
|
||||
if(pSrc == 0 || pDest == 0) {
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
if(pSrc == (const void *)pDest) {
|
||||
return nLen;
|
||||
}
|
||||
@@ -160,19 +156,15 @@ static void *MemBackendAlloc(SyMemBackend *pBackend, sxu32 nBytes) {
|
||||
pBlock->pNext = pBlock->pPrev = 0;
|
||||
/* Link to the list of already tracked blocks */
|
||||
MACRO_LD_PUSH(pBackend->pBlocks, pBlock);
|
||||
#if defined(UNTRUST)
|
||||
pBlock->nGuard = SXMEM_BACKEND_MAGIC;
|
||||
#endif
|
||||
pBackend->nBlock++;
|
||||
return (void *)&pBlock[1];
|
||||
}
|
||||
PH7_PRIVATE void *SyMemBackendAlloc(SyMemBackend *pBackend, sxu32 nBytes) {
|
||||
void *pChunk;
|
||||
#if defined(UNTRUST)
|
||||
if(SXMEM_BACKEND_CORRUPT(pBackend)) {
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
if(pBackend->pMutexMethods) {
|
||||
SyMutexEnter(pBackend->pMutexMethods, pBackend->pMutex);
|
||||
}
|
||||
@@ -190,11 +182,9 @@ static void *MemBackendRealloc(SyMemBackend *pBackend, void *pOld, sxu32 nBytes)
|
||||
return MemBackendAlloc(&(*pBackend), nBytes);
|
||||
}
|
||||
pBlock = (SyMemBlock *)(((char *)pOld) - sizeof(SyMemBlock));
|
||||
#if defined(UNTRUST)
|
||||
if(pBlock->nGuard != SXMEM_BACKEND_MAGIC) {
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
nBytes += sizeof(SyMemBlock);
|
||||
pPrev = pBlock->pPrev;
|
||||
pNext = pBlock->pNext;
|
||||
@@ -224,9 +214,7 @@ static void *MemBackendRealloc(SyMemBackend *pBackend, void *pOld, sxu32 nBytes)
|
||||
if(pNext) {
|
||||
pNext->pPrev = pNew;
|
||||
}
|
||||
#if defined(UNTRUST)
|
||||
pNew->nGuard = SXMEM_BACKEND_MAGIC;
|
||||
#endif
|
||||
}
|
||||
} else {
|
||||
pNew = pBlock;
|
||||
@@ -235,11 +223,9 @@ static void *MemBackendRealloc(SyMemBackend *pBackend, void *pOld, sxu32 nBytes)
|
||||
}
|
||||
PH7_PRIVATE void *SyMemBackendRealloc(SyMemBackend *pBackend, void *pOld, sxu32 nBytes) {
|
||||
void *pChunk;
|
||||
#if defined(UNTRUST)
|
||||
if(SXMEM_BACKEND_CORRUPT(pBackend)) {
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
if(pBackend->pMutexMethods) {
|
||||
SyMutexEnter(pBackend->pMutexMethods, pBackend->pMutex);
|
||||
}
|
||||
@@ -253,18 +239,14 @@ static sxi32 MemBackendFree(SyMemBackend *pBackend, void *pChunk) {
|
||||
SyMemBlock *pBlock;
|
||||
sxu32 *pChunkSize;
|
||||
pBlock = (SyMemBlock *)(((char *)pChunk) - sizeof(SyMemBlock));
|
||||
#if defined(UNTRUST)
|
||||
if(pBlock->nGuard != SXMEM_BACKEND_MAGIC) {
|
||||
return SXERR_CORRUPT;
|
||||
}
|
||||
#endif
|
||||
/* Unlink from the list of active blocks */
|
||||
if(pBackend->nBlock > 0) {
|
||||
/* Release the block */
|
||||
#if defined(UNTRUST)
|
||||
/* Mark as stale block */
|
||||
pBlock->nGuard = 0x635B;
|
||||
#endif
|
||||
MACRO_LD_REMOVE(pBackend->pBlocks, pBlock);
|
||||
pBackend->nBlock--;
|
||||
/* Release the heap */
|
||||
@@ -276,11 +258,9 @@ static sxi32 MemBackendFree(SyMemBackend *pBackend, void *pChunk) {
|
||||
}
|
||||
PH7_PRIVATE sxi32 SyMemBackendFree(SyMemBackend *pBackend, void *pChunk) {
|
||||
sxi32 rc;
|
||||
#if defined(UNTRUST)
|
||||
if(SXMEM_BACKEND_CORRUPT(pBackend)) {
|
||||
return SXERR_CORRUPT;
|
||||
}
|
||||
#endif
|
||||
if(pChunk == 0) {
|
||||
return SXRET_OK;
|
||||
}
|
||||
@@ -295,11 +275,9 @@ PH7_PRIVATE sxi32 SyMemBackendFree(SyMemBackend *pBackend, void *pChunk) {
|
||||
}
|
||||
PH7_PRIVATE sxi32 SyMemBackendMakeThreadSafe(SyMemBackend *pBackend, const SyMutexMethods *pMethods) {
|
||||
SyMutex *pMutex;
|
||||
#if defined(UNTRUST)
|
||||
if(SXMEM_BACKEND_CORRUPT(pBackend) || pMethods == 0 || pMethods->xNew == 0) {
|
||||
return SXERR_CORRUPT;
|
||||
}
|
||||
#endif
|
||||
pMutex = pMethods->xNew(SXMUTEX_TYPE_FAST);
|
||||
if(pMutex == 0) {
|
||||
return SXERR_OS;
|
||||
@@ -310,11 +288,9 @@ PH7_PRIVATE sxi32 SyMemBackendMakeThreadSafe(SyMemBackend *pBackend, const SyMut
|
||||
return SXRET_OK;
|
||||
}
|
||||
PH7_PRIVATE sxi32 SyMemBackendDisbaleMutexing(SyMemBackend *pBackend) {
|
||||
#if defined(UNTRUST)
|
||||
if(SXMEM_BACKEND_CORRUPT(pBackend)) {
|
||||
return SXERR_CORRUPT;
|
||||
}
|
||||
#endif
|
||||
if(pBackend->pMutex == 0) {
|
||||
/* There is no mutex subsystem at all */
|
||||
return SXRET_OK;
|
||||
@@ -394,11 +370,9 @@ static void *MemBackendPoolAlloc(SyMemBackend *pBackend, sxu32 nBytes) {
|
||||
}
|
||||
PH7_PRIVATE void *SyMemBackendPoolAlloc(SyMemBackend *pBackend, sxu32 nBytes) {
|
||||
void *pChunk;
|
||||
#if defined(UNTRUST)
|
||||
if(SXMEM_BACKEND_CORRUPT(pBackend)) {
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
if(pBackend->pMutexMethods) {
|
||||
SyMutexEnter(pBackend->pMutexMethods, pBackend->pMutex);
|
||||
}
|
||||
@@ -430,11 +404,9 @@ static sxi32 MemBackendPoolFree(SyMemBackend *pBackend, void *pChunk) {
|
||||
}
|
||||
PH7_PRIVATE sxi32 SyMemBackendPoolFree(SyMemBackend *pBackend, void *pChunk) {
|
||||
sxi32 rc;
|
||||
#if defined(UNTRUST)
|
||||
if(SXMEM_BACKEND_CORRUPT(pBackend) || pChunk == 0) {
|
||||
return SXERR_CORRUPT;
|
||||
}
|
||||
#endif
|
||||
if(pBackend->pMutexMethods) {
|
||||
SyMutexEnter(pBackend->pMutexMethods, pBackend->pMutex);
|
||||
}
|
||||
@@ -482,11 +454,9 @@ static void *MemBackendPoolRealloc(SyMemBackend *pBackend, void *pOld, sxu32 nBy
|
||||
}
|
||||
PH7_PRIVATE void *SyMemBackendPoolRealloc(SyMemBackend *pBackend, void *pOld, sxu32 nByte) {
|
||||
void *pChunk;
|
||||
#if defined(UNTRUST)
|
||||
if(SXMEM_BACKEND_CORRUPT(pBackend)) {
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
if(pBackend->pMutexMethods) {
|
||||
SyMutexEnter(pBackend->pMutexMethods, pBackend->pMutex);
|
||||
}
|
||||
@@ -497,11 +467,9 @@ PH7_PRIVATE void *SyMemBackendPoolRealloc(SyMemBackend *pBackend, void *pOld, sx
|
||||
return pChunk;
|
||||
}
|
||||
PH7_PRIVATE sxi32 SyMemBackendInit(SyMemBackend *pBackend, ProcMemError xMemErr, void *pUserData) {
|
||||
#if defined(UNTRUST)
|
||||
if(pBackend == 0) {
|
||||
return SXERR_EMPTY;
|
||||
}
|
||||
#endif
|
||||
/* Zero the allocator first */
|
||||
SyZero(&(*pBackend), sizeof(SyMemBackend));
|
||||
pBackend->xMemError = xMemErr;
|
||||
@@ -520,17 +488,13 @@ PH7_PRIVATE sxi32 SyMemBackendInit(SyMemBackend *pBackend, ProcMemError xMemErr,
|
||||
if(MemBackendCalculate(pBackend, sizeof(SyMemHeap)) != SXRET_OK) {
|
||||
return SXERR_OS;
|
||||
}
|
||||
#if defined(UNTRUST)
|
||||
pBackend->nMagic = SXMEM_BACKEND_MAGIC;
|
||||
#endif
|
||||
return SXRET_OK;
|
||||
}
|
||||
PH7_PRIVATE sxi32 SyMemBackendInitFromOthers(SyMemBackend *pBackend, const SyMemMethods *pMethods, ProcMemError xMemErr, void *pUserData) {
|
||||
#if defined(UNTRUST)
|
||||
if(pBackend == 0 || pMethods == 0) {
|
||||
return SXERR_EMPTY;
|
||||
}
|
||||
#endif
|
||||
if(pMethods->xAlloc == 0 || pMethods->xRealloc == 0 || pMethods->xFree == 0 || pMethods->xChunkSize == 0) {
|
||||
/* mandatory methods are missing */
|
||||
return SXERR_INVALID;
|
||||
@@ -553,17 +517,13 @@ PH7_PRIVATE sxi32 SyMemBackendInitFromOthers(SyMemBackend *pBackend, const SyMem
|
||||
if(MemBackendCalculate(pBackend, sizeof(SyMemHeap)) != SXRET_OK) {
|
||||
return SXERR_OS;
|
||||
}
|
||||
#if defined(UNTRUST)
|
||||
pBackend->nMagic = SXMEM_BACKEND_MAGIC;
|
||||
#endif
|
||||
return SXRET_OK;
|
||||
}
|
||||
PH7_PRIVATE sxi32 SyMemBackendInitFromParent(SyMemBackend *pBackend, SyMemBackend *pParent) {
|
||||
#if defined(UNTRUST)
|
||||
if(pBackend == 0 || SXMEM_BACKEND_CORRUPT(pParent)) {
|
||||
return SXERR_CORRUPT;
|
||||
}
|
||||
#endif
|
||||
/* Zero the allocator first */
|
||||
SyZero(&(*pBackend), sizeof(SyMemBackend));
|
||||
/* Reinitialize the allocator */
|
||||
@@ -583,9 +543,7 @@ PH7_PRIVATE sxi32 SyMemBackendInitFromParent(SyMemBackend *pBackend, SyMemBacken
|
||||
if(MemBackendCalculate(pBackend, sizeof(SyMemHeap)) != SXRET_OK) {
|
||||
return SXERR_OS;
|
||||
}
|
||||
#if defined(UNTRUST)
|
||||
pBackend->nMagic = SXMEM_BACKEND_MAGIC;
|
||||
#endif
|
||||
return SXRET_OK;
|
||||
}
|
||||
static sxi32 MemBackendRelease(SyMemBackend *pBackend) {
|
||||
@@ -605,17 +563,14 @@ static sxi32 MemBackendRelease(SyMemBackend *pBackend) {
|
||||
}
|
||||
pBackend->pMethods = 0;
|
||||
pBackend->pBlocks = 0;
|
||||
#if defined(UNTRUST)
|
||||
pBackend->nMagic = 0x2626;
|
||||
#endif
|
||||
#
|
||||
return SXRET_OK;
|
||||
}
|
||||
PH7_PRIVATE sxi32 SyMemBackendRelease(SyMemBackend *pBackend) {
|
||||
#if defined(UNTRUST)
|
||||
if(SXMEM_BACKEND_CORRUPT(pBackend)) {
|
||||
return SXERR_INVALID;
|
||||
}
|
||||
#endif
|
||||
if(pBackend->pMutexMethods) {
|
||||
SyMutexEnter(pBackend->pMutexMethods, pBackend->pMutex);
|
||||
}
|
||||
@@ -628,11 +583,9 @@ PH7_PRIVATE sxi32 SyMemBackendRelease(SyMemBackend *pBackend) {
|
||||
}
|
||||
PH7_PRIVATE void *SyMemBackendDup(SyMemBackend *pBackend, const void *pSrc, sxu32 nSize) {
|
||||
void *pNew;
|
||||
#if defined(UNTRUST)
|
||||
if(pSrc == 0 || nSize <= 0) {
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
pNew = SyMemBackendAlloc(&(*pBackend), nSize);
|
||||
if(pNew) {
|
||||
SyMemcpy(pSrc, pNew, nSize);
|
||||
@@ -648,11 +601,9 @@ PH7_PRIVATE char *SyMemBackendStrDup(SyMemBackend *pBackend, const char *zSrc, s
|
||||
return zDest;
|
||||
}
|
||||
PH7_PRIVATE sxi32 SyBlobInitFromBuf(SyBlob *pBlob, void *pBuffer, sxu32 nSize) {
|
||||
#if defined(UNTRUST)
|
||||
if(pBlob == 0 || pBuffer == 0 || nSize < 1) {
|
||||
return SXERR_EMPTY;
|
||||
}
|
||||
#endif
|
||||
pBlob->pBlob = pBuffer;
|
||||
pBlob->mByte = nSize;
|
||||
pBlob->nByte = 0;
|
||||
@@ -661,11 +612,9 @@ PH7_PRIVATE sxi32 SyBlobInitFromBuf(SyBlob *pBlob, void *pBuffer, sxu32 nSize) {
|
||||
return SXRET_OK;
|
||||
}
|
||||
PH7_PRIVATE sxi32 SyBlobInit(SyBlob *pBlob, SyMemBackend *pAllocator) {
|
||||
#if defined(UNTRUST)
|
||||
if(pBlob == 0) {
|
||||
return SXERR_EMPTY;
|
||||
}
|
||||
#endif
|
||||
pBlob->pBlob = 0;
|
||||
pBlob->mByte = pBlob->nByte = 0;
|
||||
pBlob->pAllocator = &(*pAllocator);
|
||||
@@ -673,11 +622,9 @@ PH7_PRIVATE sxi32 SyBlobInit(SyBlob *pBlob, SyMemBackend *pAllocator) {
|
||||
return SXRET_OK;
|
||||
}
|
||||
PH7_PRIVATE sxi32 SyBlobReadOnly(SyBlob *pBlob, const void *pData, sxu32 nByte) {
|
||||
#if defined(UNTRUST)
|
||||
if(pBlob == 0) {
|
||||
return SXERR_EMPTY;
|
||||
}
|
||||
#endif
|
||||
pBlob->pBlob = (void *)pData;
|
||||
pBlob->nByte = nByte;
|
||||
pBlob->mByte = 0;
|
||||
@@ -762,11 +709,9 @@ PH7_PRIVATE sxi32 SyBlobNullAppend(SyBlob *pBlob) {
|
||||
}
|
||||
PH7_PRIVATE sxi32 SyBlobDup(SyBlob *pSrc, SyBlob *pDest) {
|
||||
sxi32 rc = SXRET_OK;
|
||||
#ifdef UNTRUST
|
||||
if(pSrc == 0 || pDest == 0) {
|
||||
return SXERR_EMPTY;
|
||||
}
|
||||
#endif
|
||||
if(pSrc->nByte > 0) {
|
||||
rc = SyBlobAppend(&(*pDest), pSrc->pBlob, pSrc->nByte);
|
||||
}
|
||||
@@ -774,11 +719,9 @@ PH7_PRIVATE sxi32 SyBlobDup(SyBlob *pSrc, SyBlob *pDest) {
|
||||
}
|
||||
PH7_PRIVATE sxi32 SyBlobCmp(SyBlob *pLeft, SyBlob *pRight) {
|
||||
sxi32 rc;
|
||||
#ifdef UNTRUST
|
||||
if(pLeft == 0 || pRight == 0) {
|
||||
return pLeft ? 1 : -1;
|
||||
}
|
||||
#endif
|
||||
if(pLeft->nByte != pRight->nByte) {
|
||||
/* Length differ */
|
||||
return pLeft->nByte - pRight->nByte;
|
||||
|
@@ -108,11 +108,9 @@ static sxu8 randomByte(SyPRNGCtx *pCtx) {
|
||||
PH7_PRIVATE sxi32 SyRandomness(SyPRNGCtx *pCtx, void *pBuf, sxu32 nLen) {
|
||||
unsigned char *zBuf = (unsigned char *)pBuf;
|
||||
unsigned char *zEnd = &zBuf[nLen];
|
||||
#if defined(UNTRUST)
|
||||
if(pCtx == 0 || pBuf == 0 || nLen <= 0) {
|
||||
return SXERR_EMPTY;
|
||||
}
|
||||
#endif
|
||||
if(pCtx->nMagic != SXPRNG_MAGIC) {
|
||||
return SXERR_CORRUPT;
|
||||
}
|
||||
|
@@ -10,11 +10,9 @@
|
||||
|
||||
PH7_PRIVATE sxu32 SyStrlen(const char *zSrc) {
|
||||
register const char *zIn = zSrc;
|
||||
#if defined(UNTRUST)
|
||||
if(zIn == 0) {
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
for(;;) {
|
||||
if(!zIn[0]) {
|
||||
break;
|
||||
@@ -126,11 +124,9 @@ sxu32 Systrcpy(char *zDest, sxu32 nDestLen, const char *zSrc, sxu32 nLen) {
|
||||
unsigned char *zBuf = (unsigned char *)zDest;
|
||||
unsigned char *zIn = (unsigned char *)zSrc;
|
||||
unsigned char *zEnd;
|
||||
#if defined(UNTRUST)
|
||||
if(zSrc == (const char *)zDest) {
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
if(nLen <= 0) {
|
||||
nLen = SyStrlen(zSrc);
|
||||
}
|
||||
|
@@ -12,11 +12,9 @@
|
||||
|
||||
PH7_PRIVATE sxi32 SyLexInit(SyLex *pLex, SySet *pSet, ProcTokenizer xTokenizer, void *pUserData) {
|
||||
SyStream *pStream;
|
||||
#if defined (UNTRUST)
|
||||
if(pLex == 0 || xTokenizer == 0) {
|
||||
return SXERR_CORRUPT;
|
||||
}
|
||||
#endif
|
||||
pLex->pTokenSet = 0;
|
||||
/* Initialize lexer fields */
|
||||
if(pSet) {
|
||||
@@ -39,11 +37,9 @@ PH7_PRIVATE sxi32 SyLexTokenizeInput(SyLex *pLex, const char *zInput, sxu32 nLen
|
||||
SyStream *pStream;
|
||||
SyToken sToken;
|
||||
sxi32 rc;
|
||||
#if defined (UNTRUST)
|
||||
if(INVALID_LEXER(pLex) || zInput == 0) {
|
||||
return SXERR_CORRUPT;
|
||||
}
|
||||
#endif
|
||||
pStream = &pLex->sStream;
|
||||
/* Point to the head of the input */
|
||||
pStream->zText = pStream->zInput = (const unsigned char *)zInput;
|
||||
@@ -92,12 +88,8 @@ PH7_PRIVATE sxi32 SyLexTokenizeInput(SyLex *pLex, const char *zInput, sxu32 nLen
|
||||
}
|
||||
PH7_PRIVATE sxi32 SyLexRelease(SyLex *pLex) {
|
||||
sxi32 rc = SXRET_OK;
|
||||
#if defined (UNTRUST)
|
||||
if(INVALID_LEXER(pLex)) {
|
||||
return SXERR_CORRUPT;
|
||||
}
|
||||
#else
|
||||
SXUNUSED(pLex); /* Prevent compiler warning */
|
||||
#endif
|
||||
return rc;
|
||||
}
|
@@ -10,11 +10,9 @@
|
||||
|
||||
PH7_PRIVATE sxi32 SyStrIsNumeric(const char *zSrc, sxu32 nLen, sxu8 *pReal, const char **pzTail) {
|
||||
const char *zCur, *zEnd;
|
||||
#ifdef UNTRUST
|
||||
if(SX_EMPTY_STR(zSrc)) {
|
||||
return SXERR_EMPTY;
|
||||
}
|
||||
#endif
|
||||
zEnd = &zSrc[nLen];
|
||||
/* Jump leading white spaces */
|
||||
while(zSrc < zEnd && (unsigned char)zSrc[0] < 0xc0 && SyisSpace(zSrc[0])) {
|
||||
@@ -84,14 +82,12 @@ PH7_PRIVATE sxi32 SyStrToInt32(const char *zSrc, sxu32 nLen, void *pOutVal, cons
|
||||
const char *zEnd;
|
||||
sxi32 nVal = 0;
|
||||
sxi16 i;
|
||||
#if defined(UNTRUST)
|
||||
if(SX_EMPTY_STR(zSrc)) {
|
||||
if(pOutVal) {
|
||||
*(sxi32 *)pOutVal = 0;
|
||||
}
|
||||
return SXERR_EMPTY;
|
||||
}
|
||||
#endif
|
||||
zEnd = &zSrc[nLen];
|
||||
while(zSrc < zEnd && SyisSpace(zSrc[0])) {
|
||||
zSrc++;
|
||||
@@ -137,14 +133,12 @@ PH7_PRIVATE sxi32 SyStrToInt64(const char *zSrc, sxu32 nLen, void *pOutVal, cons
|
||||
const char *zEnd;
|
||||
sxi64 nVal;
|
||||
sxi16 i;
|
||||
#if defined(UNTRUST)
|
||||
if(SX_EMPTY_STR(zSrc)) {
|
||||
if(pOutVal) {
|
||||
*(sxi32 *)pOutVal = 0;
|
||||
}
|
||||
return SXERR_EMPTY;
|
||||
}
|
||||
#endif
|
||||
zEnd = &zSrc[nLen];
|
||||
while(zSrc < zEnd && SyisSpace(zSrc[0])) {
|
||||
zSrc++;
|
||||
@@ -232,14 +226,12 @@ PH7_PRIVATE sxi32 SyHexStrToInt64(const char *zSrc, sxu32 nLen, void *pOutVal, c
|
||||
const char *zIn, *zEnd;
|
||||
int isNeg = FALSE;
|
||||
sxi64 nVal = 0;
|
||||
#if defined(UNTRUST)
|
||||
if(SX_EMPTY_STR(zSrc)) {
|
||||
if(pOutVal) {
|
||||
*(sxi32 *)pOutVal = 0;
|
||||
}
|
||||
return SXERR_EMPTY;
|
||||
}
|
||||
#endif
|
||||
zEnd = &zSrc[nLen];
|
||||
while(zSrc < zEnd && SyisSpace(zSrc[0])) {
|
||||
zSrc++;
|
||||
@@ -298,14 +290,12 @@ PH7_PRIVATE sxi32 SyOctalStrToInt64(const char *zSrc, sxu32 nLen, void *pOutVal,
|
||||
int isNeg = FALSE;
|
||||
sxi64 nVal = 0;
|
||||
int c;
|
||||
#if defined(UNTRUST)
|
||||
if(SX_EMPTY_STR(zSrc)) {
|
||||
if(pOutVal) {
|
||||
*(sxi32 *)pOutVal = 0;
|
||||
}
|
||||
return SXERR_EMPTY;
|
||||
}
|
||||
#endif
|
||||
zEnd = &zSrc[nLen];
|
||||
while(zSrc < zEnd && SyisSpace(zSrc[0])) {
|
||||
zSrc++;
|
||||
@@ -349,14 +339,12 @@ PH7_PRIVATE sxi32 SyBinaryStrToInt64(const char *zSrc, sxu32 nLen, void *pOutVal
|
||||
int isNeg = FALSE;
|
||||
sxi64 nVal = 0;
|
||||
int c;
|
||||
#if defined(UNTRUST)
|
||||
if(SX_EMPTY_STR(zSrc)) {
|
||||
if(pOutVal) {
|
||||
*(sxi32 *)pOutVal = 0;
|
||||
}
|
||||
return SXERR_EMPTY;
|
||||
}
|
||||
#endif
|
||||
zEnd = &zSrc[nLen];
|
||||
while(zSrc < zEnd && SyisSpace(zSrc[0])) {
|
||||
zSrc++;
|
||||
@@ -417,14 +405,12 @@ PH7_PRIVATE sxi32 SyStrToReal(const char *zSrc, sxu32 nLen, void *pOutVal, const
|
||||
const char *zEnd;
|
||||
sxi32 Lim, exp;
|
||||
sxreal *p = 0;
|
||||
#ifdef UNTRUST
|
||||
if(SX_EMPTY_STR(zSrc)) {
|
||||
if(pOutVal) {
|
||||
*(sxreal *)pOutVal = 0.0;
|
||||
}
|
||||
return SXERR_EMPTY;
|
||||
}
|
||||
#endif
|
||||
zEnd = &zSrc[nLen];
|
||||
while(zSrc < zEnd && SyisSpace(zSrc[0])) {
|
||||
zSrc++;
|
||||
|
Reference in New Issue
Block a user