Code changes to get the code to compile under GCC....

courgette/adjustment_method_2.cc

 // Copyright (c) 2009 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 190 matching lines @@
 
   AssignmentCandidates* candidates();
 
   Label* label_;             // The label that this info a surrogate for.
 
   uint32 is_model_ : 1;      // Is the label in the model?
   uint32 debug_index_ : 31;  // A small number for naming the label in debug
                              // output. The pair (is_model_, debug_index_) is
                              // unique.
 
-  uint32 refs_;              // Number of times this Label is referenced.
+  int refs_;                 // Number of times this Label is referenced.
 
   LabelInfo* assignment_;    // Label from other program corresponding to this.
 
   std::vector<uint32> positions_;  // Offsets into the trace of references.
 
  private:
   AssignmentCandidates* candidates_;
 
   void operator=(const LabelInfo*);  // Disallow assignment only.
   // Public compiler generated copy constructor is needed to constuct
@@ skipping 174 matching lines @@
   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 =
         owning_set->insert(Shingle(trace, position));
-    // pair.first is the newly inserted Shingle or the previouly inserted one
-    // that looks the same according to the comparator.
-    pair.first->add_position(position);
-    return &*pair.first;
+    // pair.first iterator 'points' to the newly inserted Shingle or the
+    // previouly inserted one that looks the same according to the comparator.
+
+    // const_cast required because key is const.  We modify the Shingle
+    // extensively but not in a way that affects InterningLess.
+    Shingle* shingle = const_cast<Shingle*>(&*pair.first);
+    shingle->add_position(position);
+    return shingle;
   }
 
   LabelInfo* at(size_t i) const { return trace_[exemplar_position_ + i]; }
   void add_position(size_t position) { positions_.push_back(position); }
   size_t position_count() const { return positions_.size(); }
 
   bool InModel() const { return at(0)->is_model_; }
 
   ShinglePattern* pattern() const { return pattern_; }
   void set_pattern(ShinglePattern* pattern) { pattern_ = pattern; }
@@ skipping 530 matching lines @@
     } else {
       pattern->program_histogram_.insert(ShinglePattern::FreqView(shingle));
       pattern->program_coverage_ += shingle->position_count();
     }
   }
 
   void InitialClassify() {
     for (Shingle::OwningSet::iterator p = shingle_instances_.begin();
          p != shingle_instances_.end();
          ++p) {
-      Reclassify(&*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;
     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_;
@@ skipping 57 matching lines @@
       // Useless pattern.
     } else {
       active_non_single_use_patterns_.insert(pattern);
       AddPatternToLabelQueue(pattern, +1);
     }
   }
 
   void AddPatternToLabelQueue(const ShinglePattern* pattern, int sign) {
     // For each possible assignment in this pattern, update the potential
     // contributions to the LabelInfo queues.
-    size_t model_histogram_size = pattern->model_histogram_.size();
-    size_t program_histogram_size = pattern->program_histogram_.size();
 
     // We want to find for each symbol (LabelInfo) the maximum contribution that
     // could be achieved by making shingle-wise assignments between shingles in
     // the model and shingles in the program.
     //
     // If the shingles in the histograms are independent (no two shingles have a
     // symbol in common) then any permutation of the assignments is possible,
     // and the maximum contribution can be found by taking the maximum over all
     // the pairs.
     //
     // If the shingles are dependent two things happen.  The maximum
     // contribution to any given symbol is a sum because the symbol has
     // contributions from all the shingles containing it.  Second, some
     // assignments are blocked by previous incompatible assignments.  We want to
     // avoid a combinatorial search, so we ignore the blocking.
 
-    const int kUnwieldy = 5;
+    const size_t kUnwieldy = 5;
 
     typedef std::map<LabelInfo*, int> LabelToScore;
     typedef std::map<LabelInfo*, LabelToScore > ScoreSet;
     ScoreSet maxima;
 
     size_t n_model_samples = 0;
     for (ShinglePattern::Histogram::const_iterator model_iter =
              pattern->model_histogram_.begin();
          model_iter != pattern->model_histogram_.end();
          ++model_iter) {
@@ skipping 242 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 
 }  // namespace adjustment_method_2
 
 AdjustmentMethod* AdjustmentMethod::MakeShingleAdjustmentMethod() {
   return new adjustment_method_2::Adjuster();
 }
 
 }  // namespace courgette