|
|
@ -1,47 +1,55 @@ |
|
|
(function (process) { |
|
|
(function(process) { |
|
|
|
|
|
|
|
|
global = this; |
|
|
global = this; |
|
|
global.process = process; |
|
|
global.process = process; |
|
|
global.global = global; |
|
|
global.global = global; |
|
|
global.GLOBAL = global; |
|
|
global.GLOBAL = global; |
|
|
global.root = global; |
|
|
global.root = global; |
|
|
|
|
|
|
|
|
/** deprecation errors ************************************************/ |
|
|
/** deprecation errors ************************************************/ |
|
|
|
|
|
|
|
|
function removed (reason) { |
|
|
function removed(reason) { |
|
|
return function () { |
|
|
return function() { |
|
|
throw new Error(reason); |
|
|
throw new Error(reason); |
|
|
}; |
|
|
}; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
process.debug = removed("process.debug() has moved. Use require('sys') to bring it back."); |
|
|
process.debug = |
|
|
process.error = removed("process.error() has moved. Use require('sys') to bring it back."); |
|
|
removed('process.debug() use console.error() instead'); |
|
|
process.watchFile = removed("process.watchFile() has moved to fs.watchFile()"); |
|
|
process.error = |
|
|
process.unwatchFile = removed("process.unwatchFile() has moved to fs.unwatchFile()"); |
|
|
removed('process.error() use console.error() instead'); |
|
|
process.mixin = removed('process.mixin() has been removed.'); |
|
|
process.watchFile = |
|
|
process.createChildProcess = removed("childProcess API has changed. See doc/api.txt."); |
|
|
removed('process.watchFile() has moved to fs.watchFile()'); |
|
|
process.inherits = removed("process.inherits() has moved to sys.inherits."); |
|
|
process.unwatchFile = |
|
|
process._byteLength = removed("process._byteLength() has moved to Buffer.byteLength"); |
|
|
removed('process.unwatchFile() has moved to fs.unwatchFile()'); |
|
|
|
|
|
process.mixin = |
|
|
process.assert = function (x, msg) { |
|
|
removed('process.mixin() has been removed.'); |
|
|
if (!x) throw new Error(msg || "assertion error"); |
|
|
process.createChildProcess = |
|
|
}; |
|
|
removed('childProcess API has changed. See doc/api.txt.'); |
|
|
|
|
|
process.inherits = |
|
|
var evals = process.binding('evals'); |
|
|
removed('process.inherits() has moved to sys.inherits.'); |
|
|
|
|
|
process._byteLength = |
|
|
// lazy loaded.
|
|
|
removed('process._byteLength() has moved to Buffer.byteLength'); |
|
|
var constants; |
|
|
|
|
|
function lazyConstants () { |
|
|
process.assert = function(x, msg) { |
|
|
if (!constants) constants = process.binding("constants"); |
|
|
if (!x) throw new Error(msg || 'assertion error'); |
|
|
|
|
|
}; |
|
|
|
|
|
|
|
|
|
|
|
var evals = process.binding('evals'); |
|
|
|
|
|
|
|
|
|
|
|
// lazy loaded.
|
|
|
|
|
|
var constants; |
|
|
|
|
|
function lazyConstants() { |
|
|
|
|
|
if (!constants) constants = process.binding('constants'); |
|
|
return constants; |
|
|
return constants; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// nextTick()
|
|
|
// nextTick()
|
|
|
|
|
|
|
|
|
var nextTickQueue = []; |
|
|
var nextTickQueue = []; |
|
|
|
|
|
|
|
|
process._tickCallback = function () { |
|
|
process._tickCallback = function() { |
|
|
var l = nextTickQueue.length; |
|
|
var l = nextTickQueue.length; |
|
|
if (l === 0) return; |
|
|
if (l === 0) return; |
|
|
|
|
|
|
|
|
@ -50,55 +58,55 @@ process._tickCallback = function () { |
|
|
nextTickQueue[i](); |
|
|
nextTickQueue[i](); |
|
|
} |
|
|
} |
|
|
} |
|
|
} |
|
|
catch(e) { |
|
|
catch (e) { |
|
|
nextTickQueue.splice(0, i+1); |
|
|
nextTickQueue.splice(0, i + 1); |
|
|
if (i+1 < l) { |
|
|
if (i + 1 < l) { |
|
|
process._needTickCallback(); |
|
|
process._needTickCallback(); |
|
|
} |
|
|
} |
|
|
throw e; // process.nextTick error, or 'error' event on first tick
|
|
|
throw e; // process.nextTick error, or 'error' event on first tick
|
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
nextTickQueue.splice(0, l); |
|
|
nextTickQueue.splice(0, l); |
|
|
}; |
|
|
}; |
|
|
|
|
|
|
|
|
process.nextTick = function (callback) { |
|
|
process.nextTick = function(callback) { |
|
|
nextTickQueue.push(callback); |
|
|
nextTickQueue.push(callback); |
|
|
process._needTickCallback(); |
|
|
process._needTickCallback(); |
|
|
}; |
|
|
}; |
|
|
|
|
|
|
|
|
var internalModuleCache = {}; |
|
|
var internalModuleCache = {}; |
|
|
|
|
|
|
|
|
// This contains the source code for the files in lib/
|
|
|
// This contains the source code for the files in lib/
|
|
|
// Like, natives.fs is the contents of lib/fs.js
|
|
|
// Like, natives.fs is the contents of lib/fs.js
|
|
|
var natives = process.binding('natives'); |
|
|
var natives = process.binding('natives'); |
|
|
|
|
|
|
|
|
// Native modules don't need a full require function. So we can bootstrap
|
|
|
// Native modules don't need a full require function. So we can bootstrap
|
|
|
// most of the system with this mini-require.
|
|
|
// most of the system with this mini-require.
|
|
|
function requireNative (id) { |
|
|
function requireNative(id) { |
|
|
if (internalModuleCache[id]) return internalModuleCache[id].exports; |
|
|
if (internalModuleCache[id]) return internalModuleCache[id].exports; |
|
|
if (!natives[id]) throw new Error('No such native module ' + id); |
|
|
if (!natives[id]) throw new Error('No such native module ' + id); |
|
|
|
|
|
|
|
|
var fn = evals.Script.runInThisContext( |
|
|
var fn = evals.Script.runInThisContext( |
|
|
"(function (module, exports, require) {" + natives[id] + "\n})", |
|
|
'(function (module, exports, require) {' + natives[id] + '\n})', |
|
|
id + '.js'); |
|
|
id + '.js'); |
|
|
var m = {id: id, exports: {}}; |
|
|
var m = {id: id, exports: {}}; |
|
|
fn(m, m.exports, requireNative); |
|
|
fn(m, m.exports, requireNative); |
|
|
m.loaded = true; |
|
|
m.loaded = true; |
|
|
internalModuleCache[id] = m; |
|
|
internalModuleCache[id] = m; |
|
|
return m.exports; |
|
|
return m.exports; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
// Module System
|
|
|
// Module System
|
|
|
var module = (function () { |
|
|
var module = (function() { |
|
|
var exports = {}; |
|
|
var exports = {}; |
|
|
// Set the environ variable NODE_MODULE_CONTEXTS=1 to make node load all
|
|
|
// Set the environ variable NODE_MODULE_CONTEXTS=1 to make node load all
|
|
|
// modules in thier own context.
|
|
|
// modules in thier own context.
|
|
|
var contextLoad = false; |
|
|
var contextLoad = false; |
|
|
if (+process.env["NODE_MODULE_CONTEXTS"] > 0) contextLoad = true; |
|
|
if (+process.env['NODE_MODULE_CONTEXTS'] > 0) contextLoad = true; |
|
|
|
|
|
|
|
|
var moduleCache = {}; |
|
|
var moduleCache = {}; |
|
|
|
|
|
|
|
|
function Module (id, parent) { |
|
|
function Module(id, parent) { |
|
|
this.id = id; |
|
|
this.id = id; |
|
|
this.exports = {}; |
|
|
this.exports = {}; |
|
|
this.parent = parent; |
|
|
this.parent = parent; |
|
|
@ -112,33 +120,36 @@ var module = (function () { |
|
|
|
|
|
|
|
|
// Modules
|
|
|
// Modules
|
|
|
|
|
|
|
|
|
var debugLevel = parseInt(process.env["NODE_DEBUG"], 16); |
|
|
var debugLevel = parseInt(process.env['NODE_DEBUG'], 16); |
|
|
function debug (x) { |
|
|
if (debugLevel & 1) { |
|
|
if (debugLevel & 1) console.error(x); |
|
|
debug = function(x) { console.error(x); }; |
|
|
|
|
|
} else { |
|
|
|
|
|
debug = function() { }; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var path = requireNative('path'); |
|
|
var path = requireNative('path'); |
|
|
|
|
|
|
|
|
var modulePaths = [path.join(process.execPath, "..", "..", "lib", "node")]; |
|
|
var modulePaths = [path.join(process.execPath, '..', '..', 'lib', 'node')]; |
|
|
|
|
|
|
|
|
if (process.env["HOME"]) { |
|
|
if (process.env['HOME']) { |
|
|
modulePaths.unshift(path.join(process.env["HOME"], ".node_libraries")); |
|
|
modulePaths.unshift(path.join(process.env['HOME'], '.node_libraries')); |
|
|
modulePaths.unshift(path.join(process.env["HOME"], ".node_modules")); |
|
|
modulePaths.unshift(path.join(process.env['HOME'], '.node_modules')); |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
if (process.env["NODE_PATH"]) { |
|
|
if (process.env['NODE_PATH']) { |
|
|
modulePaths = process.env["NODE_PATH"].split(":").concat(modulePaths); |
|
|
modulePaths = process.env['NODE_PATH'].split(':').concat(modulePaths); |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
var extensions = {}; |
|
|
var extensions = {}; |
|
|
var registerExtension = removed('require.registerExtension() removed. Use require.extensions instead'); |
|
|
var registerExtension = |
|
|
|
|
|
removed('require.registerExtension() removed.' + |
|
|
|
|
|
' Use require.extensions instead'); |
|
|
|
|
|
|
|
|
// Which files to traverse while finding id? Returns generator function.
|
|
|
// Which files to traverse while finding id? Returns generator function.
|
|
|
function traverser (id, dirs) { |
|
|
function traverser(id, dirs) { |
|
|
var head = [], inDir = [], dirs = dirs.slice(), |
|
|
var head = [], inDir = [], dirs = dirs.slice(), |
|
|
exts = Object.keys(extensions); |
|
|
exts = Object.keys(extensions); |
|
|
return function next () { |
|
|
return function next() { |
|
|
var result = head.shift(); |
|
|
var result = head.shift(); |
|
|
if (result) { return result; } |
|
|
if (result) { return result; } |
|
|
|
|
|
|
|
|
@ -147,11 +158,11 @@ var module = (function () { |
|
|
|
|
|
|
|
|
var dir = dirs.shift(); |
|
|
var dir = dirs.shift(); |
|
|
if (dir !== undefined) { |
|
|
if (dir !== undefined) { |
|
|
function direct (ext) { return path.join(dir, id + ext); } |
|
|
function direct(ext) { return path.join(dir, id + ext); } |
|
|
function index (ext) { return path.join(dir, id, 'index' + ext); } |
|
|
function index(ext) { return path.join(dir, id, 'index' + ext); } |
|
|
inDir = [ |
|
|
inDir = [ |
|
|
function () { return exts.map(direct); }, |
|
|
function() { return exts.map(direct); }, |
|
|
function () { return exts.map(index); } |
|
|
function() { return exts.map(index); } |
|
|
]; |
|
|
]; |
|
|
head = [path.join(dir, id)]; |
|
|
head = [path.join(dir, id)]; |
|
|
return next(); |
|
|
return next(); |
|
|
@ -159,14 +170,15 @@ var module = (function () { |
|
|
}; |
|
|
}; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
function findModulePath (request, paths) { |
|
|
function findModulePath(request, paths) { |
|
|
var nextLoc = traverser(request, request.charAt(0) === '/' ? [''] : paths); |
|
|
var nextLoc = |
|
|
|
|
|
traverser(request, request.charAt(0) === '/' ? [''] : paths); |
|
|
|
|
|
|
|
|
var fs = requireNative('fs'); |
|
|
var fs = requireNative('fs'); |
|
|
|
|
|
|
|
|
var location, stats; |
|
|
var location, stats; |
|
|
while (location = nextLoc()) { |
|
|
while (location = nextLoc()) { |
|
|
try { stats = fs.statSync(location); } catch(e) { continue; } |
|
|
try { stats = fs.statSync(location); } catch (e) { continue; } |
|
|
if (stats && !stats.isDirectory()) return location; |
|
|
if (stats && !stats.isDirectory()) return location; |
|
|
} |
|
|
} |
|
|
return false; |
|
|
return false; |
|
|
@ -174,12 +186,12 @@ var module = (function () { |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// sync - no i/o performed
|
|
|
// sync - no i/o performed
|
|
|
function resolveModuleLookupPaths (request, parent) { |
|
|
function resolveModuleLookupPaths(request, parent) { |
|
|
|
|
|
|
|
|
if (natives[request]) return [request, []]; |
|
|
if (natives[request]) return [request, []]; |
|
|
|
|
|
|
|
|
var start = request.substring(0, 2); |
|
|
var start = request.substring(0, 2); |
|
|
if (start !== "./" && start !== "..") { |
|
|
if (start !== './' && start !== '..') { |
|
|
return [request, modulePaths]; |
|
|
return [request, modulePaths]; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
@ -202,13 +214,14 @@ var module = (function () { |
|
|
if (parentIdPath === '.' && id.indexOf('/') === -1) { |
|
|
if (parentIdPath === '.' && id.indexOf('/') === -1) { |
|
|
id = './' + id; |
|
|
id = './' + id; |
|
|
} |
|
|
} |
|
|
debug("RELATIVE: requested:" + request + " set ID to: "+id+" from "+parent.id); |
|
|
debug('RELATIVE: requested:' + request + |
|
|
|
|
|
' set ID to: ' + id + ' from ' + parent.id); |
|
|
return [id, [path.dirname(parent.filename)]]; |
|
|
return [id, [path.dirname(parent.filename)]]; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function loadModule (request, parent) { |
|
|
function loadModule(request, parent) { |
|
|
debug("loadModule REQUEST " + (request) + " parent: " + parent.id); |
|
|
debug('loadModule REQUEST ' + (request) + ' parent: ' + parent.id); |
|
|
|
|
|
|
|
|
var resolved = resolveModuleFilename(request, parent); |
|
|
var resolved = resolveModuleFilename(request, parent); |
|
|
var id = resolved[0]; |
|
|
var id = resolved[0]; |
|
|
@ -219,7 +232,7 @@ var module = (function () { |
|
|
if (natives[id]) { |
|
|
if (natives[id]) { |
|
|
// REPL is a special case, because it needs the real require.
|
|
|
// REPL is a special case, because it needs the real require.
|
|
|
if (id == 'repl') { |
|
|
if (id == 'repl') { |
|
|
var replModule = new Module("repl"); |
|
|
var replModule = new Module('repl'); |
|
|
replModule._compile(natives.repl, 'repl.js'); |
|
|
replModule._compile(natives.repl, 'repl.js'); |
|
|
internalModuleCache.repl = replModule; |
|
|
internalModuleCache.repl = replModule; |
|
|
return replModule.exports; |
|
|
return replModule.exports; |
|
|
@ -238,14 +251,15 @@ var module = (function () { |
|
|
return module.exports; |
|
|
return module.exports; |
|
|
}; |
|
|
}; |
|
|
|
|
|
|
|
|
function resolveModuleFilename (request, parent) { |
|
|
function resolveModuleFilename(request, parent) { |
|
|
if (natives[request]) return [request, request]; |
|
|
if (natives[request]) return [request, request]; |
|
|
var resolvedModule = resolveModuleLookupPaths(request, parent), |
|
|
var resolvedModule = resolveModuleLookupPaths(request, parent), |
|
|
id = resolvedModule[0], |
|
|
id = resolvedModule[0], |
|
|
paths = resolvedModule[1]; |
|
|
paths = resolvedModule[1]; |
|
|
|
|
|
|
|
|
// look up the filename first, since that's the cache key.
|
|
|
// look up the filename first, since that's the cache key.
|
|
|
debug("looking for " + JSON.stringify(id) + " in " + JSON.stringify(paths)); |
|
|
debug('looking for ' + JSON.stringify(id) + |
|
|
|
|
|
' in ' + JSON.stringify(paths)); |
|
|
var filename = findModulePath(request, paths); |
|
|
var filename = findModulePath(request, paths); |
|
|
if (!filename) { |
|
|
if (!filename) { |
|
|
throw new Error("Cannot find module '" + request + "'"); |
|
|
throw new Error("Cannot find module '" + request + "'"); |
|
|
@ -254,8 +268,9 @@ var module = (function () { |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Module.prototype.load = function (filename) { |
|
|
Module.prototype.load = function(filename) { |
|
|
debug("load " + JSON.stringify(filename) + " for module " + JSON.stringify(this.id)); |
|
|
debug('load ' + JSON.stringify(filename) + |
|
|
|
|
|
' for module ' + JSON.stringify(this.id)); |
|
|
|
|
|
|
|
|
process.assert(!this.loaded); |
|
|
process.assert(!this.loaded); |
|
|
this.filename = filename; |
|
|
this.filename = filename; |
|
|
@ -268,16 +283,16 @@ var module = (function () { |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Returns exception if any
|
|
|
// Returns exception if any
|
|
|
Module.prototype._compile = function (content, filename) { |
|
|
Module.prototype._compile = function(content, filename) { |
|
|
var self = this; |
|
|
var self = this; |
|
|
// remove shebang
|
|
|
// remove shebang
|
|
|
content = content.replace(/^\#\!.*/, ''); |
|
|
content = content.replace(/^\#\!.*/, ''); |
|
|
|
|
|
|
|
|
function require (path) { |
|
|
function require(path) { |
|
|
return loadModule(path, self); |
|
|
return loadModule(path, self); |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
require.resolve = function (request) { |
|
|
require.resolve = function(request) { |
|
|
return resolveModuleFilename(request, self)[1]; |
|
|
return resolveModuleFilename(request, self)[1]; |
|
|
} |
|
|
} |
|
|
require.paths = modulePaths; |
|
|
require.paths = modulePaths; |
|
|
@ -291,7 +306,7 @@ var module = (function () { |
|
|
var dirname = path.dirname(filename); |
|
|
var dirname = path.dirname(filename); |
|
|
|
|
|
|
|
|
if (contextLoad) { |
|
|
if (contextLoad) { |
|
|
if (self.id !== ".") { |
|
|
if (self.id !== '.') { |
|
|
debug('load submodule'); |
|
|
debug('load submodule'); |
|
|
// not root module
|
|
|
// not root module
|
|
|
var sandbox = {}; |
|
|
var sandbox = {}; |
|
|
@ -321,36 +336,38 @@ var module = (function () { |
|
|
|
|
|
|
|
|
} else { |
|
|
} else { |
|
|
// create wrapper function
|
|
|
// create wrapper function
|
|
|
var wrapper = "(function (exports, require, module, __filename, __dirname) { " |
|
|
var wrapper = |
|
|
+ content |
|
|
'(function (exports, require, module, __filename, __dirname) { ' + |
|
|
+ "\n});"; |
|
|
content + |
|
|
|
|
|
'\n});'; |
|
|
|
|
|
|
|
|
var compiledWrapper = evals.Script.runInThisContext(wrapper, filename); |
|
|
var compiledWrapper = evals.Script.runInThisContext(wrapper, filename); |
|
|
if (filename === process.argv[1] && global.v8debug) { |
|
|
if (filename === process.argv[1] && global.v8debug) { |
|
|
global.v8debug.Debug.setBreakPoint(compiledWrapper, 0, 0); |
|
|
global.v8debug.Debug.setBreakPoint(compiledWrapper, 0, 0); |
|
|
} |
|
|
} |
|
|
return compiledWrapper.apply(self.exports, [self.exports, require, self, filename, dirname]); |
|
|
var args = [self.exports, require, self, filename, dirname]; |
|
|
|
|
|
return compiledWrapper.apply(self.exports, args); |
|
|
} |
|
|
} |
|
|
}; |
|
|
}; |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Native extension for .js
|
|
|
// Native extension for .js
|
|
|
extensions['.js'] = function (module, filename) { |
|
|
extensions['.js'] = function(module, filename) { |
|
|
var content = requireNative('fs').readFileSync(filename, 'utf8'); |
|
|
var content = requireNative('fs').readFileSync(filename, 'utf8'); |
|
|
module._compile(content, filename); |
|
|
module._compile(content, filename); |
|
|
}; |
|
|
}; |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Native extension for .node
|
|
|
// Native extension for .node
|
|
|
extensions['.node'] = function (module, filename) { |
|
|
extensions['.node'] = function(module, filename) { |
|
|
process.dlopen(filename, module.exports); |
|
|
process.dlopen(filename, module.exports); |
|
|
}; |
|
|
}; |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// bootstrap main module.
|
|
|
// bootstrap main module.
|
|
|
exports.runMain = function () { |
|
|
exports.runMain = function() { |
|
|
// Load the main module--the command line argument.
|
|
|
// Load the main module--the command line argument.
|
|
|
process.mainModule = new Module("."); |
|
|
process.mainModule = new Module('.'); |
|
|
try { |
|
|
try { |
|
|
process.mainModule.load(process.argv[1]); |
|
|
process.mainModule.load(process.argv[1]); |
|
|
} catch (e) { |
|
|
} catch (e) { |
|
|
@ -364,37 +381,37 @@ var module = (function () { |
|
|
}; |
|
|
}; |
|
|
|
|
|
|
|
|
// bootstrap repl
|
|
|
// bootstrap repl
|
|
|
exports.requireRepl = function () { return loadModule("repl", "."); }; |
|
|
exports.requireRepl = function() { return loadModule('repl', '.'); }; |
|
|
|
|
|
|
|
|
// export for --eval
|
|
|
// export for --eval
|
|
|
exports.Module = Module; |
|
|
exports.Module = Module; |
|
|
|
|
|
|
|
|
return exports; |
|
|
return exports; |
|
|
})(); |
|
|
})(); |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Load events module in order to access prototype elements on process like
|
|
|
// Load events module in order to access prototype elements on process like
|
|
|
// process.addListener.
|
|
|
// process.addListener.
|
|
|
var events = requireNative('events'); |
|
|
var events = requireNative('events'); |
|
|
|
|
|
|
|
|
// Signal Handlers
|
|
|
// Signal Handlers
|
|
|
(function() { |
|
|
(function() { |
|
|
var signalWatchers = {}; |
|
|
var signalWatchers = {}; |
|
|
var addListener = process.addListener; |
|
|
var addListener = process.addListener; |
|
|
var removeListener = process.removeListener; |
|
|
var removeListener = process.removeListener; |
|
|
|
|
|
|
|
|
function isSignal (event) { |
|
|
function isSignal(event) { |
|
|
return event.slice(0, 3) === 'SIG' && lazyConstants()[event]; |
|
|
return event.slice(0, 3) === 'SIG' && lazyConstants()[event]; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
// Wrap addListener for the special signal types
|
|
|
// Wrap addListener for the special signal types
|
|
|
process.on = process.addListener = function (type, listener) { |
|
|
process.on = process.addListener = function(type, listener) { |
|
|
var ret = addListener.apply(this, arguments); |
|
|
var ret = addListener.apply(this, arguments); |
|
|
if (isSignal(type)) { |
|
|
if (isSignal(type)) { |
|
|
if (!signalWatchers.hasOwnProperty(type)) { |
|
|
if (!signalWatchers.hasOwnProperty(type)) { |
|
|
var b = process.binding('signal_watcher'); |
|
|
var b = process.binding('signal_watcher'); |
|
|
var w = new b.SignalWatcher(lazyConstants()[type]); |
|
|
var w = new b.SignalWatcher(lazyConstants()[type]); |
|
|
w.callback = function () { process.emit(type); }; |
|
|
w.callback = function() { process.emit(type); }; |
|
|
signalWatchers[type] = w; |
|
|
signalWatchers[type] = w; |
|
|
w.start(); |
|
|
w.start(); |
|
|
|
|
|
|
|
|
@ -406,7 +423,7 @@ var events = requireNative('events'); |
|
|
return ret; |
|
|
return ret; |
|
|
}; |
|
|
}; |
|
|
|
|
|
|
|
|
process.removeListener = function (type, listener) { |
|
|
process.removeListener = function(type, listener) { |
|
|
var ret = removeListener.apply(this, arguments); |
|
|
var ret = removeListener.apply(this, arguments); |
|
|
if (isSignal(type)) { |
|
|
if (isSignal(type)) { |
|
|
process.assert(signalWatchers.hasOwnProperty(type)); |
|
|
process.assert(signalWatchers.hasOwnProperty(type)); |
|
|
@ -418,32 +435,32 @@ var events = requireNative('events'); |
|
|
|
|
|
|
|
|
return ret; |
|
|
return ret; |
|
|
}; |
|
|
}; |
|
|
})(); |
|
|
})(); |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
global.setTimeout = function () { |
|
|
global.setTimeout = function() { |
|
|
var t = requireNative('timers'); |
|
|
var t = requireNative('timers'); |
|
|
return t.setTimeout.apply(this, arguments); |
|
|
return t.setTimeout.apply(this, arguments); |
|
|
}; |
|
|
}; |
|
|
|
|
|
|
|
|
global.setInterval = function () { |
|
|
global.setInterval = function() { |
|
|
var t = requireNative('timers'); |
|
|
var t = requireNative('timers'); |
|
|
return t.setInterval.apply(this, arguments); |
|
|
return t.setInterval.apply(this, arguments); |
|
|
}; |
|
|
}; |
|
|
|
|
|
|
|
|
global.clearTimeout = function () { |
|
|
global.clearTimeout = function() { |
|
|
var t = requireNative('timers'); |
|
|
var t = requireNative('timers'); |
|
|
return t.clearTimeout.apply(this, arguments); |
|
|
return t.clearTimeout.apply(this, arguments); |
|
|
}; |
|
|
}; |
|
|
|
|
|
|
|
|
global.clearInterval = function () { |
|
|
global.clearInterval = function() { |
|
|
var t = requireNative('timers'); |
|
|
var t = requireNative('timers'); |
|
|
return t.clearInterval.apply(this, arguments); |
|
|
return t.clearInterval.apply(this, arguments); |
|
|
}; |
|
|
}; |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var stdout; |
|
|
var stdout; |
|
|
process.__defineGetter__('stdout', function () { |
|
|
process.__defineGetter__('stdout', function() { |
|
|
if (stdout) return stdout; |
|
|
if (stdout) return stdout; |
|
|
|
|
|
|
|
|
var binding = process.binding('stdio'), |
|
|
var binding = process.binding('stdio'), |
|
|
@ -455,18 +472,18 @@ process.__defineGetter__('stdout', function () { |
|
|
stdout = new fs.WriteStream(null, {fd: fd}); |
|
|
stdout = new fs.WriteStream(null, {fd: fd}); |
|
|
} else { |
|
|
} else { |
|
|
stdout = new net.Stream(fd); |
|
|
stdout = new net.Stream(fd); |
|
|
// FIXME Should probably have an option in net.Stream to create a stream from
|
|
|
// FIXME Should probably have an option in net.Stream to create a
|
|
|
// an existing fd which is writable only. But for now we'll just add
|
|
|
// stream from an existing fd which is writable only. But for now
|
|
|
// this hack and set the `readable` member to false.
|
|
|
// we'll just add this hack and set the `readable` member to false.
|
|
|
// Test: ./node test/fixtures/echo.js < /etc/passwd
|
|
|
// Test: ./node test/fixtures/echo.js < /etc/passwd
|
|
|
stdout.readable = false; |
|
|
stdout.readable = false; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
return stdout; |
|
|
return stdout; |
|
|
}); |
|
|
}); |
|
|
|
|
|
|
|
|
var stdin; |
|
|
var stdin; |
|
|
process.openStdin = function () { |
|
|
process.openStdin = function() { |
|
|
if (stdin) return stdin; |
|
|
if (stdin) return stdin; |
|
|
|
|
|
|
|
|
var binding = process.binding('stdio'), |
|
|
var binding = process.binding('stdio'), |
|
|
@ -484,53 +501,54 @@ process.openStdin = function () { |
|
|
stdin.resume(); |
|
|
stdin.resume(); |
|
|
|
|
|
|
|
|
return stdin; |
|
|
return stdin; |
|
|
}; |
|
|
}; |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Lazy load console object
|
|
|
// Lazy load console object
|
|
|
global.__defineGetter__('console', function () { |
|
|
global.__defineGetter__('console', function() { |
|
|
return requireNative('console'); |
|
|
return requireNative('console'); |
|
|
}); |
|
|
}); |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
global.Buffer = requireNative('buffer').Buffer; |
|
|
global.Buffer = requireNative('buffer').Buffer; |
|
|
|
|
|
|
|
|
process.exit = function (code) { |
|
|
process.exit = function(code) { |
|
|
process.emit("exit", code || 0); |
|
|
process.emit('exit', code || 0); |
|
|
process.reallyExit(code || 0); |
|
|
process.reallyExit(code || 0); |
|
|
}; |
|
|
}; |
|
|
|
|
|
|
|
|
process.kill = function (pid, sig) { |
|
|
process.kill = function(pid, sig) { |
|
|
sig = sig || 'SIGTERM'; |
|
|
sig = sig || 'SIGTERM'; |
|
|
if (!lazyConstants()[sig]) throw new Error("Unknown signal: " + sig); |
|
|
if (!lazyConstants()[sig]) throw new Error('Unknown signal: ' + sig); |
|
|
process._kill(pid, lazyConstants()[sig]); |
|
|
process._kill(pid, lazyConstants()[sig]); |
|
|
}; |
|
|
}; |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var cwd = process.cwd(); |
|
|
var cwd = process.cwd(); |
|
|
var path = requireNative('path'); |
|
|
var path = requireNative('path'); |
|
|
|
|
|
|
|
|
// Make process.argv[0] and process.argv[1] into full paths.
|
|
|
// Make process.argv[0] and process.argv[1] into full paths.
|
|
|
if (process.argv[0].indexOf('/') > 0) { |
|
|
if (process.argv[0].indexOf('/') > 0) { |
|
|
process.argv[0] = path.join(cwd, process.argv[0]); |
|
|
process.argv[0] = path.join(cwd, process.argv[0]); |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
if (process.argv[1]) { |
|
|
if (process.argv[1]) { |
|
|
// Load module
|
|
|
// Load module
|
|
|
if (process.argv[1].charAt(0) != "/" && !(/^http:\/\//).exec(process.argv[1])) { |
|
|
if (process.argv[1].charAt(0) != '/' && |
|
|
|
|
|
!(/^http:\/\//).exec(process.argv[1])) { |
|
|
process.argv[1] = path.join(cwd, process.argv[1]); |
|
|
process.argv[1] = path.join(cwd, process.argv[1]); |
|
|
} |
|
|
} |
|
|
// REMOVEME: nextTick should not be necessary. This hack to get
|
|
|
// REMOVEME: nextTick should not be necessary. This hack to get
|
|
|
// test/simple/test-exception-handler2.js working.
|
|
|
// test/simple/test-exception-handler2.js working.
|
|
|
process.nextTick(module.runMain); |
|
|
process.nextTick(module.runMain); |
|
|
|
|
|
|
|
|
} else if (process._eval) { |
|
|
} else if (process._eval) { |
|
|
// -e, --eval
|
|
|
// -e, --eval
|
|
|
var rv = new module.Module()._compile('return eval(process._eval)', 'eval'); |
|
|
var rv = new module.Module()._compile('return eval(process._eval)', 'eval'); |
|
|
console.log(rv); |
|
|
console.log(rv); |
|
|
} else { |
|
|
} else { |
|
|
// REPL
|
|
|
// REPL
|
|
|
module.requireRepl().start(); |
|
|
module.requireRepl().start(); |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
}); |
|
|
}); |
|
|
|
Ryan Dahl
14 years ago