* Update to RegExp parsing and AST.

regexp2000/src/regexp-macro-assembler-ia32.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 44 matching lines @@
  *       - return address
  * ebp-> - old ebp
  *       - register 0  ebp[-4]
  *       - register 1  ebp[-8]
  *       - ...
  *
  * The data before ebp must be placed there by the calling code.
  */
 
 RegExpMacroAssemblerIA32::RegExpMacroAssemblerIA32()
- : masm_(new MacroAssembler(NULL, kRegExpCodeSize)),
-   constants_(kRegExpConstantsSize),
-   num_registers_(0),
-   ignore_case(false) {}
+  : masm_(new MacroAssembler(NULL, kRegExpCodeSize)),
+    constants_(kRegExpConstantsSize),
+    num_registers_(0),
+    ignore_case(false) {}
 
 
 RegExpMacroAssemblerIA32::~RegExpMacroAssemblerIA32() {
   delete masm_;
 }
 
 
 #define __ masm_->
 
 void RegExpMacroAssemblerIA32::AdvanceCurrentPosition(int by) {
@@ skipping 22 matching lines @@
 void RegExpMacroAssemblerIA32::Bind(Label* label) {
   __ bind(label);
 }
 
 
 void RegExpMacroAssemblerIA32::CheckBitmap(uc16 start,
                                            Label* bitmap,
                                            Label* on_zero) {
   ReadCurrentChar(eax);
   __ sub(eax, start);
-  __ cmp(eax, 64); // FIXME: 64 = length_of_bitmap_in_bits.
+  __ cmp(eax, 64);  // FIXME: 64 = length_of_bitmap_in_bits.
   BranchOrBacktrack(greater_equal, on_zero);
   __ mov(ebx, eax);
   __ shr(ebx, 3);
-  // TODO: Where is the bitmap stored? Pass the bitmap as argument instead.
+  // TODO(lrn): Where is the bitmap stored? Pass the bitmap as argument instead.
   // __ mov(ecx, position_of_bitmap);
   __ movzx_b(ebx, Operand(ecx, ebx, times_1, 0));
   __ and_(eax, (1<<3)-1);
   __ bt(ebx, eax);
   __ j(greater_equal, on_zero);  // Aka. jump on carry set.
 }
 
 
 void RegExpMacroAssemblerIA32::CheckCharacterClass(RegExpCharacterClass *cclass,
                                                    Label* on_failure) {
@@ skipping 11 matching lines @@
       }
     }
   }
   int byte_length = str.length() * sizeof(SubjectChar);
   __ mov(ebx, edi);
   __ add(ebx, byte_length);
   __ cmp(ebx, esi);
   BranchOrBacktrack(greater_equal, on_failure);
 
   if (str.length() <= kMaxInlineStringTests || ignore_case()) {
-    // TODO: make proper loop if str.length is large but ignore_case is true;
-    for(int i = 0; i < str.length(); i++) {
+    // TODO(lrn): make loop if str.length is large but ignore_case is true;
+    for (int i = 0; i < str.length(); i++) {
       ReadChar(eax, i);
       if (ignore_case()) {
         Canonicalize(eax);
       }
       __ cmp(eax, str[i]);
       BranchOrBacktrack(not_equal, on_failure);
     }
     add(edi, byte_length);
   } else {
     int offset;
     ArraySlice<SubjectChar> constant_buffer =
         constants_.GetBuffer<SubjectChar>(str.length());
     for (int i = 0; i < str.length(); i++) {
       constant_buffer[i] = str[i];
     }
     __ mov(ebx, esi);
     LoadConstantBufferAddress(esi, constant_buffer);
     __ mov(ecx, str.length());
     if (sizeof(SubjectChar) == 1) {
       __ rep_cmpsb();
     } else {
-      ASSERT(sizeof(SubjectChar)==2);
+      ASSERT(sizeof(SubjectChar) == 2);
       __ rep_cmpsw();
     }
     __ mov(esi, ebx);
     BranchOrBacktrack(not_equal, on_failure);
   }
 };
 
 
 void RegExpMacroAssemblerIA32::CheckCurrentPosition(int register_index,
                                                     Label* on_equal) {
@@ skipping 13 matching lines @@
 
   Label fallthrough;
 
   ReadCurrentChar(eax);
   __ sub(eax, start);
   __ cmp(eax, 64);  // FIXME: 64 = size of map in bytes. Found somehow??
   __ j(greater_equal, &fallthrough);
 
   __ mov(ebx, eax);
   __ shr(eax, 2);
-  __ movzx_b(eax, Operand(ecx, eax)); // FIXME: ecx holds address of map
+  __ movzx_b(eax, Operand(ecx, eax));  // FIXME: ecx holds address of map
   Label got_nybble;
   Label high_bits;
   __ and_(ebx, 0x03);
   __ shr(eax, ebx);
 
   Label second_bit_set, case_3, case_1;
   __ test(eax, 2);
   __ j(not_equal, &second_bit_set);
   __ test(eax, 1);
   __ j(not_equal, &case_1);
@@ skipping 41 matching lines @@
     byte start,
     Label* byte_map,
     const Vector<Label*>& destinations) {
   Label fallthrough;
   ReadCurrentChar(eax);
   __ shr(eax, 8);
   __ sub(eax, start);
   __ cmp(eax, destinations.length() - start);
   __ j(greater_equal, &fallthrough);
 
-  // TODO jumptable: jump to destinations[eax]
+  // TODO(lrn) jumptable: jump to destinations[eax]
   __ bind(&fallthrough);
 }
 
 
 void RegExpMacroAssemblerIA32::EmitOrLink(Label* label) {
   UNREACHABLE();  // Has no use.
 }
 
 
 void RegExpMacroAssemblerIA32::Fail() {
   Exit(false);
 }
 
 Handle<Object> RegExpMacroAssemblerIA32::GetCode() {
   // something
   return Handle();
 }
 
 
-void RegExpMacroAssemblerIA32::GoTo(Label &to) {
+void RegExpMacroAssemblerIA32::GoTo(Label* to) {
   __ jmp(to);
 }
 
 
 void RegExpMacroAssemblerIA32::IfRegisterGE(int reg,
                                             int comparand,
                                             Label* if_ge) {
   __ cmp(register_location(reg), comparand);
   BranchOrBacktrack(greater_equal, if_ge);
 }
@@ skipping 94 matching lines @@
     Label end;
     __ cmp(reg, 'a');
     __ j(below, &end);
     __ cmp(reg, 'z');
     __ j(above, &end);
     __ sub(reg, 'a' - 'A');
     __ bind(&end);
     return;
   }
   ASSERT(sizeof(SubjectChar) == 2);
-  // TODO: Use some tables.
+  // TODO(lrn): Use some tables.
 }
 
 
 void RegExpMacroAssemblerIA32::Exit(bool success) {
   if (success) {
     // Copy captures to output capture array.
   }
   __ leave();
   __ mov(eax, success ? 1 : 0);
   __ ret();
 }
 
 
 void RegExpMacroAssemblerIA32::ReadChar(Register destination, int offset) {
   if (sizeof(SubjectChar) == 1) {
     __ movzx_b(destination, Operand(edi, offset));
     return;
   }
   ASSERT(sizeof(SubjectChar) == 2);
   __ movzx_w(destination, Operand(edi, offset * 2));
 }
 
 
 void RegExpMacroAssemblerIA32::ReadCurrentChar(Register destination) {
   mov(destination, edx);
 }
 
 
-template <typename T>
-void LoadConstantBufferAddress(Register reg, ArraySlice<T>& buffer) {
-  __ mov(reg, buffer.array());
-  __ add(reg, buffer.base_offset());
+void RegExpMacroAssemblerIA32::LoadConstantBufferAddress(
+    Register reg, ArraySlice<T>* buffer) {
+  __ mov(reg, buffer->array());
+  __ add(reg, buffer->base_offset());
 }
 
 #undef __
 }}