Explicit casts to avoid conversion warnings

tautschnig · tautschnig · commit 86f73d8fc596 · 2025-02-07T13:52:33.000Z
Visual Studio warns about signed/unsigned conversion and limited range of types.
diff --git a/src/ansi-c/expr2c.cpp b/src/ansi-c/expr2c.cpp
@@ -2233,7 +2233,7 @@ std::string expr2ct::convert_array(const exprt &src)
       if(last_was_hex)
       {
         // we use "string splicing" to avoid ambiguity
-        if(isxdigit(ch))
+        if(isxdigit(static_cast<int>(ch)))
           dest+="\" \"";
 
         last_was_hex=false;
diff --git a/src/ansi-c/literals/convert_string_literal.cpp b/src/ansi-c/literals/convert_string_literal.cpp
@@ -36,7 +36,7 @@ std::basic_string<char32_t> convert_one_string_literal(const std::string &src)
     // pad into wide string
     value.resize(utf8_value.size());
     for(std::size_t i=0; i<utf8_value.size(); i++)
-      value[i]=utf8_value[i];
+      value[i] = static_cast<unsigned int>(utf8_value[i]);
 
     return value;
   }
@@ -59,7 +59,7 @@ std::basic_string<char32_t> convert_one_string_literal(const std::string &src)
     std::basic_string<char32_t> value;
     value.resize(char_value.size());
     for(std::size_t i=0; i<char_value.size(); i++)
-      value[i]=char_value[i];
+      value[i] = static_cast<unsigned int>(char_value[i]);
 
     return value;
   }
@@ -143,7 +143,7 @@ exprt convert_string_literal(const std::string &src)
     {
       // Loss of data here if value[i]>255.
       // gcc issues a warning in this case.
-      char_value[i]=value[i];
+      char_value[i] = static_cast<char>(value[i]);
     }
 
     return string_constantt(char_value);
diff --git a/src/ansi-c/literals/unescape_string.cpp b/src/ansi-c/literals/unescape_string.cpp
@@ -43,15 +43,15 @@ std::basic_string<T> unescape_string_templ(const std::string &src)
 
   for(unsigned i=0; i<src.size(); i++)
   {
-    T ch=(unsigned char)src[i];
+    T ch = static_cast<T>(static_cast<unsigned char>(src[i]));
 
     if(ch=='\\') // escape?
     {
       // go to next character
       i++;
       INVARIANT(i < src.size(), "backslash can't be last character");
 
-      ch=(unsigned char)src[i];
+      ch = static_cast<T>(static_cast<unsigned char>(src[i]));
       switch(ch)
       {
       case '\\': dest.push_back(ch); break;
@@ -105,7 +105,7 @@ std::basic_string<T> unescape_string_templ(const std::string &src)
           // go back
           i--;
 
-          ch=hex_to_unsigned(hex.c_str(), hex.size());
+          ch = static_cast<T>(hex_to_unsigned(hex.c_str(), hex.size()));
         }
 
         // if T isn't sufficiently wide to hold unsigned values
@@ -116,7 +116,7 @@ std::basic_string<T> unescape_string_templ(const std::string &src)
         break;
 
       default:
-        if(isdigit(ch)) // octal
+        if(isdigit(static_cast<int>(ch))) // octal
         {
           std::string octal;
 
@@ -129,7 +129,7 @@ std::basic_string<T> unescape_string_templ(const std::string &src)
           // go back
           i--;
 
-          ch=octal_to_unsigned(octal.c_str(), octal.size());
+          ch = static_cast<T>(octal_to_unsigned(octal.c_str(), octal.size()));
           dest.push_back(ch);
         }
         else
diff --git a/src/goto-checker/symex_coverage.cpp b/src/goto-checker/symex_coverage.cpp
@@ -194,7 +194,8 @@ goto_program_coverage_recordt::goto_program_coverage_recordt(
         xmlt &condition = conditions.new_element("condition");
         condition.set_attribute("number", std::to_string(number++));
         condition.set_attribute("type", "jump");
-        unsigned taken = c.second.false_taken + c.second.true_taken;
+        unsigned taken =
+          static_cast<unsigned>(c.second.false_taken + c.second.true_taken);
         total_taken += taken;
         condition.set_attribute("coverage", rate(taken, 2, true));
       }
diff --git a/src/goto-programs/elf_reader.cpp b/src/goto-programs/elf_reader.cpp
@@ -107,7 +107,8 @@ elf_readert::elf_readert(std::istream &_in):in(_in)
     for(std::size_t i=0; i<elf32_section_header_table.size(); i++)
     {
       // go to right place
-      in.seekg(elf32_header.e_shoff+i*elf32_header.e_shentsize);
+      in.seekg(static_cast<std::streamoff>(
+        elf32_header.e_shoff + i * elf32_header.e_shentsize));
 
       // read section header
       in.read(
@@ -187,7 +188,8 @@ elf_readert::elf_readert(std::istream &_in):in(_in)
     for(std::size_t i=0; i<elf64_section_header_table.size(); i++)
     {
       // go to right place
-      in.seekg(elf64_header.e_shoff+i*elf64_header.e_shentsize);
+      in.seekg(static_cast<std::streamoff>(
+        elf64_header.e_shoff + i * elf64_header.e_shentsize));
 
       // read section header
       in.read(
diff --git a/src/goto-programs/elf_reader.h b/src/goto-programs/elf_reader.h
@@ -143,9 +143,14 @@ class elf_readert
 
   std::streampos section_offset(std::size_t index) const
   {
-    return
-      elf_class==ELF32?elf32_section_header_table[index].sh_offset:
-                       elf64_section_header_table[index].sh_offset;
+    // Visual Studio insists on a type cast to std::streamoff, for an unknown
+    // reason
+    if(elf_class == ELF32)
+      return static_cast<std::streamoff>(
+        elf32_section_header_table[index].sh_offset);
+    else
+      return static_cast<std::streamoff>(
+        elf64_section_header_table[index].sh_offset);
   }
 
   bool has_section(const std::string &name) const;
diff --git a/src/goto-programs/read_bin_goto_object.cpp b/src/goto-programs/read_bin_goto_object.cpp
@@ -146,7 +146,8 @@ static void read_bin_functions_object(
       std::size_t t_count = irepconverter.read_gb_word(in); // # of targets
       for(std::size_t i=0; i<t_count; i++)
         // just save the target numbers
-        target_map[itarget].push_back(irepconverter.read_gb_word(in));
+        target_map[itarget].push_back(
+          static_cast<unsigned>(irepconverter.read_gb_word(in)));
 
       std::size_t l_count = irepconverter.read_gb_word(in); // # of labels
 
diff --git a/src/goto-programs/read_goto_binary.cpp b/src/goto-programs/read_goto_binary.cpp
@@ -98,7 +98,7 @@ static bool read_goto_binary(
       for(unsigned i=0; i<elf_reader.number_of_sections; i++)
         if(elf_reader.section_name(i)=="goto-cc")
         {
-          in.seekg(elf_reader.section_offset(i));
+          in.seekg(static_cast<std::streamoff>(elf_reader.section_offset(i)));
           return read_bin_goto_object(
             in, filename, symbol_table, goto_functions, message_handler);
         }
diff --git a/src/solvers/floatbv/float_bv.cpp b/src/solvers/floatbv/float_bv.cpp
@@ -426,7 +426,7 @@ exprt float_bvt::conversion(
 
   int sourceSmallestNormalExponent = -((1 << (src_spec.e - 1)) - 1);
   int sourceSmallestDenormalExponent =
-    sourceSmallestNormalExponent - src_spec.f;
+    sourceSmallestNormalExponent - static_cast<int>(src_spec.f);
 
   // Using the fact that f doesn't include the hidden bit
 
diff --git a/src/solvers/floatbv/float_utils.cpp b/src/solvers/floatbv/float_utils.cpp
@@ -168,7 +168,7 @@ bvt float_utilst::conversion(
 
   int sourceSmallestNormalExponent=-((1 << (spec.e - 1)) - 1);
   int sourceSmallestDenormalExponent =
-    sourceSmallestNormalExponent - spec.f;
+    sourceSmallestNormalExponent - static_cast<int>(spec.f);
 
   // Using the fact that f doesn't include the hidden bit
 
diff --git a/src/solvers/sat/cnf.cpp b/src/solvers/sat/cnf.cpp
@@ -384,7 +384,7 @@ literalt cnft::lselect(literalt a, literalt b, literalt c)
 /// \return New variable as literal
 literalt cnft::new_variable()
 {
-  literalt l(_no_variables, false);
+  literalt l(static_cast<literalt::var_not>(_no_variables), false);
 
   set_no_variables(_no_variables+1);
 
diff --git a/src/solvers/sat/satcheck_minisat2.cpp b/src/solvers/sat/satcheck_minisat2.cpp
@@ -309,7 +309,7 @@ void satcheck_minisat2_baset<T>::set_assignment(literalt a, bool value)
 
   try
   {
-    unsigned v = a.var_no();
+    unsigned v = static_cast<unsigned>(a.var_no());
     bool sign = a.sign();
 
     // MiniSat2 kills the model in case of UNSAT
@@ -359,7 +359,7 @@ void satcheck_minisat_simplifiert::set_frozen(literalt a)
     if(!a.is_constant())
     {
       add_variables();
-      solver->setFrozen(a.var_no(), true);
+      solver->setFrozen(static_cast<int>(a.var_no()), true);
     }
   }
   catch(const Minisat::OutOfMemoryException &)
@@ -374,5 +374,5 @@ bool satcheck_minisat_simplifiert::is_eliminated(literalt a) const
 {
   PRECONDITION(!a.is_constant());
 
-  return solver->isEliminated(a.var_no());
+  return solver->isEliminated(static_cast<int>(a.var_no()));
 }
diff --git a/src/solvers/smt2/smt2_conv.cpp b/src/solvers/smt2/smt2_conv.cpp
@@ -917,7 +917,7 @@ literalt smt2_convt::convert(const exprt &expr)
 
   exprt prepared_expr = prepare_for_convert_expr(expr);
 
-  literalt l(no_boolean_variables, false);
+  literalt l(static_cast<unsigned>(no_boolean_variables), false);
   no_boolean_variables++;
 
   out << "; convert\n";
diff --git a/src/solvers/strings/string_constraint_generator_float.cpp b/src/solvers/strings/string_constraint_generator_float.cpp
@@ -79,7 +79,7 @@ exprt constant_float(const double f, const ieee_float_spect &float_spec)
 {
   ieee_float_valuet fl(float_spec);
   if(float_spec == ieee_float_spect::single_precision())
-    fl.from_float(f);
+    fl.from_float(static_cast<float>(f));
   else if(float_spec == ieee_float_spect::double_precision())
     fl.from_double(f);
   else
diff --git a/src/util/arith_tools.cpp b/src/util/arith_tools.cpp
@@ -290,7 +290,8 @@ bool get_bvrep_bit(
     "bvrep is hexadecimal, upper-case");
 
   const unsigned char nibble_value =
-    isdigit(nibble) ? nibble - '0' : nibble - 'A' + 10;
+    isdigit(nibble) ? static_cast<unsigned char>(nibble - '0')
+                    : static_cast<unsigned char>(nibble - 'A' + 10);
 
   return ((nibble_value >> (bit_index % 4)) & 1) != 0;
 }
diff --git a/src/util/irep_hash.h b/src/util/irep_hash.h
@@ -83,7 +83,8 @@ inline std::size_t basic_hash_combine<32>(
   std::size_t h1,
   std::size_t h2)
 {
-  return ROTL32(h1, 7)^h2;
+  return static_cast<std::size_t>(
+    ROTL32(static_cast<uint32_t>(h1), 7) ^ static_cast<uint32_t>(h2));
 }
 
 template<>
diff --git a/src/util/irep_serialization.cpp b/src/util/irep_serialization.cpp
@@ -129,7 +129,7 @@ void write_gb_word(std::ostream &out, std::size_t u)
 
     if(u==0)
     {
-      out.put(value);
+      out.put(static_cast<char>(value));
       break;
     }
 
diff --git a/src/util/run.cpp b/src/util/run.cpp
@@ -342,7 +342,7 @@ int run(
   CloseHandle(piProcInfo.hProcess);
   CloseHandle(piProcInfo.hThread);
 
-  return exit_code;
+  return static_cast<int>(exit_code);
 
 #else
   int stdin_fd = stdio_redirection(STDIN_FILENO, std_input);
diff --git a/src/util/small_map.h b/src/util/small_map.h
@@ -389,7 +389,7 @@ class small_mapt
 
   const_value_iterator value_begin() const
   {
-    return const_value_iterator(*this, size() - 1);
+    return const_value_iterator(*this, static_cast<int>(size()) - 1);
   }
 
   const_value_iterator value_end() const
diff --git a/src/util/string_container.cpp b/src/util/string_container.cpp
@@ -40,7 +40,7 @@ unsigned string_containert::get(const char *s)
   if(it!=hash_table.end())
     return it->second;
 
-  size_t r=hash_table.size();
+  const unsigned r = static_cast<unsigned>(hash_table.size());
 
   // these are stable
   string_list.push_back(std::string(s));
@@ -63,7 +63,7 @@ unsigned string_containert::get(const std::string &s)
   if(it!=hash_table.end())
     return it->second;
 
-  size_t r=hash_table.size();
+  const unsigned r = static_cast<unsigned>(hash_table.size());
 
   // these are stable
   string_list.push_back(s);
diff --git a/src/util/tempfile.cpp b/src/util/tempfile.cpp
@@ -130,7 +130,7 @@ std::string get_temporary_file(
 
   char *t_ptr=strdup(t_template.c_str());
 
-  int fd=mkstemps(t_ptr, suffix.size());
+  int fd = mkstemps(t_ptr, static_cast<int>(suffix.size()));
 
   if(fd<0)
     throw system_exceptiont("Failed to open temporary file");
diff --git a/src/util/xml.cpp b/src/util/xml.cpp
@@ -260,7 +260,8 @@ std::string xmlt::unescape(const std::string &str)
         result+='&';
       else if(tmp[0]=='#' && tmp[1]!='x')
       {
-        char c=unsafe_string2int(tmp.substr(1, tmp.size()-1));
+        char c =
+          static_cast<char>(unsafe_string2int(tmp.substr(1, tmp.size() - 1)));
         result+=c;
       }
       else

Original file line number	Diff line number	Diff line change
`@@ -2233,7 +2233,7 @@ std::string expr2ct::convert_array(const exprt &src)`
`2233`	`2233`	`if(last_was_hex)`
`2234`	`2234`	`{`
`2235`	`2235`	`// we use "string splicing" to avoid ambiguity`
`2236`		`- if(isxdigit(ch))`
	`2236`	`+ if(isxdigit(static_cast<int>(ch)))`
`2237`	`2237`	`dest+="\" \"";`
`2238`	`2238`
`2239`	`2239`	`last_was_hex=false;`
Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,7 @@ std::basic_string<char32_t> convert_one_string_literal(const std::string &src)`
`36`	`36`	`// pad into wide string`
`37`	`37`	`value.resize(utf8_value.size());`
`38`	`38`	`for(std::size_t i=0; i<utf8_value.size(); i++)`
`39`		`- value[i]=utf8_value[i];`
	`39`	`+ value[i] = static_cast<unsigned int>(utf8_value[i]);`
`40`	`40`
`41`	`41`	`return value;`
`42`	`42`	`}`
`@@ -59,7 +59,7 @@ std::basic_string<char32_t> convert_one_string_literal(const std::string &src)`
`59`	`59`	`std::basic_string<char32_t> value;`
`60`	`60`	`value.resize(char_value.size());`
`61`	`61`	`for(std::size_t i=0; i<char_value.size(); i++)`
`62`		`- value[i]=char_value[i];`
	`62`	`+ value[i] = static_cast<unsigned int>(char_value[i]);`
`63`	`63`
`64`	`64`	`return value;`
`65`	`65`	`}`
`@@ -143,7 +143,7 @@ exprt convert_string_literal(const std::string &src)`
`143`	`143`	`{`
`144`	`144`	`// Loss of data here if value[i]>255.`
`145`	`145`	`// gcc issues a warning in this case.`
`146`		`- char_value[i]=value[i];`
	`146`	`+ char_value[i] = static_cast<char>(value[i]);`
`147`	`147`	`}`
`148`	`148`
`149`	`149`	`return string_constantt(char_value);`
Original file line number	Diff line number	Diff line change
`@@ -43,15 +43,15 @@ std::basic_string<T> unescape_string_templ(const std::string &src)`
`43`	`43`
`44`	`44`	`for(unsigned i=0; i<src.size(); i++)`
`45`	`45`	`{`
`46`		`- T ch=(unsigned char)src[i];`
	`46`	`+ T ch = static_cast<T>(static_cast<unsigned char>(src[i]));`
`47`	`47`
`48`	`48`	`if(ch=='\\') // escape?`
`49`	`49`	`{`
`50`	`50`	`// go to next character`
`51`	`51`	`i++;`
`52`	`52`	`INVARIANT(i < src.size(), "backslash can't be last character");`
`53`	`53`
`54`		`- ch=(unsigned char)src[i];`
	`54`	`+ ch = static_cast<T>(static_cast<unsigned char>(src[i]));`
`55`	`55`	`switch(ch)`
`56`	`56`	`{`
`57`	`57`	`case '\\': dest.push_back(ch); break;`
`@@ -105,7 +105,7 @@ std::basic_string<T> unescape_string_templ(const std::string &src)`
`105`	`105`	`// go back`
`106`	`106`	`i--;`
`107`	`107`
`108`		`- ch=hex_to_unsigned(hex.c_str(), hex.size());`
	`108`	`+ ch = static_cast<T>(hex_to_unsigned(hex.c_str(), hex.size()));`
`109`	`109`	`}`
`110`	`110`
`111`	`111`	`// if T isn't sufficiently wide to hold unsigned values`
`@@ -116,7 +116,7 @@ std::basic_string<T> unescape_string_templ(const std::string &src)`
`116`	`116`	`break;`
`117`	`117`
`118`	`118`	`default:`
`119`		`- if(isdigit(ch)) // octal`
	`119`	`+ if(isdigit(static_cast<int>(ch))) // octal`
`120`	`120`	`{`
`121`	`121`	`std::string octal;`
`122`	`122`
`@@ -129,7 +129,7 @@ std::basic_string<T> unescape_string_templ(const std::string &src)`
`129`	`129`	`// go back`
`130`	`130`	`i--;`
`131`	`131`
`132`		`- ch=octal_to_unsigned(octal.c_str(), octal.size());`
	`132`	`+ ch = static_cast<T>(octal_to_unsigned(octal.c_str(), octal.size()));`
`133`	`133`	`dest.push_back(ch);`
`134`	`134`	`}`
`135`	`135`	`else`
Original file line number	Diff line number	Diff line change
`@@ -98,7 +98,7 @@ static bool read_goto_binary(`
`98`	`98`	`for(unsigned i=0; i<elf_reader.number_of_sections; i++)`
`99`	`99`	`if(elf_reader.section_name(i)=="goto-cc")`
`100`	`100`	`{`
`101`		`- in.seekg(elf_reader.section_offset(i));`
	`101`	`+ in.seekg(static_cast<std::streamoff>(elf_reader.section_offset(i)));`
`102`	`102`	`return read_bin_goto_object(`
`103`	`103`	`in, filename, symbol_table, goto_functions, message_handler);`
`104`	`104`	`}`