[parser, serializer] Fix more -Wsign-compare warnings.

src/parsing/scanner-character-streams.cc

 // Copyright 2011 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/parsing/scanner-character-streams.h"
 
 #include "include/v8.h"
 #include "src/globals.h"
 #include "src/handles.h"
 #include "src/objects-inl.h"
@@ skipping 331 matching lines @@
 
 void Utf8ExternalStreamingStream::SearchPosition(size_t position) {
   // If current_ already points to the right position, we're done.
   //
   // This is expected to be the common case, since we typically call
   // FillBuffer right after the current buffer.
   if (current_.pos.chars == position) return;
 
   // No chunks. Fetch at least one, so we can assume !chunks_.empty() below.
   if (chunks_.empty()) {
-    DCHECK_EQ(current_.chunk_no, 0);
-    DCHECK_EQ(current_.pos.bytes, 0);
-    DCHECK_EQ(current_.pos.chars, 0);
+    DCHECK_EQ(current_.chunk_no, 0u);
+    DCHECK_EQ(current_.pos.bytes, 0u);
+    DCHECK_EQ(current_.pos.chars, 0u);
     FetchChunk();
   }
 
   // Search for the last chunk whose start position is less or equal to
   // position.
   size_t chunk_no = chunks_.size() - 1;
   while (chunk_no > 0 && chunks_[chunk_no].start.chars > position) {
     chunk_no--;
   }
 
@@ skipping 66 matching lines @@
   // (The embedder might give us 1-byte blocks within a utf-8 char, so we
   //  can't guarantee progress with one chunk. Thus we iterate.)
   while (!out_of_data && buffer_cursor_ == buffer_end_) {
     // At end of current data, but there might be more? Then fetch it.
     if (current_.chunk_no == chunks_.size()) {
       out_of_data = !FetchChunk();
     }
     FillBufferFromCurrentChunk();
   }
 
-  DCHECK_EQ(current_.pos.chars - position, buffer_end_ - buffer_cursor_);
+  DCHECK_EQ(current_.pos.chars - position,
+            static_cast<size_t>(buffer_end_ - buffer_cursor_));
   return buffer_end_ - buffer_cursor_;
 }
 
 // ----------------------------------------------------------------------------
 // Chunks - helper for One- + TwoByteExternalStreamingStream
 namespace {
 
 struct Chunk {
   const uint8_t* data;
   size_t byte_length;
@@ skipping 38 matching lines @@
   // chunk to indicate the end of the stream.
   if (position >= end_pos) {
     DCHECK(out_of_data);
     return chunks.size() - 1;
   }
 
   // We almost always 'stream', meaning we want data from the last chunk, so
   // let's look at chunks back-to-front.
   size_t chunk_no = chunks.size() - 1;
   while (chunks[chunk_no].byte_pos > position) {
-    DCHECK_NE(chunk_no, 0);
+    DCHECK_NE(chunk_no, 0u);
     chunk_no--;
   }
   DCHECK_LE(chunks[chunk_no].byte_pos, position);
   DCHECK_LT(position, chunks[chunk_no].byte_pos + chunks[chunk_no].byte_length);
   return chunk_no;
 }
 
 }  // anonymous namespace
 
 // ----------------------------------------------------------------------------
@@ skipping 75 matching lines @@
   }
 
   Chunk& current = chunks_[chunk_no];
 
   // Annoying edge case: Chunks may not be 2-byte aligned, meaning that a
   // character may be split between the previous and the current chunk.
   // If we find such a lonely byte at the beginning of the chunk, we'll use
   // one_char_buffer_ to hold the full character.
   bool lonely_byte = (chunks_[chunk_no].byte_pos == (2 * position + 1));
   if (lonely_byte) {
-    DCHECK_NE(chunk_no, 0);
+    DCHECK_NE(chunk_no, 0u);
     Chunk& previous_chunk = chunks_[chunk_no - 1];
 #ifdef V8_TARGET_BIG_ENDIAN
     uc16 character = current.data[0] |
                      previous_chunk.data[previous_chunk.byte_length - 1] << 8;
 #else
     uc16 character = previous_chunk.data[previous_chunk.byte_length - 1] |
                      current.data[0] << 8;
 #endif
 
     one_char_buffer_ = character;
@@ skipping 101 matching lines @@
     buffer_cursor_ = buffer_;
     buffer_end_ = buffer_ + FillBuffer(position, chunk_no);
     DCHECK_EQ(pos(), position);
     DCHECK_LE(buffer_end_, buffer_start_ + kBufferSize);
     return buffer_cursor_ < buffer_end_;
   }
 }
 
 size_t TwoByteExternalBufferedStream::FillBuffer(size_t position,
                                                  size_t chunk_no) {
-  DCHECK_EQ(chunks_[chunk_no].byte_pos % 2, 1);
+  DCHECK_EQ(chunks_[chunk_no].byte_pos % 2, 1u);
   bool odd_start = true;
   // Align buffer_pos_ to the size of the buffer.
   {
     size_t new_pos = position / kBufferSize * kBufferSize;
     if (new_pos != position) {
       chunk_no = FindChunk(chunks_, source_, 2 * new_pos + 1);
       buffer_pos_ = new_pos;
       buffer_cursor_ = buffer_start_ + (position - buffer_pos_);
       position = new_pos;
       odd_start = chunks_[chunk_no].byte_pos % 2;
     }
   }
 
   Chunk* current = &chunks_[chunk_no];
 
   // Annoying edge case: Chunks may not be 2-byte aligned, meaning that a
   // character may be split between the previous and the current chunk.
   // If we find such a lonely byte at the beginning of the chunk, we'll copy
   // it to the first byte in buffer_.
   size_t totalLength = 0;
   bool lonely_byte = (current->byte_pos == (2 * position + 1));
   if (lonely_byte) {
-    DCHECK_NE(chunk_no, 0);
+    DCHECK_NE(chunk_no, 0u);
     Chunk& previous_chunk = chunks_[chunk_no - 1];
     *reinterpret_cast<uint8_t*>(buffer_) =
         previous_chunk.data[previous_chunk.byte_length - 1];
     totalLength++;
   }
 
   // Common case: character is in current chunk.
   DCHECK_LE(current->byte_pos, 2 * position + odd_start);
   DCHECK_LT(2 * position + 1, current->byte_pos + current->byte_length);
 
@@ skipping 83 matching lines @@
       return new OneByteExternalStreamingStream(source_stream);
     case v8::ScriptCompiler::StreamedSource::UTF8:
       return new Utf8ExternalStreamingStream(source_stream);
   }
   UNREACHABLE();
   return nullptr;
 }
 
 }  // namespace internal
 }  // namespace v8