LiveEdit: calculate a real script difference

src/liveedit-debugger.js

 // Copyright 2010 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 18 matching lines @@
 // debug-debugger.js.
 
 // A LiveEdit namespace is declared inside a single function constructor.
 Debug.LiveEdit = new function() {
 
   // Changes script text and recompiles all relevant functions if possible.
   // The change is always a substring (change_pos, change_pos + change_len)
   // being replaced with a completely different string new_str.
   //
   // Only one function will have its Code changed in result of this function.
-  // All nested functions (should they have any instances at the moment) are left
-  // unchanged and re-linked to a newly created script instance representing old
-  // version of the source. (Generally speaking,
+  // All nested functions (should they have any instances at the moment) are
+  // left unchanged and re-linked to a newly created script instance
+  // representing old version of the source. (Generally speaking,
   // during the change all nested functions are erased and completely different
   // set of nested functions are introduced.) All other functions just have
   // their positions updated.
   //
   // @param {Script} script that is being changed
-  // @param {Array} change_log a list that collects engineer-readable description
-  //     of what happened.
+  // @param {Array} change_log a list that collects engineer-readable
+  //     description of what happened.
   function ApplyPatch(script, change_pos, change_len, new_str,
       change_log) {
-  
+
     // Fully compiles source string as a script. Returns Array of
     // FunctionCompileInfo -- a descriptions of all functions of the script.
     // Elements of array are ordered by start positions of functions (from top
     // to bottom) in the source. Fields outer_index and next_sibling_index help
     // to navigate the nesting structure of functions.
     //
     // The script is used for compilation, because it produces code that
     // needs to be linked with some particular script (for nested functions).
     function DebugGatherCompileInfo(source) {
-      // Get function info, elements are partially sorted (it is a tree
-      // of nested functions serialized as parent followed by serialized children.
+      // Get function info, elements are partially sorted (it is a tree of
+      // nested functions serialized as parent followed by serialized children.
       var raw_compile_info = %LiveEditGatherCompileInfo(script, source);
   
       // Sort function infos by start position field.
       var compile_info = new Array();
       var old_index_map = new Array();
       for (var i = 0; i < raw_compile_info.length; i++) {
           compile_info.push(new FunctionCompileInfo(raw_compile_info[i]));
           old_index_map.push(i);
       }
   
@@ skipping 37 matching lines @@
           compile_info[previous_sibling].next_sibling_index = -1;
         }
       }
   
       ResetIndexes(-1, -1);
       Assert(current_index == compile_info.length);
   
       return compile_info;
     }
   
-    // Given a positions, finds a function that fully includes the entire change.
+    // Given a positions, finds a function that fully includes the entire
+    // change.
     function FindChangedFunction(compile_info, offset, len) {
       // First condition: function should start before the change region.
       // Function #0 (whole-script function) always does, but we want
       // one, that is later in this list.
       var index = 0;
       while (index + 1 < compile_info.length &&
           compile_info[index + 1].start_position <= offset) {
         index++;
       }
       // Now we are at the last function that begins before the change
@@ skipping 131 matching lines @@
     // Check that function being patched is not currently on stack.
     CheckStackActivations(
         [ FindFunctionInfo(function_being_patched) ], change_log );
   
   
     // Committing all changes.
     var old_script_name = CreateNameForOldScript(script);
   
     // Update the script text and create a new script representing an old
     // version of the script.
-    var old_script = %LiveEditReplaceScript(script, new_source, old_script_name);
+    var old_script = %LiveEditReplaceScript(script, new_source,
+        old_script_name);
   
     PatchCode(new_compile_info[function_being_patched],
         FindFunctionInfo(function_being_patched));
   
     var position_patch_report = new Array();
     change_log.push( {position_patched: position_patch_report} );
   
     var position_change_array = [ change_pos,
                                   change_pos + change_len_old,
                                   change_pos + change_len_new ];
@@ skipping 187 matching lines @@
     var diff = FindSimpleDiff(old_source, new_source);
     if (!diff) {
       return;
     }
     ApplyPatch(script, diff.change_pos, diff.old_len,
         new_source.substring(diff.change_pos, diff.change_pos + diff.new_len),
         change_log);
   }
   // Function is public.
   this.SetScriptSource = SetScriptSource;
+  
+  function CompareStringsLinewise(s1, s2) {
+    return %LiveEditCompareStringsLinewise(s1, s2);
+  }
+  // Function is public (for tests).
+  this.CompareStringsLinewise = CompareStringsLinewise;
 
   
   // Finds a difference between 2 strings in form of a single chunk.
   // This is a temporary solution. We should calculate a read diff instead.
   function FindSimpleDiff(old_source, new_source) {
     var change_pos;
     var old_len;
     var new_len;
     
     // A find range block. Whenever control leaves it, it should set 3 local
@@ skipping 46 matching lines @@
     }
 
     if (old_len == 0 && new_len == 0) {
       // no change
       return;
     }
     
     return { "change_pos": change_pos, "old_len": old_len, "new_len": new_len };
   }
 }