Fixing some warnings by adding cast from 'int' to 'size_t' in memset, memcpy, etc.

7 files changed, 28 insertions, 28 deletions

diff --git a/src/misc/vec/vecFlt.h b/src/misc/vec/vecFlt.h
index 9988deae..b5c5e498 100644
--- a/src/misc/vec/vecFlt.h
+++ b/src/misc/vec/vecFlt.h
@@ -807,10 +807,10 @@ static int Vec_FltSortCompare2( float * pp1, float * pp2 )
 static inline void Vec_FltSort( Vec_Flt_t * p, int fReverse )
 {
     if ( fReverse ) 
-        qsort( (void *)p->pArray, p->nSize, sizeof(float), 
+        qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(float), 
                 (int (*)(const void *, const void *)) Vec_FltSortCompare2 );
     else
-        qsort( (void *)p->pArray, p->nSize, sizeof(float), 
+        qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(float), 
                 (int (*)(const void *, const void *)) Vec_FltSortCompare1 );
 }
 
diff --git a/src/misc/vec/vecInt.h b/src/misc/vec/vecInt.h
index dd478a1c..76c0aca2 100644
--- a/src/misc/vec/vecInt.h
+++ b/src/misc/vec/vecInt.h
@@ -1381,20 +1381,20 @@ static int Vec_IntSortCompare2( int * pp1, int * pp2 )
 static inline void Vec_IntSort( Vec_Int_t * p, int fReverse )
 {
     if ( fReverse ) 
-        qsort( (void *)p->pArray, p->nSize, sizeof(int), 
+        qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(int), 
                 (int (*)(const void *, const void *)) Vec_IntSortCompare2 );
     else
-        qsort( (void *)p->pArray, p->nSize, sizeof(int), 
+        qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(int), 
                 (int (*)(const void *, const void *)) Vec_IntSortCompare1 );
 }
 static inline void Vec_IntSortMulti( Vec_Int_t * p, int nMulti, int fReverse )
 {
     assert( Vec_IntSize(p) % nMulti == 0 );
     if ( fReverse ) 
-        qsort( (void *)p->pArray, p->nSize/nMulti, nMulti*sizeof(int), 
+        qsort( (void *)p->pArray, (size_t)(p->nSize/nMulti), nMulti*sizeof(int), 
                 (int (*)(const void *, const void *)) Vec_IntSortCompare2 );
     else
-        qsort( (void *)p->pArray, p->nSize/nMulti, nMulti*sizeof(int), 
+        qsort( (void *)p->pArray, (size_t)(p->nSize/nMulti), nMulti*sizeof(int), 
                 (int (*)(const void *, const void *)) Vec_IntSortCompare1 );
 }
 
@@ -1638,7 +1638,7 @@ static inline int Vec_IntSortCompareUnsigned( unsigned * pp1, unsigned * pp2 )
 ***********************************************************************/
 static inline void Vec_IntSortUnsigned( Vec_Int_t * p )
 {
-    qsort( (void *)p->pArray, p->nSize, sizeof(int), 
+    qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(int), 
             (int (*)(const void *, const void *)) Vec_IntSortCompareUnsigned );
 }
 
diff --git a/src/misc/vec/vecPtr.h b/src/misc/vec/vecPtr.h
index 015aa1be..3cdd25d6 100644
--- a/src/misc/vec/vecPtr.h
+++ b/src/misc/vec/vecPtr.h
@@ -910,10 +910,10 @@ static void Vec_PtrSort( Vec_Ptr_t * p, int (*Vec_PtrSortCompare)() )
     if ( p->nSize < 2 )
         return;
     if ( Vec_PtrSortCompare == NULL )
-        qsort( (void *)p->pArray, p->nSize, sizeof(void *), 
+        qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(void *), 
                 (int (*)(const void *, const void *)) Vec_PtrSortComparePtr );
     else
-        qsort( (void *)p->pArray, p->nSize, sizeof(void *), 
+        qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(void *), 
                 (int (*)(const void *, const void *)) Vec_PtrSortCompare );
 }
 
@@ -1067,7 +1067,7 @@ static inline void Vec_PtrDoubleSimInfo( Vec_Ptr_t * vInfo )
     nWords = (unsigned *)Vec_PtrEntry(vInfo,1) - (unsigned *)Vec_PtrEntry(vInfo,0);
     vInfoNew = Vec_PtrAllocSimInfo( 2*Vec_PtrSize(vInfo), nWords );
     // copy the simulation info
-    memcpy( Vec_PtrEntry(vInfoNew,0), Vec_PtrEntry(vInfo,0), Vec_PtrSize(vInfo) * nWords * 4 );
+    memcpy( Vec_PtrEntry(vInfoNew,0), Vec_PtrEntry(vInfo,0), (size_t)(Vec_PtrSize(vInfo) * nWords * 4) );
     // replace the array
     ABC_FREE( vInfo->pArray );
     vInfo->pArray = vInfoNew->pArray;
@@ -1099,7 +1099,7 @@ static inline void Vec_PtrReallocSimInfo( Vec_Ptr_t * vInfo )
     vInfoNew = Vec_PtrAllocSimInfo( Vec_PtrSize(vInfo), 2*nWords );
     // copy the simulation info
     for ( i = 0; i < vInfo->nSize; i++ )
-        memcpy( Vec_PtrEntry(vInfoNew,i), Vec_PtrEntry(vInfo,i), nWords * 4 );
+        memcpy( Vec_PtrEntry(vInfoNew,i), Vec_PtrEntry(vInfo,i), (size_t)(nWords * 4) );
     // replace the array
     ABC_FREE( vInfo->pArray );
     vInfo->pArray = vInfoNew->pArray;
diff --git a/src/misc/vec/vecStr.h b/src/misc/vec/vecStr.h
index ef5e9a41..8c8f7e6e 100644
--- a/src/misc/vec/vecStr.h
+++ b/src/misc/vec/vecStr.h
@@ -565,7 +565,7 @@ static inline void Vec_StrPushBuffer( Vec_Str_t * p, char * pBuffer, int nSize )
 {
     if ( p->nSize + nSize > p->nCap )
         Vec_StrGrow( p, 2 * (p->nSize + nSize) );
-    memcpy( p->pArray + p->nSize, pBuffer, nSize );
+    memcpy( p->pArray + p->nSize, pBuffer, (size_t)nSize );
     p->nSize += nSize;
 }
 
@@ -916,10 +916,10 @@ static int Vec_StrSortCompare2( char * pp1, char * pp2 )
 static inline void Vec_StrSort( Vec_Str_t * p, int fReverse )
 {
     if ( fReverse ) 
-        qsort( (void *)p->pArray, p->nSize, sizeof(char), 
+        qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(char), 
                 (int (*)(const void *, const void *)) Vec_StrSortCompare2 );
     else
-        qsort( (void *)p->pArray, p->nSize, sizeof(char), 
+        qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(char), 
                 (int (*)(const void *, const void *)) Vec_StrSortCompare1 );
 }
 
@@ -940,7 +940,7 @@ static inline int Vec_StrCompareVec( Vec_Str_t * p1, Vec_Str_t * p2 )
         return (p1 != NULL) - (p2 != NULL);
     if ( Vec_StrSize(p1) != Vec_StrSize(p2) )
         return Vec_StrSize(p1) - Vec_StrSize(p2);
-    return memcmp( Vec_StrArray(p1), Vec_StrArray(p2), Vec_StrSize(p1) );
+    return memcmp( Vec_StrArray(p1), Vec_StrArray(p2), (size_t)Vec_StrSize(p1) );
 }
 
 
diff --git a/src/misc/vec/vecVec.h b/src/misc/vec/vecVec.h
index 157b887c..1d90d11c 100644
--- a/src/misc/vec/vecVec.h
+++ b/src/misc/vec/vecVec.h
@@ -554,10 +554,10 @@ static int Vec_VecSortCompare2( Vec_Ptr_t ** pp1, Vec_Ptr_t ** pp2 )
 static inline void Vec_VecSort( Vec_Vec_t * p, int fReverse )
 {
     if ( fReverse ) 
-        qsort( (void *)p->pArray, p->nSize, sizeof(void *), 
+        qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(void *), 
                 (int (*)(const void *, const void *)) Vec_VecSortCompare2 );
     else
-        qsort( (void *)p->pArray, p->nSize, sizeof(void *), 
+        qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(void *), 
                 (int (*)(const void *, const void *)) Vec_VecSortCompare1 );
 }
 
@@ -603,10 +603,10 @@ static int Vec_VecSortCompare4( Vec_Int_t ** pp1, Vec_Int_t ** pp2 )
 static inline void Vec_VecSortByFirstInt( Vec_Vec_t * p, int fReverse )
 {
     if ( fReverse ) 
-        qsort( (void *)p->pArray, p->nSize, sizeof(void *), 
+        qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(void *), 
                 (int (*)(const void *, const void *)) Vec_VecSortCompare4 );
     else
-        qsort( (void *)p->pArray, p->nSize, sizeof(void *), 
+        qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(void *), 
                 (int (*)(const void *, const void *)) Vec_VecSortCompare3 );
 }
 
diff --git a/src/misc/vec/vecWec.h b/src/misc/vec/vecWec.h
index c8c89701..e4c3d292 100644
--- a/src/misc/vec/vecWec.h
+++ b/src/misc/vec/vecWec.h
@@ -454,10 +454,10 @@ static int Vec_WecSortCompare2( Vec_Int_t * p1, Vec_Int_t * p2 )
 static inline void Vec_WecSort( Vec_Wec_t * p, int fReverse )
 {
     if ( fReverse ) 
-        qsort( (void *)p->pArray, p->nSize, sizeof(Vec_Int_t), 
+        qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(Vec_Int_t), 
                 (int (*)(const void *, const void *)) Vec_WecSortCompare2 );
     else
-        qsort( (void *)p->pArray, p->nSize, sizeof(Vec_Int_t), 
+        qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(Vec_Int_t), 
                 (int (*)(const void *, const void *)) Vec_WecSortCompare1 );
 }
 
@@ -492,10 +492,10 @@ static int Vec_WecSortCompare4( Vec_Int_t * p1, Vec_Int_t * p2 )
 static inline void Vec_WecSortByFirstInt( Vec_Wec_t * p, int fReverse )
 {
     if ( fReverse ) 
-        qsort( (void *)p->pArray, p->nSize, sizeof(Vec_Int_t), 
+        qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(Vec_Int_t), 
                 (int (*)(const void *, const void *)) Vec_WecSortCompare4 );
     else
-        qsort( (void *)p->pArray, p->nSize, sizeof(Vec_Int_t), 
+        qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(Vec_Int_t), 
                 (int (*)(const void *, const void *)) Vec_WecSortCompare3 );
 }
 
@@ -529,10 +529,10 @@ static int Vec_WecSortCompare6( Vec_Int_t * p1, Vec_Int_t * p2 )
 static inline void Vec_WecSortByLastInt( Vec_Wec_t * p, int fReverse )
 {
     if ( fReverse ) 
-        qsort( (void *)p->pArray, p->nSize, sizeof(Vec_Int_t), 
+        qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(Vec_Int_t), 
                 (int (*)(const void *, const void *)) Vec_WecSortCompare6 );
     else
-        qsort( (void *)p->pArray, p->nSize, sizeof(Vec_Int_t), 
+        qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(Vec_Int_t), 
                 (int (*)(const void *, const void *)) Vec_WecSortCompare5 );
 }
 
diff --git a/src/misc/vec/vecWrd.h b/src/misc/vec/vecWrd.h
index d286baf3..eb0c137c 100644
--- a/src/misc/vec/vecWrd.h
+++ b/src/misc/vec/vecWrd.h
@@ -1084,10 +1084,10 @@ static int Vec_WrdSortCompare2( word * pp1, word * pp2 )
 static inline void Vec_WrdSort( Vec_Wrd_t * p, int fReverse )
 {
     if ( fReverse ) 
-        qsort( (void *)p->pArray, p->nSize, sizeof(word), 
+        qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(word), 
                 (int (*)(const void *, const void *)) Vec_WrdSortCompare2 );
     else
-        qsort( (void *)p->pArray, p->nSize, sizeof(word), 
+        qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(word), 
                 (int (*)(const void *, const void *)) Vec_WrdSortCompare1 );
 }
 
@@ -1171,7 +1171,7 @@ static int Vec_WrdSortCompareUnsigned( word * pp1, word * pp2 )
 ***********************************************************************/
 static inline void Vec_WrdSortUnsigned( Vec_Wrd_t * p )
 {
-    qsort( (void *)p->pArray, p->nSize, sizeof(word), 
+    qsort( (void *)p->pArray, (size_t)p->nSize, sizeof(word), 
             (int (*)(const void *, const void *)) Vec_WrdSortCompareUnsigned );
 }