Rename Compare -> Comparator to resolve name conflict in v8::internal

src/liveedit.cc

 // Copyright 2010 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 31 matching lines @@
 
 #ifdef ENABLE_DEBUGGER_SUPPORT
 
 
 // A simple implementation of dynamic programming algorithm. It solves
 // the problem of finding the difference of 2 arrays. It uses a table of results
 // of subproblems. Each cell contains a number together with 2-bit flag
 // that helps building the chunk list.
 class Differencer {
  public:
-  explicit Differencer(Compare::Input* input)
+  explicit Differencer(Comparator::Input* input)
       : input_(input), len1_(input->getLength1()), len2_(input->getLength2()) {
     buffer_ = NewArray<int>(len1_ * len2_);
   }
   ~Differencer() {
     DeleteArray(buffer_);
   }
 
   void Initialize() {
     int array_size = len1_ * len2_;
     for (int i = 0; i < array_size; i++) {
       buffer_[i] = kEmptyCellValue;
     }
   }
 
   // Makes sure that result for the full problem is calculated and stored
   // in the table together with flags showing a path through subproblems.
   void FillTable() {
     CompareUpToTail(0, 0);
   }
 
-  void SaveResult(Compare::Output* chunk_writer) {
+  void SaveResult(Comparator::Output* chunk_writer) {
     ResultWriter writer(chunk_writer);
 
     int pos1 = 0;
     int pos2 = 0;
     while (true) {
       if (pos1 < len1_) {
         if (pos2 < len2_) {
           Direction dir = get_direction(pos1, pos2);
           switch (dir) {
             case EQ:
@@ skipping 21 matching lines @@
         if (len2_ != pos2) {
           writer.skip2(len2_ - pos2);
         }
         break;
       }
     }
     writer.close();
   }
 
  private:
-  Compare::Input* input_;
+  Comparator::Input* input_;
   int* buffer_;
   int len1_;
   int len2_;
 
   enum Direction {
     EQ = 0,
     SKIP1,
     SKIP2,
     SKIP_ANY,
 
@@ skipping 62 matching lines @@
   static const int kEmptyCellValue = -1 << kDirectionSizeBits;
 
   // This method only holds static assert statement (unfortunately you cannot
   // place one in class scope).
   void StaticAssertHolder() {
     STATIC_ASSERT(MAX_DIRECTION_FLAG_VALUE < (1 << kDirectionSizeBits));
   }
 
   class ResultWriter {
    public:
-    explicit ResultWriter(Compare::Output* chunk_writer)
+    explicit ResultWriter(Comparator::Output* chunk_writer)
         : chunk_writer_(chunk_writer), pos1_(0), pos2_(0),
           pos1_begin_(-1), pos2_begin_(-1), has_open_chunk_(false) {
     }
     void eq() {
       FlushChunk();
       pos1_++;
       pos2_++;
     }
     void skip1(int len1) {
       StartChunk();
       pos1_ += len1;
     }
     void skip2(int len2) {
       StartChunk();
       pos2_ += len2;
     }
     void close() {
       FlushChunk();
     }
 
    private:
-    Compare::Output* chunk_writer_;
+    Comparator::Output* chunk_writer_;
     int pos1_;
     int pos2_;
     int pos1_begin_;
     int pos2_begin_;
     bool has_open_chunk_;
 
     void StartChunk() {
       if (!has_open_chunk_) {
         pos1_begin_ = pos1_;
         pos2_begin_ = pos2_;
         has_open_chunk_ = true;
       }
     }
 
     void FlushChunk() {
       if (has_open_chunk_) {
         chunk_writer_->AddChunk(pos1_begin_, pos2_begin_,
                                 pos1_ - pos1_begin_, pos2_ - pos2_begin_);
         has_open_chunk_ = false;
       }
     }
   };
 };
 
 
-void Compare::CalculateDifference(Compare::Input* input,
-                                  Compare::Output* result_writer) {
+void Comparator::CalculateDifference(Comparator::Input* input,
+                                     Comparator::Output* result_writer) {
   Differencer differencer(input);
   differencer.Initialize();
   differencer.FillTable();
   differencer.SaveResult(result_writer);
 }
 
 
 static bool CompareSubstrings(Handle<String> s1, int pos1,
                               Handle<String> s2, int pos2, int len) {
   static StringInputBuffer buf1;
@@ skipping 47 matching lines @@
   Handle<FixedArray> ends_array_;
   int string_len_;
 
   int GetPosAfterNewLine(int index) {
     return Smi::cast(ends_array_->get(index))->value() + 1;
   }
 };
 
 
 // Represents 2 strings as 2 arrays of lines.
-class LineArrayCompareInput : public Compare::Input {
+class LineArrayCompareInput : public Comparator::Input {
  public:
   LineArrayCompareInput(Handle<String> s1, Handle<String> s2,
                         LineEndsWrapper line_ends1, LineEndsWrapper line_ends2)
       : s1_(s1), s2_(s2), line_ends1_(line_ends1), line_ends2_(line_ends2) {
   }
   int getLength1() {
     return line_ends1_.length();
   }
   int getLength2() {
     return line_ends2_.length();
@@ skipping 14 matching lines @@
  private:
   Handle<String> s1_;
   Handle<String> s2_;
   LineEndsWrapper line_ends1_;
   LineEndsWrapper line_ends2_;
 };
 
 
 // Stores compare result in JSArray. Each chunk is stored as 3 array elements:
 // (pos1_begin, pos1_end, pos2_end).
-class LineArrayCompareOutput : public Compare::Output {
+class LineArrayCompareOutput : public Comparator::Output {
  public:
   LineArrayCompareOutput(LineEndsWrapper line_ends1, LineEndsWrapper line_ends2)
       : array_(Factory::NewJSArray(10)), current_size_(0),
         line_ends1_(line_ends1), line_ends2_(line_ends2) {
   }
 
   void AddChunk(int line_pos1, int line_pos2, int line_len1, int line_len2) {
     int char_pos1 = line_ends1_.GetLineStart(line_pos1);
     int char_pos2 = line_ends2_.GetLineStart(line_pos2);
     int char_len1 = line_ends1_.GetLineStart(line_pos1 + line_len1) - char_pos1;
@@ skipping 20 matching lines @@
 
 
 Handle<JSArray> LiveEdit::CompareStringsLinewise(Handle<String> s1,
                                                  Handle<String> s2) {
   LineEndsWrapper line_ends1(s1);
   LineEndsWrapper line_ends2(s2);
 
   LineArrayCompareInput input(s1, s2, line_ends1, line_ends2);
   LineArrayCompareOutput output(line_ends1, line_ends2);
 
-  Compare::CalculateDifference(&input, &output);
+  Comparator::CalculateDifference(&input, &output);
 
   return output.GetResult();
 }
 
 
 static void CompileScriptForTracker(Handle<Script> script) {
   const bool is_eval = false;
   const bool is_global = true;
   // TODO(635): support extensions.
   Extension* extension = NULL;
@@ skipping 1001 matching lines @@
 
 bool LiveEditFunctionTracker::IsActive() {
   return false;
 }
 
 #endif  // ENABLE_DEBUGGER_SUPPORT
 
 
 
 } }  // namespace v8::internal