* Addressed review comments

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 294 matching lines @@
                                 Handle<Object> index) {
   switch (regexp->TypeTag()) {
     case JSRegExp::ATOM:
       return AtomExec(regexp, subject, index);
     case JSRegExp::IRREGEXP: {
       Handle<Object> result = IrregexpExec(regexp, subject, index);
       if (!result.is_null()) {
         return result;
       }
       // We couldn't handle the regexp using Irregexp, so fall back
-      // on JSCRE. We rejoice at the though of the day when this is
-      // no longer needed.
+      // on JSCRE.
       // Reset the JSRegExp to use JSCRE.
       JscrePrepare(regexp,
                    Handle<String>(regexp->Pattern()),
                    regexp->GetFlags());
       // Fall-through to JSCRE.
     }
     case JSRegExp::JSCRE:
       if (FLAG_disable_jscre) {
         UNIMPLEMENTED();
       }
       return JscreExec(regexp, subject, index);
     default:
       UNREACHABLE();
       return Handle<Object>::null();
   }
 }
 
 
 Handle<Object> RegExpImpl::ExecGlobal(Handle<JSRegExp> regexp,
                                 Handle<String> subject) {
   switch (regexp->TypeTag()) {
     case JSRegExp::ATOM:
       return AtomExecGlobal(regexp, subject);
     case JSRegExp::IRREGEXP: {
       Handle<Object> result = IrregexpExecGlobal(regexp, subject);
       if (!result.is_null()) {
         return result;
       }
       // We couldn't handle the regexp using Irregexp, so fall back
-      // on JSCRE. We rejoice at the though of the day when this is
-      // no longer needed.
+      // on JSCRE.
       // Reset the JSRegExp to use JSCRE.
       JscrePrepare(regexp,
                    Handle<String>(regexp->Pattern()),
                    regexp->GetFlags());
       // Fall-through to JSCRE.
     }
     case JSRegExp::JSCRE:
       if (FLAG_disable_jscre) {
         UNIMPLEMENTED();
       }
@@ skipping 546 matching lines @@
       } else if (shape.IsSliced()) {
         SlicedString* slice = SlicedString::cast(*subject);
         start_offset += slice->start();
         end_offset += slice->start();
         subject = Handle<String>(slice->buffer());
       }
 
       // String is now either Sequential or External
       StringShape flatshape(*subject);
       bool is_ascii = flatshape.IsAsciiRepresentation();
-      int char_size = is_ascii ? sizeof(char) : sizeof(uc16);  // NOLINT
+      int char_size_shift = is_ascii ? 0 : 1;
 
       if (flatshape.IsExternal()) {
         const byte* address;
         if (is_ascii) {
           ExternalAsciiString* ext = ExternalAsciiString::cast(*subject);
           address = reinterpret_cast<const byte*>(ext->resource()->data());
         } else {
           ExternalTwoByteString* ext = ExternalTwoByteString::cast(*subject);
           address = reinterpret_cast<const byte*>(ext->resource()->data());
         }
         rc = RegExpMacroAssemblerIA32::Execute(
             *code,
             &address,
-            start_offset * char_size,
-            end_offset * char_size,
+            start_offset << char_size_shift,
+            end_offset << char_size_shift,
             offsets_vector,
             previous_index == 0);
       } else {  // Sequential string
-        int byte_offset =
-            is_ascii ? SeqAsciiString::kHeaderSize - kHeapObjectTag:
-                       SeqTwoByteString::kHeaderSize - kHeapObjectTag;
+        Address char_address =
+            is_ascii ? SeqAsciiString::cast(*subject)->GetCharsAddress()
+                     : SeqTwoByteString::cast(*subject)->GetCharsAddress();
+        int byte_offset = char_address - reinterpret_cast<Address>(*subject);
         rc = RegExpMacroAssemblerIA32::Execute(
             *code,
             subject.location(),
-            byte_offset + start_offset * char_size,
-            byte_offset + end_offset * char_size,
+            byte_offset + (start_offset << char_size_shift),
+            byte_offset + (end_offset << char_size_shift),
             offsets_vector,
             previous_index == 0);
       }
 
       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;
           }
@@ skipping 2710 matching lines @@
   EmbeddedVector<byte, 1024> codes;
   RegExpMacroAssemblerIrregexp macro_assembler(codes);
   return compiler.Assemble(&macro_assembler,
                            node,
                            input->capture_count,
                            pattern);
 }
 
 
 }}  // namespace v8::internal