Fix lint issues....

src/assembler-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 46 matching lines @@
   Emit32(cp_offset);
 }
 
 
 void Re2kAssembler::PushBacktrack(Label* l) {
   Emit(BC_PUSH_BT);
   EmitOrLink(l);
 }
 
 
-void Re2kAssembler::PushCapture(int index) {
+void Re2kAssembler::PushRegister(int index) {
   ASSERT(index >= 0);
-  Emit(BC_PUSH_CAPTURE);
+  Emit(BC_PUSH_REGISTER);
   Emit(index);
 }
 
 
-void Re2kAssembler::SetCapture(int index, int cp_offset) {
+void Re2kAssembler::SetRegister(int index, int cp_offset) {
   ASSERT(cp_offset >= 0);
   ASSERT(index >= 0);
-  Emit(BC_SET_CAPTURE);
+  Emit(BC_SET_REGISTER);
   Emit(index);
   Emit32(cp_offset);
 }
 
 
 void Re2kAssembler::PopCurrentPosition() {
   Emit(BC_POP_CP);
 }
 
 
 void Re2kAssembler::PopBacktrack() {
   Emit(BC_POP_BT);
 }
 
 
-void Re2kAssembler::PopCapture(int index) {
-  Emit(BC_POP_CAPTURE);
+void Re2kAssembler::PopRegister(int index) {
+  Emit(BC_POP_REGISTER);
   Emit(index);
 }
 
 
 void Re2kAssembler::Fail() {
   Emit(BC_FAIL);
 }
 
 
 void Re2kAssembler::FailIfWithin(int distance_from_end) {
@@ skipping 62 matching lines @@
 
 
 void Re2kAssembler::CheckNotRange(uc16 start, uc16 end, Label* on_match) {
   Emit(BC_CHECK_NOT_RANGE);
   Emit16(start);
   Emit16(end);
   EmitOrLink(on_match);
 }
 
 
-void Re2kAssembler::CheckBackref(int capture_index, Label* on_mismatch, int cp_offset) {
+void Re2kAssembler::CheckBackref(int capture_index,
+                                 Label* on_mismatch,
+                                 int cp_offset) {
   Emit(BC_CHECK_BACKREF);
   Emit32(cp_offset);
   Emit(capture_index);
   EmitOrLink(on_mismatch);
 }
 
 
-void Re2kAssembler::CheckNotBackref(int capture_index, Label* on_match, int cp_offset) {
+void Re2kAssembler::CheckNotBackref(int capture_index,
+                                    Label* on_match,
+                                    int cp_offset) {
   Emit(BC_CHECK_NOT_BACKREF);
   Emit32(cp_offset);
   Emit(capture_index);
   EmitOrLink(on_match);
 }
 
 
+void Re2kAssembler::CheckRegister(int byte_code,
+                                  int reg_index,
+                                  uint16_t vs,
+                                  Label* on_true) {
+  Emit(byte_code);
+  Emit(reg_index);
+  Emit16(vs);
+  EmitOrLink(on_true);
+}
+
+
+void Re2kAssembler::CheckRegisterEq(int reg_index,
+                                    uint16_t vs,
+                                    Label* on_equal) {
+  CheckRegister(BC_CHECK_REGISTER_EQ, reg_index, vs, on_equal);
+}
+
+
+void Re2kAssembler::CheckRegisterLe(int reg_index,
+                                    uint16_t vs,
+                                    Label* on_less_than_equal) {
+  CheckRegister(BC_CHECK_REGISTER_LE, reg_index, vs, on_less_than_equal);
+}
+
+
+void Re2kAssembler::CheckRegisterLt(int reg_index,
+                                    uint16_t vs,
+                                    Label* on_less_than) {
+  CheckRegister(BC_CHECK_REGISTER_LT, reg_index, vs, on_less_than);
+}
+
+
+void Re2kAssembler::CheckRegisterGe(int reg_index,
+                                    uint16_t vs,
+                                    Label* on_greater_than_equal) {
+  CheckRegister(BC_CHECK_REGISTER_GE, reg_index, vs, on_greater_than_equal);
+}
+
+
+void Re2kAssembler::CheckRegisterGt(int reg_index,
+                                    uint16_t vs,
+                                    Label* on_greater_than) {
+  CheckRegister(BC_CHECK_REGISTER_GT, reg_index, vs, on_greater_than);
+}
+
+
+void Re2kAssembler::CheckRegisterNe(int reg_index,
+                                    uint16_t vs,
+                                    Label* on_not_equal) {
+  CheckRegister(BC_CHECK_REGISTER_NE, reg_index, vs, on_not_equal);
+}
+
+
 int Re2kAssembler::length() {
   return pc_;
 }
 
 
 void Re2kAssembler::Copy(Address a) {
   memcpy(a, buffer_.start(), length());
 }
 
 } }  // namespace v8::internal