Fix more MSVC warnings, courgette/ edition.

courgette/adjustment_method_2.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "courgette/adjustment_method.h"
 
 #include <algorithm>
 #include <limits>
 #include <list>
 #include <map>
@@ skipping 346 matching lines @@
 
 LabelInfo::~LabelInfo() {
   delete candidates_;
 }
 
 // A Shingle is a short fixed-length string of LabelInfos that actually occurs
 // in a Trace.  A Shingle may occur many times.  We repesent the Shingle by the
 // position of one of the occurrences in the Trace.
 class Shingle {
  public:
-  static const size_t kWidth = 5;
+  static const uint8 kWidth = 5;
 
   struct InterningLess {
     bool operator()(const Shingle& a, const Shingle& b) const;
   };
 
   typedef std::set<Shingle, InterningLess> OwningSet;
 
   static Shingle* Find(const Trace& trace, size_t position,
                        OwningSet* owning_set) {
     std::pair<OwningSet::iterator, bool> pair =
@@ skipping 45 matching lines @@
   // We can't disallow the copy constructor because we use std::set<Shingle> and
   // VS2005's implementation of std::set<T>::set() requires T to have a copy
   // constructor.
   //   DISALLOW_COPY_AND_ASSIGN(Shingle);
   void operator=(const Shingle&);  // Disallow assignment only.
 };
 
 std::string ToString(const Shingle* instance) {
   std::string s;
   const char* sep = "<";
-  for (size_t i = 0; i < Shingle::kWidth; ++i) {
+  for (uint8 i = 0; i < Shingle::kWidth; ++i) {
     // base::StringAppendF(&s, "%s%x ", sep, instance.at(i)->label_->rva_);
     s += sep;
     s += ToString(instance->at(i));
     sep = ", ";
   }
   base::StringAppendF(&s, ">(%" PRIuS ")@{%d}",
                       instance->exemplar_position_,
                       instance->position_count());
   return s;
 }
 
 
 bool Shingle::InterningLess::operator()(
     const Shingle& a,
     const Shingle& b) const {
-  for (size_t i = 0;  i < kWidth;  ++i) {
+  for (uint8 i = 0; i < kWidth; ++i) {
     LabelInfo* info_a = a.at(i);
     LabelInfo* info_b = b.at(i);
     if (info_a->label_->rva_ < info_b->label_->rva_)
       return true;
     if (info_a->label_->rva_ > info_b->label_->rva_)
       return false;
     if (info_a->is_model_ < info_b->is_model_)
       return true;
     if (info_a->is_model_ > info_b->is_model_)
       return false;
@@ skipping 59 matching lines @@
   int program_coverage_;
 };
 
 std::string ToString(const ShinglePattern::Index* index) {
   std::string s;
   if (index == NULL) {
     s = "<null>";
   } else {
     base::StringAppendF(&s, "<%d: ", index->variables_);
     const char* sep = "";
-    for (size_t i = 0;  i < Shingle::kWidth;  ++i) {
+    for (uint8 i = 0; i < Shingle::kWidth; ++i) {
       s += sep;
       sep = ", ";
       uint32 kind = index->kinds_[i];
       int offset = kind & ShinglePattern::kOffsetMask;
       if (kind & ShinglePattern::kVariable)
         base::StringAppendF(&s, "V%d", offset);
       else
         base::StringAppendF(&s, "%d", index->assigned_indexes_[offset]);
      }
     base::StringAppendF(&s, " %x", index->hash_);
@@ skipping 75 matching lines @@
   s += HistogramToStringFull(pattern->program_histogram_, "    ", max);
   return s;
 }
 
 struct ShinglePatternIndexLess {
   bool operator()(const ShinglePattern::Index& a,
                   const ShinglePattern::Index& b) const {
     if (a.hash_ < b.hash_) return true;
     if (a.hash_ > b.hash_) return false;
 
-    for (size_t i = 0;  i < Shingle::kWidth;  ++i) {
+    for (uint8 i = 0; i < Shingle::kWidth; ++i) {
       if (a.kinds_[i] < b.kinds_[i]) return true;
       if (a.kinds_[i] > b.kinds_[i]) return false;
       if ((a.kinds_[i] & ShinglePattern::kVariable) == 0) {
         if (a.assigned_indexes_[i] < b.assigned_indexes_[i])
           return true;
         if (a.assigned_indexes_[i] > b.assigned_indexes_[i])
           return false;
       }
     }
     return false;
   }
 };
 
 static uint32 hash_combine(uint32 h, uint32 v) {
   h += v;
   return (h * (37 + 0x0000d100)) ^ (h >> 13);
 }
 
 ShinglePattern::Index::Index(const Shingle* instance) {
   uint32 hash = 0;
   variables_ = 0;
   unique_variables_ = 0;
   first_variable_index_ = 255;
 
-  for (uint32 i = 0; i < Shingle::kWidth; ++i) {
+  for (uint8 i = 0; i < Shingle::kWidth; ++i) {
     LabelInfo* info = instance->at(i);
-    uint32 kind = 0;
+    uint8 kind = 0;
     int code = -1;
-    size_t j = 0;
+    uint8 j = 0;
     for ( ; j < i; ++j) {
       if (info == instance->at(j)) {  // Duplicate LabelInfo
         kind = kinds_[j];
         break;
       }
     }
     if (j == i) {  // Not found above.
       if (info->assignment_) {
         code = info->label_->index_;
         assigned_indexes_[i] = code;
@@ skipping 217 matching lines @@
     for (Shingle::OwningSet::const_iterator p = shingle_instances_.begin();
          p != shingle_instances_.end();
          ++p) {
       const Shingle& instance = *p;
       VLOG(2) << ToString(&instance) << "   " << ToString(instance.pattern());
     }
   }
 
 
   void AddShingles(size_t begin, size_t end) {
-    for (size_t i = begin;  i + Shingle::kWidth - 1 < end;  ++i) {
+    for (size_t i = begin; i + Shingle::kWidth - 1 < end; ++i) {
       instances_[i] = Shingle::Find(trace_, i, &shingle_instances_);
     }
   }
 
   void Declassify(Shingle* shingle) {
     ShinglePattern* pattern = shingle->pattern();
     if (shingle->InModel()) {
       pattern->model_histogram_.erase(ShinglePattern::FreqView(shingle));
       pattern->model_coverage_ -= shingle->position_count();
     } else {
@@ skipping 32 matching lines @@
     for (Shingle::OwningSet::iterator p = shingle_instances_.begin();
          p != shingle_instances_.end();
          ++p) {
       // GCC's set<T>::iterator::operator *() returns a const object.
       Reclassify(const_cast<Shingle*>(&*p));
     }
   }
 
   // For the positions in |info|, find the shingles that overlap that position.
   void AddAffectedPositions(LabelInfo* info, ShingleSet* affected_shingles) {
-    const size_t kWidth = Shingle::kWidth;
+    const uint8 kWidth = Shingle::kWidth;
     for (size_t i = 0;  i < info->positions_.size();  ++i) {
       size_t position = info->positions_[i];
       // Find bounds to the subrange of |trace_| we are in.
       size_t start = position < model_end_ ? 0 : model_end_;
       size_t end = position < model_end_ ? model_end_ : trace_.size();
 
       // Clip [position-kWidth+1, position+1)
-      size_t low = position > start + kWidth - 1
-          ? position - kWidth + 1
-          : start;
+      size_t low =
+          position > start + kWidth - 1 ? position - kWidth + 1 : start;
       size_t high = position + kWidth < end ? position + 1 : end - kWidth + 1;
 
       for (size_t shingle_position = low;
            shingle_position < high;
            ++shingle_position) {
         Shingle* overlapping_shingle = instances_.at(shingle_position);
         affected_shingles->insert(overlapping_shingle);
       }
     }
   }
@@ skipping 87 matching lines @@
            program_iter != pattern->program_histogram_.end();
            ++program_iter) {
         if (++n_program_samples > kUnwieldy) break;
         const ShinglePattern::FreqView& program_freq = *program_iter;
         int p1 = program_freq.count();
         const Shingle* program_instance = program_freq.instance();
 
         // int score = p1;  // ? weigh all equally??
         int score = std::min(p1, m1);
 
-        for (size_t i = 0;  i < Shingle::kWidth;  ++i) {
+        for (uint8 i = 0; i < Shingle::kWidth; ++i) {
           LabelInfo* program_info = program_instance->at(i);
           LabelInfo* model_info = model_instance->at(i);
           if ((model_info->assignment_ == NULL) !=
               (program_info->assignment_ == NULL)) {
             VLOG(2) << "ERROR " << i
                     << "\n\t"  << ToString(pattern, 10)
                     << "\n\t" << ToString(program_instance)
                     << "\n\t" << ToString(model_instance);
           }
           if (!program_info->assignment_ && !model_info->assignment_) {
@@ skipping 216 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 
 }  // namespace adjustment_method_2
 
 AdjustmentMethod* AdjustmentMethod::MakeShingleAdjustmentMethod() {
   return new adjustment_method_2::Adjuster();
 }
 
 }  // namespace courgette