Added context information to scripts

src/mirror-delay.js

 // 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 137 matching lines @@
 const BOOLEAN_TYPE = 'boolean';
 const NUMBER_TYPE = 'number';
 const STRING_TYPE = 'string';
 const OBJECT_TYPE = 'object';
 const FUNCTION_TYPE = 'function';
 const REGEXP_TYPE = 'regexp';
 const ERROR_TYPE = 'error';
 const PROPERTY_TYPE = 'property';
 const FRAME_TYPE = 'frame';
 const SCRIPT_TYPE = 'script';
+const CONTEXT_TYPE = 'context';
 
 // Maximum length when sending strings through the JSON protocol.
 const kMaxProtocolStringLength = 80;
 
 // Different kind of properties.
 PropertyKind = {};
 PropertyKind.Named   = 1;
 PropertyKind.Indexed = 2;
 
 
@@ skipping 189 matching lines @@
 /**
  * Check whether the mirror reflects a script.
  * @returns {boolean} True if the mirror reflects a script
  */
 Mirror.prototype.isScript = function() {
   return this instanceof ScriptMirror;
 }
 
 
 /**
+ * Check whether the mirror reflects a context.
+ * @returns {boolean} True if the mirror reflects a context
+ */
+Mirror.prototype.isContext = function() {
+  return this instanceof ContextMirror;
+}
+
+
+/**
  * Allocate a handle id for this object.
  */
 Mirror.prototype.allocateHandle_ = function() {
   this.handle_ = next_handle_++;
 }
 
 
 Mirror.prototype.toText = function() {
   // Simpel to text which is used when on specialization in subclass.
   return "#<" + builtins.GetInstanceName(this.constructor.name) + ">";
@@ skipping 1163 matching lines @@
 
 /**
  * Mirror object for script source.
  * @param {Script} script The script object
  * @constructor
  * @extends Mirror
  */
 function ScriptMirror(script) {
   Mirror.call(this, SCRIPT_TYPE);
   this.script_ = script;
+  this.context_ = new ContextMirror(script.context_data);
   this.allocateHandle_();
 }
 inherits(ScriptMirror, Mirror);
 
 
 ScriptMirror.prototype.value = function() {
   return this.script_;
 };
 
 
@@ skipping 41 matching lines @@
     position, include_resource_offset) {
   return this.script_.locationFromPosition(position, include_resource_offset);
 }
 
 
 ScriptMirror.prototype.sourceSlice = function (opt_from_line, opt_to_line) {
   return this.script_.sourceSlice(opt_from_line, opt_to_line);
 }
 
 
+ScriptMirror.prototype.context = function() {
+  return this.context_;
+};
+
+
 ScriptMirror.prototype.toText = function() {
   var result = '';
   result += this.name();
   result += ' (lines: ';
   if (this.lineOffset() > 0) {
     result += this.lineOffset();
     result += '-';
     result += this.lineOffset() + this.lineCount() - 1;
   } else {
     result += this.lineCount();
   }
   result += ')';
   return result;
 }
 
 
 /**
+ * Mirror object for context.
+ * @param {Object} data The context data
+ * @constructor
+ * @extends Mirror
+ */
+function ContextMirror(data) {
+  Mirror.call(this, CONTEXT_TYPE);
+  this.data_ = data;
+  this.allocateHandle_();
+}
+inherits(ContextMirror, Mirror);
+
+
+ContextMirror.prototype.data = function() {
+  return this.data_;
+};
+
+
+/**
  * Returns a mirror serializer
  *
  * @param {boolean} details Set to true to include details
+ * @param {Object} options Options comtrolling the serialization
+ *     The following options can be set:
+ *       includeSource: include ths full source of scripts
  * @returns {MirrorSerializer} mirror serializer
  */
-function MakeMirrorSerializer(details) {
-  return new JSONProtocolSerializer(details);
+function MakeMirrorSerializer(details, options) {
+  return new JSONProtocolSerializer(details, options);
 }
 
 
 /**
  * Object for serializing a mirror objects and its direct references.
  * @param {boolean} details Indicates whether to include details for the mirror
  *     serialized
  * @constructor
  */
-function JSONProtocolSerializer(details) {
+function JSONProtocolSerializer(details, options) {
   this.details_ = details;
+  this.options_ = options;
   this.mirrors_ = [ ];
 }
 
 
 /**
  * Returns a serialization of an object reference. The referenced object are
  * added to the serialization state.
  *
  * @param {Mirror} mirror The mirror to serialize
  * @returns {String} JSON serialization
@@ skipping 31 matching lines @@
   
   for (var i = 0; i < count; i++) {
     content.push(this.serialize_(this.mirrors_[i], false, false));
   }
 
   var json = ArrayToJSONArray_(content);
   return json;
 }
 
 
+JSONProtocolSerializer.prototype.includeSource_ = function() {
+  return this.options_ && this.options_.includeSource;
+}
+
+
 JSONProtocolSerializer.prototype.add_ = function(mirror) {
   // If this mirror is already in the list just return.
   for (var i = 0; i < this.mirrors_.length; i++) {
     if (this.mirrors_[i] === mirror) {
       return;
     }
   }
   
   // Add the mirror to the list of mirrors to be serialized.
   this.mirrors_.push(mirror);
 }
 
 
 JSONProtocolSerializer.prototype.serialize_ = function(mirror, reference,
                                                        details) {
   // If serializing a reference to a mirror just return the reference and add
   // the mirror to the referenced mirrors.
   if (reference &&
-      (mirror.isValue() || mirror.isScript())) {
+      (mirror.isValue() || mirror.isScript() || mirror.isContext())) {
     this.add_(mirror);
     return '{"ref":' + mirror.handle() + '}';
   }
   
   // Collect the JSON property/value pairs in an array.
   var content = new Array();
 
   // Add the mirror handle.
-  if (mirror.isValue() || mirror.isScript()) {
+  if (mirror.isValue() || mirror.isScript() || mirror.isContext()) {
     content.push(MakeJSONPair_('handle', NumberToJSON_(mirror.handle())));
   }
 
   // Always add the type.
   content.push(MakeJSONPair_('type', StringToJSON_(mirror.type())));
 
   switch (mirror.type()) {
     case UNDEFINED_TYPE:
     case NULL_TYPE:
       // Undefined and null are represented just by their type.
@@ skipping 45 matching lines @@
       if (mirror.name()) {
         content.push(MakeJSONPair_('name', StringToJSON_(mirror.name())));
       }
       content.push(MakeJSONPair_('id', NumberToJSON_(mirror.id())));
       content.push(MakeJSONPair_('lineOffset',
                                  NumberToJSON_(mirror.lineOffset())));
       content.push(MakeJSONPair_('columnOffset',
                                  NumberToJSON_(mirror.columnOffset())));
       content.push(MakeJSONPair_('lineCount',
                                  NumberToJSON_(mirror.lineCount())));
+      if (mirror.data()) {
+        content.push(MakeJSONPair_('data', JSON.stringify(mirror.data())));
+      }
+      if (this.includeSource_()) {
+        content.push(MakeJSONPair_('source',
+                                   StringToJSON_(mirror.source())));
+      } else {
+        var sourceStart = mirror.source().substring(0, 80);
+        content.push(MakeJSONPair_('sourceStart',
+                                   StringToJSON_(sourceStart)));
+      }
+      content.push(MakeJSONPair_('sourceLength',

[yurys, 2009/05/06 07:22:34]

it seems that you can switch to JSON.stringify for serialization and get rid of
all the custom json serializers(MakeJSONPair_, *ToJSON_, etc)

[Søren Thygesen Gjesse, 2009/05/06 07:48:54]

Sure, that would clean up the code quite a bit.

+                                 NumberToJSON_(mirror.source().length)));
       content.push(MakeJSONPair_('scriptType',
                                  NumberToJSON_(mirror.scriptType())));
+      if (mirror.context()) {
+        content.push(MakeJSONPair_('context',
+                                   this.serializeReference(mirror.context())));
+      }
+      break;
+
+    case CONTEXT_TYPE:
+      content.push(MakeJSONPair_('data', JSON.stringify(mirror.data())));
       break;
   }
 
   // Always add the text representation.
   content.push(MakeJSONPair_('text', StringToJSON_(mirror.toText())));
   
   // Create and return the JSON string.
   return ArrayToJSONObject_(content);
 }
 
@@ skipping 283 matching lines @@
 /**
  * Convert a Date to ISO 8601 format. To avoid depending on the Date object
  * this method calls the functions in date.js directly and not through the
  * value.
  * @param {Date} value The Date value to format as JSON
  * @return {string} JSON formatted Date value
  */
 function DateToJSON_(value) {
   return '"' + DateToISO8601_(value) + '"';
 }