Add some std:: qualifiers to types and functions.

PiperOrigin-RevId: 309110431

17 files changed, 102 insertions, 94 deletions

diff --git a/db/autocompact_test.cc b/db/autocompact_test.cc
index 9779c95..3b7241b 100644
--- a/db/autocompact_test.cc
+++ b/db/autocompact_test.cc
@@ -30,7 +30,7 @@ class AutoCompactTest : public testing::Test {
 
   std::string Key(int i) {
     char buf[100];
-    snprintf(buf, sizeof(buf), "key%06d", i);
+    std::snprintf(buf, sizeof(buf), "key%06d", i);
     return std::string(buf);
   }
 
@@ -89,8 +89,8 @@ void AutoCompactTest::DoReads(int n) {
     // Wait a little bit to allow any triggered compactions to complete.
     Env::Default()->SleepForMicroseconds(1000000);
     uint64_t size = Size(Key(0), Key(n));
-    fprintf(stderr, "iter %3d => %7.3f MB [other %7.3f MB]\n", read + 1,
-            size / 1048576.0, Size(Key(n), Key(kCount)) / 1048576.0);
+    std::fprintf(stderr, "iter %3d => %7.3f MB [other %7.3f MB]\n", read + 1,
+                 size / 1048576.0, Size(Key(n), Key(kCount)) / 1048576.0);
     if (size <= initial_size / 10) {
       break;
     }
diff --git a/db/c.cc b/db/c.cc
index 3a492f9..b5c9251 100644
--- a/db/c.cc
+++ b/db/c.cc
@@ -158,7 +158,7 @@ static bool SaveError(char** errptr, const Status& s) {
 
 static char* CopyString(const std::string& str) {
   char* result = reinterpret_cast<char*>(malloc(sizeof(char) * str.size()));
-  memcpy(result, str.data(), sizeof(char) * str.size());
+  std::memcpy(result, str.data(), sizeof(char) * str.size());
   return result;
 }
 
@@ -548,7 +548,7 @@ char* leveldb_env_get_test_directory(leveldb_env_t* env) {
   }
 
   char* buffer = static_cast<char*>(malloc(result.size() + 1));
-  memcpy(buffer, result.data(), result.size());
+  std::memcpy(buffer, result.data(), result.size());
   buffer[result.size()] = '\0';
   return buffer;
 }
diff --git a/db/corruption_test.cc b/db/corruption_test.cc
index b22f9e7..a31f448 100644
--- a/db/corruption_test.cc
+++ b/db/corruption_test.cc
@@ -58,7 +58,7 @@ class CorruptionTest : public testing::Test {
     std::string key_space, value_space;
     WriteBatch batch;
     for (int i = 0; i < n; i++) {
-      // if ((i % 100) == 0) fprintf(stderr, "@ %d of %d\n", i, n);
+      // if ((i % 100) == 0) std::fprintf(stderr, "@ %d of %d\n", i, n);
       Slice key = Key(i, &key_space);
       batch.Clear();
       batch.Put(key, Value(i, &value_space));
@@ -102,9 +102,10 @@ class CorruptionTest : public testing::Test {
     }
     delete iter;
 
-    fprintf(stderr,
-            "expected=%d..%d; got=%d; bad_keys=%d; bad_values=%d; missed=%d\n",
-            min_expected, max_expected, correct, bad_keys, bad_values, missed);
+    std::fprintf(
+        stderr,
+        "expected=%d..%d; got=%d; bad_keys=%d; bad_values=%d; missed=%d\n",
+        min_expected, max_expected, correct, bad_keys, bad_values, missed);
     ASSERT_LE(min_expected, correct);
     ASSERT_GE(max_expected, correct);
   }
@@ -169,7 +170,7 @@ class CorruptionTest : public testing::Test {
   // Return the ith key
   Slice Key(int i, std::string* storage) {
     char buf[100];
-    snprintf(buf, sizeof(buf), "%016d", i);
+    std::snprintf(buf, sizeof(buf), "%016d", i);
     storage->assign(buf, strlen(buf));
     return Slice(*storage);
   }
diff --git a/db/db_impl.cc b/db/db_impl.cc
index ca53485..59b834f 100644
--- a/db/db_impl.cc
+++ b/db/db_impl.cc
@@ -350,8 +350,8 @@ Status DBImpl::Recover(VersionEdit* edit, bool* save_manifest) {
   }
   if (!expected.empty()) {
     char buf[50];
-    snprintf(buf, sizeof(buf), "%d missing files; e.g.",
-             static_cast<int>(expected.size()));
+    std::snprintf(buf, sizeof(buf), "%d missing files; e.g.",
+                  static_cast<int>(expected.size()));
     return Status::Corruption(buf, TableFileName(dbname_, *(expected.begin())));
   }
 
@@ -1396,26 +1396,26 @@ bool DBImpl::GetProperty(const Slice& property, std::string* value) {
       return false;
     } else {
       char buf[100];
-      snprintf(buf, sizeof(buf), "%d",
-               versions_->NumLevelFiles(static_cast<int>(level)));
+      std::snprintf(buf, sizeof(buf), "%d",
+                    versions_->NumLevelFiles(static_cast<int>(level)));
       *value = buf;
       return true;
     }
   } else if (in == "stats") {
     char buf[200];
-    snprintf(buf, sizeof(buf),
-             "                               Compactions\n"
-             "Level  Files Size(MB) Time(sec) Read(MB) Write(MB)\n"
-             "--------------------------------------------------\n");
+    std::snprintf(buf, sizeof(buf),
+                  "                               Compactions\n"
+                  "Level  Files Size(MB) Time(sec) Read(MB) Write(MB)\n"
+                  "--------------------------------------------------\n");
     value->append(buf);
     for (int level = 0; level < config::kNumLevels; level++) {
       int files = versions_->NumLevelFiles(level);
       if (stats_[level].micros > 0 || files > 0) {
-        snprintf(buf, sizeof(buf), "%3d %8d %8.0f %9.0f %8.0f %9.0f\n", level,
-                 files, versions_->NumLevelBytes(level) / 1048576.0,
-                 stats_[level].micros / 1e6,
-                 stats_[level].bytes_read / 1048576.0,
-                 stats_[level].bytes_written / 1048576.0);
+        std::snprintf(buf, sizeof(buf), "%3d %8d %8.0f %9.0f %8.0f %9.0f\n",
+                      level, files, versions_->NumLevelBytes(level) / 1048576.0,
+                      stats_[level].micros / 1e6,
+                      stats_[level].bytes_read / 1048576.0,
+                      stats_[level].bytes_written / 1048576.0);
         value->append(buf);
       }
     }
@@ -1432,8 +1432,8 @@ bool DBImpl::GetProperty(const Slice& property, std::string* value) {
       total_usage += imm_->ApproximateMemoryUsage();
     }
     char buf[50];
-    snprintf(buf, sizeof(buf), "%llu",
-             static_cast<unsigned long long>(total_usage));
+    std::snprintf(buf, sizeof(buf), "%llu",
+                  static_cast<unsigned long long>(total_usage));
     value->append(buf);
     return true;
   }
diff --git a/db/db_iter.cc b/db/db_iter.cc
index 98715a9..532c2db 100644
--- a/db/db_iter.cc
+++ b/db/db_iter.cc
@@ -21,9 +21,9 @@ static void DumpInternalIter(Iterator* iter) {
   for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
     ParsedInternalKey k;
     if (!ParseInternalKey(iter->key(), &k)) {
-      fprintf(stderr, "Corrupt '%s'\n", EscapeString(iter->key()).c_str());
+      std::fprintf(stderr, "Corrupt '%s'\n", EscapeString(iter->key()).c_str());
     } else {
-      fprintf(stderr, "@ '%s'\n", k.DebugString().c_str());
+      std::fprintf(stderr, "@ '%s'\n", k.DebugString().c_str());
     }
   }
 }
diff --git a/db/db_test.cc b/db/db_test.cc
index 8cd90f3..3a45731 100644
--- a/db/db_test.cc
+++ b/db/db_test.cc
@@ -424,7 +424,7 @@ class DBTest : public testing::Test {
     for (int level = 0; level < config::kNumLevels; level++) {
       int f = NumTableFilesAtLevel(level);
       char buf[100];
-      snprintf(buf, sizeof(buf), "%s%d", (level ? "," : ""), f);
+      std::snprintf(buf, sizeof(buf), "%s%d", (level ? "," : ""), f);
       result += buf;
       if (f > 0) {
         last_non_zero_offset = result.size();
@@ -469,14 +469,14 @@ class DBTest : public testing::Test {
   }
 
   void DumpFileCounts(const char* label) {
-    fprintf(stderr, "---\n%s:\n", label);
-    fprintf(
+    std::fprintf(stderr, "---\n%s:\n", label);
+    std::fprintf(
         stderr, "maxoverlap: %lld\n",
         static_cast<long long>(dbfull()->TEST_MaxNextLevelOverlappingBytes()));
     for (int level = 0; level < config::kNumLevels; level++) {
       int num = NumTableFilesAtLevel(level);
       if (num > 0) {
-        fprintf(stderr, "  level %3d : %d files\n", level, num);
+        std::fprintf(stderr, "  level %3d : %d files\n", level, num);
       }
     }
   }
@@ -1024,7 +1024,7 @@ TEST_F(DBTest, RecoverDuringMemtableCompaction) {
 
 static std::string Key(int i) {
   char buf[100];
-  snprintf(buf, sizeof(buf), "key%06d", i);
+  std::snprintf(buf, sizeof(buf), "key%06d", i);
   return std::string(buf);
 }
 
@@ -1118,7 +1118,7 @@ TEST_F(DBTest, RepeatedWritesToSameKey) {
   for (int i = 0; i < 5 * kMaxFiles; i++) {
     Put("key", value);
     ASSERT_LE(TotalTableFiles(), kMaxFiles);
-    fprintf(stderr, "after %d: %d files\n", i + 1, TotalTableFiles());
+    std::fprintf(stderr, "after %d: %d files\n", i + 1, TotalTableFiles());
   }
 }
 
@@ -1140,7 +1140,7 @@ TEST_F(DBTest, SparseMerge) {
   // Write approximately 100MB of "B" values
   for (int i = 0; i < 100000; i++) {
     char key[100];
-    snprintf(key, sizeof(key), "B%010d", i);
+    std::snprintf(key, sizeof(key), "B%010d", i);
     Put(key, value);
   }
   Put("C", "vc");
@@ -1165,9 +1165,9 @@ TEST_F(DBTest, SparseMerge) {
 static bool Between(uint64_t val, uint64_t low, uint64_t high) {
   bool result = (val >= low) && (val <= high);
   if (!result) {
-    fprintf(stderr, "Value %llu is not in range [%llu, %llu]\n",
-            (unsigned long long)(val), (unsigned long long)(low),
-            (unsigned long long)(high));
+    std::fprintf(stderr, "Value %llu is not in range [%llu, %llu]\n",
+                 (unsigned long long)(val), (unsigned long long)(low),
+                 (unsigned long long)(high));
   }
   return result;
 }
@@ -1501,7 +1501,7 @@ TEST_F(DBTest, Fflush_Issue474) {
   static const int kNum = 100000;
   Random rnd(test::RandomSeed());
   for (int i = 0; i < kNum; i++) {
-    fflush(nullptr);
+    std::fflush(nullptr);
     ASSERT_LEVELDB_OK(Put(RandomKey(&rnd), RandomString(&rnd, 100)));
   }
 }
@@ -1578,7 +1578,7 @@ TEST_F(DBTest, CustomComparator) {
   for (int run = 0; run < 2; run++) {
     for (int i = 0; i < 1000; i++) {
       char buf[100];
-      snprintf(buf, sizeof(buf), "[%d]", i * 10);
+      std::snprintf(buf, sizeof(buf), "[%d]", i * 10);
       ASSERT_LEVELDB_OK(Put(buf, buf));
     }
     Compact("[0]", "[1000000]");
@@ -1748,7 +1748,7 @@ TEST_F(DBTest, NonWritableFileSystem) {
   std::string big(100000, 'x');
   int errors = 0;
   for (int i = 0; i < 20; i++) {
-    fprintf(stderr, "iter %d; errors %d\n", i, errors);
+    std::fprintf(stderr, "iter %d; errors %d\n", i, errors);
     if (!Put("foo", big).ok()) {
       errors++;
       DelayMilliseconds(100);
@@ -1901,7 +1901,7 @@ TEST_F(DBTest, BloomFilter) {
     ASSERT_EQ(Key(i), Get(Key(i)));
   }
   int reads = env_->random_read_counter_.Read();
-  fprintf(stderr, "%d present => %d reads\n", N, reads);
+  std::fprintf(stderr, "%d present => %d reads\n", N, reads);
   ASSERT_GE(reads, N);
   ASSERT_LE(reads, N + 2 * N / 100);
 
@@ -1911,7 +1911,7 @@ TEST_F(DBTest, BloomFilter) {
     ASSERT_EQ("NOT_FOUND", Get(Key(i) + ".missing"));
   }
   reads = env_->random_read_counter_.Read();
-  fprintf(stderr, "%d missing => %d reads\n", N, reads);
+  std::fprintf(stderr, "%d missing => %d reads\n", N, reads);
   ASSERT_LE(reads, 3 * N / 100);
 
   env_->delay_data_sync_.store(false, std::memory_order_release);
@@ -1944,7 +1944,7 @@ static void MTThreadBody(void* arg) {
   int id = t->id;
   DB* db = t->state->test->db_;
   int counter = 0;
-  fprintf(stderr, "... starting thread %d\n", id);
+  std::fprintf(stderr, "... starting thread %d\n", id);
   Random rnd(1000 + id);
   std::string value;
   char valbuf[1500];
@@ -1953,13 +1953,13 @@ static void MTThreadBody(void* arg) {
 
     int key = rnd.Uniform(kNumKeys);
     char keybuf[20];
-    snprintf(keybuf, sizeof(keybuf), "%016d", key);
+    std::snprintf(keybuf, sizeof(keybuf), "%016d", key);
 
     if (rnd.OneIn(2)) {
       // Write values of the form <key, my id, counter>.
       // We add some padding for force compactions.
-      snprintf(valbuf, sizeof(valbuf), "%d.%d.%-1000d", key, id,
-               static_cast<int>(counter));
+      std::snprintf(valbuf, sizeof(valbuf), "%d.%d.%-1000d", key, id,
+                    static_cast<int>(counter));
       ASSERT_LEVELDB_OK(db->Put(WriteOptions(), Slice(keybuf), Slice(valbuf)));
     } else {
       // Read a value and verify that it matches the pattern written above.
@@ -1980,7 +1980,7 @@ static void MTThreadBody(void* arg) {
     counter++;
   }
   t->state->thread_done[id].store(true, std::memory_order_release);
-  fprintf(stderr, "... stopping thread %d after %d ops\n", id, counter);
+  std::fprintf(stderr, "... stopping thread %d after %d ops\n", id, counter);
 }
 
 }  // namespace
@@ -2134,30 +2134,31 @@ static bool CompareIterators(int step, DB* model, DB* db,
        ok && miter->Valid() && dbiter->Valid(); miter->Next(), dbiter->Next()) {
     count++;
     if (miter->key().compare(dbiter->key()) != 0) {
-      fprintf(stderr, "step %d: Key mismatch: '%s' vs. '%s'\n", step,
-              EscapeString(miter->key()).c_str(),
-              EscapeString(dbiter->key()).c_str());
+      std::fprintf(stderr, "step %d: Key mismatch: '%s' vs. '%s'\n", step,
+                   EscapeString(miter->key()).c_str(),
+                   EscapeString(dbiter->key()).c_str());
       ok = false;
       break;
     }
 
     if (miter->value().compare(dbiter->value()) != 0) {
-      fprintf(stderr, "step %d: Value mismatch for key '%s': '%s' vs. '%s'\n",
-              step, EscapeString(miter->key()).c_str(),
-              EscapeString(miter->value()).c_str(),
-              EscapeString(miter->value()).c_str());
+      std::fprintf(stderr,
+                   "step %d: Value mismatch for key '%s': '%s' vs. '%s'\n",
+                   step, EscapeString(miter->key()).c_str(),
+                   EscapeString(miter->value()).c_str(),
+                   EscapeString(miter->value()).c_str());
       ok = false;
     }
   }
 
   if (ok) {
     if (miter->Valid() != dbiter->Valid()) {
-      fprintf(stderr, "step %d: Mismatch at end of iterators: %d vs. %d\n",
-              step, miter->Valid(), dbiter->Valid());
+      std::fprintf(stderr, "step %d: Mismatch at end of iterators: %d vs. %d\n",
+                   step, miter->Valid(), dbiter->Valid());
       ok = false;
     }
   }
-  fprintf(stderr, "%d entries compared: ok=%d\n", count, ok);
+  std::fprintf(stderr, "%d entries compared: ok=%d\n", count, ok);
   delete miter;
   delete dbiter;
   return ok;
@@ -2173,7 +2174,7 @@ TEST_F(DBTest, Randomized) {
     std::string k, v;
     for (int step = 0; step < N; step++) {
       if (step % 100 == 0) {
-        fprintf(stderr, "Step %d of %d\n", step, N);
+        std::fprintf(stderr, "Step %d of %d\n", step, N);
       }
       // TODO(sanjay): Test Get() works
       int p = rnd.Uniform(100);
@@ -2233,7 +2234,7 @@ TEST_F(DBTest, Randomized) {
 
 std::string MakeKey(unsigned int num) {
   char buf[30];
-  snprintf(buf, sizeof(buf), "%016u", num);
+  std::snprintf(buf, sizeof(buf), "%016u", num);
   return std::string(buf);
 }
 
@@ -2283,10 +2284,10 @@ void BM_LogAndApply(int iters, int num_base_files) {
   uint64_t stop_micros = env->NowMicros();
   unsigned int us = stop_micros - start_micros;
   char buf[16];
-  snprintf(buf, sizeof(buf), "%d", num_base_files);
-  fprintf(stderr,
-          "BM_LogAndApply/%-6s   %8d iters : %9u us (%7.0f us / iter)\n", buf,
-          iters, us, ((float)us) / iters);
+  std::snprintf(buf, sizeof(buf), "%d", num_base_files);
+  std::fprintf(stderr,
+               "BM_LogAndApply/%-6s   %8d iters : %9u us (%7.0f us / iter)\n",
+               buf, iters, us, ((float)us) / iters);
 }
 
 }  // namespace leveldb
diff --git a/db/dbformat.cc b/db/dbformat.cc
index 019aa92..2a5749f 100644
--- a/db/dbformat.cc
+++ b/db/dbformat.cc
@@ -126,7 +126,7 @@ LookupKey::LookupKey(const Slice& user_key, SequenceNumber s) {
   start_ = dst;
   dst = EncodeVarint32(dst, usize + 8);
   kstart_ = dst;
-  memcpy(dst, user_key.data(), usize);
+  std::memcpy(dst, user_key.data(), usize);
   dst += usize;
   EncodeFixed64(dst, PackSequenceAndType(s, kValueTypeForSeek));
   dst += 8;
diff --git a/db/fault_injection_test.cc b/db/fault_injection_test.cc
index 8f2b647..6eebafa 100644
--- a/db/fault_injection_test.cc
+++ b/db/fault_injection_test.cc
@@ -427,7 +427,7 @@ class FaultInjectionTest : public testing::Test {
           EXPECT_EQ(value_space, val);
         }
       } else if (s.ok()) {
-        fprintf(stderr, "Expected an error at %d, but was OK\n", i);
+        std::fprintf(stderr, "Expected an error at %d, but was OK\n", i);
         s = Status::IOError(dbname_, "Expected value error:");
       } else {
         s = Status::OK();  // An expected error
@@ -439,7 +439,7 @@ class FaultInjectionTest : public testing::Test {
   // Return the ith key
   Slice Key(int i, std::string* storage) const {
     char buf[100];
-    snprintf(buf, sizeof(buf), "%016d", i);
+    std::snprintf(buf, sizeof(buf), "%016d", i);
     storage->assign(buf, strlen(buf));
     return Slice(*storage);
   }
diff --git a/db/filename.cc b/db/filename.cc
index f6bec00..e526249 100644
--- a/db/filename.cc
+++ b/db/filename.cc
@@ -20,8 +20,8 @@ Status WriteStringToFileSync(Env* env, const Slice& data,
 static std::string MakeFileName(const std::string& dbname, uint64_t number,
                                 const char* suffix) {
   char buf[100];
-  snprintf(buf, sizeof(buf), "/%06llu.%s",
-           static_cast<unsigned long long>(number), suffix);
+  std::snprintf(buf, sizeof(buf), "/%06llu.%s",
+                static_cast<unsigned long long>(number), suffix);
   return dbname + buf;
 }
 
@@ -43,8 +43,8 @@ std::string SSTTableFileName(const std::string& dbname, uint64_t number) {
 std::string DescriptorFileName(const std::string& dbname, uint64_t number) {
   assert(number > 0);
   char buf[100];
-  snprintf(buf, sizeof(buf), "/MANIFEST-%06llu",
-           static_cast<unsigned long long>(number));
+  std::snprintf(buf, sizeof(buf), "/MANIFEST-%06llu",
+                static_cast<unsigned long long>(number));
   return dbname + buf;
 }
 
diff --git a/db/leveldbutil.cc b/db/leveldbutil.cc
index 8e94abd..95ee897 100644
--- a/db/leveldbutil.cc
+++ b/db/leveldbutil.cc
@@ -28,7 +28,7 @@ bool HandleDumpCommand(Env* env, char** files, int num) {
   for (int i = 0; i < num; i++) {
     Status s = DumpFile(env, files[i], &printer);
     if (!s.ok()) {
-      fprintf(stderr, "%s\n", s.ToString().c_str());
+      std::fprintf(stderr, "%s\n", s.ToString().c_str());
       ok = false;
     }
   }
@@ -39,9 +39,10 @@ bool HandleDumpCommand(Env* env, char** files, int num) {
 }  // namespace leveldb
 
 static void Usage() {
-  fprintf(stderr,
-          "Usage: leveldbutil command...\n"
-          "   dump files...         -- dump contents of specified files\n");
+  std::fprintf(
+      stderr,
+      "Usage: leveldbutil command...\n"
+      "   dump files...         -- dump contents of specified files\n");
 }
 
 int main(int argc, char** argv) {
diff --git a/db/log_reader.cc b/db/log_reader.cc
index dcd4b75..9880279 100644
--- a/db/log_reader.cc
+++ b/db/log_reader.cc
@@ -160,7 +160,7 @@ bool Reader::ReadRecord(Slice* record, std::string* scratch) {
 
       default: {
         char buf[40];
-        snprintf(buf, sizeof(buf), "unknown record type %u", record_type);
+        std::snprintf(buf, sizeof(buf), "unknown record type %u", record_type);
         ReportCorruption(
             (fragment.size() + (in_fragmented_record ? scratch->size() : 0)),
             buf);
diff --git a/db/log_test.cc b/db/log_test.cc
index c765e93..346b19c 100644
--- a/db/log_test.cc
+++ b/db/log_test.cc
@@ -27,7 +27,7 @@ static std::string BigString(const std::string& partial_string, size_t n) {
 // Construct a string from a number
 static std::string NumberString(int n) {
   char buf[50];
-  snprintf(buf, sizeof(buf), "%d.", n);
+  std::snprintf(buf, sizeof(buf), "%d.", n);
   return std::string(buf);
 }
 
diff --git a/db/memtable.cc b/db/memtable.cc
index 00931d4..f42774d 100644
--- a/db/memtable.cc
+++ b/db/memtable.cc
@@ -88,12 +88,12 @@ void MemTable::Add(SequenceNumber s, ValueType type, const Slice& key,
                              val_size;
   char* buf = arena_.Allocate(encoded_len);
   char* p = EncodeVarint32(buf, internal_key_size);
-  memcpy(p, key.data(), key_size);
+  std::memcpy(p, key.data(), key_size);
   p += key_size;
   EncodeFixed64(p, (s << 8) | type);
   p += 8;
   p = EncodeVarint32(p, val_size);
-  memcpy(p, value.data(), val_size);
+  std::memcpy(p, value.data(), val_size);
   assert(p + val_size == buf + encoded_len);
   table_.Insert(buf);
 }
diff --git a/db/recovery_test.cc b/db/recovery_test.cc
index e5cc916..3db817e 100644
--- a/db/recovery_test.cc
+++ b/db/recovery_test.cc
@@ -160,7 +160,8 @@ class RecoveryTest : public testing::Test {
 
 TEST_F(RecoveryTest, ManifestReused) {
   if (!CanAppend()) {
-    fprintf(stderr, "skipping test because env does not support appending\n");
+    std::fprintf(stderr,
+                 "skipping test because env does not support appending\n");
     return;
   }
   ASSERT_LEVELDB_OK(Put("foo", "bar"));
@@ -176,7 +177,8 @@ TEST_F(RecoveryTest, ManifestReused) {
 
 TEST_F(RecoveryTest, LargeManifestCompacted) {
   if (!CanAppend()) {
-    fprintf(stderr, "skipping test because env does not support appending\n");
+    std::fprintf(stderr,
+                 "skipping test because env does not support appending\n");
     return;
   }
   ASSERT_LEVELDB_OK(Put("foo", "bar"));
@@ -216,7 +218,8 @@ TEST_F(RecoveryTest, NoLogFiles) {
 
 TEST_F(RecoveryTest, LogFileReuse) {
   if (!CanAppend()) {
-    fprintf(stderr, "skipping test because env does not support appending\n");
+    std::fprintf(stderr,
+                 "skipping test because env does not support appending\n");
     return;
   }
   for (int i = 0; i < 2; i++) {
@@ -249,7 +252,7 @@ TEST_F(RecoveryTest, MultipleMemTables) {
   const int kNum = 1000;
   for (int i = 0; i < kNum; i++) {
     char buf[100];
-    snprintf(buf, sizeof(buf), "%050d", i);
+    std::snprintf(buf, sizeof(buf), "%050d", i);
     ASSERT_LEVELDB_OK(Put(buf, buf));
   }
   ASSERT_EQ(0, NumTables());
@@ -268,7 +271,7 @@ TEST_F(RecoveryTest, MultipleMemTables) {
   ASSERT_NE(old_log_file, FirstLogFile()) << "must not reuse log";
   for (int i = 0; i < kNum; i++) {
     char buf[100];
-    snprintf(buf, sizeof(buf), "%050d", i);
+    std::snprintf(buf, sizeof(buf), "%050d", i);
     ASSERT_EQ(buf, Get(buf));
   }
 }
diff --git a/db/repair.cc b/db/repair.cc
index d2a495e..97a27c6 100644
--- a/db/repair.cc
+++ b/db/repair.cc
@@ -372,7 +372,8 @@ class Repairer {
                     t.meta.largest);
     }
 
-    // fprintf(stderr, "NewDescriptor:\n%s\n", edit_.DebugString().c_str());
+    // std::fprintf(stderr,
+    //              "NewDescriptor:\n%s\n", edit_.DebugString().c_str());
     {
       log::Writer log(file);
       std::string record;
diff --git a/db/skiplist_test.cc b/db/skiplist_test.cc
index b548017..79a5b86 100644
--- a/db/skiplist_test.cc
+++ b/db/skiplist_test.cc
@@ -346,7 +346,7 @@ static void RunConcurrent(int run) {
   const int kSize = 1000;
   for (int i = 0; i < N; i++) {
     if ((i % 100) == 0) {
-      fprintf(stderr, "Run %d of %d\n", i, N);
+      std::fprintf(stderr, "Run %d of %d\n", i, N);
     }
     TestState state(seed + 1);
     Env::Default()->Schedule(ConcurrentReader, &state);
diff --git a/db/version_set.cc b/db/version_set.cc
index f23ae14..a459587 100644
--- a/db/version_set.cc
+++ b/db/version_set.cc
@@ -703,10 +703,10 @@ class VersionSet::Builder {
           const InternalKey& prev_end = v->files_[level][i - 1]->largest;
           const InternalKey& this_begin = v->files_[level][i]->smallest;
           if (vset_->icmp_.Compare(prev_end, this_begin) >= 0) {
-            fprintf(stderr, "overlapping ranges in same level %s vs. %s\n",
-                    prev_end.DebugString().c_str(),
-                    this_begin.DebugString().c_str());
-            abort();
+            std::fprintf(stderr, "overlapping ranges in same level %s vs. %s\n",
+                         prev_end.DebugString().c_str(),
+                         this_begin.DebugString().c_str());
+            std::abort();
           }
         }
       }
@@ -1100,11 +1100,12 @@ int VersionSet::NumLevelFiles(int level) const {
 const char* VersionSet::LevelSummary(LevelSummaryStorage* scratch) const {
   // Update code if kNumLevels changes
   static_assert(config::kNumLevels == 7, "");
-  snprintf(scratch->buffer, sizeof(scratch->buffer),
-           "files[ %d %d %d %d %d %d %d ]", int(current_->files_[0].size()),
-           int(current_->files_[1].size()), int(current_->files_[2].size()),
-           int(current_->files_[3].size()), int(current_->files_[4].size()),
-           int(current_->files_[5].size()), int(current_->files_[6].size()));
+  std::snprintf(
+      scratch->buffer, sizeof(scratch->buffer), "files[ %d %d %d %d %d %d %d ]",
+      int(current_->files_[0].size()), int(current_->files_[1].size()),
+      int(current_->files_[2].size()), int(current_->files_[3].size()),
+      int(current_->files_[4].size()), int(current_->files_[5].size()),
+      int(current_->files_[6].size()));
   return scratch->buffer;
 }