Fix -Wsign-compare warnings in parser, scanner, regexp, runtime.

src/builtins/builtins-regexp.cc

 // Copyright 2016 the V8 project 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 "src/builtins/builtins-utils.h"
 #include "src/builtins/builtins.h"
 
 #include "src/code-factory.h"
 #include "src/regexp/jsregexp.h"
 #include "src/regexp/regexp-utils.h"
@@ skipping 1294 matching lines @@
       }
       continue;
     }
 
     {
       Handle<String> substr =
           factory->NewSubString(string, current_index, start_match);
       elems = FixedArray::SetAndGrow(elems, num_elems++, substr);
     }
 
-    if (num_elems == limit) break;
+    if (static_cast<uint32_t>(num_elems) == limit) break;
 
     for (int i = 2; i < match_indices->NumberOfCaptureRegisters(); i += 2) {
       const int start = match_indices->Capture(i);
       const int end = match_indices->Capture(i + 1);
 
       if (end != -1) {
         Handle<String> substr = factory->NewSubString(string, start, end);
         elems = FixedArray::SetAndGrow(elems, num_elems++, substr);
       } else {
         elems = FixedArray::SetAndGrow(elems, num_elems++,
                                        factory->undefined_value());
       }
 
-      if (num_elems == limit) {
+      if (static_cast<uint32_t>(num_elems) == limit) {
         return NewJSArrayWithElements(isolate, elems, num_elems);
       }
     }
 
     start_index = current_index = end_index;
   }
 
   return NewJSArrayWithElements(isolate, elems, num_elems);
 }
 
@@ skipping 153 matching lines @@
     if (end == prev_string_index) {
       string_index = RegExpUtils::AdvanceStringIndex(isolate, string,
                                                      string_index, unicode);
       continue;
     }
 
     {
       Handle<String> substr =
           factory->NewSubString(string, prev_string_index, string_index);
       elems = FixedArray::SetAndGrow(elems, num_elems++, substr);
-      if (num_elems == limit) {
+      if (static_cast<uint32_t>(num_elems) == limit) {
         return *NewJSArrayWithElements(isolate, elems, num_elems);
       }
     }
 
     prev_string_index = end;
 
     Handle<Object> num_captures_obj;
     ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
         isolate, num_captures_obj,
         Object::GetProperty(result, isolate->factory()->length_string()));
 
     ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
         isolate, num_captures_obj, Object::ToLength(isolate, num_captures_obj));
     const int num_captures =
         std::max(Handle<Smi>::cast(num_captures_obj)->value(), 0);
 
     for (int i = 1; i < num_captures; i++) {
       Handle<Object> capture;
       ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
           isolate, capture, Object::GetElement(isolate, result, i));
       elems = FixedArray::SetAndGrow(elems, num_elems++, capture);
-      if (num_elems == limit) {
+      if (static_cast<uint32_t>(num_elems) == limit) {
         return *NewJSArrayWithElements(isolate, elems, num_elems);
       }
     }
 
     string_index = prev_string_index;
   }
 
   {
     Handle<String> substr =
         factory->NewSubString(string, prev_string_index, length);
@@ skipping 472 matching lines @@
   a->Bind(&if_matched);
   {
     Node* result = ConstructNewResultFromMatchInfo(isolate, a, context,
                                                    match_indices, string);
     a->Return(result);
   }
 }
 
 }  // namespace internal
 }  // namespace v8