/*---------------------------------------------------------------------------------------------

* Copyright (c) Microsoft Corporation. All rights reserved.

* Licensed under the MIT License. See License.txt in the project root for license information.

*--------------------------------------------------------------------------------------------*/

!function() {

var CHUNK_SIZE = 100; // break large objects into chunks of this size

var INDEX_PATTERN = /^(0|[1-9][0-9]*)$/;

// try to load 'vm' even if 'require' isn't available in the current context

var vm = process.mainModule ? process.mainModule.require('vm') : require('vm');

// the following objects should be available in all versions of node.js

var LookupMirror = vm.runInDebugContext('LookupMirror');

var DebugCommandProcessor = vm.runInDebugContext('DebugCommandProcessor');

/*

* Retrieving index and named properties of an object requires some work in recent versions of node

* because 'propertyNames' no longer takes a filter argument.

*/

var indexedPropertyCount;

var namedPropertyCount;

var hasManyProperties;

var namedProperties;

try {

var PropertyKind = vm.runInDebugContext('PropertyKind');

if (!PropertyKind) {

throw new Error("undef");

}

indexedPropertyCount = function(mirror) {

return mirror.propertyNames(PropertyKind.Indexed).length;

};

namedPropertyCount = function(mirror) {

return mirror.propertyNames(PropertyKind.Named).length;

};

hasManyProperties = function(mirror, limit) {

return mirror.propertyNames(PropertyKind.Named | PropertyKind.Indexed, limit).length >= limit;

};

namedProperties = function(mirror) {

return mirror.propertyNames(PropertyKind.Named);

};

} catch (error) {

indexedPropertyCount = function(mirror) {

var n = 0;

var names = mirror.propertyNames();

for (var i = 0; i < names.length; i++) {

if (isIndex(names[i])) {

n++;

}

}

return n;

};

namedPropertyCount = function(mirror) {

var n = 0;

var names = mirror.propertyNames();

for (var i = 0; i < names.length; i++) {

if (!isIndex(names[i])) {

n++;

}

}

return n;

};

hasManyProperties = function(mirror, limit) {

return mirror.propertyNames().length >= limit;

};

namedProperties = function(mirror) {

var named = [];

var names = mirror.propertyNames();

for (var i = 0; i < names.length; i++) {

var name = names[i];

if (!isIndex(name)) {

named.push(name);

}

}

return named;

};

}

var isIndex = function(name) {

switch (typeof name) {

case 'number':

return true;

case 'string':

return INDEX_PATTERN.test(name);

default:

return false;

}

};

/**

* In old versions of node it was possible to monkey patch the JSON response serializer.

* This made it possible to drop large objects from the 'refs' array (that is part of every protocol response).

*/

try {

var JSONProtocolSerializer = vm.runInDebugContext('JSONProtocolSerializer');

JSONProtocolSerializer.prototype.serializeReferencedObjects = function () {

var content = [];

for (var i = 0; i < this.mirrors_.length; i++) {

var m = this.mirrors_[i];

if (m.isArray()) continue;

if (m.isObject()) {

if (m.handle() < 0) {

// we cannot drop transient objects from 'refs' because they cannot be looked up later

} else {

if (hasManyProperties(m, CHUNK_SIZE)) {

continue;

}

}

}

content.push(this.serialize_(m, false, false));

}

return content;

};

} catch (error) {

// since overriding 'serializeReferencedObjects' is optional, we can silently ignore the error.

}

/**

* This new protocol request makes it possible to retrieve a range of values from a large object.

* 'mode' controls whether 'named' or 'indexed' or 'all' types of properties are returned.

* For 'indexed' or 'all' mode 'start' and 'count' specify the range of properties to return.

*/

DebugCommandProcessor.prototype.dispatch_['vscode_slice'] = function(request, response) {

var handle = request.arguments.handle;

var start = request.arguments.start;

var count = request.arguments.count;

var mode = request.arguments.mode;

var mirror = LookupMirror(handle);

if (!mirror) {

return response.failed('Object #' + handle + '# not found');

}

var result = [];

if (mode === 'named' || mode === 'all') {

if (mirror.isArray() || mirror.isObject()) {

var names = namedProperties(mirror);

for (var i = 0; i < names.length; i++) {

var name = names[i];

var p = mirror.property(name);

result.push({ name: name, value: p.value() });

}

}

}

if (mode === 'indexed' || mode === 'all') {

if (mirror.isArray()) {

var a = mirror.indexedPropertiesFromRange(start, start+count-1);

for (var i = 0; i < a.length; i++) {

result.push({ name: (start+i).toString(), value: a[i].value() });

}

} else if (mirror.isObject()) {

for (var i = 0, j = start; i < count; i++, j++) {

var p = mirror.property(j.toString());

result.push({ name: j.toString(), value: p.value() });

}

}

}

response.body = {

result: result

};

};

/**

* If the passed mirror object is a large array or object this function

* returns the mirror without its properties but with two size attributes ('vscode_namedCnt', 'vscode_indexedCnt') instead.

*/

var dehydrate = function(mirror) {

var namedCnt = -1;

var indexedCnt = -1;

if (mirror.isArray()) {

namedCnt = namedPropertyCount(mirror);

indexedCnt = mirror.length();

} else if (mirror.isObject()) {

switch (mirror.className()) {

case 'ArrayBuffer':

case 'Int8Array':

case 'Uint8Array':

case 'Uint8ClampedArray':

case 'Int16Array':

case 'Uint16Array':

case 'Int32Array':

case 'Uint32Array':

case 'Float32Array':

case 'Float64Array':

namedCnt = namedPropertyCount(mirror);

indexedCnt = indexedPropertyCount(mirror);

break;

default:

break;

}

}

if (indexedCnt > CHUNK_SIZE) {

return {

type: 'object',

handle: mirror.handle(),

className: mirror.className(),

vscode_namedCnt: namedCnt,

vscode_indexedCnt: indexedCnt

};

}

return mirror;

};

/**

* This override removes the properties of large data structures from the lookup response

* and returns the size of the data structure instead.

*/

DebugCommandProcessor.prototype.dispatch_['vscode_lookup'] = function(request, response) {

var result = this.lookupRequest_(request, response);

if (!result && response.body) {

var handles = request.arguments.handles;

for (var i = 0; i < handles.length; i++) {

var handle = handles[i];

response.body[handle] = dehydrate(response.body[handle]);

}

}

return result;

};

/**

* This override removes the properties of large data structures from the lookup response

* and returns the size of the data structure instead.

*/

DebugCommandProcessor.prototype.dispatch_['vscode_evaluate'] = function(request, response) {

var result = this.evaluateRequest_(request, response);

if (!result) {

response.body = dehydrate(response.body);

}

return result;

};

/**

* This override trims the maximum number of local variables to 'maxLocals'.

*/

DebugCommandProcessor.prototype.dispatch_['vscode_scopes'] = function(request, response) {

var result = this.scopesRequest_(request, response);

if (!result) {

var maxLocals = request.arguments.maxLocals;

var scopes = response.body.scopes;

for (var i = 0; i < scopes.length-1; i++) {

var details = scopes[i].details_.details_;

if (details && details[0] === 1) { // locals

var locals = details[1];

var names = Object.keys(locals);

if (names.length > maxLocals) {

var locals2 = {};

for (var j = 0; j < maxLocals; j++) {

var name = names[j];

locals2[name] = locals[name];

}

details[1] = locals2;

response.body.vscode_locals = names.length; // remember original number of locals

}

}

}

}

return result;

};

}()