More string fixups -- fix more latent bugs assuming null-terminated string_view

Author: lgritz

src/include/OpenImageIO/strutil.h

@@ -290,102 +290,108 @@ float OIIO_API strtof (const char *nptr, char **endptr, const std::locale& loc);
 
 
 
-// Helper template to test if a string is a generic type
-template<typename T>
-inline bool string_is (string_view /*s*/) {
-    return false; // Generic: assume there is an explicit specialization
-}
-// Special case for int
-template <> inline bool string_is<int> (string_view s) {
-    if (s.empty())
-        return false;
-    char *endptr = 0;
-    strtol (s.data(), &endptr, 10);
-    return (s.data() + s.size() == endptr);
-}
-// Special case for float. Note that by using Strutil::strtof, this always
-// treats '.' as the decimal character.
-template <> inline bool string_is<float> (string_view s) {
-    if (s.empty())
-        return false;
-    char *endptr = 0;
-    Strutil::strtof (s.data(), &endptr);
-    return (s.data() + s.size() == endptr);
-}
-
-
-
 // stoi() returns the int conversion of text from several string types.
 // No exceptions or errors -- parsing errors just return 0.
-inline int stoi (const char* s) {
-    return s && s[0] ? strtol (s, nullptr, 10) : 0;
-}
-inline int stoi (const std::string& s) { return Strutil::stoi(s.c_str()); }
-inline int stoi (string_view s) { return Strutil::stoi (std::string(s)); }
-
+OIIO_API int stoi (const char* s, size_t* pos=0, int base=10);
+OIIO_API int stoi (const std::string& s, size_t* pos=0, int base=10);
+OIIO_API int stoi (string_view s, size_t* pos=0, int base=10);
+// N.B. For users of ustring, there's a stoi(ustring) defined in ustring.h.
 
 
 // stoul() returns the unsigned int conversion of text from several string
 // types. No exceptions or errors -- parsing errors just return 0.
-inline unsigned int stoul (const char* s) {
-    return s && s[0] ? strtoul (s, nullptr, 10) : 0;
-}
-inline unsigned int stoul (const std::string& s) { return Strutil::stoul(s.c_str()); }
-inline unsigned int stoul (string_view s) { return Strutil::stoul (std::string(s)); }
-
+OIIO_API unsigned int stoul (const char* s, size_t* pos=0, int base=10);
+OIIO_API unsigned int stoul (const std::string& s, size_t* pos=0, int base=10);
+OIIO_API unsigned int stoul (string_view s, size_t* pos=0, int base=10);
+// N.B. For users of ustring, there's a stoi(ustring) defined in ustring.h.
 
 
 /// stof() returns the float conversion of text from several string types.
 /// No exceptions or errors -- parsing errors just return 0.0. These always
 /// use '.' for the decimal mark (versus atof and std::strtof, which are
 /// locale-dependent).
-inline float stof (const std::string& s) {
-    return s.size() ? Strutil::strtof (s.c_str(), nullptr) : 0.0f;
-}
-inline float stof (const char* s) {
-    return Strutil::strtof (s, nullptr);
-}
-inline float stof (string_view s) {
-    return Strutil::strtof (std::string(s).c_str(), nullptr);
-}
+OIIO_API float stof (const std::string& s, size_t* pos=0);
+OIIO_API float stof (const char* s, size_t* pos=0);
+OIIO_API float stof (string_view s, size_t* pos=0);
+// N.B. For users of ustring, there's a stof(ustring) defined in ustring.h.
 
 // stof() version that takes an explicit locale (for example, if you pass a
 // default-constructed std::locale, it will use the current native locale's
 // decimal conventions).
-inline float stof (const std::string& s, const std::locale& loc) {
-    return s.size() ? Strutil::strtof (s.c_str(), nullptr, loc) : 0.0f;
+OIIO_API float stof (const std::string& s, const std::locale& loc, size_t* pos=0);
+OIIO_API float stof (const char* s, const std::locale& loc, size_t* pos=0);
+OIIO_API float stof (string_view s, const std::locale& loc, size_t* pos=0);
+
+
+
+/// Return true if the string is exactly (other than leading whitespace)
+/// a valid int.
+inline bool string_is_int (string_view s) {
+    size_t pos;
+    Strutil::stoi (s, &pos);
+    return pos && pos >= s.size();   // consumed the whole string
 }
-inline float stof (const char* s, const std::locale& loc) {
-    return Strutil::strtof (s, nullptr, loc);
+
+/// Return true if the string is exactly (other than leading whitespace)
+/// a valid float. This operations in a locale-independent manner, i.e.,
+/// it assumes '.' as the decimal mark.
+inline bool string_is_float (string_view s) {
+    size_t pos;
+    Strutil::stof (s, &pos);
+    return pos && pos >= s.size();   // consumed the whole string
 }
-inline float stof (string_view s, const std::locale& loc) {
-    return Strutil::strtof (std::string(s).c_str(), nullptr, loc);
+
+/// Return true if the string is exactly (other than leading whitespace)
+/// a valid float. This operations uses an explicit locale.
+inline bool string_is_float (string_view s, const std::locale& loc) {
+    size_t pos;
+    Strutil::stof (s, loc, &pos);
+    return pos && pos >= s.size();   // consumed the whole string
 }
 
 
 
 // Helper template to convert from generic type to string (using default
-// locale).
+// locale). Used when you want stoX but you're in a template.
 template<typename T>
 inline T from_string (string_view s) {
     return T(s); // Generic: assume there is an explicit converter
 }
 // Special case for int
 template<> inline int from_string<int> (string_view s) {
-    return s.size() ? strtol (s.c_str(), nullptr, 10) : 0;
+    return Strutil::stoi(s);
 }
 // Special case for uint
 template<> inline unsigned int from_string<unsigned int> (string_view s) {
-    return s.size() ? strtoul (s.c_str(), nullptr, 10) : (unsigned int)0;
+    return Strutil::stoul(s);
 }
 // Special case for float -- note that by using Strutil::strtof, this
 // always treats '.' as the decimal mark.
 template<> inline float from_string<float> (string_view s) {
-    return s.size() ? Strutil::strtof (s.c_str(), nullptr) : 0.0f;
+    return Strutil::stof(s);
 }
 
 
 
+// Helper template to test if a string is a generic type. Used instead of
+// string_is_X, but when you're inside templated code.
+template<typename T>
+inline bool string_is (string_view /*s*/) {
+    return false; // Generic: assume there is an explicit specialization
+}
+// Special case for int
+template <> inline bool string_is<int> (string_view s) {
+    return string_is_int (s);
+}
+// Special case for float. Note that by using Strutil::stof, this always
+// treats '.' as the decimal character.
+template <> inline bool string_is<float> (string_view s) {
+    return string_is_float (s);
+}
+
+
+
+
 /// Given a string containing values separated by a comma (or optionally
 /// another separator), extract the individual values, placing them into
 /// vals[] which is presumed to already contain defaults.  If only a single

src/include/OpenImageIO/ustring.h

@@ -765,9 +765,9 @@ inline bool iequals (const std::string &a, ustring b) {
 // add ustring variants of stoi and stof from OpenImageIO/strutil.h
 namespace Strutil {
 inline int stoi (ustring s) { return Strutil::stoi (s.c_str()); }
-inline int stof (ustring s) { return Strutil::strtof (s.c_str()); }
+inline int stof (ustring s) { return Strutil::stof (s.c_str()); }
 inline int stof (ustring s, const std::locale& loc) {
-    return Strutil::strtof (s.c_str(), nullptr, loc);
+    return Strutil::stof (s.c_str(), loc);
 }
 } // end namespace Strutil
 

src/libutil/filesystem.cpp

@@ -723,16 +723,16 @@ Filesystem::enumerate_sequence (string_view desc, std::vector<int> &numbers)
         // If 'y' is used, generate the complement.
         std::vector<std::string> range;
         Strutil::split (s, range, "-", 2);
-        int first = Strutil::from_string<int> (range[0]);
+        int first = Strutil::stoi (range[0]);
         int last = first;
         int step = 1;
         bool complement = false;
         if (range.size() > 1) {
-            last = Strutil::from_string<int> (range[1]);
+            last = Strutil::stoi (range[1]);
             if (const char *x = strchr (range[1].c_str(), 'x'))
-                step = (int) strtol (x+1, NULL, 10);
+                step = Strutil::stoi (x+1);
             else if (const char *x = strchr (range[1].c_str(), 'y')) {
-                step = (int) strtol (x+1, NULL, 10);
+                step = Strutil::stoi (x+1);
                 complement = true;
             }
             if (step == 0)
@@ -989,7 +989,7 @@ Filesystem::scan_for_matching_filenames(const std::string &pattern_,
             match_results<std::string::const_iterator> frame_match;
             if (regex_match (f, frame_match, pattern_re)) {
                 std::string thenumber (frame_match[1].first, frame_match[1].second);
-                int frame = (int)strtol (thenumber.c_str(), NULL, 10);
+                int frame = Strutil::stoi (thenumber);
                 matches.push_back (std::make_pair (frame, f));
             }
         }