Fix lint issues....

src/interpreter-re2k.cc

 // Copyright 2008 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 21 matching lines @@
 #include "utils.h"
 #include "ast.h"
 #include "bytecodes-re2k.h"
 #include "interpreter-re2k.h"
 
 
 namespace v8 { namespace internal {
 
 
 template <typename Char>
-static bool RawMatch(const byte* code_base, Vector<const Char> subject, int* captures, int current) {
+static bool RawMatch(const byte* code_base,
+                     Vector<const Char> subject,
+                     int* registers,
+                     int current) {
   const byte* pc = code_base;
   int backtrack_stack[1000];
   int backtrack_stack_space = 1000;
   int* backtrack_sp = backtrack_stack;
   int current_char = -1;
   while (true) {
     switch (*pc) {
       case BC_BREAK:
         UNREACHABLE();
         return false;
       case BC_PUSH_CP:
         if (--backtrack_stack_space < 0) {
           return false;  // No match on backtrack stack overflow.
         }
         *backtrack_sp++ = current + Load32(pc + 1);
         pc += 5;
         break;
       case BC_PUSH_BT:
         if (--backtrack_stack_space < 0) {
           return false;  // No match on backtrack stack overflow.
         }
         *backtrack_sp++ = Load32(pc + 1);
         pc += 5;
         break;
-      case BC_PUSH_CAPTURE:
+      case BC_PUSH_REGISTER:
         if (--backtrack_stack_space < 0) {
           return false;  // No match on backtrack stack overflow.
         }
-        *backtrack_sp++ = captures[pc[1]];
+        *backtrack_sp++ = registers[pc[1]];
         pc += 2;
         break;
-      case BC_SET_CAPTURE:
-        captures[pc[1]] = current + Load32(pc + 2);
+      case BC_SET_REGISTER:
+        registers[pc[1]] = current + Load32(pc + 2);
         pc += 6;
         break;
       case BC_POP_CP:
         backtrack_stack_space++;
         --backtrack_sp;
         current = *backtrack_sp;
         pc += 1;
         break;
       case BC_POP_BT:
         backtrack_stack_space++;
         --backtrack_sp;
         pc = code_base + *backtrack_sp;
         break;
-      case BC_POP_CAPTURE:
+      case BC_POP_REGISTER:
         backtrack_stack_space++;
         --backtrack_sp;
-        captures[pc[1]] = *backtrack_sp;
+        registers[pc[1]] = *backtrack_sp;
         pc += 2;
         break;
       case BC_FAIL:
         return false;
       case BC_FAIL_IF_WITHIN:
         if (current + Load32(pc + 1) >= subject.length()) {
           return false;
         }
         pc += 5;
         break;
@@ skipping 47 matching lines @@
       case BC_CHECK_NOT_RANGE: {
         int start = Load16(pc + 1);
         int end = Load16(pc + 3);
         if (current_char < start || current_char > end || current_char == -1) {
           pc = code_base + Load32(pc + 5);
         } else {
           pc += 9;
         }
         break;
       }
+      case BC_CHECK_REGISTER_EQ:
+        if (registers[pc[1]] == Load16(pc + 2)) {
+          pc = code_base + Load32(pc + 4);
+        } else {
+          pc += 8;
+        }
+        break;
+      case BC_CHECK_REGISTER_LE:
+        if (registers[pc[1]] <= Load16(pc + 2)) {
+          pc = code_base + Load32(pc + 4);
+        } else {
+          pc += 8;
+        }
+        break;
+      case BC_CHECK_REGISTER_LT:
+        if (registers[pc[1]] < Load16(pc + 2)) {
+          pc = code_base + Load32(pc + 4);
+        } else {
+          pc += 8;
+        }
+        break;
+      case BC_CHECK_REGISTER_GE:
+        if (registers[pc[1]] >= Load16(pc + 2)) {
+          pc = code_base + Load32(pc + 4);
+        } else {
+          pc += 8;
+        }
+        break;
+      case BC_CHECK_REGISTER_GT:
+        if (registers[pc[1]] > Load16(pc + 2)) {
+          pc = code_base + Load32(pc + 4);
+        } else {
+          pc += 8;
+        }
+        break;
+      case BC_CHECK_REGISTER_NE:
+        if (registers[pc[1]] != Load16(pc + 2)) {
+          pc = code_base + Load32(pc + 4);
+        } else {
+          pc += 8;
+        }
+        break;
       case BC_CHECK_BACKREF:
       case BC_CHECK_NOT_BACKREF:
       case BC_CHECK_BITMAP:
       case BC_CHECK_NOT_BITMAP:
       default:
         UNREACHABLE();
         break;
     }
   }
 }
 
 
-bool Re2kInterpreter::Match(ByteArray* code_array, String* subject, int* captures, int start_position) {
+bool Re2kInterpreter::Match(ByteArray* code_array,
+                            String* subject,
+                            int* registers,
+                            int start_position) {
   const byte* code_base = code_array->GetDataStartAddress();
   StringShape shape(subject);
   ASSERT(subject->IsFlat(shape));
   if (shape.IsAsciiRepresentation()) {
-    return RawMatch(code_base, subject->ToAsciiVector(), captures, start_position);
+    return RawMatch(code_base,
+                    subject->ToAsciiVector(),
+                    registers,
+                    start_position);
   } else {
-    return RawMatch(code_base, subject->ToUC16Vector(), captures, start_position);
+    return RawMatch(code_base,
+                    subject->ToUC16Vector(),
+                    registers,
+                    start_position);
   }
 }
 
 } }  // namespace v8::internal