Skip to content

A
abc
Commit 3cce04c6 by Alan Mishchenko
Options

Fixing some more warnings by adding cast from 'int' to 'size_t'.

parent f657d9a7
Showing with 73 additions and 73 deletions
src/misc/extra/extra.h
...@@ -249,9 +249,9 @@ static inline void Extra_ProgressBarUpdate( ProgressBar * p, int nItemsCur, char ...@@ -249,9 +249,9 @@ static inline void Extra_ProgressBarUpdate( ProgressBar * p, int nItemsCur, char
static inline int Extra_BitWordNum( int nBits ) { return nBits/(8*sizeof(unsigned)) + ((nBits%(8*sizeof(unsigned))) > 0); } static inline int Extra_BitWordNum( int nBits ) { return nBits/(8*sizeof(unsigned)) + ((nBits%(8*sizeof(unsigned))) > 0); }
static inline int Extra_TruthWordNum( int nVars ) { return nVars <= 5 ? 1 : (1 << (nVars - 5)); } static inline int Extra_TruthWordNum( int nVars ) { return nVars <= 5 ? 1 : (1 << (nVars - 5)); }
static inline void Extra_TruthSetBit( unsigned * p, int Bit ) { p[Bit>>5] |= (1<<(Bit & 31)); } static inline void Extra_TruthSetBit( unsigned * p, int Bit ) { p[Bit>>5] |= (unsigned)(1<<(Bit & 31)); }
static inline void Extra_TruthXorBit( unsigned * p, int Bit ) { p[Bit>>5] ^= (1<<(Bit & 31)); } static inline void Extra_TruthXorBit( unsigned * p, int Bit ) { p[Bit>>5] ^= (unsigned)(1<<(Bit & 31)); }
static inline int Extra_TruthHasBit( unsigned * p, int Bit ) { return (p[Bit>>5] & (1<<(Bit & 31))) > 0; } static inline int Extra_TruthHasBit( unsigned * p, int Bit ) { return (p[Bit>>5] & (unsigned)(1<<(Bit & 31))) > 0; }
static inline int Extra_WordCountOnes( unsigned uWord ) static inline int Extra_WordCountOnes( unsigned uWord )
{ {
......
src/misc/util/abc_global.h
...@@ -280,17 +280,17 @@ static inline int Abc_Float2Int( float Val ) { union { int x; f ...@@ -280,17 +280,17 @@ static inline int Abc_Float2Int( float Val ) { union { int x; f
static inline float Abc_Int2Float( int Num ) { union { int x; float y; } v; v.x = Num; return v.y; } static inline float Abc_Int2Float( int Num ) { union { int x; float y; } v; v.x = Num; return v.y; }
static inline word Abc_Dbl2Word( double Dbl ) { union { word x; double y; } v; v.y = Dbl; return v.x; } static inline word Abc_Dbl2Word( double Dbl ) { union { word x; double y; } v; v.y = Dbl; return v.x; }
static inline double Abc_Word2Dbl( word Num ) { union { word x; double y; } v; v.x = Num; return v.y; } static inline double Abc_Word2Dbl( word Num ) { union { word x; double y; } v; v.x = Num; return v.y; }
static inline int Abc_Base2Log( unsigned n ) { int r; if ( n < 2 ) return n; for ( r = 0, n--; n; n >>= 1, r++ ) {}; return r; } static inline int Abc_Base2Log( unsigned n ) { int r; if ( n < 2 ) return (int)n; for ( r = 0, n--; n; n >>= 1, r++ ) {}; return r; }
static inline int Abc_Base10Log( unsigned n ) { int r; if ( n < 2 ) return n; for ( r = 0, n--; n; n /= 10, r++ ) {}; return r; } static inline int Abc_Base10Log( unsigned n ) { int r; if ( n < 2 ) return (int)n; for ( r = 0, n--; n; n /= 10, r++ ) {}; return r; }
static inline int Abc_Base16Log( unsigned n ) { int r; if ( n < 2 ) return n; for ( r = 0, n--; n; n /= 16, r++ ) {}; return r; } static inline int Abc_Base16Log( unsigned n ) { int r; if ( n < 2 ) return (int)n; for ( r = 0, n--; n; n /= 16, r++ ) {}; return r; }
static inline char * Abc_UtilStrsav( char * s ) { return s ? strcpy(ABC_ALLOC(char, strlen(s)+1), s) : NULL; } static inline char * Abc_UtilStrsav( char * s ) { return s ? strcpy(ABC_ALLOC(char, strlen(s)+1), s) : NULL; }
static inline int Abc_BitWordNum( int nBits ) { return (nBits>>5) + ((nBits&31) > 0); } static inline int Abc_BitWordNum( int nBits ) { return (nBits>>5) + ((nBits&31) > 0); }
static inline int Abc_Bit6WordNum( int nBits ) { return (nBits>>6) + ((nBits&63) > 0); } static inline int Abc_Bit6WordNum( int nBits ) { return (nBits>>6) + ((nBits&63) > 0); }
static inline int Abc_TruthWordNum( int nVars ) { return nVars <= 5 ? 1 : (1 << (nVars - 5)); } static inline int Abc_TruthWordNum( int nVars ) { return nVars <= 5 ? 1 : (1 << (nVars - 5)); }
static inline int Abc_Truth6WordNum( int nVars ) { return nVars <= 6 ? 1 : (1 << (nVars - 6)); } static inline int Abc_Truth6WordNum( int nVars ) { return nVars <= 6 ? 1 : (1 << (nVars - 6)); }
static inline int Abc_InfoHasBit( unsigned * p, int i ) { return (p[(i)>>5] & (1<<((i) & 31))) > 0; } static inline int Abc_InfoHasBit( unsigned * p, int i ) { return (p[(i)>>5] & (unsigned)(1<<((i) & 31))) > 0; }
static inline void Abc_InfoSetBit( unsigned * p, int i ) { p[(i)>>5] |= (1<<((i) & 31)); } static inline void Abc_InfoSetBit( unsigned * p, int i ) { p[(i)>>5] |= (unsigned)(1<<((i) & 31)); }
static inline void Abc_InfoXorBit( unsigned * p, int i ) { p[(i)>>5] ^= (1<<((i) & 31)); } static inline void Abc_InfoXorBit( unsigned * p, int i ) { p[(i)>>5] ^= (unsigned)(1<<((i) & 31)); }
static inline unsigned Abc_InfoMask( int nVar ) { return (~(unsigned)0) >> (32-nVar); } static inline unsigned Abc_InfoMask( int nVar ) { return (~(unsigned)0) >> (32-nVar); }
static inline int Abc_Var2Lit( int Var, int c ) { assert(Var >= 0 && !(c >> 1)); return Var + Var + c; } static inline int Abc_Var2Lit( int Var, int c ) { assert(Var >= 0 && !(c >> 1)); return Var + Var + c; }
...@@ -438,7 +438,7 @@ static inline int Abc_PrimeCudd( unsigned int p ) ...@@ -438,7 +438,7 @@ static inline int Abc_PrimeCudd( unsigned int p )
i = 3; i = 3;
while ((unsigned) (i * i) <= p) while ((unsigned) (i * i) <= p)
{ {
if (p % i == 0) { if (p % (unsigned)i == 0) {
pn = 0; pn = 0;
break; break;
} }
...@@ -448,7 +448,7 @@ static inline int Abc_PrimeCudd( unsigned int p ) ...@@ -448,7 +448,7 @@ static inline int Abc_PrimeCudd( unsigned int p )
else else
pn = 0; pn = 0;
} while (!pn); } while (!pn);
return(p); return (int)(p);
} // end of Cudd_Prime } // end of Cudd_Prime
......
src/misc/util/utilTruth.h
...@@ -146,24 +146,24 @@ static inline int Abc_TtBitCount16( int i ) { return Abc_TtBitCount8[i & 0xFF] + ...@@ -146,24 +146,24 @@ static inline int Abc_TtBitCount16( int i ) { return Abc_TtBitCount8[i & 0xFF] +
***********************************************************************/ ***********************************************************************/
// read/write/flip i-th bit of a bit string table: // read/write/flip i-th bit of a bit string table:
static inline int Abc_TtGetBit( word * p, int i ) { return (int)(p[i>>6] >> (i & 63)) & 1; } static inline int Abc_TtGetBit( word * p, int i ) { return (int)(p[i>>6] >> (word)(i & 63)) & 1; }
static inline void Abc_TtSetBit( word * p, int i ) { p[i>>6] |= (((word)1)<<(i & 63)); } static inline void Abc_TtSetBit( word * p, int i ) { p[i>>6] |= (word)(((word)1)<<(i & 63)); }
static inline void Abc_TtXorBit( word * p, int i ) { p[i>>6] ^= (((word)1)<<(i & 63)); } static inline void Abc_TtXorBit( word * p, int i ) { p[i>>6] ^= (word)(((word)1)<<(i & 63)); }
// read/write k-th digit d of a quaternary number: // read/write k-th digit d of a quaternary number:
static inline int Abc_TtGetQua( word * p, int k ) { return (int)(p[k>>5] >> ((k<<1) & 63)) & 3; } static inline int Abc_TtGetQua( word * p, int k ) { return (int)(p[k>>5] >> (word)((k<<1) & 63)) & 3; }
static inline void Abc_TtSetQua( word * p, int k, int d ) { p[k>>5] |= (((word)d)<<((k<<1) & 63)); } static inline void Abc_TtSetQua( word * p, int k, int d ) { p[k>>5] |= (word)(((word)d)<<((k<<1) & 63)); }
static inline void Abc_TtXorQua( word * p, int k, int d ) { p[k>>5] ^= (((word)d)<<((k<<1) & 63)); } static inline void Abc_TtXorQua( word * p, int k, int d ) { p[k>>5] ^= (word)(((word)d)<<((k<<1) & 63)); }
// read/write k-th digit d of a hexadecimal number: // read/write k-th digit d of a hexadecimal number:
static inline int Abc_TtGetHex( word * p, int k ) { return (int)(p[k>>4] >> ((k<<2) & 63)) & 15; } static inline int Abc_TtGetHex( word * p, int k ) { return (int)(p[k>>4] >> (word)((k<<2) & 63)) & 15; }
static inline void Abc_TtSetHex( word * p, int k, int d ) { p[k>>4] |= (((word)d)<<((k<<2) & 63)); } static inline void Abc_TtSetHex( word * p, int k, int d ) { p[k>>4] |= (word)(((word)d)<<((k<<2) & 63)); }
static inline void Abc_TtXorHex( word * p, int k, int d ) { p[k>>4] ^= (((word)d)<<((k<<2) & 63)); } static inline void Abc_TtXorHex( word * p, int k, int d ) { p[k>>4] ^= (word)(((word)d)<<((k<<2) & 63)); }
// read/write k-th digit d of a 256-base number: // read/write k-th digit d of a 256-base number:
static inline int Abc_TtGet256( word * p, int k ) { return (int)(p[k>>3] >> ((k<<3) & 63)) & 255; } static inline int Abc_TtGet256( word * p, int k ) { return (int)(p[k>>3] >> (word)((k<<3) & 63)) & 255; }
static inline void Abc_TtSet256( word * p, int k, int d ) { p[k>>3] |= (((word)d)<<((k<<3) & 63)); } static inline void Abc_TtSet256( word * p, int k, int d ) { p[k>>3] |= (word)(((word)d)<<((k<<3) & 63)); }
static inline void Abc_TtXor256( word * p, int k, int d ) { p[k>>3] ^= (((word)d)<<((k<<3) & 63)); } static inline void Abc_TtXor256( word * p, int k, int d ) { p[k>>3] ^= (word)(((word)d)<<((k<<3) & 63)); }
/**Function************************************************************* /**Function*************************************************************
......
src/misc/vec/vecAtt.h
...@@ -108,7 +108,7 @@ static inline Vec_Att_t * Vec_AttAlloc( ...@@ -108,7 +108,7 @@ static inline Vec_Att_t * Vec_AttAlloc(
p->pFuncFreeObj = pFuncFreeObj; p->pFuncFreeObj = pFuncFreeObj;
p->nCap = nSize? nSize : 16; p->nCap = nSize? nSize : 16;
p->pArrayPtr = ABC_ALLOC( void *, p->nCap ); p->pArrayPtr = ABC_ALLOC( void *, p->nCap );
memset( p->pArrayPtr, 0, sizeof(void *) * p->nCap ); memset( p->pArrayPtr, 0, sizeof(void *) * (size_t)p->nCap );
return p; return p;
} }
...@@ -167,7 +167,7 @@ static inline void Vec_AttClear( Vec_Att_t * p ) ...@@ -167,7 +167,7 @@ static inline void Vec_AttClear( Vec_Att_t * p )
if ( p->pArrayPtr[i] ) if ( p->pArrayPtr[i] )
p->pFuncFreeObj( p->pMan, p->pArrayPtr[i] ); p->pFuncFreeObj( p->pMan, p->pArrayPtr[i] );
} }
memset( p->pArrayPtr, 0, sizeof(void *) * p->nCap ); memset( p->pArrayPtr, 0, sizeof(void *) * (size_t)p->nCap );
} }
/**Function************************************************************* /**Function*************************************************************
...@@ -209,7 +209,7 @@ static inline void Vec_AttGrow( Vec_Att_t * p, int nCapMin ) ...@@ -209,7 +209,7 @@ static inline void Vec_AttGrow( Vec_Att_t * p, int nCapMin )
if ( p->nCap >= nCapMin ) if ( p->nCap >= nCapMin )
return; return;
p->pArrayPtr = ABC_REALLOC( void *, p->pArrayPtr, nCapMin ); p->pArrayPtr = ABC_REALLOC( void *, p->pArrayPtr, nCapMin );
memset( p->pArrayPtr + p->nCap, 0, sizeof(void *) * (nCapMin - p->nCap) ); memset( p->pArrayPtr + p->nCap, 0, sizeof(void *) * (size_t)(nCapMin - p->nCap) );
p->nCap = nCapMin; p->nCap = nCapMin;
} }
......
src/misc/vec/vecBit.h
...@@ -105,7 +105,7 @@ static inline Vec_Bit_t * Vec_BitStart( int nSize ) ...@@ -105,7 +105,7 @@ static inline Vec_Bit_t * Vec_BitStart( int nSize )
nSize = (nSize >> 5) + ((nSize & 31) > 0); nSize = (nSize >> 5) + ((nSize & 31) > 0);
p = Vec_BitAlloc( nSize * 32 ); p = Vec_BitAlloc( nSize * 32 );
p->nSize = nSize * 32; p->nSize = nSize * 32;
memset( p->pArray, 0, sizeof(int) * nSize ); memset( p->pArray, 0, sizeof(int) * (size_t)nSize );
return p; return p;
} }
...@@ -126,7 +126,7 @@ static inline Vec_Bit_t * Vec_BitStartFull( int nSize ) ...@@ -126,7 +126,7 @@ static inline Vec_Bit_t * Vec_BitStartFull( int nSize )
nSize = (nSize >> 5) + ((nSize & 31) > 0); nSize = (nSize >> 5) + ((nSize & 31) > 0);
p = Vec_BitAlloc( nSize * 32 ); p = Vec_BitAlloc( nSize * 32 );
p->nSize = nSize * 32; p->nSize = nSize * 32;
memset( p->pArray, 0xff, sizeof(int) * nSize ); memset( p->pArray, 0xff, sizeof(int) * (size_t)nSize );
return p; return p;
} }
...@@ -149,7 +149,7 @@ static inline Vec_Bit_t * Vec_BitDup( Vec_Bit_t * pVec ) ...@@ -149,7 +149,7 @@ static inline Vec_Bit_t * Vec_BitDup( Vec_Bit_t * pVec )
p->nSize = pVec->nSize; p->nSize = pVec->nSize;
p->nCap = pVec->nSize; p->nCap = pVec->nSize;
p->pArray = p->nCap? ABC_ALLOC( int, p->nCap >> 5 ) : NULL; p->pArray = p->nCap? ABC_ALLOC( int, p->nCap >> 5 ) : NULL;
memcpy( p->pArray, pVec->pArray, sizeof(int) * (p->nCap >> 5) ); memcpy( p->pArray, pVec->pArray, sizeof(int) * (size_t)(p->nCap >> 5) );
return p; return p;
} }
......
src/misc/vec/vecFlt.h
...@@ -113,7 +113,7 @@ static inline Vec_Flt_t * Vec_FltStart( int nSize ) ...@@ -113,7 +113,7 @@ static inline Vec_Flt_t * Vec_FltStart( int nSize )
Vec_Flt_t * p; Vec_Flt_t * p;
p = Vec_FltAlloc( nSize ); p = Vec_FltAlloc( nSize );
p->nSize = nSize; p->nSize = nSize;
memset( p->pArray, 0, sizeof(float) * nSize ); memset( p->pArray, 0, sizeof(float) * (size_t)nSize );
return p; return p;
} }
static inline Vec_Flt_t * Vec_FltStartFull( int nSize ) static inline Vec_Flt_t * Vec_FltStartFull( int nSize )
...@@ -121,7 +121,7 @@ static inline Vec_Flt_t * Vec_FltStartFull( int nSize ) ...@@ -121,7 +121,7 @@ static inline Vec_Flt_t * Vec_FltStartFull( int nSize )
Vec_Flt_t * p; Vec_Flt_t * p;
p = Vec_FltAlloc( nSize ); p = Vec_FltAlloc( nSize );
p->nSize = nSize; p->nSize = nSize;
memset( p->pArray, 0xFF, sizeof(float) * nSize ); memset( p->pArray, 0xFF, sizeof(float) * (size_t)nSize );
return p; return p;
} }
...@@ -164,7 +164,7 @@ static inline Vec_Flt_t * Vec_FltAllocArrayCopy( float * pArray, int nSize ) ...@@ -164,7 +164,7 @@ static inline Vec_Flt_t * Vec_FltAllocArrayCopy( float * pArray, int nSize )
p->nSize = nSize; p->nSize = nSize;
p->nCap = nSize; p->nCap = nSize;
p->pArray = ABC_ALLOC( float, nSize ); p->pArray = ABC_ALLOC( float, nSize );
memcpy( p->pArray, pArray, sizeof(float) * nSize ); memcpy( p->pArray, pArray, sizeof(float) * (size_t)nSize );
return p; return p;
} }
...@@ -186,7 +186,7 @@ static inline Vec_Flt_t * Vec_FltDup( Vec_Flt_t * pVec ) ...@@ -186,7 +186,7 @@ static inline Vec_Flt_t * Vec_FltDup( Vec_Flt_t * pVec )
p->nSize = pVec->nSize; p->nSize = pVec->nSize;
p->nCap = pVec->nCap; p->nCap = pVec->nCap;
p->pArray = p->nCap? ABC_ALLOC( float, p->nCap ) : NULL; p->pArray = p->nCap? ABC_ALLOC( float, p->nCap ) : NULL;
memcpy( p->pArray, pVec->pArray, sizeof(float) * pVec->nSize ); memcpy( p->pArray, pVec->pArray, sizeof(float) * (size_t)pVec->nSize );
return p; return p;
} }
...@@ -347,7 +347,7 @@ static inline int Vec_FltCap( Vec_Flt_t * p ) ...@@ -347,7 +347,7 @@ static inline int Vec_FltCap( Vec_Flt_t * p )
***********************************************************************/ ***********************************************************************/
static inline double Vec_FltMemory( Vec_Flt_t * p ) static inline double Vec_FltMemory( Vec_Flt_t * p )
{ {
return !p ? 0.0 : 1.0 * sizeof(float) * p->nCap + sizeof(Vec_Flt_t); return !p ? 0.0 : 1.0 * sizeof(float) * (size_t)p->nCap + sizeof(Vec_Flt_t);
} }
/**Function************************************************************* /**Function*************************************************************
......
src/misc/vec/vecHsh.h
...@@ -307,7 +307,7 @@ static inline int * Hsh_IntManLookup( Hsh_IntMan_t * p, unsigned * pData ) ...@@ -307,7 +307,7 @@ static inline int * Hsh_IntManLookup( Hsh_IntMan_t * p, unsigned * pData )
Hsh_IntObj_t * pObj; Hsh_IntObj_t * pObj;
int * pPlace = Vec_IntEntryP( p->vTable, Hsh_IntManHash(pData, p->nSize, Vec_IntSize(p->vTable)) ); int * pPlace = Vec_IntEntryP( p->vTable, Hsh_IntManHash(pData, p->nSize, Vec_IntSize(p->vTable)) );
for ( ; (pObj = Hsh_IntObj(p, *pPlace)); pPlace = &pObj->iNext ) for ( ; (pObj = Hsh_IntObj(p, *pPlace)); pPlace = &pObj->iNext )
if ( !memcmp( pData, Hsh_IntData(p, pObj->iData), sizeof(int) * p->nSize ) ) if ( !memcmp( pData, Hsh_IntData(p, pObj->iData), sizeof(int) * (size_t)p->nSize ) )
return pPlace; return pPlace;
assert( *pPlace == -1 ); assert( *pPlace == -1 );
return pPlace; return pPlace;
...@@ -377,7 +377,7 @@ static inline Hsh_IntMan_t * Hsh_WrdManHashArrayStart( Vec_Wrd_t * vDataW, int n ...@@ -377,7 +377,7 @@ static inline Hsh_IntMan_t * Hsh_WrdManHashArrayStart( Vec_Wrd_t * vDataW, int n
Hsh_IntMan_t * p; Hsh_IntMan_t * p;
int i, nEntries = Vec_WrdSize(vDataW) / nSize; int i, nEntries = Vec_WrdSize(vDataW) / nSize;
Vec_Int_t * vData = Vec_IntAlloc( 2*Vec_WrdSize(vDataW) ); Vec_Int_t * vData = Vec_IntAlloc( 2*Vec_WrdSize(vDataW) );
memcpy( Vec_IntArray(vData), Vec_WrdArray(vDataW), sizeof(word)*Vec_WrdSize(vDataW) ); memcpy( Vec_IntArray(vData), Vec_WrdArray(vDataW), sizeof(word)*(size_t)Vec_WrdSize(vDataW) );
vData->nSize = 2*Vec_WrdSize(vDataW); vData->nSize = 2*Vec_WrdSize(vDataW);
/* /*
for ( i = 0; i < 30; i++ ) for ( i = 0; i < 30; i++ )
...@@ -528,7 +528,7 @@ static inline int Hsh_VecManAdd( Hsh_VecMan_t * p, Vec_Int_t * vVec ) ...@@ -528,7 +528,7 @@ static inline int Hsh_VecManAdd( Hsh_VecMan_t * p, Vec_Int_t * vVec )
} }
pPlace = Vec_IntEntryP( p->vTable, Hsh_VecManHash(vVec, Vec_IntSize(p->vTable)) ); pPlace = Vec_IntEntryP( p->vTable, Hsh_VecManHash(vVec, Vec_IntSize(p->vTable)) );
for ( ; (pObj = Hsh_VecObj(p, *pPlace)); pPlace = &pObj->iNext ) for ( ; (pObj = Hsh_VecObj(p, *pPlace)); pPlace = &pObj->iNext )
if ( pObj->nSize == Vec_IntSize(vVec) && !memcmp( pObj->pArray, Vec_IntArray(vVec), sizeof(int) * pObj->nSize ) ) if ( pObj->nSize == Vec_IntSize(vVec) && !memcmp( pObj->pArray, Vec_IntArray(vVec), sizeof(int) * (size_t)pObj->nSize ) )
return *pPlace; return *pPlace;
*pPlace = Vec_IntSize(p->vMap); *pPlace = Vec_IntSize(p->vMap);
assert( Vec_IntSize(p->vData) % 2 == 0 ); assert( Vec_IntSize(p->vData) % 2 == 0 );
......
src/misc/vec/vecInt.h
...@@ -127,7 +127,7 @@ static inline Vec_Int_t * Vec_IntStart( int nSize ) ...@@ -127,7 +127,7 @@ static inline Vec_Int_t * Vec_IntStart( int nSize )
Vec_Int_t * p; Vec_Int_t * p;
p = Vec_IntAlloc( nSize ); p = Vec_IntAlloc( nSize );
p->nSize = nSize; p->nSize = nSize;
if ( p->pArray ) memset( p->pArray, 0, sizeof(int) * nSize ); if ( p->pArray ) memset( p->pArray, 0, sizeof(int) * (size_t)nSize );
return p; return p;
} }
static inline Vec_Int_t * Vec_IntStartFull( int nSize ) static inline Vec_Int_t * Vec_IntStartFull( int nSize )
...@@ -135,7 +135,7 @@ static inline Vec_Int_t * Vec_IntStartFull( int nSize ) ...@@ -135,7 +135,7 @@ static inline Vec_Int_t * Vec_IntStartFull( int nSize )
Vec_Int_t * p; Vec_Int_t * p;
p = Vec_IntAlloc( nSize ); p = Vec_IntAlloc( nSize );
p->nSize = nSize; p->nSize = nSize;
if ( p->pArray ) memset( p->pArray, 0xff, sizeof(int) * nSize ); if ( p->pArray ) memset( p->pArray, 0xff, sizeof(int) * (size_t)nSize );
return p; return p;
} }
static inline Vec_Int_t * Vec_IntStartRange( int First, int Range ) static inline Vec_Int_t * Vec_IntStartRange( int First, int Range )
...@@ -210,7 +210,7 @@ static inline Vec_Int_t * Vec_IntAllocArrayCopy( int * pArray, int nSize ) ...@@ -210,7 +210,7 @@ static inline Vec_Int_t * Vec_IntAllocArrayCopy( int * pArray, int nSize )
p->nSize = nSize; p->nSize = nSize;
p->nCap = nSize; p->nCap = nSize;
p->pArray = ABC_ALLOC( int, nSize ); p->pArray = ABC_ALLOC( int, nSize );
memcpy( p->pArray, pArray, sizeof(int) * nSize ); memcpy( p->pArray, pArray, sizeof(int) * (size_t)nSize );
return p; return p;
} }
...@@ -232,7 +232,7 @@ static inline Vec_Int_t * Vec_IntDup( Vec_Int_t * pVec ) ...@@ -232,7 +232,7 @@ static inline Vec_Int_t * Vec_IntDup( Vec_Int_t * pVec )
p->nSize = pVec->nSize; p->nSize = pVec->nSize;
p->nCap = pVec->nSize; p->nCap = pVec->nSize;
p->pArray = p->nCap? ABC_ALLOC( int, p->nCap ) : NULL; p->pArray = p->nCap? ABC_ALLOC( int, p->nCap ) : NULL;
memcpy( p->pArray, pVec->pArray, sizeof(int) * pVec->nSize ); memcpy( p->pArray, pVec->pArray, sizeof(int) * (size_t)pVec->nSize );
return p; return p;
} }
...@@ -331,7 +331,7 @@ static inline int * Vec_IntReleaseNewArray( Vec_Int_t * p ) ...@@ -331,7 +331,7 @@ static inline int * Vec_IntReleaseNewArray( Vec_Int_t * p )
{ {
int * pArray = ABC_ALLOC( int, p->nSize+1 ); int * pArray = ABC_ALLOC( int, p->nSize+1 );
pArray[0] = p->nSize+1; pArray[0] = p->nSize+1;
memcpy( pArray+1, p->pArray, sizeof(int)*p->nSize ); memcpy( pArray+1, p->pArray, sizeof(int)*(size_t)p->nSize );
return pArray; return pArray;
} }
...@@ -404,7 +404,7 @@ static inline int Vec_IntCap( Vec_Int_t * p ) ...@@ -404,7 +404,7 @@ static inline int Vec_IntCap( Vec_Int_t * p )
***********************************************************************/ ***********************************************************************/
static inline double Vec_IntMemory( Vec_Int_t * p ) static inline double Vec_IntMemory( Vec_Int_t * p )
{ {
return !p ? 0.0 : 1.0 * sizeof(int) * p->nCap + sizeof(Vec_Int_t) ; return !p ? 0.0 : 1.0 * sizeof(int) * (size_t)p->nCap + sizeof(Vec_Int_t) ;
} }
/**Function************************************************************* /**Function*************************************************************
...@@ -1558,7 +1558,7 @@ static inline int * Vec_IntUniqueLookup( Vec_Int_t * vData, int i, int nIntSize, ...@@ -1558,7 +1558,7 @@ static inline int * Vec_IntUniqueLookup( Vec_Int_t * vData, int i, int nIntSize,
{ {
int * pData = Vec_IntEntryP( vData, i*nIntSize ); int * pData = Vec_IntEntryP( vData, i*nIntSize );
for ( ; *pStart != -1; pStart = pNexts + *pStart ) for ( ; *pStart != -1; pStart = pNexts + *pStart )
if ( !memcmp( pData, Vec_IntEntryP(vData, *pStart*nIntSize), sizeof(int) * nIntSize ) ) if ( !memcmp( pData, Vec_IntEntryP(vData, *pStart*nIntSize), sizeof(int) * (size_t)nIntSize ) )
return pStart; return pStart;
return pStart; return pStart;
} }
...@@ -2018,7 +2018,7 @@ static inline int Vec_IntCompareVec( Vec_Int_t * p1, Vec_Int_t * p2 ) ...@@ -2018,7 +2018,7 @@ static inline int Vec_IntCompareVec( Vec_Int_t * p1, Vec_Int_t * p2 )
return (p1 != NULL) - (p2 != NULL); return (p1 != NULL) - (p2 != NULL);
if ( Vec_IntSize(p1) != Vec_IntSize(p2) ) if ( Vec_IntSize(p1) != Vec_IntSize(p2) )
return Vec_IntSize(p1) - Vec_IntSize(p2); return Vec_IntSize(p1) - Vec_IntSize(p2);
return memcmp( Vec_IntArray(p1), Vec_IntArray(p2), sizeof(int)*Vec_IntSize(p1) ); return memcmp( Vec_IntArray(p1), Vec_IntArray(p2), sizeof(int)*(size_t)Vec_IntSize(p1) );
} }
/**Function************************************************************* /**Function*************************************************************
......
src/misc/vec/vecMem.h
...@@ -236,12 +236,12 @@ static inline word * Vec_MemGetEntry( Vec_Mem_t * p, int i ) ...@@ -236,12 +236,12 @@ static inline word * Vec_MemGetEntry( Vec_Mem_t * p, int i )
static inline void Vec_MemSetEntry( Vec_Mem_t * p, int i, word * pEntry ) static inline void Vec_MemSetEntry( Vec_Mem_t * p, int i, word * pEntry )
{ {
word * pPlace = Vec_MemGetEntry( p, i ); word * pPlace = Vec_MemGetEntry( p, i );
memmove( pPlace, pEntry, sizeof(word) * p->nEntrySize ); memmove( pPlace, pEntry, sizeof(word) * (size_t)p->nEntrySize );
} }
static inline void Vec_MemPush( Vec_Mem_t * p, word * pEntry ) static inline void Vec_MemPush( Vec_Mem_t * p, word * pEntry )
{ {
word * pPlace = Vec_MemGetEntry( p, p->nEntries ); word * pPlace = Vec_MemGetEntry( p, p->nEntries );
memmove( pPlace, pEntry, sizeof(word) * p->nEntrySize ); memmove( pPlace, pEntry, sizeof(word) * (size_t)p->nEntrySize );
} }
/**Function************************************************************* /**Function*************************************************************
......
src/misc/vec/vecPtr.h
...@@ -120,7 +120,7 @@ static inline Vec_Ptr_t * Vec_PtrStart( int nSize ) ...@@ -120,7 +120,7 @@ static inline Vec_Ptr_t * Vec_PtrStart( int nSize )
Vec_Ptr_t * p; Vec_Ptr_t * p;
p = Vec_PtrAlloc( nSize ); p = Vec_PtrAlloc( nSize );
p->nSize = nSize; p->nSize = nSize;
memset( p->pArray, 0, sizeof(void *) * nSize ); memset( p->pArray, 0, sizeof(void *) * (size_t)nSize );
return p; return p;
} }
...@@ -163,7 +163,7 @@ static inline Vec_Ptr_t * Vec_PtrAllocArrayCopy( void ** pArray, int nSize ) ...@@ -163,7 +163,7 @@ static inline Vec_Ptr_t * Vec_PtrAllocArrayCopy( void ** pArray, int nSize )
p->nSize = nSize; p->nSize = nSize;
p->nCap = nSize; p->nCap = nSize;
p->pArray = ABC_ALLOC( void *, nSize ); p->pArray = ABC_ALLOC( void *, nSize );
memcpy( p->pArray, pArray, sizeof(void *) * nSize ); memcpy( p->pArray, pArray, sizeof(void *) * (size_t)nSize );
return p; return p;
} }
...@@ -185,7 +185,7 @@ static inline Vec_Ptr_t * Vec_PtrDup( Vec_Ptr_t * pVec ) ...@@ -185,7 +185,7 @@ static inline Vec_Ptr_t * Vec_PtrDup( Vec_Ptr_t * pVec )
p->nSize = pVec->nSize; p->nSize = pVec->nSize;
p->nCap = pVec->nCap; p->nCap = pVec->nCap;
p->pArray = p->nCap? ABC_ALLOC( void *, p->nCap ) : NULL; p->pArray = p->nCap? ABC_ALLOC( void *, p->nCap ) : NULL;
memcpy( p->pArray, pVec->pArray, sizeof(void *) * pVec->nSize ); memcpy( p->pArray, pVec->pArray, sizeof(void *) * (size_t)pVec->nSize );
return p; return p;
} }
static inline Vec_Ptr_t * Vec_PtrDupStr( Vec_Ptr_t * pVec ) static inline Vec_Ptr_t * Vec_PtrDupStr( Vec_Ptr_t * pVec )
...@@ -350,7 +350,7 @@ static inline int Vec_PtrCap( Vec_Ptr_t * p ) ...@@ -350,7 +350,7 @@ static inline int Vec_PtrCap( Vec_Ptr_t * p )
***********************************************************************/ ***********************************************************************/
static inline double Vec_PtrMemory( Vec_Ptr_t * p ) static inline double Vec_PtrMemory( Vec_Ptr_t * p )
{ {
return !p ? 0.0 : 1.0 * sizeof(void *) * p->nCap + sizeof(Vec_Ptr_t); return !p ? 0.0 : 1.0 * sizeof(void *) * (size_t)p->nCap + sizeof(Vec_Ptr_t);
} }
/**Function************************************************************* /**Function*************************************************************
...@@ -620,7 +620,7 @@ static inline void Vec_PtrCopy( Vec_Ptr_t * pDest, Vec_Ptr_t * pSour ) ...@@ -620,7 +620,7 @@ static inline void Vec_PtrCopy( Vec_Ptr_t * pDest, Vec_Ptr_t * pSour )
{ {
pDest->nSize = 0; pDest->nSize = 0;
Vec_PtrGrow( pDest, pSour->nSize ); Vec_PtrGrow( pDest, pSour->nSize );
memcpy( pDest->pArray, pSour->pArray, sizeof(void *) * pSour->nSize ); memcpy( pDest->pArray, pSour->pArray, sizeof(void *) * (size_t)pSour->nSize );
pDest->nSize = pSour->nSize; pDest->nSize = pSour->nSize;
} }
...@@ -824,8 +824,8 @@ static inline void Vec_PtrReorder( Vec_Ptr_t * p, int nItems ) ...@@ -824,8 +824,8 @@ static inline void Vec_PtrReorder( Vec_Ptr_t * p, int nItems )
{ {
assert( nItems < p->nSize ); assert( nItems < p->nSize );
Vec_PtrGrow( p, nItems + p->nSize ); Vec_PtrGrow( p, nItems + p->nSize );
memmove( (char **)p->pArray + p->nSize, p->pArray, nItems * sizeof(void*) ); memmove( (char **)p->pArray + p->nSize, p->pArray, (size_t)nItems * sizeof(void*) );
memmove( p->pArray, (char **)p->pArray + nItems, p->nSize * sizeof(void*) ); memmove( p->pArray, (char **)p->pArray + nItems, (size_t)p->nSize * sizeof(void*) );
} }
/**Function************************************************************* /**Function*************************************************************
...@@ -988,7 +988,7 @@ static inline Vec_Ptr_t * Vec_PtrAllocSimInfo( int nEntries, int nWords ) ...@@ -988,7 +988,7 @@ static inline Vec_Ptr_t * Vec_PtrAllocSimInfo( int nEntries, int nWords )
void ** pMemory; void ** pMemory;
unsigned * pInfo; unsigned * pInfo;
int i; int i;
pMemory = (void **)ABC_ALLOC( char, (sizeof(void *) + sizeof(unsigned) * nWords) * nEntries ); pMemory = (void **)ABC_ALLOC( char, (sizeof(void *) + sizeof(unsigned) * (size_t)nWords) * nEntries );
pInfo = (unsigned *)(pMemory + nEntries); pInfo = (unsigned *)(pMemory + nEntries);
for ( i = 0; i < nEntries; i++ ) for ( i = 0; i < nEntries; i++ )
pMemory[i] = pInfo + i * nWords; pMemory[i] = pInfo + i * nWords;
...@@ -1026,7 +1026,7 @@ static inline void Vec_PtrCleanSimInfo( Vec_Ptr_t * vInfo, int iWord, int nWords ...@@ -1026,7 +1026,7 @@ static inline void Vec_PtrCleanSimInfo( Vec_Ptr_t * vInfo, int iWord, int nWords
{ {
int i; int i;
for ( i = 0; i < vInfo->nSize; i++ ) for ( i = 0; i < vInfo->nSize; i++ )
memset( (char*)Vec_PtrEntry(vInfo,i) + 4*iWord, 0, 4*(nWords-iWord) ); memset( (char*)Vec_PtrEntry(vInfo,i) + 4*iWord, 0, (size_t)(4*(nWords-iWord)) );
} }
/**Function************************************************************* /**Function*************************************************************
...@@ -1044,7 +1044,7 @@ static inline void Vec_PtrFillSimInfo( Vec_Ptr_t * vInfo, int iWord, int nWords ...@@ -1044,7 +1044,7 @@ static inline void Vec_PtrFillSimInfo( Vec_Ptr_t * vInfo, int iWord, int nWords
{ {
int i; int i;
for ( i = 0; i < vInfo->nSize; i++ ) for ( i = 0; i < vInfo->nSize; i++ )
memset( (char*)Vec_PtrEntry(vInfo,i) + 4*iWord, 0xFF, 4*(nWords-iWord) ); memset( (char*)Vec_PtrEntry(vInfo,i) + 4*iWord, 0xFF, (size_t)(4*(nWords-iWord)) );
} }
/**Function************************************************************* /**Function*************************************************************
......
src/misc/vec/vecQue.h
...@@ -103,8 +103,8 @@ static inline void Vec_QueGrow( Vec_Que_t * p, int nCapMin ) ...@@ -103,8 +103,8 @@ static inline void Vec_QueGrow( Vec_Que_t * p, int nCapMin )
return; return;
p->pHeap = ABC_REALLOC( int, p->pHeap, nCapMin ); p->pHeap = ABC_REALLOC( int, p->pHeap, nCapMin );
p->pOrder = ABC_REALLOC( int, p->pOrder, nCapMin ); p->pOrder = ABC_REALLOC( int, p->pOrder, nCapMin );
memset( p->pHeap + p->nCap, 0xff, (nCapMin - p->nCap) * sizeof(int) ); memset( p->pHeap + p->nCap, 0xff, (size_t)(nCapMin - p->nCap) * sizeof(int) );
memset( p->pOrder + p->nCap, 0xff, (nCapMin - p->nCap) * sizeof(int) ); memset( p->pOrder + p->nCap, 0xff, (size_t)(nCapMin - p->nCap) * sizeof(int) );
p->nCap = nCapMin; p->nCap = nCapMin;
} }
static inline void Vec_QueClear( Vec_Que_t * p ) static inline void Vec_QueClear( Vec_Que_t * p )
......
src/misc/vec/vecSet.h
...@@ -195,7 +195,7 @@ static inline double Vec_ReportMemory( Vec_Set_t * p ) ...@@ -195,7 +195,7 @@ static inline double Vec_ReportMemory( Vec_Set_t * p )
{ {
double Mem = sizeof(Vec_Set_t); double Mem = sizeof(Vec_Set_t);
Mem += p->nPagesAlloc * sizeof(void *); Mem += p->nPagesAlloc * sizeof(void *);
Mem += sizeof(word) * (int)(((word)1) << p->nPageSize) * (1 + p->iPage); Mem += sizeof(word) * (size_t)(((word)1) << p->nPageSize) * (size_t)(1 + p->iPage);
return Mem; return Mem;
} }
...@@ -220,7 +220,7 @@ static inline int Vec_SetAppend( Vec_Set_t * p, int * pArray, int nSize ) ...@@ -220,7 +220,7 @@ static inline int Vec_SetAppend( Vec_Set_t * p, int * pArray, int nSize )
if ( ++p->iPage == p->nPagesAlloc ) if ( ++p->iPage == p->nPagesAlloc )
{ {
p->pPages = ABC_REALLOC( word *, p->pPages, p->nPagesAlloc * 2 ); p->pPages = ABC_REALLOC( word *, p->pPages, p->nPagesAlloc * 2 );
memset( p->pPages + p->nPagesAlloc, 0, sizeof(word *) * p->nPagesAlloc ); memset( p->pPages + p->nPagesAlloc, 0, sizeof(word *) * (size_t)p->nPagesAlloc );
p->nPagesAlloc *= 2; p->nPagesAlloc *= 2;
} }
if ( p->pPages[p->iPage] == NULL ) if ( p->pPages[p->iPage] == NULL )
...@@ -229,7 +229,7 @@ static inline int Vec_SetAppend( Vec_Set_t * p, int * pArray, int nSize ) ...@@ -229,7 +229,7 @@ static inline int Vec_SetAppend( Vec_Set_t * p, int * pArray, int nSize )
p->pPages[p->iPage][1] = ~0; p->pPages[p->iPage][1] = ~0;
} }
if ( pArray ) if ( pArray )
memcpy( p->pPages[p->iPage] + Vec_SetLimit(p->pPages[p->iPage]), pArray, sizeof(int) * nSize ); memcpy( p->pPages[p->iPage] + Vec_SetLimit(p->pPages[p->iPage]), pArray, sizeof(int) * (size_t)nSize );
Vec_SetIncLimit( p->pPages[p->iPage], nWords ); Vec_SetIncLimit( p->pPages[p->iPage], nWords );
return Vec_SetHandCurrent(p) - nWords; return Vec_SetHandCurrent(p) - nWords;
} }
......
src/misc/vec/vecStr.h
...@@ -107,7 +107,7 @@ static inline Vec_Str_t * Vec_StrStart( int nSize ) ...@@ -107,7 +107,7 @@ static inline Vec_Str_t * Vec_StrStart( int nSize )
Vec_Str_t * p; Vec_Str_t * p;
p = Vec_StrAlloc( nSize ); p = Vec_StrAlloc( nSize );
p->nSize = nSize; p->nSize = nSize;
memset( p->pArray, 0, sizeof(char) * nSize ); memset( p->pArray, 0, sizeof(char) * (size_t)nSize );
return p; return p;
} }
...@@ -150,7 +150,7 @@ static inline Vec_Str_t * Vec_StrAllocArrayCopy( char * pArray, int nSize ) ...@@ -150,7 +150,7 @@ static inline Vec_Str_t * Vec_StrAllocArrayCopy( char * pArray, int nSize )
p->nSize = nSize; p->nSize = nSize;
p->nCap = nSize; p->nCap = nSize;
p->pArray = ABC_ALLOC( char, nSize ); p->pArray = ABC_ALLOC( char, nSize );
memcpy( p->pArray, pArray, sizeof(char) * nSize ); memcpy( p->pArray, pArray, sizeof(char) * (size_t)nSize );
return p; return p;
} }
...@@ -172,7 +172,7 @@ static inline Vec_Str_t * Vec_StrDup( Vec_Str_t * pVec ) ...@@ -172,7 +172,7 @@ static inline Vec_Str_t * Vec_StrDup( Vec_Str_t * pVec )
p->nSize = pVec->nSize; p->nSize = pVec->nSize;
p->nCap = pVec->nCap; p->nCap = pVec->nCap;
p->pArray = p->nCap? ABC_ALLOC( char, p->nCap ) : NULL; p->pArray = p->nCap? ABC_ALLOC( char, p->nCap ) : NULL;
memcpy( p->pArray, pVec->pArray, sizeof(char) * pVec->nSize ); memcpy( p->pArray, pVec->pArray, sizeof(char) * (size_t)pVec->nSize );
return p; return p;
} }
...@@ -337,7 +337,7 @@ static inline int Vec_StrCap( Vec_Str_t * p ) ...@@ -337,7 +337,7 @@ static inline int Vec_StrCap( Vec_Str_t * p )
***********************************************************************/ ***********************************************************************/
static inline double Vec_StrMemory( Vec_Str_t * p ) static inline double Vec_StrMemory( Vec_Str_t * p )
{ {
return !p ? 0.0 : 1.0 * sizeof(char) * p->nCap + sizeof(Vec_Str_t); return !p ? 0.0 : 1.0 * sizeof(char) * (size_t)p->nCap + sizeof(Vec_Str_t);
} }
/**Function************************************************************* /**Function*************************************************************
......
src/misc/vec/vecWec.h
...@@ -129,7 +129,7 @@ static inline void Vec_WecGrow( Vec_Wec_t * p, int nCapMin ) ...@@ -129,7 +129,7 @@ static inline void Vec_WecGrow( Vec_Wec_t * p, int nCapMin )
if ( p->nCap >= nCapMin ) if ( p->nCap >= nCapMin )
return; return;
p->pArray = ABC_REALLOC( Vec_Int_t, p->pArray, nCapMin ); p->pArray = ABC_REALLOC( Vec_Int_t, p->pArray, nCapMin );
memset( p->pArray + p->nCap, 0, sizeof(Vec_Int_t) * (nCapMin - p->nCap) ); memset( p->pArray + p->nCap, 0, sizeof(Vec_Int_t) * (size_t)(nCapMin - p->nCap) );
p->nCap = nCapMin; p->nCap = nCapMin;
} }
static inline void Vec_WecInit( Vec_Wec_t * p, int nSize ) static inline void Vec_WecInit( Vec_Wec_t * p, int nSize )
...@@ -339,7 +339,7 @@ static inline double Vec_WecMemory( Vec_Wec_t * p ) ...@@ -339,7 +339,7 @@ static inline double Vec_WecMemory( Vec_Wec_t * p )
if ( p == NULL ) return 0.0; if ( p == NULL ) return 0.0;
Mem = sizeof(Vec_Int_t) * Vec_WecCap(p); Mem = sizeof(Vec_Int_t) * Vec_WecCap(p);
for ( i = 0; i < p->nSize; i++ ) for ( i = 0; i < p->nSize; i++ )
Mem += sizeof(int) * Vec_IntCap( Vec_WecEntry(p, i) ); Mem += sizeof(int) * (size_t)Vec_IntCap( Vec_WecEntry(p, i) );
return Mem; return Mem;
} }
......
src/misc/vec/vecWrd.h
...@@ -115,7 +115,7 @@ static inline Vec_Wrd_t * Vec_WrdStart( int nSize ) ...@@ -115,7 +115,7 @@ static inline Vec_Wrd_t * Vec_WrdStart( int nSize )
Vec_Wrd_t * p; Vec_Wrd_t * p;
p = Vec_WrdAlloc( nSize ); p = Vec_WrdAlloc( nSize );
p->nSize = nSize; p->nSize = nSize;
memset( p->pArray, 0, sizeof(word) * nSize ); memset( p->pArray, 0, sizeof(word) * (size_t)nSize );
return p; return p;
} }
...@@ -135,7 +135,7 @@ static inline Vec_Wrd_t * Vec_WrdStartFull( int nSize ) ...@@ -135,7 +135,7 @@ static inline Vec_Wrd_t * Vec_WrdStartFull( int nSize )
Vec_Wrd_t * p; Vec_Wrd_t * p;
p = Vec_WrdAlloc( nSize ); p = Vec_WrdAlloc( nSize );
p->nSize = nSize; p->nSize = nSize;
memset( p->pArray, 0xff, sizeof(word) * nSize ); memset( p->pArray, 0xff, sizeof(word) * (size_t)nSize );
return p; return p;
} }
...@@ -200,7 +200,7 @@ static inline Vec_Wrd_t * Vec_WrdAllocArrayCopy( word * pArray, int nSize ) ...@@ -200,7 +200,7 @@ static inline Vec_Wrd_t * Vec_WrdAllocArrayCopy( word * pArray, int nSize )
p->nSize = nSize; p->nSize = nSize;
p->nCap = nSize; p->nCap = nSize;
p->pArray = ABC_ALLOC( word, nSize ); p->pArray = ABC_ALLOC( word, nSize );
memcpy( p->pArray, pArray, sizeof(word) * nSize ); memcpy( p->pArray, pArray, sizeof(word) * (size_t)nSize );
return p; return p;
} }
...@@ -222,7 +222,7 @@ static inline Vec_Wrd_t * Vec_WrdDup( Vec_Wrd_t * pVec ) ...@@ -222,7 +222,7 @@ static inline Vec_Wrd_t * Vec_WrdDup( Vec_Wrd_t * pVec )
p->nSize = pVec->nSize; p->nSize = pVec->nSize;
p->nCap = pVec->nSize; p->nCap = pVec->nSize;
p->pArray = p->nCap? ABC_ALLOC( word, p->nCap ) : NULL; p->pArray = p->nCap? ABC_ALLOC( word, p->nCap ) : NULL;
memcpy( p->pArray, pVec->pArray, sizeof(word) * pVec->nSize ); memcpy( p->pArray, pVec->pArray, sizeof(word) * (size_t)pVec->nSize );
return p; return p;
} }
...@@ -377,7 +377,7 @@ static inline int Vec_WrdCap( Vec_Wrd_t * p ) ...@@ -377,7 +377,7 @@ static inline int Vec_WrdCap( Vec_Wrd_t * p )
***********************************************************************/ ***********************************************************************/
static inline double Vec_WrdMemory( Vec_Wrd_t * p ) static inline double Vec_WrdMemory( Vec_Wrd_t * p )
{ {
return !p ? 0.0 : 1.0 * sizeof(word) * p->nCap + sizeof(Vec_Wrd_t); return !p ? 0.0 : 1.0 * sizeof(word) * (size_t)p->nCap + sizeof(Vec_Wrd_t);
} }
/**Function************************************************************* /**Function*************************************************************
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment