* Lint fixes

src/jsregexp.cc

 // Copyright 2006-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 498 matching lines @@
       if (rc) {
         // Capture values are relative to start_offset only.
         for (int i = 0; i < offsets_vector_length; i++) {
           if (offsets_vector[i] >= 0) {
             offsets_vector[i] += previous_index;
           }
         }
       }
       break;
     }
-    default:
-    case RegExpMacroAssembler::kARMImplementation:
-      UNREACHABLE();
-      rc = false;
-      break;
     case RegExpMacroAssembler::kBytecodeImplementation: {
       Handle<ByteArray> byte_codes = IrregexpCode(regexp);
 
       rc = IrregexpInterpreter::Match(byte_codes,
                                       two_byte_subject,
                                       offsets_vector,
                                       previous_index);
       break;
     }
+    case RegExpMacroAssembler::kARMImplementation:
+    default:
+      UNREACHABLE();
+      rc = false;
+      break;
     }
   }
 
   if (!rc) {
     return Factory::null_value();
   }
 
   Handle<FixedArray> array = Factory::NewFixedArray(2 * (num_captures+1));
   // The captures come in (start, end+1) pairs.
   for (int i = 0; i < 2 * (num_captures+1); i += 2) {
@@ skipping 50 matching lines @@
   for (int i = 0; i < 2 * (num_captures+1); i += 2) {
     array->set(i, Smi::FromInt(offsets_vector[i]));
     array->set(i+1, Smi::FromInt(offsets_vector[i+1]));
   }
   return Factory::NewJSArrayWithElements(array);
 }
 
 
 class OffsetsVector {
  public:
-  inline OffsetsVector(int num_registers) :
-    offsets_vector_length_(num_registers) {
+  inline OffsetsVector(int num_registers)
+      : offsets_vector_length_(num_registers) {
     if (offsets_vector_length_ > kStaticOffsetsVectorSize) {
       vector_ = NewArray<int>(offsets_vector_length_);
     } else {
       vector_ = static_offsets_vector_;
     }
   }
 
 
   inline ~OffsetsVector() {
     if (offsets_vector_length_ > kStaticOffsetsVectorSize) {
@@ skipping 18 matching lines @@
   static const int kStaticOffsetsVectorSize = 50;
   static int static_offsets_vector_[kStaticOffsetsVectorSize];
 };
 
 
 int OffsetsVector::static_offsets_vector_[
     OffsetsVector::kStaticOffsetsVectorSize];
 
 
 Handle<Object> RegExpImpl::IrregexpExec(Handle<JSRegExp> regexp,
-                                    Handle<String> subject,
-                                    Handle<Object> index) {
+                                        Handle<String> subject,
+                                        Handle<Object> index) {
   ASSERT_EQ(regexp->TypeTag(), JSRegExp::IRREGEXP);
   ASSERT(!regexp->DataAt(JSRegExp::kIrregexpDataIndex)->IsUndefined());
 
   // Prepare space for the return values.
   int number_of_registers = IrregexpNumberOfRegisters(regexp);
   OffsetsVector offsets(number_of_registers);
 
   int num_captures = IrregexpNumberOfCaptures(regexp);
 
   int previous_index = static_cast<int>(DoubleToInteger(index->Number()));
@@ skipping 142 matching lines @@
   if (matches->IsNull()) {  // Exited loop normally.
     return result;
   } else {  // Exited loop with the exception in matches.
     return matches;
   }
 }
 
 
 int RegExpImpl::JscreNumberOfCaptures(Handle<JSRegExp> re) {
   FixedArray* value = FixedArray::cast(re->DataAt(JSRegExp::kJscreDataIndex));
-  return Smi::cast(value->get(kJscreNumberOfCapturesIndex))->
-      value();
+  return Smi::cast(value->get(kJscreNumberOfCapturesIndex))-> value();
 }
 
 
 ByteArray* RegExpImpl::JscreInternal(Handle<JSRegExp> re) {
   FixedArray* value = FixedArray::cast(re->DataAt(JSRegExp::kJscreDataIndex));
   return ByteArray::cast(value->get(kJscreInternalIndex));
 }
 
 
 int RegExpImpl::IrregexpNumberOfCaptures(Handle<JSRegExp> re) {
@@ skipping 1776 matching lines @@
   byte codes[1024];
   IrregexpAssembler assembler(Vector<byte>(codes, 1024));
   RegExpMacroAssemblerIrregexp macro_assembler(&assembler);
   return compiler.Assemble(&macro_assembler,
                            node,
                            input->capture_count);
 }
 
 
 }}  // namespace v8::internal