misc compilation warning fixes

jeremyselan · jeremyselan · commit 1076a670f2a8 · 2011-06-20T11:52:45.000-07:00
This makes pystring compile without warnings on gcc44, when compiled using the da
-Wall flag. Most of the changes are issues related to the intermixing of size_type / int
types, where the updated version of the code attempts to do as few type changes
to the user arguments as possible. This code has been running cross-platform
in OpenColorIO for the last few months, and is well tested.
diff --git a/pystring.cpp b/pystring.cpp
@@ -31,12 +31,13 @@
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ///////////////////////////////////////////////////////////////////////////////
 
-#include <ctype.h>
-#include <string.h>
-#include <iostream>
-#include <algorithm>
 #include "pystring.h"
 
+#include <algorithm>
+#include <cctype>
+#include <cstring>
+#include <iostream>
+
 namespace pystring
 {
 
@@ -397,13 +398,14 @@ namespace pystring
     //////////////////////////////////////////////////////////////////////////////////////////////
     ///
     ///
-    int __adjustslicepos( std::string::size_type len, int pos )
+    int __adjustslicepos( std::string::size_type len_, int pos )
     {
-        int intlen = len, value;
+        int len = static_cast<int>(len_);
+        int value;
 
         if ( pos < 0 )
         {
-            value = intlen + pos;
+            value = len + pos;
         }
         else
         {
@@ -415,7 +417,7 @@ namespace pystring
             value = 0;
         }
 
-        else if ( value > ( int ) len )
+        else if ( value > len)
         {
             value = len;
         }
@@ -431,14 +433,14 @@ namespace pystring
     ///
     bool startswith( const std::string & str, const std::string & prefix, int start, int end )
     {
-        std::string::size_type startp, endp;
-
+        int startp, endp;
+        
         startp = __adjustslicepos( str.size(), start );
         endp = __adjustslicepos( str.size(), end );
 
         if ( start > (int) str.size() ) return false;
 
-        if ( endp - startp < prefix.size()   ) return false;
+        if ( endp - startp < (int) prefix.size()   ) return false;
         return __substrcmp( str, prefix, startp );
 
     }
@@ -448,18 +450,19 @@ namespace pystring
     ///
     bool endswith( const std::string & str, const std::string & suffix, int start, int end )
     {
-        std::string::size_type startp, endp;
+        int startp, endp;
 
         startp = __adjustslicepos( str.size(), start );
         endp = __adjustslicepos( str.size(), end );
-
+        
+        int suffixsize = (int) suffix.size();
         int upper = endp;
-        int lower = ( upper - suffix.size() ) > startp ? ( upper - suffix.size() ) : startp;
+        int lower = ( upper - suffixsize ) > startp ? ( upper - suffixsize ) : startp;
 
         if ( start > (int) str.size() ) return false;
 
 
-        if ( upper - lower < ( int ) suffix.size() )
+        if ( upper - lower < suffixsize )
         {
             return false;
         }
@@ -624,12 +627,12 @@ namespace pystring
 
         if ( len > 0)
         {
-            if (::islower(s[0])) s[0] = ::toupper( s[0] );
+            if (::islower(s[0])) s[0] = (char) ::toupper( s[0] );
         }
 
         for ( i = 1; i < len; ++i )
         {
-            if (::isupper(s[i])) s[i] = ::tolower( s[i] );
+            if (::isupper(s[i])) s[i] = (char) ::tolower( s[i] );
         }
 
         return s;
@@ -645,7 +648,7 @@ namespace pystring
 
         for ( i = 0; i < len; ++i )
         {
-            if ( ::isupper( s[i] ) ) s[i] = ::tolower( s[i] );
+            if ( ::isupper( s[i] ) ) s[i] = (char) ::tolower( s[i] );
         }
 
         return s;
@@ -661,7 +664,7 @@ namespace pystring
 
         for ( i = 0; i < len; ++i )
         {
-            if ( ::islower( s[i] ) ) s[i] = ::toupper( s[i] );
+            if ( ::islower( s[i] ) ) s[i] = (char) ::toupper( s[i] );
         }
 
         return s;
@@ -677,8 +680,8 @@ namespace pystring
 
         for ( i = 0; i < len; ++i )
         {
-            if ( ::islower( s[i] ) ) s[i] = ::toupper( s[i] );
-            else if (::isupper( s[i] ) ) s[i] = ::tolower( s[i] );
+            if ( ::islower( s[i] ) ) s[i] = (char) ::toupper( s[i] );
+            else if (::isupper( s[i] ) ) s[i] = (char) ::tolower( s[i] );
         }
 
         return s;
@@ -700,15 +703,15 @@ namespace pystring
             {
                 if ( !previous_is_cased )
                 {
-                    s[i] = ::toupper(c);
+                    s[i] = (char) ::toupper(c);
                 }
                 previous_is_cased = true;
             }
             else if ( ::isupper(c) )
             {
                 if ( previous_is_cased )
                 {
-                    s[i] = ::tolower(c);
+                    s[i] = (char) ::tolower(c);
                 }
                 previous_is_cased = true;
             }
@@ -776,9 +779,9 @@ namespace pystring
     ///
     std::string zfill( const std::string & str, int width )
     {
-        std::string::size_type len = str.size();
+        int len = (int)str.size();
 
-        if ( ( int ) len >= width )
+        if ( len >= width )
         {
             return str;
         }
@@ -825,10 +828,10 @@ namespace pystring
     ///
     std::string center( const std::string & str, int width )
     {
-        std::string::size_type len = str.size();
+        int len = (int) str.size();
         int marg, left;
 
-        if ( (( int ) len ) >= width ) return str;
+        if ( len >= width ) return str;
 
         marg = width - len;
         left = marg / 2 + (marg & width & 1);
@@ -842,7 +845,7 @@ namespace pystring
     ///
     int find( const std::string & str, const std::string & sub, int start, int end  )
     {
-        std::string::size_type startp, endp;
+        int startp, endp;
 
         startp = __adjustslicepos( str.size(), start );
         endp = __adjustslicepos( str.size(), end );
@@ -851,12 +854,12 @@ namespace pystring
 
         result = str.find( sub, startp );
 
-        if( result == std::string::npos || result >= endp)
+        if( result == std::string::npos || result >= (std::string::size_type)endp)
         {
             return -1;
         }
 
-        return result;
+        return (int)result;
     }
 
     //////////////////////////////////////////////////////////////////////////////////////////////
@@ -872,7 +875,7 @@ namespace pystring
     ///
     int rfind( const std::string & str, const std::string & sub, int start, int end )
     {
-        std::string::size_type startp, endp;
+        int startp, endp;
 
         startp = __adjustslicepos( str.size(), start );
         endp = __adjustslicepos( str.size(), end );
@@ -881,9 +884,10 @@ namespace pystring
 
         result = str.rfind( sub, endp );
 
-        if( result == std::string::npos || result < startp ) return -1;
-        return result;
-
+        if( result == std::string::npos || result < (std::string::size_type)startp )
+            return -1;
+        
+        return (int)result;
     }
 
     //////////////////////////////////////////////////////////////////////////////////////////////
@@ -953,7 +957,7 @@ namespace pystring
 
             if ( cursor < 0 ) break;
 
-            cursor += substr.size();
+            cursor += (int) substr.size();
             nummatches += 1;
         }
 
@@ -982,7 +986,7 @@ namespace pystring
 
             s.replace( cursor, oldlen, newstr );
 
-            cursor += newlen;
+            cursor += (int) newlen;
             ++sofar;
         }
 
@@ -1035,7 +1039,7 @@ namespace pystring
     ///
     std::string slice( const std::string & str, int start, int end )
     {
-        std::string::size_type startp, endp;
+        int startp, endp;
 
         startp = __adjustslicepos( str.size(), start );
         endp = __adjustslicepos( str.size(), end );

Original file line number	Diff line number	Diff line change
`@@ -31,12 +31,13 @@`
`31`	`31`	`// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.`
`32`	`32`	`///////////////////////////////////////////////////////////////////////////////`
`33`	`33`
`34`		`-#include <ctype.h>`
`35`		`-#include <string.h>`
`36`		`-#include <iostream>`
`37`		`-#include <algorithm>`
`38`	`34`	`#include "pystring.h"`
`39`	`35`
	`36`	`+#include <algorithm>`
	`37`	`+#include <cctype>`
	`38`	`+#include <cstring>`
	`39`	`+#include <iostream>`
	`40`	`+`
`40`	`41`	`namespace pystring`
`41`	`42`	`{`
`42`	`43`
`@@ -397,13 +398,14 @@ namespace pystring`
`397`	`398`	`//////////////////////////////////////////////////////////////////////////////////////////////`
`398`	`399`	`///`
`399`	`400`	`///`
`400`		`- int __adjustslicepos( std::string::size_type len, int pos )`
	`401`	`+ int __adjustslicepos( std::string::size_type len_, int pos )`
`401`	`402`	`{`
`402`		`- int intlen = len, value;`
	`403`	`+ int len = static_cast<int>(len_);`
	`404`	`+ int value;`
`403`	`405`
`404`	`406`	`if ( pos < 0 )`
`405`	`407`	`{`
`406`		`- value = intlen + pos;`
	`408`	`+ value = len + pos;`
`407`	`409`	`}`
`408`	`410`	`else`
`409`	`411`	`{`
`@@ -415,7 +417,7 @@ namespace pystring`
`415`	`417`	`value = 0;`
`416`	`418`	`}`
`417`	`419`
`418`		`- else if ( value > ( int ) len )`
	`420`	`+ else if ( value > len)`
`419`	`421`	`{`
`420`	`422`	`value = len;`
`421`	`423`	`}`
`@@ -431,14 +433,14 @@ namespace pystring`
`431`	`433`	`///`
`432`	`434`	`bool startswith( const std::string & str, const std::string & prefix, int start, int end )`
`433`	`435`	`{`
`434`		`- std::string::size_type startp, endp;`
`435`		`-`
	`436`	`+ int startp, endp;`
	`437`	`+`
`436`	`438`	`startp = __adjustslicepos( str.size(), start );`
`437`	`439`	`endp = __adjustslicepos( str.size(), end );`
`438`	`440`
`439`	`441`	`if ( start > (int) str.size() ) return false;`
`440`	`442`
`441`		`- if ( endp - startp < prefix.size() ) return false;`
	`443`	`+ if ( endp - startp < (int) prefix.size() ) return false;`
`442`	`444`	`return __substrcmp( str, prefix, startp );`
`443`	`445`
`444`	`446`	`}`
`@@ -448,18 +450,19 @@ namespace pystring`
`448`	`450`	`///`
`449`	`451`	`bool endswith( const std::string & str, const std::string & suffix, int start, int end )`
`450`	`452`	`{`
`451`		`- std::string::size_type startp, endp;`
	`453`	`+ int startp, endp;`
`452`	`454`
`453`	`455`	`startp = __adjustslicepos( str.size(), start );`
`454`	`456`	`endp = __adjustslicepos( str.size(), end );`
`455`		`-`
	`457`	`+`
	`458`	`+ int suffixsize = (int) suffix.size();`
`456`	`459`	`int upper = endp;`
`457`		`- int lower = ( upper - suffix.size() ) > startp ? ( upper - suffix.size() ) : startp;`
	`460`	`+ int lower = ( upper - suffixsize ) > startp ? ( upper - suffixsize ) : startp;`
`458`	`461`
`459`	`462`	`if ( start > (int) str.size() ) return false;`
`460`	`463`
`461`	`464`
`462`		`- if ( upper - lower < ( int ) suffix.size() )`
	`465`	`+ if ( upper - lower < suffixsize )`
`463`	`466`	`{`
`464`	`467`	`return false;`
`465`	`468`	`}`
`@@ -624,12 +627,12 @@ namespace pystring`
`624`	`627`
`625`	`628`	`if ( len > 0)`
`626`	`629`	`{`
`627`		`- if (::islower(s[0])) s[0] = ::toupper( s[0] );`
	`630`	`+ if (::islower(s[0])) s[0] = (char) ::toupper( s[0] );`
`628`	`631`	`}`
`629`	`632`
`630`	`633`	`for ( i = 1; i < len; ++i )`
`631`	`634`	`{`
`632`		`- if (::isupper(s[i])) s[i] = ::tolower( s[i] );`
	`635`	`+ if (::isupper(s[i])) s[i] = (char) ::tolower( s[i] );`
`633`	`636`	`}`
`634`	`637`
`635`	`638`	`return s;`
`@@ -645,7 +648,7 @@ namespace pystring`
`645`	`648`
`646`	`649`	`for ( i = 0; i < len; ++i )`
`647`	`650`	`{`
`648`		`- if ( ::isupper( s[i] ) ) s[i] = ::tolower( s[i] );`
	`651`	`+ if ( ::isupper( s[i] ) ) s[i] = (char) ::tolower( s[i] );`
`649`	`652`	`}`
`650`	`653`
`651`	`654`	`return s;`
`@@ -661,7 +664,7 @@ namespace pystring`
`661`	`664`
`662`	`665`	`for ( i = 0; i < len; ++i )`
`663`	`666`	`{`
`664`		`- if ( ::islower( s[i] ) ) s[i] = ::toupper( s[i] );`
	`667`	`+ if ( ::islower( s[i] ) ) s[i] = (char) ::toupper( s[i] );`
`665`	`668`	`}`
`666`	`669`
`667`	`670`	`return s;`
`@@ -677,8 +680,8 @@ namespace pystring`
`677`	`680`
`678`	`681`	`for ( i = 0; i < len; ++i )`
`679`	`682`	`{`
`680`		`- if ( ::islower( s[i] ) ) s[i] = ::toupper( s[i] );`
`681`		`- else if (::isupper( s[i] ) ) s[i] = ::tolower( s[i] );`
	`683`	`+ if ( ::islower( s[i] ) ) s[i] = (char) ::toupper( s[i] );`
	`684`	`+ else if (::isupper( s[i] ) ) s[i] = (char) ::tolower( s[i] );`
`682`	`685`	`}`
`683`	`686`
`684`	`687`	`return s;`
`@@ -700,15 +703,15 @@ namespace pystring`
`700`	`703`	`{`
`701`	`704`	`if ( !previous_is_cased )`
`702`	`705`	`{`
`703`		`- s[i] = ::toupper(c);`
	`706`	`+ s[i] = (char) ::toupper(c);`
`704`	`707`	`}`
`705`	`708`	`previous_is_cased = true;`
`706`	`709`	`}`
`707`	`710`	`else if ( ::isupper(c) )`
`708`	`711`	`{`
`709`	`712`	`if ( previous_is_cased )`
`710`	`713`	`{`
`711`		`- s[i] = ::tolower(c);`
	`714`	`+ s[i] = (char) ::tolower(c);`
`712`	`715`	`}`
`713`	`716`	`previous_is_cased = true;`
`714`	`717`	`}`
`@@ -776,9 +779,9 @@ namespace pystring`
`776`	`779`	`///`
`777`	`780`	`std::string zfill( const std::string & str, int width )`
`778`	`781`	`{`
`779`		`- std::string::size_type len = str.size();`
	`782`	`+ int len = (int)str.size();`
`780`	`783`
`781`		`- if ( ( int ) len >= width )`
	`784`	`+ if ( len >= width )`
`782`	`785`	`{`
`783`	`786`	`return str;`
`784`	`787`	`}`
`@@ -825,10 +828,10 @@ namespace pystring`
`825`	`828`	`///`
`826`	`829`	`std::string center( const std::string & str, int width )`
`827`	`830`	`{`
`828`		`- std::string::size_type len = str.size();`
	`831`	`+ int len = (int) str.size();`
`829`	`832`	`int marg, left;`
`830`	`833`
`831`		`- if ( (( int ) len ) >= width ) return str;`
	`834`	`+ if ( len >= width ) return str;`
`832`	`835`
`833`	`836`	`marg = width - len;`
`834`	`837`	`left = marg / 2 + (marg & width & 1);`
`@@ -842,7 +845,7 @@ namespace pystring`
`842`	`845`	`///`
`843`	`846`	`int find( const std::string & str, const std::string & sub, int start, int end )`
`844`	`847`	`{`
`845`		`- std::string::size_type startp, endp;`
	`848`	`+ int startp, endp;`
`846`	`849`
`847`	`850`	`startp = __adjustslicepos( str.size(), start );`
`848`	`851`	`endp = __adjustslicepos( str.size(), end );`
`@@ -851,12 +854,12 @@ namespace pystring`
`851`	`854`
`852`	`855`	`result = str.find( sub, startp );`
`853`	`856`
`854`		`- if( result == std::string::npos \|\| result >= endp)`
	`857`	`+ if( result == std::string::npos \|\| result >= (std::string::size_type)endp)`
`855`	`858`	`{`
`856`	`859`	`return -1;`
`857`	`860`	`}`
`858`	`861`
`859`		`- return result;`
	`862`	`+ return (int)result;`
`860`	`863`	`}`
`861`	`864`
`862`	`865`	`//////////////////////////////////////////////////////////////////////////////////////////////`
`@@ -872,7 +875,7 @@ namespace pystring`
`872`	`875`	`///`
`873`	`876`	`int rfind( const std::string & str, const std::string & sub, int start, int end )`
`874`	`877`	`{`
`875`		`- std::string::size_type startp, endp;`
	`878`	`+ int startp, endp;`
`876`	`879`
`877`	`880`	`startp = __adjustslicepos( str.size(), start );`
`878`	`881`	`endp = __adjustslicepos( str.size(), end );`
`@@ -881,9 +884,10 @@ namespace pystring`
`881`	`884`
`882`	`885`	`result = str.rfind( sub, endp );`
`883`	`886`
`884`		`- if( result == std::string::npos \|\| result < startp ) return -1;`
`885`		`- return result;`
`886`		`-`
	`887`	`+ if( result == std::string::npos \|\| result < (std::string::size_type)startp )`
	`888`	`+ return -1;`
	`889`	`+`
	`890`	`+ return (int)result;`
`887`	`891`	`}`
`888`	`892`
`889`	`893`	`//////////////////////////////////////////////////////////////////////////////////////////////`
`@@ -953,7 +957,7 @@ namespace pystring`
`953`	`957`
`954`	`958`	`if ( cursor < 0 ) break;`
`955`	`959`
`956`		`- cursor += substr.size();`
	`960`	`+ cursor += (int) substr.size();`
`957`	`961`	`nummatches += 1;`
`958`	`962`	`}`
`959`	`963`
`@@ -982,7 +986,7 @@ namespace pystring`
`982`	`986`
`983`	`987`	`s.replace( cursor, oldlen, newstr );`
`984`	`988`
`985`		`- cursor += newlen;`
	`989`	`+ cursor += (int) newlen;`
`986`	`990`	`++sofar;`
`987`	`991`	`}`
`988`	`992`
`@@ -1035,7 +1039,7 @@ namespace pystring`
`1035`	`1039`	`///`
`1036`	`1040`	`std::string slice( const std::string & str, int start, int end )`
`1037`	`1041`	`{`
`1038`		`- std::string::size_type startp, endp;`
	`1042`	`+ int startp, endp;`
`1039`	`1043`
`1040`	`1044`	`startp = __adjustslicepos( str.size(), start );`
`1041`	`1045`	`endp = __adjustslicepos( str.size(), end );`