lukechilds
/
node
mirror of https://github.com/lukechilds/node.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
10689 Commits
131 Branches
446 Tags
325 MiB
Tree: d790f61221
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'd790f61221'
${ noResults }
node/src/node.cc

3705 lines
101 KiB
Raw Normal View History

core: use proper #include directives
13 years ago
#include "node.h"
src: more lint after cpplint tightening Commit 847c6d9 adds a 'project headers before system headers' check to cpplint. Update the files in src/ to make the linter pass again.
12 years ago
#include "node_buffer.h"
#include "node_constants.h"
#include "node_file.h"
#include "node_http_parser.h"
#include "node_javascript.h"
#include "node_version.h"
v8_platform: provide default v8::Platform impl Provide default Platform implementation for v8's purposes.
10 years ago
#include "node_v8_platform.h"
everything is changed. i've waited much too long to commit. this is awful. i'm sorry for being so messy.
16 years ago
src: more lint after cpplint tightening Commit 847c6d9 adds a 'project headers before system headers' check to cpplint. Update the files in src/ to make the linter pass again.
12 years ago
#if defined HAVE_PERFCTR
#include "node_counters.h"
#endif
#if HAVE_OPENSSL
#include "node_crypto.h"
#endif
Integrate libuv into build system
14 years ago
build, i18n: improve Intl build, add "--with-intl" The two main goals of this change are: - To make it easier to build the Intl option using ICU (particularly, using a newer ICU than v8/Chromium's version) - To enable a much smaller ICU build with only English support The goal here is to get node.js binaries built this way by default so that the Intl API can be used. Additional data can be added at execution time (see Readme and wiki) More details are at https://github.com/joyent/node/pull/7719 In particular, this change adds the "--with-intl=" configure option to provide more ways of building "Intl": - "full-icu" picks up an ICU from deps/icu - "small-icu" is similar, but builds only English - "system-icu" uses pkg-config to find an installed ICU - "none" does nothing (no Intl) For Windows builds, the "full-icu" or "small-icu" options are added to vcbuild.bat. Note that the existing "--with-icu-path" option is not removed from configure, but may not be used alongside the new option. Wiki changes have already been made on https://github.com/joyent/node/wiki/Installation and a new page created at https://github.com/joyent/node/wiki/Intl (marked as provisional until this change lands.) Summary of changes: * README.md : doc updates * .gitignore : added "deps/icu" as this is the location where ICU is unpacked to. * Makefile : added the tools/icu/* files to cpplint, but excluded a problematic file. * configure : added the "--with-intl" option mentioned above. Calculate at config time the list of ICU source files to use and data packaging options. * node.gyp : add the new files src/node_i18n.cc/.h as well as ICU linkage. * src/node.cc : add call into node::i18n::InitializeICUDirectory(icu_data_dir) as well as new --icu-data-dir option and NODE_ICU_DATA env variable to configure ICU data loading. This loading is only relevant in the "small" configuration. * src/node_i18n.cc : new source file for the above Initialize.. function, to setup ICU as needed. * tools/icu : new directory with some tools needed for this build. * tools/icu/icu-generic.gyp : new .gyp file that builds ICU in some new ways, both on unix/mac and windows. * tools/icu/icu-system.gyp : new .gyp file to build node against a pkg-config detected ICU. * tools/icu/icu_small.json : new config file for the "English-only" small build. * tools/icu/icutrim.py : new tool for trimming down ICU data. Reads the above .json file. * tools/icu/iculslocs.cc : new tool for repairing ICU data manifests after trim operation. * tools/icu/no-op.cc : dummy file to force .gyp into using a C++ linker. * vcbuild.bat : added small-icu and full-icu options, to call into configure. * Fixed toolset dependencies, see https://github.com/joyent/node/pull/7719#issuecomment-54641687 Note that because of a bug in gyp {CC,CXX}_host must also be set. Otherwise gcc/g++ will be used by default for part of the build. Reviewed-by: Trevor Norris <trev.norris@gmail.com> Reviewed-by: Fedor Indutny <fedor@indutny.com>
10 years ago
#if defined(NODE_HAVE_I18N_SUPPORT)
#include "node_i18n.h"
#endif
build: use zero overhead systemtap probes Profiling suggested that on Linux sometimes over 10% of CPU time was being spent inside the systemtap probe entry points in the binding layer, even when the process was not actively being traced with the `stap` tool. That's why this commit makes it possible to use the *_ENABLED() macros and bail out early when we're not being traced, reducing the overhead of unused probes to (almost) zero. Said macros were already being generated by `dtrace -h` but were not usable because they rely on external definitions. To remedy that, we now generate the accompanying object files with `dtrace -G`. This commit includes a change to libuv that has been landed upstream in commit joyent/libuv@3c172ea.
11 years ago
#if defined HAVE_DTRACE || defined HAVE_ETW
src: more lint after cpplint tightening Commit 847c6d9 adds a 'project headers before system headers' check to cpplint. Update the files in src/ to make the linter pass again.
12 years ago
#include "node_dtrace.h"
Don't compile in node_dtrace.cc when not supported
13 years ago
#endif
src: more lint after cpplint tightening Commit 847c6d9 adds a 'project headers before system headers' check to cpplint. Update the files in src/ to make the linter pass again.
12 years ago
#include "ares.h"
node: add AsyncListener support AsyncListener is a JS API that works in tandem with the AsyncWrap class to allow the user to be alerted to key events in the life cycle of an asynchronous event. The AsyncWrap class has its own MakeCallback implementation that core will be migrated to use, and uses state sharing techniques to allow quicker communication between JS and C++ whether the async event callbacks need to be called.
11 years ago
#include "async-wrap.h"
#include "async-wrap-inl.h"
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now "remember" the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
#include "env.h"
#include "env-inl.h"
src: more lint after cpplint tightening Commit 847c6d9 adds a 'project headers before system headers' check to cpplint. Update the files in src/ to make the linter pass again.
12 years ago
#include "handle_wrap.h"
#include "req_wrap.h"
#include "string_bytes.h"
Merge remote-tracking branch 'upstream/v0.10' Conflicts: AUTHORS ChangeLog deps/v8/src/api.cc deps/v8/src/unicode-inl.h deps/v8/src/unicode.h lib/_stream_readable.js lib/http.js src/cares_wrap.cc src/node.cc src/node_crypto.cc src/node_dtrace.cc src/node_file.cc src/node_stat_watcher.cc src/node_version.h src/process_wrap.cc src/string_bytes.cc src/string_bytes.h src/udp_wrap.cc src/util.h test/simple/test-buffer.js test/simple/test-stream2-compatibility.js
11 years ago
#include "util.h"
src: more lint after cpplint tightening Commit 847c6d9 adds a 'project headers before system headers' check to cpplint. Update the files in src/ to make the linter pass again.
12 years ago
#include "uv.h"
#include "v8-debug.h"
src: notify V8 profiler when we're idle Inform V8's CPU profiler when we're idle. The profiler is sampling-based but not all samples are created equal; mark the wall clock time spent in epoll_wait() and friends so profiling tools can filter it out. The samples still end up in v8.log but with state=IDLE rather than state=EXTERNAL.
11 years ago
#include "v8-profiler.h"
src: more lint after cpplint tightening Commit 847c6d9 adds a 'project headers before system headers' check to cpplint. Update the files in src/ to make the linter pass again.
12 years ago
#include "zlib.h"
#include <errno.h>
#include <limits.h> // PATH_MAX
Clean up the way windows headers are included Plus make inclusion order a little more consistent in general
14 years ago
#include <locale.h>
Batch of ev -&gt; uv changes
14 years ago
#include <signal.h>
Major refactoring: program name now &#34;node&#34; Trying to make a more moduler design. Two libraries currently &#34;TCP&#34; and &#34;HTTP&#34; each have their own file. Other major feature added here is multiple web servers! excitement.
16 years ago
#include <stdio.h>
Fix ::exit() compile issues. Thanks Matthias!
16 years ago
#include <stdlib.h>
Just add an extra include for strings.h - don&#39;t try to be cute
15 years ago
#include <string.h>
src: more lint after cpplint tightening Commit 847c6d9 adds a &#39;project headers before system headers&#39; check to cpplint. Update the files in src/ to make the linter pass again.
12 years ago
#include <sys/types.h>
#if defined(_MSC_VER)
Basic VC++ compatibility work.
14 years ago
#include <direct.h>
src: more lint after cpplint tightening Commit 847c6d9 adds a &#39;project headers before system headers&#39; check to cpplint. Update the files in src/ to make the linter pass again.
12 years ago
#include <io.h>
Basic VC++ compatibility work.
14 years ago
#include <process.h>
src: more lint after cpplint tightening Commit 847c6d9 adds a &#39;project headers before system headers&#39; check to cpplint. Update the files in src/ to make the linter pass again.
12 years ago
#define strcasecmp _stricmp
Basic VC++ compatibility work.
14 years ago
#define getpid _getpid
Fix MSVS building.
14 years ago
#define umask _umask
typedef int mode_t;
src: more lint after cpplint tightening Commit 847c6d9 adds a &#39;project headers before system headers&#39; check to cpplint. Update the files in src/ to make the linter pass again.
12 years ago
#else
src: raise maximum file descriptor limit Do a binary search for the maximum RLIMIT_NOFILE. Works around the low, low limits on certain high, high-priced devices from Cupertino, CA.
11 years ago
#include <sys/resource.h> // getrlimit, setrlimit
src: more lint after cpplint tightening Commit 847c6d9 adds a &#39;project headers before system headers&#39; check to cpplint. Update the files in src/ to make the linter pass again.
12 years ago
#include <unistd.h> // setuid, getuid
Basic VC++ compatibility work.
14 years ago
#endif
exit program on top level exceptions (also lots of reorg.)
16 years ago
build: add android support Resolves minor discrepancies between android and standard POSIX systems. In addition, some configure parameters were added, and a helper-script for android configuration. Ideally, this script should be merged into the standard configure script. To build for android, source the android-configure script with an NDK path: source ./android-configure ~/android-ndk-r8d This will create an android standalone toolchain and export the necessary environment parameters. After that, build as normal: make -j8 After the build, you should now have android-compatible NodeJS binaries.
12 years ago
#if defined(__POSIX__) && !defined(__ANDROID__)
src: more lint after cpplint tightening Commit 847c6d9 adds a &#39;project headers before system headers&#39; check to cpplint. Update the files in src/ to make the linter pass again.
12 years ago
#include <pwd.h> // getpwnam()
#include <grp.h> // getgrnam()
Fix headers for node.cc
14 years ago
#endif
src: lint c++ code
12 years ago
#ifdef __APPLE__
src: more lint after cpplint tightening Commit 847c6d9 adds a &#39;project headers before system headers&#39; check to cpplint. Update the files in src/ to make the linter pass again.
12 years ago
#include <crt_externs.h>
#define environ (*_NSGetEnviron())
src: lint c++ code
12 years ago
#elif !defined(_MSC_VER)
Add &#39;extern char **environ&#39; so that the new ENV code compiles. Problem appeared in dc39e8202456686513c43a4e2c4e5e505eb3a901.
16 years ago
extern char **environ;
src: lint c++ code
12 years ago
#endif
Add &#39;extern char **environ&#39; so that the new ENV code compiles. Problem appeared in dc39e8202456686513c43a4e2c4e5e505eb3a901.
16 years ago
Revert support for isolates. It was decided that the performance benefits that isolates offer (faster spin-up times for worker processes, faster inter-worker communication, possibly a lower memory footprint) are not actual bottlenecks for most people and do not outweigh the potential stability issues and intrusive changes to the code base that first-class support for isolates requires. Hence, this commit backs out all isolates-related changes. Good bye, isolates. We hardly knew ye.
13 years ago
namespace node {
Statically define symbols ~7% improvement in hello world HTTP response bench.
15 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
using v8::Array;
src: enable native v8 typed arrays This commit removes our homegrown typed arrays implementation and enables V8&#39;s built-in typed arrays implementation.
12 years ago
using v8::ArrayBuffer;
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
using v8::Boolean;
using v8::Context;
src: update to v8 3.24 APIs
11 years ago
using v8::EscapableHandleScope;
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
using v8::Exception;
using v8::Function;
using v8::FunctionCallbackInfo;
using v8::FunctionTemplate;
string_bytes: don&#39;t use named imports in header It imports the definition into every source file that includes string_bytes.h, as evidenced by the build suddenly breaking left and right because of missing Handle/Local/String/Value imports.
12 years ago
using v8::Handle;
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
using v8::HandleScope;
using v8::HeapStatistics;
using v8::Integer;
using v8::Isolate;
string_bytes: don&#39;t use named imports in header It imports the definition into every source file that includes string_bytes.h, as evidenced by the build suddenly breaking left and right because of missing Handle/Local/String/Value imports.
12 years ago
using v8::Local;
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
using v8::Locker;
using v8::Message;
using v8::Number;
using v8::Object;
using v8::ObjectTemplate;
using v8::PropertyCallbackInfo;
string_bytes: don&#39;t use named imports in header It imports the definition into every source file that includes string_bytes.h, as evidenced by the build suddenly breaking left and right because of missing Handle/Local/String/Value imports.
12 years ago
using v8::String;
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
using v8::TryCatch;
using v8::Uint32;
using v8::V8;
using v8::Value;
src: update use of ExternalArrayType constants Continuation of 4809c7a to update the use of v8::ExternalArrayType. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
10 years ago
using v8::kExternalUint32Array;
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
Revert support for isolates. It was decided that the performance benefits that isolates offer (faster spin-up times for worker processes, faster inter-worker communication, possibly a lower memory footprint) are not actual bottlenecks for most people and do not outweigh the potential stability issues and intrusive changes to the code base that first-class support for isolates requires. Hence, this commit backs out all isolates-related changes. Good bye, isolates. We hardly knew ye.
13 years ago
static bool print_eval = false;
cmd: add a -i / --interactive flag to force the REPL This is the only way to spawn a node child process in REPL mode, and will also be needed to be able to use the REPL in MinTTY.
13 years ago
static bool force_repl = false;
Add --no-deprecation and --trace-deprecation flags
13 years ago
static bool trace_deprecation = false;
node: Add --throw-deprecation Extremely handy when tracking down a flood of recursive nextTick warnings.
12 years ago
static bool throw_deprecation = false;
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
static const char* eval_string = nullptr;
Revert support for isolates. It was decided that the performance benefits that isolates offer (faster spin-up times for worker processes, faster inter-worker communication, possibly a lower memory footprint) are not actual bottlenecks for most people and do not outweigh the potential stability issues and intrusive changes to the code base that first-class support for isolates requires. Hence, this commit backs out all isolates-related changes. Good bye, isolates. We hardly knew ye.
13 years ago
static bool use_debug_agent = false;
static bool debug_wait_connect = false;
src: lint c++ code
12 years ago
static int debug_port = 5858;
src: only start idle notifier when profiling The previous commit adds a notifier that tells the V8 profiler when node.js is idle, i.e. when it&#39;s about to start sleeping in the platform&#39;s equivalent of epoll_wait(). This commit adds a heuristic that only starts the notifier when the V8 profiler is started from the command line.
11 years ago
static bool v8_is_profiling = false;
modules: adding load linked modules feature - introduced NM_F_LINKED flag to identify linked modules - setting node_is_initialized after calling V8::Initialize in order to make the right decision during initial module registration - introduced modlist_linked in order to track modules that were pre-registered in order to complete it once node is initialized - completing registration of linked module similarly to the way it&#39;s done inside DLOpen PR-URL: https://github.com/iojs/io.js/pull/8 Reviewed-by: Trevor Norris &lt;trev.norris@gmail.com&gt; Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
static bool node_is_initialized = false;
node: register modules from DSO constructors Built-in modules should be automatically registered, replacing the static module list. Add-on modules should also be automatically registered via DSO constructors. This improves flexibility in adding built-in modules and is also a prerequisite to pure-C addon modules.
11 years ago
static node_module* modpending;
static node_module* modlist_builtin;
modules: adding load linked modules feature - introduced NM_F_LINKED flag to identify linked modules - setting node_is_initialized after calling V8::Initialize in order to make the right decision during initial module registration - introduced modlist_linked in order to track modules that were pre-registered in order to complete it once node is initialized - completing registration of linked module similarly to the way it&#39;s done inside DLOpen PR-URL: https://github.com/iojs/io.js/pull/8 Reviewed-by: Trevor Norris &lt;trev.norris@gmail.com&gt; Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
static node_module* modlist_linked;
node: register modules from DSO constructors Built-in modules should be automatically registered, replacing the static module list. Add-on modules should also be automatically registered via DSO constructors. This improves flexibility in adding built-in modules and is also a prerequisite to pure-C addon modules.
11 years ago
static node_module* modlist_addon;
Allow process.setuid() and process.setgid() to accept string names in lieu of numeric IDs
15 years ago
build, i18n: improve Intl build, add &#34;--with-intl&#34; The two main goals of this change are: - To make it easier to build the Intl option using ICU (particularly, using a newer ICU than v8/Chromium&#39;s version) - To enable a much smaller ICU build with only English support The goal here is to get node.js binaries built this way by default so that the Intl API can be used. Additional data can be added at execution time (see Readme and wiki) More details are at https://github.com/joyent/node/pull/7719 In particular, this change adds the &#34;--with-intl=&#34; configure option to provide more ways of building &#34;Intl&#34;: - &#34;full-icu&#34; picks up an ICU from deps/icu - &#34;small-icu&#34; is similar, but builds only English - &#34;system-icu&#34; uses pkg-config to find an installed ICU - &#34;none&#34; does nothing (no Intl) For Windows builds, the &#34;full-icu&#34; or &#34;small-icu&#34; options are added to vcbuild.bat. Note that the existing &#34;--with-icu-path&#34; option is not removed from configure, but may not be used alongside the new option. Wiki changes have already been made on https://github.com/joyent/node/wiki/Installation and a new page created at https://github.com/joyent/node/wiki/Intl (marked as provisional until this change lands.) Summary of changes: * README.md : doc updates * .gitignore : added &#34;deps/icu&#34; as this is the location where ICU is unpacked to. * Makefile : added the tools/icu/* files to cpplint, but excluded a problematic file. * configure : added the &#34;--with-intl&#34; option mentioned above. Calculate at config time the list of ICU source files to use and data packaging options. * node.gyp : add the new files src/node_i18n.cc/.h as well as ICU linkage. * src/node.cc : add call into node::i18n::InitializeICUDirectory(icu_data_dir) as well as new --icu-data-dir option and NODE_ICU_DATA env variable to configure ICU data loading. This loading is only relevant in the &#34;small&#34; configuration. * src/node_i18n.cc : new source file for the above Initialize.. function, to setup ICU as needed. * tools/icu : new directory with some tools needed for this build. * tools/icu/icu-generic.gyp : new .gyp file that builds ICU in some new ways, both on unix/mac and windows. * tools/icu/icu-system.gyp : new .gyp file to build node against a pkg-config detected ICU. * tools/icu/icu_small.json : new config file for the &#34;English-only&#34; small build. * tools/icu/icutrim.py : new tool for trimming down ICU data. Reads the above .json file. * tools/icu/iculslocs.cc : new tool for repairing ICU data manifests after trim operation. * tools/icu/no-op.cc : dummy file to force .gyp into using a C++ linker. * vcbuild.bat : added small-icu and full-icu options, to call into configure. * Fixed toolset dependencies, see https://github.com/joyent/node/pull/7719#issuecomment-54641687 Note that because of a bug in gyp {CC,CXX}_host must also be set. Otherwise gcc/g++ will be used by default for part of the build. Reviewed-by: Trevor Norris &lt;trev.norris@gmail.com&gt; Reviewed-by: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
#if defined(NODE_HAVE_I18N_SUPPORT)
// Path to ICU data (for i18n / Intl)
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
static const char* icu_data_dir = nullptr;
build, i18n: improve Intl build, add &#34;--with-intl&#34; The two main goals of this change are: - To make it easier to build the Intl option using ICU (particularly, using a newer ICU than v8/Chromium&#39;s version) - To enable a much smaller ICU build with only English support The goal here is to get node.js binaries built this way by default so that the Intl API can be used. Additional data can be added at execution time (see Readme and wiki) More details are at https://github.com/joyent/node/pull/7719 In particular, this change adds the &#34;--with-intl=&#34; configure option to provide more ways of building &#34;Intl&#34;: - &#34;full-icu&#34; picks up an ICU from deps/icu - &#34;small-icu&#34; is similar, but builds only English - &#34;system-icu&#34; uses pkg-config to find an installed ICU - &#34;none&#34; does nothing (no Intl) For Windows builds, the &#34;full-icu&#34; or &#34;small-icu&#34; options are added to vcbuild.bat. Note that the existing &#34;--with-icu-path&#34; option is not removed from configure, but may not be used alongside the new option. Wiki changes have already been made on https://github.com/joyent/node/wiki/Installation and a new page created at https://github.com/joyent/node/wiki/Intl (marked as provisional until this change lands.) Summary of changes: * README.md : doc updates * .gitignore : added &#34;deps/icu&#34; as this is the location where ICU is unpacked to. * Makefile : added the tools/icu/* files to cpplint, but excluded a problematic file. * configure : added the &#34;--with-intl&#34; option mentioned above. Calculate at config time the list of ICU source files to use and data packaging options. * node.gyp : add the new files src/node_i18n.cc/.h as well as ICU linkage. * src/node.cc : add call into node::i18n::InitializeICUDirectory(icu_data_dir) as well as new --icu-data-dir option and NODE_ICU_DATA env variable to configure ICU data loading. This loading is only relevant in the &#34;small&#34; configuration. * src/node_i18n.cc : new source file for the above Initialize.. function, to setup ICU as needed. * tools/icu : new directory with some tools needed for this build. * tools/icu/icu-generic.gyp : new .gyp file that builds ICU in some new ways, both on unix/mac and windows. * tools/icu/icu-system.gyp : new .gyp file to build node against a pkg-config detected ICU. * tools/icu/icu_small.json : new config file for the &#34;English-only&#34; small build. * tools/icu/icutrim.py : new tool for trimming down ICU data. Reads the above .json file. * tools/icu/iculslocs.cc : new tool for repairing ICU data manifests after trim operation. * tools/icu/no-op.cc : dummy file to force .gyp into using a C++ linker. * vcbuild.bat : added small-icu and full-icu options, to call into configure. * Fixed toolset dependencies, see https://github.com/joyent/node/pull/7719#issuecomment-54641687 Note that because of a bug in gyp {CC,CXX}_host must also be set. Otherwise gcc/g++ will be used by default for part of the build. Reviewed-by: Trevor Norris &lt;trev.norris@gmail.com&gt; Reviewed-by: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
#endif
Apply --no-deprecation to C++ warnings as well
13 years ago
// used by C++ modules as well
bool no_deprecation = false;
Revert support for isolates. It was decided that the performance benefits that isolates offer (faster spin-up times for worker processes, faster inter-worker communication, possibly a lower memory footprint) are not actual bottlenecks for most people and do not outweigh the potential stability issues and intrusive changes to the code base that first-class support for isolates requires. Hence, this commit backs out all isolates-related changes. Good bye, isolates. We hardly knew ye.
13 years ago
// process-relative uptime base, initialized at start-up
static double prog_start_time;
debugger: make busy loops SIGUSR1-interruptible Commit 30e5366b (&#34;core: Use a uv_signal for debug listener&#34;) changed SIGUSR1 handling from a signal handler to libuv&#39;s uv_signal_*() functionality to fix a race condition (and possible hang) in the signal handler. While a good change in itself, it made it impossible to interrupt long running scripts. When a script is stuck in a busy loop, control never returns to the event loop, which in turn means the signal callback - and therefore the debugger - is never invoked. This commit changes SIGUSR1 handling back to a normal signal handler but one that treads _very_ carefully.
11 years ago
static bool debugger_running;
src: make node_isolate global V8 3.15 has new API functions that let you specify the Isolate. V8 and node.js generally spend 0.5-3.5% of the time in pthread_getspecific(), looking up the current Isolate. Avoid that overhead by making &#34;our&#34; isolate global so we can pass it around. The change to the new API is introduced in follow-up commits.
12 years ago
static uv_async_t dispatch_debug_messages_async;
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
static Isolate* node_isolate = nullptr;
src: make node_isolate global V8 3.15 has new API functions that let you specify the Isolate. V8 and node.js generally spend 0.5-3.5% of the time in pthread_getspecific(), looking up the current Isolate. Avoid that overhead by making &#34;our&#34; isolate global so we can pass it around. The change to the new API is introduced in follow-up commits.
12 years ago
string_bytes: Guarantee valid utf-8 output Previously v8&#39;s WriteUtf8 function would produce invalid utf-8 output when encountering unmatched surrogate code units [1]. The new REPLACE_INVALID_UTF8 option fixes that by replacing invalid code points with the unicode replacement character. [1]: JS Strings are defined as arrays of 16 bit unsigned integers. There is no unicode enforcement, so one can easily end up with invalid unicode code unit sequences inside a string.
11 years ago
int WRITE_UTF8_FLAGS = v8::String::HINT_MANY_WRITES_EXPECTED |
v8::String::NO_NULL_TERMINATION;
libeio bugfix part 3 Finally (hopefully) fix the issue that Felix reported. It&#39;s only appearing on macintosh (test/mjsunit/test-eio-race3.js) The trick/hack is to call eio_poll() again before reentering the event loop. Additionally this commit implements a more complex method of calling eio_poll(), occasionally dropping to an ev_idle watcher. See also: 3f3977283419fe81e09aa23b91e59de959a84abd http://lists.schmorp.de/pipermail/libev/2010q1/000855.html http://groups.google.com/group/nodejs/browse_thread/thread/9f8db11c792a68bb/a89705f68971f53c
15 years ago
src: enable native v8 typed arrays This commit removes our homegrown typed arrays implementation and enables V8&#39;s built-in typed arrays implementation.
12 years ago
class ArrayBufferAllocator : public ArrayBuffer::Allocator {
src: lint c++ code
12 years ago
public:
src: enable native v8 typed arrays This commit removes our homegrown typed arrays implementation and enables V8&#39;s built-in typed arrays implementation.
12 years ago
// Impose an upper limit to avoid out of memory errors that bring down
// the process.
static const size_t kMaxLength = 0x3fffffff;
static ArrayBufferAllocator the_singleton;
src: mark empty destructors as default Mark empty destructors as having a default no-op implementation. Remove a few unused constructors and destructors while we are here.
10 years ago
virtual ~ArrayBufferAllocator() = default;
src: mark virtual functions with override keyword Add `override` keywords where appropriate. Makes maintenance easier because the compiler will shout at you when a base class changes in an incompatible way.
10 years ago
virtual void* Allocate(size_t length) override;
virtual void* AllocateUninitialized(size_t length) override;
virtual void Free(void* data, size_t length) override;
src: lint c++ code
12 years ago
private:
src: mark empty destructors as default Mark empty destructors as having a default no-op implementation. Remove a few unused constructors and destructors while we are here.
10 years ago
ArrayBufferAllocator() = default;
src: update DISALLOW_COPY_AND_ASSIGN() to c++11 Mark the matrix of copy/move constructor/assignment operator as deleted. Prevents the object from being copied around (the macro already did that pre-C++11), but also from being moved out.
10 years ago
DISALLOW_COPY_AND_ASSIGN(ArrayBufferAllocator);
src: enable native v8 typed arrays This commit removes our homegrown typed arrays implementation and enables V8&#39;s built-in typed arrays implementation.
12 years ago
};
ArrayBufferAllocator ArrayBufferAllocator::the_singleton;
void* ArrayBufferAllocator::Allocate(size_t length) {
cpplint: disallow if one-liners
11 years ago
if (length > kMaxLength)
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
return nullptr;
node: follow specification, zero-fill ArrayBuffers Fixes #6664
11 years ago
char* data = new char[length];
memset(data, 0, length);
return data;
src: enable native v8 typed arrays This commit removes our homegrown typed arrays implementation and enables V8&#39;s built-in typed arrays implementation.
12 years ago
}
src: update after v8 api changes
11 years ago
void* ArrayBufferAllocator::AllocateUninitialized(size_t length) {
if (length > kMaxLength)
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
return nullptr;
src: update after v8 api changes
11 years ago
return new char[length];
}
void ArrayBufferAllocator::Free(void* data, size_t length) {
src: enable native v8 typed arrays This commit removes our homegrown typed arrays implementation and enables V8&#39;s built-in typed arrays implementation.
12 years ago
delete[] static_cast<char*>(data);
}
src: update uv callbacks after API changes async, timer, prepare, idle and check handles no longer get a status parameter since they can never fail.
11 years ago
static void CheckImmediate(uv_check_t* handle) {
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
Environment* env = Environment::from_immediate_check_handle(handle);
src: remove `node_isolate` from source fix #6899
11 years ago
HandleScope scope(env->isolate());
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
Context::Scope context_scope(env->context());
MakeCallback(env, env->process_object(), env->immediate_callback_string());
timer: move setImmediate from timer to uv_check uv_check is the robust place to invoke setImmediate callbacks after process.nextTick and before timers(setTimeout/setInterval)
12 years ago
}
src: update uv callbacks after API changes async, timer, prepare, idle and check handles no longer get a status parameter since they can never fail.
11 years ago
static void IdleImmediateDummy(uv_idle_t* handle) {
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
// Do nothing. Only for maintaining event loop.
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
// TODO(bnoordhuis) Maybe make libuv accept nullptr idle callbacks.
timer: move setImmediate from timer to uv_check uv_check is the robust place to invoke setImmediate callbacks after process.nextTick and before timers(setTimeout/setInterval)
12 years ago
}
Unify ErrnoException creation
15 years ago
static inline const char *errno_string(int errorno) {
#define ERRNO_CASE(e) case e: return #e;
switch (errorno) {
#ifdef EACCES
ERRNO_CASE(EACCES);
#endif
#ifdef EADDRINUSE
ERRNO_CASE(EADDRINUSE);
#endif
#ifdef EADDRNOTAVAIL
ERRNO_CASE(EADDRNOTAVAIL);
#endif
#ifdef EAFNOSUPPORT
ERRNO_CASE(EAFNOSUPPORT);
#endif
#ifdef EAGAIN
ERRNO_CASE(EAGAIN);
Resolve EWOULDBLOCK to string if different thatn EAGAIN
15 years ago
#endif
#ifdef EWOULDBLOCK
# if EAGAIN != EWOULDBLOCK
Unify ErrnoException creation
15 years ago
ERRNO_CASE(EWOULDBLOCK);
# endif
#endif
#ifdef EALREADY
ERRNO_CASE(EALREADY);
#endif
#ifdef EBADF
ERRNO_CASE(EBADF);
#endif
#ifdef EBADMSG
ERRNO_CASE(EBADMSG);
#endif
#ifdef EBUSY
ERRNO_CASE(EBUSY);
#endif
#ifdef ECANCELED
ERRNO_CASE(ECANCELED);
#endif
#ifdef ECHILD
ERRNO_CASE(ECHILD);
#endif
#ifdef ECONNABORTED
ERRNO_CASE(ECONNABORTED);
#endif
#ifdef ECONNREFUSED
ERRNO_CASE(ECONNREFUSED);
#endif
#ifdef ECONNRESET
ERRNO_CASE(ECONNRESET);
#endif
#ifdef EDEADLK
ERRNO_CASE(EDEADLK);
#endif
#ifdef EDESTADDRREQ
ERRNO_CASE(EDESTADDRREQ);
#endif
#ifdef EDOM
ERRNO_CASE(EDOM);
#endif
#ifdef EDQUOT
ERRNO_CASE(EDQUOT);
#endif
#ifdef EEXIST
ERRNO_CASE(EEXIST);
#endif
#ifdef EFAULT
ERRNO_CASE(EFAULT);
#endif
#ifdef EFBIG
ERRNO_CASE(EFBIG);
#endif
#ifdef EHOSTUNREACH
ERRNO_CASE(EHOSTUNREACH);
#endif
#ifdef EIDRM
ERRNO_CASE(EIDRM);
#endif
#ifdef EILSEQ
ERRNO_CASE(EILSEQ);
#endif
#ifdef EINPROGRESS
ERRNO_CASE(EINPROGRESS);
#endif
#ifdef EINTR
ERRNO_CASE(EINTR);
#endif
#ifdef EINVAL
ERRNO_CASE(EINVAL);
#endif
#ifdef EIO
ERRNO_CASE(EIO);
#endif
#ifdef EISCONN
ERRNO_CASE(EISCONN);
#endif
#ifdef EISDIR
ERRNO_CASE(EISDIR);
#endif
#ifdef ELOOP
ERRNO_CASE(ELOOP);
#endif
#ifdef EMFILE
ERRNO_CASE(EMFILE);
#endif
#ifdef EMLINK
ERRNO_CASE(EMLINK);
#endif
#ifdef EMSGSIZE
ERRNO_CASE(EMSGSIZE);
#endif
#ifdef EMULTIHOP
ERRNO_CASE(EMULTIHOP);
#endif
#ifdef ENAMETOOLONG
ERRNO_CASE(ENAMETOOLONG);
#endif
#ifdef ENETDOWN
ERRNO_CASE(ENETDOWN);
#endif
#ifdef ENETRESET
ERRNO_CASE(ENETRESET);
#endif
#ifdef ENETUNREACH
ERRNO_CASE(ENETUNREACH);
#endif
#ifdef ENFILE
ERRNO_CASE(ENFILE);
#endif
#ifdef ENOBUFS
ERRNO_CASE(ENOBUFS);
#endif
#ifdef ENODATA
ERRNO_CASE(ENODATA);
#endif
#ifdef ENODEV
ERRNO_CASE(ENODEV);
#endif
#ifdef ENOENT
ERRNO_CASE(ENOENT);
#endif
#ifdef ENOEXEC
ERRNO_CASE(ENOEXEC);
#endif
#ifdef ENOLINK
ERRNO_CASE(ENOLINK);
#endif
Fix signo_string for linux and solaris
15 years ago
#ifdef ENOLCK
# if ENOLINK != ENOLCK
ERRNO_CASE(ENOLCK);
# endif
#endif
Unify ErrnoException creation
15 years ago
#ifdef ENOMEM
ERRNO_CASE(ENOMEM);
#endif
#ifdef ENOMSG
ERRNO_CASE(ENOMSG);
#endif
#ifdef ENOPROTOOPT
ERRNO_CASE(ENOPROTOOPT);
#endif
#ifdef ENOSPC
ERRNO_CASE(ENOSPC);
#endif
#ifdef ENOSR
ERRNO_CASE(ENOSR);
#endif
#ifdef ENOSTR
ERRNO_CASE(ENOSTR);
#endif
#ifdef ENOSYS
ERRNO_CASE(ENOSYS);
#endif
#ifdef ENOTCONN
ERRNO_CASE(ENOTCONN);
#endif
#ifdef ENOTDIR
ERRNO_CASE(ENOTDIR);
#endif
#ifdef ENOTEMPTY
ERRNO_CASE(ENOTEMPTY);
#endif
#ifdef ENOTSOCK
ERRNO_CASE(ENOTSOCK);
#endif
#ifdef ENOTSUP
ERRNO_CASE(ENOTSUP);
#else
# ifdef EOPNOTSUPP
ERRNO_CASE(EOPNOTSUPP);
# endif
#endif
#ifdef ENOTTY
ERRNO_CASE(ENOTTY);
#endif
#ifdef ENXIO
ERRNO_CASE(ENXIO);
#endif
#ifdef EOVERFLOW
ERRNO_CASE(EOVERFLOW);
#endif
#ifdef EPERM
ERRNO_CASE(EPERM);
#endif
#ifdef EPIPE
ERRNO_CASE(EPIPE);
#endif
#ifdef EPROTO
ERRNO_CASE(EPROTO);
#endif
#ifdef EPROTONOSUPPORT
ERRNO_CASE(EPROTONOSUPPORT);
#endif
#ifdef EPROTOTYPE
ERRNO_CASE(EPROTOTYPE);
#endif
#ifdef ERANGE
ERRNO_CASE(ERANGE);
#endif
#ifdef EROFS
ERRNO_CASE(EROFS);
#endif
#ifdef ESPIPE
ERRNO_CASE(ESPIPE);
#endif
#ifdef ESRCH
ERRNO_CASE(ESRCH);
#endif
#ifdef ESTALE
ERRNO_CASE(ESTALE);
#endif
#ifdef ETIME
ERRNO_CASE(ETIME);
#endif
#ifdef ETIMEDOUT
ERRNO_CASE(ETIMEDOUT);
#endif
#ifdef ETXTBSY
ERRNO_CASE(ETXTBSY);
#endif
#ifdef EXDEV
ERRNO_CASE(EXDEV);
#endif
default: return "";
}
}
Properly handle child process exit codes The child process &#39;exit&#39; was returning the status of the process, rather than the exit code. This patch properly deconstructs the status into the exit code and the term signal a process may have received. See: http://pod.tst.eu/http://cvs.schmorp.de/libev/ev.pod#Watcher_Specific_Functions_and_Data_-5 and waitpid(2)
15 years ago
const char *signo_string(int signo) {
#define SIGNO_CASE(e) case e: return #e;
switch (signo) {
#ifdef SIGHUP
SIGNO_CASE(SIGHUP);
#endif
#ifdef SIGINT
SIGNO_CASE(SIGINT);
#endif
#ifdef SIGQUIT
SIGNO_CASE(SIGQUIT);
#endif
#ifdef SIGILL
SIGNO_CASE(SIGILL);
#endif
#ifdef SIGTRAP
SIGNO_CASE(SIGTRAP);
#endif
#ifdef SIGABRT
SIGNO_CASE(SIGABRT);
#endif
#ifdef SIGIOT
# if SIGABRT != SIGIOT
SIGNO_CASE(SIGIOT);
# endif
#endif
#ifdef SIGBUS
SIGNO_CASE(SIGBUS);
#endif
#ifdef SIGFPE
SIGNO_CASE(SIGFPE);
#endif
#ifdef SIGKILL
SIGNO_CASE(SIGKILL);
#endif
#ifdef SIGUSR1
SIGNO_CASE(SIGUSR1);
#endif
#ifdef SIGSEGV
SIGNO_CASE(SIGSEGV);
#endif
#ifdef SIGUSR2
SIGNO_CASE(SIGUSR2);
#endif
#ifdef SIGPIPE
SIGNO_CASE(SIGPIPE);
#endif
#ifdef SIGALRM
SIGNO_CASE(SIGALRM);
#endif
SIGNO_CASE(SIGTERM);
There&#39;s no SIGCHLD on windows
14 years ago
#ifdef SIGCHLD
Properly handle child process exit codes The child process &#39;exit&#39; was returning the status of the process, rather than the exit code. This patch properly deconstructs the status into the exit code and the term signal a process may have received. See: http://pod.tst.eu/http://cvs.schmorp.de/libev/ev.pod#Watcher_Specific_Functions_and_Data_-5 and waitpid(2)
15 years ago
SIGNO_CASE(SIGCHLD);
There&#39;s no SIGCHLD on windows
14 years ago
#endif
Properly handle child process exit codes The child process &#39;exit&#39; was returning the status of the process, rather than the exit code. This patch properly deconstructs the status into the exit code and the term signal a process may have received. See: http://pod.tst.eu/http://cvs.schmorp.de/libev/ev.pod#Watcher_Specific_Functions_and_Data_-5 and waitpid(2)
15 years ago
#ifdef SIGSTKFLT
SIGNO_CASE(SIGSTKFLT);
#endif
#ifdef SIGCONT
SIGNO_CASE(SIGCONT);
#endif
#ifdef SIGSTOP
SIGNO_CASE(SIGSTOP);
#endif
#ifdef SIGTSTP
SIGNO_CASE(SIGTSTP);
#endif
process: use uv_signal instead of ev_signal
13 years ago
#ifdef SIGBREAK
SIGNO_CASE(SIGBREAK);
#endif
Properly handle child process exit codes The child process &#39;exit&#39; was returning the status of the process, rather than the exit code. This patch properly deconstructs the status into the exit code and the term signal a process may have received. See: http://pod.tst.eu/http://cvs.schmorp.de/libev/ev.pod#Watcher_Specific_Functions_and_Data_-5 and waitpid(2)
15 years ago
#ifdef SIGTTIN
SIGNO_CASE(SIGTTIN);
#endif
#ifdef SIGTTOU
SIGNO_CASE(SIGTTOU);
#endif
#ifdef SIGURG
SIGNO_CASE(SIGURG);
#endif
#ifdef SIGXCPU
SIGNO_CASE(SIGXCPU);
#endif
#ifdef SIGXFSZ
SIGNO_CASE(SIGXFSZ);
#endif
#ifdef SIGVTALRM
SIGNO_CASE(SIGVTALRM);
#endif
#ifdef SIGPROF
SIGNO_CASE(SIGPROF);
#endif
#ifdef SIGWINCH
SIGNO_CASE(SIGWINCH);
#endif
#ifdef SIGIO
SIGNO_CASE(SIGIO);
#endif
#ifdef SIGPOLL
Fix signo_string for linux and solaris
15 years ago
# if SIGPOLL != SIGIO
Properly handle child process exit codes The child process &#39;exit&#39; was returning the status of the process, rather than the exit code. This patch properly deconstructs the status into the exit code and the term signal a process may have received. See: http://pod.tst.eu/http://cvs.schmorp.de/libev/ev.pod#Watcher_Specific_Functions_and_Data_-5 and waitpid(2)
15 years ago
SIGNO_CASE(SIGPOLL);
Fix signo_string for linux and solaris
15 years ago
# endif
Properly handle child process exit codes The child process &#39;exit&#39; was returning the status of the process, rather than the exit code. This patch properly deconstructs the status into the exit code and the term signal a process may have received. See: http://pod.tst.eu/http://cvs.schmorp.de/libev/ev.pod#Watcher_Specific_Functions_and_Data_-5 and waitpid(2)
15 years ago
#endif
#ifdef SIGLOST
SIGNO_CASE(SIGLOST);
#endif
#ifdef SIGPWR
Port to cygwin
15 years ago
# if SIGPWR != SIGLOST
Properly handle child process exit codes The child process &#39;exit&#39; was returning the status of the process, rather than the exit code. This patch properly deconstructs the status into the exit code and the term signal a process may have received. See: http://pod.tst.eu/http://cvs.schmorp.de/libev/ev.pod#Watcher_Specific_Functions_and_Data_-5 and waitpid(2)
15 years ago
SIGNO_CASE(SIGPWR);
Port to cygwin
15 years ago
# endif
Properly handle child process exit codes The child process &#39;exit&#39; was returning the status of the process, rather than the exit code. This patch properly deconstructs the status into the exit code and the term signal a process may have received. See: http://pod.tst.eu/http://cvs.schmorp.de/libev/ev.pod#Watcher_Specific_Functions_and_Data_-5 and waitpid(2)
15 years ago
#endif
#ifdef SIGSYS
SIGNO_CASE(SIGSYS);
#endif
default: return "";
}
}
Unify ErrnoException creation
15 years ago
headers: remove env.h from node_internals.h `env.h` is an internal header file and should not be copied or exposed to the users. Additionally, export convenience `Throw*` methods with `v8::Isolate*` as a first argument.
11 years ago
// Convenience methods
void ThrowError(v8::Isolate* isolate, const char* errmsg) {
Environment::GetCurrent(isolate)->ThrowError(errmsg);
}
void ThrowTypeError(v8::Isolate* isolate, const char* errmsg) {
Environment::GetCurrent(isolate)->ThrowTypeError(errmsg);
}
void ThrowRangeError(v8::Isolate* isolate, const char* errmsg) {
Environment::GetCurrent(isolate)->ThrowRangeError(errmsg);
}
void ThrowErrnoException(v8::Isolate* isolate,
int errorno,
const char* syscall,
const char* message,
const char* path) {
Environment::GetCurrent(isolate)->ThrowErrnoException(errorno,
syscall,
message,
path);
}
void ThrowUVException(v8::Isolate* isolate,
int errorno,
const char* syscall,
const char* message,
const char* path) {
Environment::GetCurrent(isolate)->ThrowErrnoException(errorno,
syscall,
message,
path);
}
src: remove `node_isolate` from source fix #6899
11 years ago
Local<Value> ErrnoException(Isolate* isolate,
int errorno,
Unify ErrnoException creation
15 years ago
const char *syscall,
Added better error messages for async and sync fs calls with paths
15 years ago
const char *msg,
const char *path) {
src: remove `node_isolate` from source fix #6899
11 years ago
Environment* env = Environment::GetCurrent(isolate);
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
Added better error messages for async and sync fs calls with paths
15 years ago
Local<Value> e;
src: remove `node_isolate` from source fix #6899
11 years ago
Local<String> estring = OneByteString(env->isolate(), errno_string(errorno));
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (msg == nullptr || msg[0] == '\0') {
Improve error reporting on windows
14 years ago
msg = strerror(errorno);
}
src: remove `node_isolate` from source fix #6899
11 years ago
Local<String> message = OneByteString(env->isolate(), msg);
Unify ErrnoException creation
15 years ago
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
Local<String> cons1 =
src: remove `node_isolate` from source fix #6899
11 years ago
String::Concat(estring, FIXED_ONE_BYTE_STRING(env->isolate(), ", "));
Unify ErrnoException creation
15 years ago
Local<String> cons2 = String::Concat(cons1, message);
Added better error messages for async and sync fs calls with paths
15 years ago
if (path) {
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
Local<String> cons3 =
src: remove `node_isolate` from source fix #6899
11 years ago
String::Concat(cons2, FIXED_ONE_BYTE_STRING(env->isolate(), " '"));
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
Local<String> cons4 =
src: remove `node_isolate` from source fix #6899
11 years ago
String::Concat(cons3, String::NewFromUtf8(env->isolate(), path));
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
Local<String> cons5 =
src: remove `node_isolate` from source fix #6899
11 years ago
String::Concat(cons4, FIXED_ONE_BYTE_STRING(env->isolate(), "'"));
Added better error messages for async and sync fs calls with paths
15 years ago
e = Exception::Error(cons5);
} else {
e = Exception::Error(cons2);
}
src: pass Isolate to additional locations Due to a recent V8 upgrade, more methods require Isolate as an argument. PR-URL: https://github.com/iojs/io.js/pull/244 Reviewed-by: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
Local<Object> obj = e->ToObject(env->isolate());
src: update to v8 3.24 APIs
11 years ago
obj->Set(env->errno_string(), Integer::New(env->isolate(), errorno));
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
obj->Set(env->code_string(), estring);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (path != nullptr) {
src: remove `node_isolate` from source fix #6899
11 years ago
obj->Set(env->path_string(), String::NewFromUtf8(env->isolate(), path));
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
}
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (syscall != nullptr) {
src: remove `node_isolate` from source fix #6899
11 years ago
obj->Set(env->syscall_string(), OneByteString(env->isolate(), syscall));
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
}
Added better error messages for async and sync fs calls with paths
15 years ago
Unify ErrnoException creation
15 years ago
return e;
}
Rename FSError to UVException and move to node.cc
13 years ago
// hack alert! copy of ErrnoException, tuned for uv errors
src: remove `node_isolate` from source fix #6899
11 years ago
Local<Value> UVException(Isolate* isolate,
int errorno,
Rename FSError to UVException and move to node.cc
13 years ago
const char *syscall,
const char *msg,
const char *path) {
src: remove `node_isolate` from source fix #6899
11 years ago
Environment* env = Environment::GetCurrent(isolate);
Rename FSError to UVException and move to node.cc
13 years ago
if (!msg || !msg[0])
src, lib: update after internal api change Libuv now returns errors directly. Make everything in src/ and lib/ follow suit. The changes to lib/ are not strictly necessary but they remove the need for the abominations that are process._errno and node::SetErrno().
12 years ago
msg = uv_strerror(errorno);
Rename FSError to UVException and move to node.cc
13 years ago
src: remove `node_isolate` from source fix #6899
11 years ago
Local<String> estring = OneByteString(env->isolate(), uv_err_name(errorno));
Local<String> message = OneByteString(env->isolate(), msg);
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
Local<String> cons1 =
src: remove `node_isolate` from source fix #6899
11 years ago
String::Concat(estring, FIXED_ONE_BYTE_STRING(env->isolate(), ", "));
Rename FSError to UVException and move to node.cc
13 years ago
Local<String> cons2 = String::Concat(cons1, message);
Local<Value> e;
Local<String> path_str;
if (path) {
#ifdef _WIN32
if (strncmp(path, "\\\\?\\UNC\\", 8) == 0) {
src: remove `node_isolate` from source fix #6899
11 years ago
path_str = String::Concat(FIXED_ONE_BYTE_STRING(env->isolate(), "\\\\"),
String::NewFromUtf8(env->isolate(), path + 8));
Rename FSError to UVException and move to node.cc
13 years ago
} else if (strncmp(path, "\\\\?\\", 4) == 0) {
src: remove `node_isolate` from source fix #6899
11 years ago
path_str = String::NewFromUtf8(env->isolate(), path + 4);
Rename FSError to UVException and move to node.cc
13 years ago
} else {
src: remove `node_isolate` from source fix #6899
11 years ago
path_str = String::NewFromUtf8(env->isolate(), path);
Rename FSError to UVException and move to node.cc
13 years ago
}
#else
src: remove `node_isolate` from source fix #6899
11 years ago
path_str = String::NewFromUtf8(env->isolate(), path);
Rename FSError to UVException and move to node.cc
13 years ago
#endif
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
Local<String> cons3 =
src: remove `node_isolate` from source fix #6899
11 years ago
String::Concat(cons2, FIXED_ONE_BYTE_STRING(env->isolate(), " '"));
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
Local<String> cons4 =
String::Concat(cons3, path_str);
Local<String> cons5 =
src: remove `node_isolate` from source fix #6899
11 years ago
String::Concat(cons4, FIXED_ONE_BYTE_STRING(env->isolate(), "'"));
Rename FSError to UVException and move to node.cc
13 years ago
e = Exception::Error(cons5);
} else {
e = Exception::Error(cons2);
}
src: pass Isolate to additional locations Due to a recent V8 upgrade, more methods require Isolate as an argument. PR-URL: https://github.com/iojs/io.js/pull/244 Reviewed-by: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
Local<Object> obj = e->ToObject(env->isolate());
src: lint c++ code
12 years ago
// TODO(piscisaureus) errno should probably go
src: update to v8 3.24 APIs
11 years ago
obj->Set(env->errno_string(), Integer::New(env->isolate(), errorno));
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
obj->Set(env->code_string(), estring);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (path != nullptr) {
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
obj->Set(env->path_string(), path_str);
}
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (syscall != nullptr) {
src: remove `node_isolate` from source fix #6899
11 years ago
obj->Set(env->syscall_string(), OneByteString(env->isolate(), syscall));
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
}
Rename FSError to UVException and move to node.cc
13 years ago
return e;
}
src: ignore risky env vars when setuid root On POSIX platforms, check that the uid and gid match the euid and egid respectively before looking up the environment variable. Before this commit, an i18n-enabled suid node would cheerfully load attacker-controlled ICU data through the NODE_ICU_DATA environment variable. This commit is not a complete fix. For example, it&#39;s up for debate what to do with the NODE_CHANNEL_FD environment variable. PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
// Look up environment variable unless running as setuid root.
inline const char* secure_getenv(const char* key) {
#ifndef _WIN32
if (getuid() != geteuid() || getgid() != getegid())
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
return nullptr;
src: ignore risky env vars when setuid root On POSIX platforms, check that the uid and gid match the euid and egid respectively before looking up the environment variable. Before this commit, an i18n-enabled suid node would cheerfully load attacker-controlled ICU data through the NODE_ICU_DATA environment variable. This commit is not a complete fix. For example, it&#39;s up for debate what to do with the NODE_CHANNEL_FD environment variable. PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
#endif
return getenv(key);
}
Windows: ErrnoException shouldn&#39;t mix up crt and win32 errors
13 years ago
#ifdef _WIN32
Remove platform files, and use uv platform api
13 years ago
// Does about the same as strerror(),
// but supports all windows error messages
windows: fix memory leak in WinapiErrnoException Fix https://github.com/joyent/node/issues/2341 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
static const char *winapi_strerror(const int errorno, bool* must_free) {
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
char *errmsg = nullptr;
Remove platform files, and use uv platform api
13 years ago
FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
FORMAT_MESSAGE_IGNORE_INSERTS, nullptr, errorno,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&errmsg, 0, nullptr);
Remove platform files, and use uv platform api
13 years ago
if (errmsg) {
windows: fix memory leak in WinapiErrnoException Fix https://github.com/joyent/node/issues/2341 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
*must_free = true;
Remove platform files, and use uv platform api
13 years ago
// Remove trailing newlines
for (int i = strlen(errmsg) - 1;
i >= 0 && (errmsg[i] == '\n' || errmsg[i] == '\r'); i--) {
errmsg[i] = '\0';
}
return errmsg;
} else {
// FormatMessage failed
windows: fix memory leak in WinapiErrnoException Fix https://github.com/joyent/node/issues/2341 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
*must_free = false;
Remove platform files, and use uv platform api
13 years ago
return "Unknown error";
}
}
src: node.cc use isolate-&gt;ThrowException Environment doesn&#39;t have ThrowException, we meant isolate here. Introduced in commit 75adde07f9a2de7f38a67bec72bd377d450bdb52.
11 years ago
Local<Value> WinapiErrnoException(Isolate* isolate,
src: remove `node_isolate` from source fix #6899
11 years ago
int errorno,
Implement process._debugProcess
13 years ago
const char* syscall,
const char* msg,
const char* path) {
src: node.cc use isolate-&gt;ThrowException Environment doesn&#39;t have ThrowException, we meant isolate here. Introduced in commit 75adde07f9a2de7f38a67bec72bd377d450bdb52.
11 years ago
Environment* env = Environment::GetCurrent(isolate);
Windows: ErrnoException shouldn&#39;t mix up crt and win32 errors
13 years ago
Local<Value> e;
windows: fix memory leak in WinapiErrnoException Fix https://github.com/joyent/node/issues/2341 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
bool must_free = false;
Implement process._debugProcess
13 years ago
if (!msg || !msg[0]) {
windows: fix memory leak in WinapiErrnoException Fix https://github.com/joyent/node/issues/2341 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
msg = winapi_strerror(errorno, &must_free);
Windows: ErrnoException shouldn&#39;t mix up crt and win32 errors
13 years ago
}
src: remove `node_isolate` from source fix #6899
11 years ago
Local<String> message = OneByteString(env->isolate(), msg);
Windows: ErrnoException shouldn&#39;t mix up crt and win32 errors
13 years ago
if (path) {
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
Local<String> cons1 =
src: node.cc use isolate-&gt;ThrowException Environment doesn&#39;t have ThrowException, we meant isolate here. Introduced in commit 75adde07f9a2de7f38a67bec72bd377d450bdb52.
11 years ago
String::Concat(message, FIXED_ONE_BYTE_STRING(isolate, " '"));
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
Local<String> cons2 =
src: node.cc use isolate-&gt;ThrowException Environment doesn&#39;t have ThrowException, we meant isolate here. Introduced in commit 75adde07f9a2de7f38a67bec72bd377d450bdb52.
11 years ago
String::Concat(cons1, String::NewFromUtf8(isolate, path));
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
Local<String> cons3 =
src: node.cc use isolate-&gt;ThrowException Environment doesn&#39;t have ThrowException, we meant isolate here. Introduced in commit 75adde07f9a2de7f38a67bec72bd377d450bdb52.
11 years ago
String::Concat(cons2, FIXED_ONE_BYTE_STRING(isolate, "'"));
Windows: ErrnoException shouldn&#39;t mix up crt and win32 errors
13 years ago
e = Exception::Error(cons3);
} else {
e = Exception::Error(message);
}
src: pass Isolate to additional locations Due to a recent V8 upgrade, more methods require Isolate as an argument. PR-URL: https://github.com/iojs/io.js/pull/244 Reviewed-by: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
Local<Object> obj = e->ToObject(env->isolate());
src: update to v8 3.24 APIs
11 years ago
obj->Set(env->errno_string(), Integer::New(isolate, errorno));
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (path != nullptr) {
src: node.cc use isolate-&gt;ThrowException Environment doesn&#39;t have ThrowException, we meant isolate here. Introduced in commit 75adde07f9a2de7f38a67bec72bd377d450bdb52.
11 years ago
obj->Set(env->path_string(), String::NewFromUtf8(isolate, path));
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
}
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (syscall != nullptr) {
src: node.cc use isolate-&gt;ThrowException Environment doesn&#39;t have ThrowException, we meant isolate here. Introduced in commit 75adde07f9a2de7f38a67bec72bd377d450bdb52.
11 years ago
obj->Set(env->syscall_string(), OneByteString(isolate, syscall));
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
}
Windows: ErrnoException shouldn&#39;t mix up crt and win32 errors
13 years ago
windows: fix memory leak in WinapiErrnoException Fix https://github.com/joyent/node/issues/2341 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
if (must_free)
LocalFree((HLOCAL)msg);
Windows: ErrnoException shouldn&#39;t mix up crt and win32 errors
13 years ago
return e;
}
#endif
src: revert domain using AsyncListeners This is a slightly modified revert of bc39bdd. Getting domains to use AsyncListeners became too much of a challenge with many edge cases. While this is still a goal, it will have to be deferred for now until more test coverage can be provided.
11 years ago
void SetupDomainUse(const FunctionCallbackInfo<Value>& args) {
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
src: revert domain using AsyncListeners This is a slightly modified revert of bc39bdd. Getting domains to use AsyncListeners became too much of a challenge with many edge cases. While this is still a goal, it will have to be deferred for now until more test coverage can be provided.
11 years ago
if (env->using_domains())
return;
env->set_using_domains(true);
src: remove `node_isolate` from source fix #6899
11 years ago
HandleScope scope(env->isolate());
src: revert domain using AsyncListeners This is a slightly modified revert of bc39bdd. Getting domains to use AsyncListeners became too much of a challenge with many edge cases. While this is still a goal, it will have to be deferred for now until more test coverage can be provided.
11 years ago
Local<Object> process_object = env->process_object();
src: remove `node_isolate` from source fix #6899
11 years ago
Local<String> tick_callback_function_key = env->tick_domain_cb_string();
src: revert domain using AsyncListeners This is a slightly modified revert of bc39bdd. Getting domains to use AsyncListeners became too much of a challenge with many edge cases. While this is still a goal, it will have to be deferred for now until more test coverage can be provided.
11 years ago
Local<Function> tick_callback_function =
process_object->Get(tick_callback_function_key).As<Function>();
if (!tick_callback_function->IsFunction()) {
fprintf(stderr, "process._tickDomainCallback assigned to non-function\n");
abort();
}
src: remove `node_isolate` from source fix #6899
11 years ago
process_object->Set(env->tick_callback_string(), tick_callback_function);
src: revert domain using AsyncListeners This is a slightly modified revert of bc39bdd. Getting domains to use AsyncListeners became too much of a challenge with many edge cases. While this is still a goal, it will have to be deferred for now until more test coverage can be provided.
11 years ago
env->set_tick_callback_function(tick_callback_function);
src: replace assert() with CHECK() Mechanically replace assert() statements with UNREACHABLE(), CHECK(), or CHECK_{EQ,NE,LT,GT,LE,GE}() statements. The exceptions are src/node.h and src/node_object_wrap.h because they are public headers. PR-URL: https://github.com/node-forward/node/pull/16 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
CHECK(args[0]->IsArray());
CHECK(args[1]->IsObject());
src: revert domain using AsyncListeners This is a slightly modified revert of bc39bdd. Getting domains to use AsyncListeners became too much of a challenge with many edge cases. While this is still a goal, it will have to be deferred for now until more test coverage can be provided.
11 years ago
env->set_domain_array(args[0].As<Array>());
Local<Object> domain_flag_obj = args[1].As<Object>();
Environment::DomainFlag* domain_flag = env->domain_flag();
domain_flag_obj->SetIndexedPropertiesToExternalArrayData(
domain_flag->fields(),
src: update use of ExternalArrayType constants Continuation of 4809c7a to update the use of v8::ExternalArrayType. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
10 years ago
kExternalUint32Array,
src: revert domain using AsyncListeners This is a slightly modified revert of bc39bdd. Getting domains to use AsyncListeners became too much of a challenge with many edge cases. While this is still a goal, it will have to be deferred for now until more test coverage can be provided.
11 years ago
domain_flag->fields_count());
// Do a little housekeeping.
env->process_object()->Delete(
FIXED_ONE_BYTE_STRING(args.GetIsolate(), "_setupDomainUse"));
}
node: support v8 microtask queue When V8 started supporting Promises natively it also introduced a microtack queue. This feature operates similar to process.nextTick(), and created an issue where neither knew when the other had run. This patch has nextTick() call the microtask queue runner at the end of processing callbacks in the nextTickQueue. Fixes: https://github.com/joyent/node/issues/7714 Reviewed-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
10 years ago
void RunMicrotasks(const FunctionCallbackInfo<Value>& args) {
args.GetIsolate()->RunMicrotasks();
}
src: revert domain using AsyncListeners This is a slightly modified revert of bc39bdd. Getting domains to use AsyncListeners became too much of a challenge with many edge cases. While this is still a goal, it will have to be deferred for now until more test coverage can be provided.
11 years ago
node: add AsyncListener support AsyncListener is a JS API that works in tandem with the AsyncWrap class to allow the user to be alerted to key events in the life cycle of an asynchronous event. The AsyncWrap class has its own MakeCallback implementation that core will be migrated to use, and uses state sharing techniques to allow quicker communication between JS and C++ whether the async event callbacks need to be called.
11 years ago
void SetupNextTick(const FunctionCallbackInfo<Value>& args) {
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
node: add AsyncListener support AsyncListener is a JS API that works in tandem with the AsyncWrap class to allow the user to be alerted to key events in the life cycle of an asynchronous event. The AsyncWrap class has its own MakeCallback implementation that core will be migrated to use, and uses state sharing techniques to allow quicker communication between JS and C++ whether the async event callbacks need to be called.
11 years ago
src: replace assert() with CHECK() Mechanically replace assert() statements with UNREACHABLE(), CHECK(), or CHECK_{EQ,NE,LT,GT,LE,GE}() statements. The exceptions are src/node.h and src/node_object_wrap.h because they are public headers. PR-URL: https://github.com/node-forward/node/pull/16 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
CHECK(args[0]->IsObject());
CHECK(args[1]->IsFunction());
CHECK(args[2]->IsObject());
node: add AsyncListener support AsyncListener is a JS API that works in tandem with the AsyncWrap class to allow the user to be alerted to key events in the life cycle of an asynchronous event. The AsyncWrap class has its own MakeCallback implementation that core will be migrated to use, and uses state sharing techniques to allow quicker communication between JS and C++ whether the async event callbacks need to be called.
11 years ago
// Values use to cross communicate with processNextTick.
Local<Object> tick_info_obj = args[0].As<Object>();
tick_info_obj->SetIndexedPropertiesToExternalArrayData(
env->tick_info()->fields(),
src: update use of ExternalArrayType constants Continuation of 4809c7a to update the use of v8::ExternalArrayType. Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
10 years ago
kExternalUint32Array,
node: add AsyncListener support AsyncListener is a JS API that works in tandem with the AsyncWrap class to allow the user to be alerted to key events in the life cycle of an asynchronous event. The AsyncWrap class has its own MakeCallback implementation that core will be migrated to use, and uses state sharing techniques to allow quicker communication between JS and C++ whether the async event callbacks need to be called.
11 years ago
env->tick_info()->fields_count());
env->set_tick_callback_function(args[1].As<Function>());
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
env->SetMethod(args[2].As<Object>(), "runMicrotasks", RunMicrotasks);
node: support v8 microtask queue When V8 started supporting Promises natively it also introduced a microtack queue. This feature operates similar to process.nextTick(), and created an issue where neither knew when the other had run. This patch has nextTick() call the microtask queue runner at the end of processing callbacks in the nextTickQueue. Fixes: https://github.com/joyent/node/issues/7714 Reviewed-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
10 years ago
node: add AsyncListener support AsyncListener is a JS API that works in tandem with the AsyncWrap class to allow the user to be alerted to key events in the life cycle of an asynchronous event. The AsyncWrap class has its own MakeCallback implementation that core will be migrated to use, and uses state sharing techniques to allow quicker communication between JS and C++ whether the async event callbacks need to be called.
11 years ago
// Do a little housekeeping.
env->process_object()->Delete(
FIXED_ONE_BYTE_STRING(args.GetIsolate(), "_setupNextTick"));
domain: share object and state with native land Change process.domain to use a getter/setter and access that property via an array index. These are much faster to get from c++, and it can be passed to _setupDomainUse and stored as a Persistent&lt;Array&gt;. InDomain() and GetDomain() as trivial ways to access the domain information in the native layer. Important because we&#39;ll be able to quickly access if a domain is active. Instead of just whether the domain module has been loaded.
12 years ago
}
node, async-wrap: remove MakeDomainCallback C++ won&#39;t deoptimize like JS if specific conditional branches are sporadically met in the future. Combined with the amount of code duplication removal and simplified maintenance complexity, it makes more sense to merge MakeCallback and MakeDomainCallback. Additionally, type casting in V8 before verifying what that type is will cause V8 to abort in debug mode if that type isn&#39;t what was expected. Fix this by first checking the v8::Value before casting. PR-URL: https://github.com/joyent/node/pull/8110 Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt; Reviewed-by: Fedor Indutny &lt;fedor@indutny.com&gt; Reviewed-by: Alexis Campailla &lt;alexis@janeasystems.com&gt; Reviewed-by: Julien Gilli &lt;julien.gilli@joyent.com&gt;
10 years ago
Handle<Value> MakeCallback(Environment* env,
Handle<Value> recv,
const Handle<Function> callback,
int argc,
Handle<Value> argv[]) {
src: revert domain using AsyncListeners This is a slightly modified revert of bc39bdd. Getting domains to use AsyncListeners became too much of a challenge with many edge cases. While this is still a goal, it will have to be deferred for now until more test coverage can be provided.
11 years ago
// If you hit this assertion, you forgot to enter the v8::Context first.
src: replace assert() with CHECK() Mechanically replace assert() statements with UNREACHABLE(), CHECK(), or CHECK_{EQ,NE,LT,GT,LE,GE}() statements. The exceptions are src/node.h and src/node_object_wrap.h because they are public headers. PR-URL: https://github.com/node-forward/node/pull/16 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
CHECK_EQ(env->context(), env->isolate()->GetCurrentContext());
src: revert domain using AsyncListeners This is a slightly modified revert of bc39bdd. Getting domains to use AsyncListeners became too much of a challenge with many edge cases. While this is still a goal, it will have to be deferred for now until more test coverage can be provided.
11 years ago
Local<Object> process = env->process_object();
src: update MakeCallback() function prototype Make it possible to invoke MakeCallback() on a v8::Value but only for the variant that takes a v8::Function as the thing to call. The const char* and v8::String variants still require a v8::Object because the function to call is looked up as a property on the receiver, but that only works when the receiver is an object, not a primitive.
11 years ago
Local<Object> object, domain;
async-wrap: add event hooks Call a user-defined callback at specific points in the lifetime of an asynchronous event. Which are on instantiation, just before/after the callback has been run. **If any of these callbacks throws an exception, there is no forgiveness or recovery. A message will be displayed and a core file dumped.** Currently these only tie into AsyncWrap, meaning no call to a hook callback will be made for timers or process.nextTick() events. Though those will be added in a future commit. Here are a few notes on how to make the hooks work: - The &#34;this&#34; of all event hook callbacks is the request object. - The zero field (kCallInitHook) of the flags object passed to setupHooks() must be set != 0 before the init callback will be called. - kCallInitHook only affects the calling of the init callback. If the request object has been run through the create callback it will always run the before/after callbacks. Regardless of kCallInitHook. - In the init callback the property &#34;_asyncQueue&#34; must be attached to the request object. e.g. function initHook() { this._asyncQueue = {}; } - DO NOT inspect the properties of the object in the init callback. Since the object is in the middle of being instantiated there are some cases when a getter is not complete, and doing so will cause Node to crash. PR-URL: https://github.com/joyent/node/pull/8110 Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt; Reviewed-by: Fedor Indutny &lt;fedor@indutny.com&gt; Reviewed-by: Alexis Campailla &lt;alexis@janeasystems.com&gt; Reviewed-by: Julien Gilli &lt;julien.gilli@joyent.com&gt;
10 years ago
bool has_async_queue = false;
src: update MakeCallback() function prototype Make it possible to invoke MakeCallback() on a v8::Value but only for the variant that takes a v8::Function as the thing to call. The const char* and v8::String variants still require a v8::Object because the function to call is looked up as a property on the receiver, but that only works when the receiver is an object, not a primitive.
11 years ago
bool has_domain = false;
src: revert domain using AsyncListeners This is a slightly modified revert of bc39bdd. Getting domains to use AsyncListeners became too much of a challenge with many edge cases. While this is still a goal, it will have to be deferred for now until more test coverage can be provided.
11 years ago
async-wrap: add event hooks Call a user-defined callback at specific points in the lifetime of an asynchronous event. Which are on instantiation, just before/after the callback has been run. **If any of these callbacks throws an exception, there is no forgiveness or recovery. A message will be displayed and a core file dumped.** Currently these only tie into AsyncWrap, meaning no call to a hook callback will be made for timers or process.nextTick() events. Though those will be added in a future commit. Here are a few notes on how to make the hooks work: - The &#34;this&#34; of all event hook callbacks is the request object. - The zero field (kCallInitHook) of the flags object passed to setupHooks() must be set != 0 before the init callback will be called. - kCallInitHook only affects the calling of the init callback. If the request object has been run through the create callback it will always run the before/after callbacks. Regardless of kCallInitHook. - In the init callback the property &#34;_asyncQueue&#34; must be attached to the request object. e.g. function initHook() { this._asyncQueue = {}; } - DO NOT inspect the properties of the object in the init callback. Since the object is in the middle of being instantiated there are some cases when a getter is not complete, and doing so will cause Node to crash. PR-URL: https://github.com/joyent/node/pull/8110 Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt; Reviewed-by: Fedor Indutny &lt;fedor@indutny.com&gt; Reviewed-by: Alexis Campailla &lt;alexis@janeasystems.com&gt; Reviewed-by: Julien Gilli &lt;julien.gilli@joyent.com&gt;
10 years ago
if (recv->IsObject()) {
object = recv.As<Object>();
Local<Value> async_queue_v = object->Get(env->async_queue_string());
if (async_queue_v->IsObject())
has_async_queue = true;
}
node, async-wrap: remove MakeDomainCallback C++ won&#39;t deoptimize like JS if specific conditional branches are sporadically met in the future. Combined with the amount of code duplication removal and simplified maintenance complexity, it makes more sense to merge MakeCallback and MakeDomainCallback. Additionally, type casting in V8 before verifying what that type is will cause V8 to abort in debug mode if that type isn&#39;t what was expected. Fix this by first checking the v8::Value before casting. PR-URL: https://github.com/joyent/node/pull/8110 Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt; Reviewed-by: Fedor Indutny &lt;fedor@indutny.com&gt; Reviewed-by: Alexis Campailla &lt;alexis@janeasystems.com&gt; Reviewed-by: Julien Gilli &lt;julien.gilli@joyent.com&gt;
10 years ago
if (env->using_domains()) {
CHECK(recv->IsObject());
Local<Value> domain_v = object->Get(env->domain_string());
src: update MakeCallback() function prototype Make it possible to invoke MakeCallback() on a v8::Value but only for the variant that takes a v8::Function as the thing to call. The const char* and v8::String variants still require a v8::Object because the function to call is looked up as a property on the receiver, but that only works when the receiver is an object, not a primitive.
11 years ago
has_domain = domain_v->IsObject();
if (has_domain) {
domain = domain_v.As<Object>();
node, async-wrap: remove MakeDomainCallback C++ won&#39;t deoptimize like JS if specific conditional branches are sporadically met in the future. Combined with the amount of code duplication removal and simplified maintenance complexity, it makes more sense to merge MakeCallback and MakeDomainCallback. Additionally, type casting in V8 before verifying what that type is will cause V8 to abort in debug mode if that type isn&#39;t what was expected. Fix this by first checking the v8::Value before casting. PR-URL: https://github.com/joyent/node/pull/8110 Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt; Reviewed-by: Fedor Indutny &lt;fedor@indutny.com&gt; Reviewed-by: Alexis Campailla &lt;alexis@janeasystems.com&gt; Reviewed-by: Julien Gilli &lt;julien.gilli@joyent.com&gt;
10 years ago
if (domain->Get(env->disposed_string())->IsTrue())
src: remove `node_isolate` from source fix #6899
11 years ago
return Undefined(env->isolate());
src: revert domain using AsyncListeners This is a slightly modified revert of bc39bdd. Getting domains to use AsyncListeners became too much of a challenge with many edge cases. While this is still a goal, it will have to be deferred for now until more test coverage can be provided.
11 years ago
}
}
node, async-wrap: remove MakeDomainCallback C++ won&#39;t deoptimize like JS if specific conditional branches are sporadically met in the future. Combined with the amount of code duplication removal and simplified maintenance complexity, it makes more sense to merge MakeCallback and MakeDomainCallback. Additionally, type casting in V8 before verifying what that type is will cause V8 to abort in debug mode if that type isn&#39;t what was expected. Fix this by first checking the v8::Value before casting. PR-URL: https://github.com/joyent/node/pull/8110 Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt; Reviewed-by: Fedor Indutny &lt;fedor@indutny.com&gt; Reviewed-by: Alexis Campailla &lt;alexis@janeasystems.com&gt; Reviewed-by: Julien Gilli &lt;julien.gilli@joyent.com&gt;
10 years ago
TryCatch try_catch;
try_catch.SetVerbose(true);
src: revert domain using AsyncListeners This is a slightly modified revert of bc39bdd. Getting domains to use AsyncListeners became too much of a challenge with many edge cases. While this is still a goal, it will have to be deferred for now until more test coverage can be provided.
11 years ago
if (has_domain) {
node, async-wrap: remove MakeDomainCallback C++ won&#39;t deoptimize like JS if specific conditional branches are sporadically met in the future. Combined with the amount of code duplication removal and simplified maintenance complexity, it makes more sense to merge MakeCallback and MakeDomainCallback. Additionally, type casting in V8 before verifying what that type is will cause V8 to abort in debug mode if that type isn&#39;t what was expected. Fix this by first checking the v8::Value before casting. PR-URL: https://github.com/joyent/node/pull/8110 Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt; Reviewed-by: Fedor Indutny &lt;fedor@indutny.com&gt; Reviewed-by: Alexis Campailla &lt;alexis@janeasystems.com&gt; Reviewed-by: Julien Gilli &lt;julien.gilli@joyent.com&gt;
10 years ago
Local<Value> enter_v = domain->Get(env->enter_string());
if (enter_v->IsFunction()) {
enter_v.As<Function>()->Call(domain, 0, nullptr);
node,async-wrap: verify domain enter/exit are set The REPL global object lazy loads modules by placing getters for each. This causes MakeDomainCallback() to be run if a native module is loaded from the REPL, but if the domain module hasn&#39;t been loaded then there are no enter/exit callbacks to be called. Causing an assert() to fail. Fix the issue by conditionally running the callback instead of asserting it is available. Also add &#34;addon&#34; test to verify the fix. Fixes: #8231 Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
10 years ago
if (try_catch.HasCaught())
return Undefined(env->isolate());
src: revert domain using AsyncListeners This is a slightly modified revert of bc39bdd. Getting domains to use AsyncListeners became too much of a challenge with many edge cases. While this is still a goal, it will have to be deferred for now until more test coverage can be provided.
11 years ago
}
}
async-wrap: add event hooks Call a user-defined callback at specific points in the lifetime of an asynchronous event. Which are on instantiation, just before/after the callback has been run. **If any of these callbacks throws an exception, there is no forgiveness or recovery. A message will be displayed and a core file dumped.** Currently these only tie into AsyncWrap, meaning no call to a hook callback will be made for timers or process.nextTick() events. Though those will be added in a future commit. Here are a few notes on how to make the hooks work: - The &#34;this&#34; of all event hook callbacks is the request object. - The zero field (kCallInitHook) of the flags object passed to setupHooks() must be set != 0 before the init callback will be called. - kCallInitHook only affects the calling of the init callback. If the request object has been run through the create callback it will always run the before/after callbacks. Regardless of kCallInitHook. - In the init callback the property &#34;_asyncQueue&#34; must be attached to the request object. e.g. function initHook() { this._asyncQueue = {}; } - DO NOT inspect the properties of the object in the init callback. Since the object is in the middle of being instantiated there are some cases when a getter is not complete, and doing so will cause Node to crash. PR-URL: https://github.com/joyent/node/pull/8110 Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt; Reviewed-by: Fedor Indutny &lt;fedor@indutny.com&gt; Reviewed-by: Alexis Campailla &lt;alexis@janeasystems.com&gt; Reviewed-by: Julien Gilli &lt;julien.gilli@joyent.com&gt;
10 years ago
if (has_async_queue) {
try_catch.SetVerbose(false);
env->async_hooks_pre_function()->Call(object, 0, nullptr);
if (try_catch.HasCaught())
FatalError("node:;MakeCallback", "pre hook threw");
try_catch.SetVerbose(true);
}
node, async-wrap: remove MakeDomainCallback C++ won&#39;t deoptimize like JS if specific conditional branches are sporadically met in the future. Combined with the amount of code duplication removal and simplified maintenance complexity, it makes more sense to merge MakeCallback and MakeDomainCallback. Additionally, type casting in V8 before verifying what that type is will cause V8 to abort in debug mode if that type isn&#39;t what was expected. Fix this by first checking the v8::Value before casting. PR-URL: https://github.com/joyent/node/pull/8110 Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt; Reviewed-by: Fedor Indutny &lt;fedor@indutny.com&gt; Reviewed-by: Alexis Campailla &lt;alexis@janeasystems.com&gt; Reviewed-by: Julien Gilli &lt;julien.gilli@joyent.com&gt;
10 years ago
Local<Value> ret = callback->Call(recv, argc, argv);
node: avoid automatic microtask runs Since we are taking control of the microtask queue it makes sense to disable autorun and only run microtasks when necessary. Just setting isolate-&gt;SetAutorunMicrotasks(false) would cause _tickCallback() not to be called. Automatically running the microtask queue will cause it to run: * After callback invocation * Inside _tickCallback() * After _tickCallback() invocation The third one is unnecessary as the microtask queue is guaranteed to be empty at this point. The first only needs to be run manually when _tickCallback() isn&#39;t going to be called by MakeCallback(). Reviewed-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
10 years ago
async-wrap: add event hooks Call a user-defined callback at specific points in the lifetime of an asynchronous event. Which are on instantiation, just before/after the callback has been run. **If any of these callbacks throws an exception, there is no forgiveness or recovery. A message will be displayed and a core file dumped.** Currently these only tie into AsyncWrap, meaning no call to a hook callback will be made for timers or process.nextTick() events. Though those will be added in a future commit. Here are a few notes on how to make the hooks work: - The &#34;this&#34; of all event hook callbacks is the request object. - The zero field (kCallInitHook) of the flags object passed to setupHooks() must be set != 0 before the init callback will be called. - kCallInitHook only affects the calling of the init callback. If the request object has been run through the create callback it will always run the before/after callbacks. Regardless of kCallInitHook. - In the init callback the property &#34;_asyncQueue&#34; must be attached to the request object. e.g. function initHook() { this._asyncQueue = {}; } - DO NOT inspect the properties of the object in the init callback. Since the object is in the middle of being instantiated there are some cases when a getter is not complete, and doing so will cause Node to crash. PR-URL: https://github.com/joyent/node/pull/8110 Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt; Reviewed-by: Fedor Indutny &lt;fedor@indutny.com&gt; Reviewed-by: Alexis Campailla &lt;alexis@janeasystems.com&gt; Reviewed-by: Julien Gilli &lt;julien.gilli@joyent.com&gt;
10 years ago
if (has_async_queue) {
try_catch.SetVerbose(false);
env->async_hooks_post_function()->Call(object, 0, nullptr);
if (try_catch.HasCaught())
FatalError("node::MakeCallback", "post hook threw");
try_catch.SetVerbose(true);
}
node, async-wrap: remove MakeDomainCallback C++ won&#39;t deoptimize like JS if specific conditional branches are sporadically met in the future. Combined with the amount of code duplication removal and simplified maintenance complexity, it makes more sense to merge MakeCallback and MakeDomainCallback. Additionally, type casting in V8 before verifying what that type is will cause V8 to abort in debug mode if that type isn&#39;t what was expected. Fix this by first checking the v8::Value before casting. PR-URL: https://github.com/joyent/node/pull/8110 Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt; Reviewed-by: Fedor Indutny &lt;fedor@indutny.com&gt; Reviewed-by: Alexis Campailla &lt;alexis@janeasystems.com&gt; Reviewed-by: Julien Gilli &lt;julien.gilli@joyent.com&gt;
10 years ago
if (has_domain) {
Local<Value> exit_v = domain->Get(env->exit_string());
if (exit_v->IsFunction()) {
exit_v.As<Function>()->Call(domain, 0, nullptr);
if (try_catch.HasCaught())
return Undefined(env->isolate());
}
src: revert domain using AsyncListeners This is a slightly modified revert of bc39bdd. Getting domains to use AsyncListeners became too much of a challenge with many edge cases. While this is still a goal, it will have to be deferred for now until more test coverage can be provided.
11 years ago
}
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
env->tick_callback_function()->Call(process, 0, nullptr);
src: replace assert() with CHECK() Mechanically replace assert() statements with UNREACHABLE(), CHECK(), or CHECK_{EQ,NE,LT,GT,LE,GE}() statements. The exceptions are src/node.h and src/node_object_wrap.h because they are public headers. PR-URL: https://github.com/node-forward/node/pull/16 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
CHECK_EQ(env->context(), env->isolate()->GetCurrentContext());
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
process: streamlining tick callback logic * Callbacks from spinner now calls its own function, separate from the tickCallback logic * MakeCallback will call a domain specific function if a domain is detected * _tickCallback assumes no domains, until nextTick receives a callback with a domain. After that _tickCallback is overridden with the domain specific implementation. * _needTickCallback runs in startup() instead of nextTick (isaacs) * Fix bug in _fatalException where exit would be called twice (isaacs) * Process.domain has a default value of null * Manually track nextTickQueue.length (will be useful later) * Update tests to reflect internal api changes
12 years ago
if (try_catch.HasCaught()) {
src: remove `node_isolate` from source fix #6899
11 years ago
return Undefined(env->isolate());
process: streamlining tick callback logic * Callbacks from spinner now calls its own function, separate from the tickCallback logic * MakeCallback will call a domain specific function if a domain is detected * _tickCallback assumes no domains, until nextTick receives a callback with a domain. After that _tickCallback is overridden with the domain specific implementation. * _needTickCallback runs in startup() instead of nextTick (isaacs) * Fix bug in _fatalException where exit would be called twice (isaacs) * Process.domain has a default value of null * Manually track nextTickQueue.length (will be useful later) * Update tests to reflect internal api changes
12 years ago
}
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
Environment::TickInfo* tick_info = env->tick_info();
node: add AsyncListener support AsyncListener is a JS API that works in tandem with the AsyncWrap class to allow the user to be alerted to key events in the life cycle of an asynchronous event. The AsyncWrap class has its own MakeCallback implementation that core will be migrated to use, and uses state sharing techniques to allow quicker communication between JS and C++ whether the async event callbacks need to be called.
11 years ago
if (tick_info->in_tick()) {
node: add inTick and lastThrew to infoBox To prevent all unnecessary calls to JS from MakeCallback, the remaining two immediate return variables inTick and lastThrew have been added to infoBox. Now MakeCallback should never need to call into JS unless it absolutely has to. Also removed Tock. Performance tests showed it was at least as fast or faster than using a normal object, and this is more readable.
12 years ago
return ret;
}
node: avoid automatic microtask runs Since we are taking control of the microtask queue it makes sense to disable autorun and only run microtasks when necessary. Just setting isolate-&gt;SetAutorunMicrotasks(false) would cause _tickCallback() not to be called. Automatically running the microtask queue will cause it to run: * After callback invocation * Inside _tickCallback() * After _tickCallback() invocation The third one is unnecessary as the microtask queue is guaranteed to be empty at this point. The first only needs to be run manually when _tickCallback() isn&#39;t going to be called by MakeCallback(). Reviewed-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
10 years ago
if (tick_info->length() == 0) {
env->isolate()->RunMicrotasks();
}
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
if (tick_info->length() == 0) {
tick_info->set_index(0);
node: revert removal of MakeCallback In 0168109 an implementation of MakeCallback was accidently removed. It has been re-added.
12 years ago
return ret;
process: allow ticker to cross communicate better Using external memory values allows for quick communication between js and cc land, so we can check if the js land callback needs to be run. (this is where I meant that manually tracking nextTickQueue.length would be helpful) Also did some minor cleanup of removing the old Tick and StartTickSpinner functions, and a few unneeded comments. Conflicts: src/node.cc
12 years ago
}
node: don&#39;t share state with in_tick/last_threw There was no need to share state between C++ and JS for these two values. So they have been moved to their respective locations. This will help performance only a tiny bit, but it does help code complexity much more.
12 years ago
tick_info->set_in_tick(true);
process: streamlining tick callback logic * Callbacks from spinner now calls its own function, separate from the tickCallback logic * MakeCallback will call a domain specific function if a domain is detected * _tickCallback assumes no domains, until nextTick receives a callback with a domain. After that _tickCallback is overridden with the domain specific implementation. * _needTickCallback runs in startup() instead of nextTick (isaacs) * Fix bug in _fatalException where exit would be called twice (isaacs) * Process.domain has a default value of null * Manually track nextTickQueue.length (will be useful later) * Update tests to reflect internal api changes
12 years ago
// process nextTicks after call
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
env->tick_callback_function()->Call(process, 0, nullptr);
Domain hooks in ReqWrap&lt;T&gt; and MakeCallback
13 years ago
node: don&#39;t share state with in_tick/last_threw There was no need to share state between C++ and JS for these two values. So they have been moved to their respective locations. This will help performance only a tiny bit, but it does help code complexity much more.
12 years ago
tick_info->set_in_tick(false);
Domain hooks in ReqWrap&lt;T&gt; and MakeCallback
13 years ago
if (try_catch.HasCaught()) {
node: don&#39;t share state with in_tick/last_threw There was no need to share state between C++ and JS for these two values. So they have been moved to their respective locations. This will help performance only a tiny bit, but it does help code complexity much more.
12 years ago
tick_info->set_last_threw(true);
src: remove `node_isolate` from source fix #6899
11 years ago
return Undefined(env->isolate());
Move MakeCallback and SetErrno to node.cc
14 years ago
}
MakeCallback: Return the callback return value
13 years ago
node: revert removal of MakeCallback In 0168109 an implementation of MakeCallback was accidently removed. It has been re-added.
12 years ago
return ret;
}
src: add MakeCallback() that takes an array index Internal helper function for dispatching by array index rather than named property.
12 years ago
// Internal only.
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
Handle<Value> MakeCallback(Environment* env,
src: update MakeCallback() function prototype Make it possible to invoke MakeCallback() on a v8::Value but only for the variant that takes a v8::Function as the thing to call. The const char* and v8::String variants still require a v8::Object because the function to call is looked up as a property on the receiver, but that only works when the receiver is an object, not a primitive.
11 years ago
Handle<Object> recv,
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
uint32_t index,
int argc,
Handle<Value> argv[]) {
node, async-wrap: remove MakeDomainCallback C++ won&#39;t deoptimize like JS if specific conditional branches are sporadically met in the future. Combined with the amount of code duplication removal and simplified maintenance complexity, it makes more sense to merge MakeCallback and MakeDomainCallback. Additionally, type casting in V8 before verifying what that type is will cause V8 to abort in debug mode if that type isn&#39;t what was expected. Fix this by first checking the v8::Value before casting. PR-URL: https://github.com/joyent/node/pull/8110 Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt; Reviewed-by: Fedor Indutny &lt;fedor@indutny.com&gt; Reviewed-by: Alexis Campailla &lt;alexis@janeasystems.com&gt; Reviewed-by: Julien Gilli &lt;julien.gilli@joyent.com&gt;
10 years ago
Local<Value> cb_v = recv->Get(index);
CHECK(cb_v->IsFunction());
return MakeCallback(env, recv.As<Value>(), cb_v.As<Function>(), argc, argv);
src: add MakeCallback() that takes an array index Internal helper function for dispatching by array index rather than named property.
12 years ago
}
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
Handle<Value> MakeCallback(Environment* env,
src: update MakeCallback() function prototype Make it possible to invoke MakeCallback() on a v8::Value but only for the variant that takes a v8::Function as the thing to call. The const char* and v8::String variants still require a v8::Object because the function to call is looked up as a property on the receiver, but that only works when the receiver is an object, not a primitive.
11 years ago
Handle<Object> recv,
Handle<String> symbol,
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
int argc,
Handle<Value> argv[]) {
node, async-wrap: remove MakeDomainCallback C++ won&#39;t deoptimize like JS if specific conditional branches are sporadically met in the future. Combined with the amount of code duplication removal and simplified maintenance complexity, it makes more sense to merge MakeCallback and MakeDomainCallback. Additionally, type casting in V8 before verifying what that type is will cause V8 to abort in debug mode if that type isn&#39;t what was expected. Fix this by first checking the v8::Value before casting. PR-URL: https://github.com/joyent/node/pull/8110 Signed-off-by: Trevor Norris &lt;trev.norris@gmail.com&gt; Reviewed-by: Fedor Indutny &lt;fedor@indutny.com&gt; Reviewed-by: Alexis Campailla &lt;alexis@janeasystems.com&gt; Reviewed-by: Julien Gilli &lt;julien.gilli@joyent.com&gt;
10 years ago
Local<Value> cb_v = recv->Get(symbol);
CHECK(cb_v->IsFunction());
return MakeCallback(env, recv.As<Value>(), cb_v.As<Function>(), argc, argv);
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
}
Move MakeCallback and SetErrno to node.cc
14 years ago
process: streamlining tick callback logic * Callbacks from spinner now calls its own function, separate from the tickCallback logic * MakeCallback will call a domain specific function if a domain is detected * _tickCallback assumes no domains, until nextTick receives a callback with a domain. After that _tickCallback is overridden with the domain specific implementation. * _needTickCallback runs in startup() instead of nextTick (isaacs) * Fix bug in _fatalException where exit would be called twice (isaacs) * Process.domain has a default value of null * Manually track nextTickQueue.length (will be useful later) * Update tests to reflect internal api changes
12 years ago
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
Handle<Value> MakeCallback(Environment* env,
src: update MakeCallback() function prototype Make it possible to invoke MakeCallback() on a v8::Value but only for the variant that takes a v8::Function as the thing to call. The const char* and v8::String variants still require a v8::Object because the function to call is looked up as a property on the receiver, but that only works when the receiver is an object, not a primitive.
11 years ago
Handle<Object> recv,
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
const char* method,
int argc,
Handle<Value> argv[]) {
src: remove `node_isolate` from source fix #6899
11 years ago
Local<String> method_string = OneByteString(env->isolate(), method);
src: update MakeCallback() function prototype Make it possible to invoke MakeCallback() on a v8::Value but only for the variant that takes a v8::Function as the thing to call. The const char* and v8::String variants still require a v8::Object because the function to call is looked up as a property on the receiver, but that only works when the receiver is an object, not a primitive.
11 years ago
return MakeCallback(env, recv, method_string, argc, argv);
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
}
process: streamlining tick callback logic * Callbacks from spinner now calls its own function, separate from the tickCallback logic * MakeCallback will call a domain specific function if a domain is detected * _tickCallback assumes no domains, until nextTick receives a callback with a domain. After that _tickCallback is overridden with the domain specific implementation. * _needTickCallback runs in startup() instead of nextTick (isaacs) * Fix bug in _fatalException where exit would be called twice (isaacs) * Process.domain has a default value of null * Manually track nextTickQueue.length (will be useful later) * Update tests to reflect internal api changes
12 years ago
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
src: remove `node_isolate` from source fix #6899
11 years ago
Handle<Value> MakeCallback(Isolate* isolate,
Handle<Object> recv,
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
const char* method,
int argc,
Handle<Value> argv[]) {
src: update to v8 3.24 APIs
11 years ago
EscapableHandleScope handle_scope(isolate);
src: update MakeCallback() function prototype Make it possible to invoke MakeCallback() on a v8::Value but only for the variant that takes a v8::Function as the thing to call. The const char* and v8::String variants still require a v8::Object because the function to call is looked up as a property on the receiver, but that only works when the receiver is an object, not a primitive.
11 years ago
Local<Context> context = recv->CreationContext();
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
Environment* env = Environment::GetCurrent(context);
Context::Scope context_scope(context);
src: update to v8 3.24 APIs
11 years ago
return handle_scope.Escape(
Local<Value>::New(isolate, MakeCallback(env, recv, method, argc, argv)));
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
}
src: remove `node_isolate` from source fix #6899
11 years ago
Handle<Value> MakeCallback(Isolate* isolate,
Handle<Object> recv,
src: update MakeCallback() function prototype Make it possible to invoke MakeCallback() on a v8::Value but only for the variant that takes a v8::Function as the thing to call. The const char* and v8::String variants still require a v8::Object because the function to call is looked up as a property on the receiver, but that only works when the receiver is an object, not a primitive.
11 years ago
Handle<String> symbol,
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
int argc,
Handle<Value> argv[]) {
src: update to v8 3.24 APIs
11 years ago
EscapableHandleScope handle_scope(isolate);
src: update MakeCallback() function prototype Make it possible to invoke MakeCallback() on a v8::Value but only for the variant that takes a v8::Function as the thing to call. The const char* and v8::String variants still require a v8::Object because the function to call is looked up as a property on the receiver, but that only works when the receiver is an object, not a primitive.
11 years ago
Local<Context> context = recv->CreationContext();
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
Environment* env = Environment::GetCurrent(context);
Context::Scope context_scope(context);
src: update to v8 3.24 APIs
11 years ago
return handle_scope.Escape(
Local<Value>::New(isolate, MakeCallback(env, recv, symbol, argc, argv)));
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
}
src: remove `node_isolate` from source fix #6899
11 years ago
Handle<Value> MakeCallback(Isolate* isolate,
Handle<Object> recv,
src: update MakeCallback() function prototype Make it possible to invoke MakeCallback() on a v8::Value but only for the variant that takes a v8::Function as the thing to call. The const char* and v8::String variants still require a v8::Object because the function to call is looked up as a property on the receiver, but that only works when the receiver is an object, not a primitive.
11 years ago
Handle<Function> callback,
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
int argc,
Handle<Value> argv[]) {
src: update to v8 3.24 APIs
11 years ago
EscapableHandleScope handle_scope(isolate);
src: update MakeCallback() function prototype Make it possible to invoke MakeCallback() on a v8::Value but only for the variant that takes a v8::Function as the thing to call. The const char* and v8::String variants still require a v8::Object because the function to call is looked up as a property on the receiver, but that only works when the receiver is an object, not a primitive.
11 years ago
Local<Context> context = recv->CreationContext();
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
Environment* env = Environment::GetCurrent(context);
Context::Scope context_scope(context);
src: update to v8 3.24 APIs
11 years ago
return handle_scope.Escape(Local<Value>::New(
isolate,
MakeCallback(env, recv.As<Value>(), callback, argc, argv)));
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
}
src: remove `node_isolate` from source fix #6899
11 years ago
enum encoding ParseEncoding(Isolate* isolate,
Handle<Value> encoding_v,
enum encoding _default) {
HandleScope scope(isolate);
Byte stream to V8 decoding and encoding. This does not (should not) change behavior. Pulls those two functions (encode/decode) out into node.cc.
16 years ago
cpplint: disallow if one-liners
11 years ago
if (!encoding_v->IsString())
return _default;
Byte stream to V8 decoding and encoding. This does not (should not) change behavior. Pulls those two functions (encode/decode) out into node.cc.
16 years ago
src: pass Isolate to node::Utf8Value constructor Initial attempt to remove all uses of Isolate::GetCurrent(). Still exists a few locations, but this works out a heavy usage. PR-URL: https://github.com/iojs/io.js/pull/244 Reviewed-by: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
node::Utf8Value encoding(isolate, encoding_v);
Remove &#34;raw&#34; encoding. Rename &#34;raws&#34; to &#34;binary&#34;. Deprecation warnings have been added to help the conversion to this new API.
16 years ago
if (strcasecmp(*encoding, "utf8") == 0) {
return UTF8;
Also accept &#39;utf-8&#39; to specify utf8 encodings.
15 years ago
} else if (strcasecmp(*encoding, "utf-8") == 0) {
return UTF8;
Remove &#34;raw&#34; encoding. Rename &#34;raws&#34; to &#34;binary&#34;. Deprecation warnings have been added to help the conversion to this new API.
16 years ago
} else if (strcasecmp(*encoding, "ascii") == 0) {
return ASCII;
Buffer: adjust buffer size so the base64-decoded input fits snugly. Stops Valgrind from complaining about uninitialized memory access.
15 years ago
} else if (strcasecmp(*encoding, "base64") == 0) {
return BASE64;
UCS-2 support Closes GH-644.
14 years ago
} else if (strcasecmp(*encoding, "ucs2") == 0) {
return UCS2;
} else if (strcasecmp(*encoding, "ucs-2") == 0) {
return UCS2;
buffer: fix byteLength with UTF-16LE Fixes #4075.
12 years ago
} else if (strcasecmp(*encoding, "utf16le") == 0) {
return UCS2;
} else if (strcasecmp(*encoding, "utf-16le") == 0) {
return UCS2;
Remove &#34;raw&#34; encoding. Rename &#34;raws&#34; to &#34;binary&#34;. Deprecation warnings have been added to help the conversion to this new API.
16 years ago
} else if (strcasecmp(*encoding, "binary") == 0) {
return BINARY;
crypto: bring module into modern age Introduce &#39;buffer&#39; encoding, allow returning and giving buffers as arguments of &#39;crypto&#39; routines. Fix #3278
12 years ago
} else if (strcasecmp(*encoding, "buffer") == 0) {
return BUFFER;
Closes GH-695 Add &#39;hex&#39; encoding to Buffer
14 years ago
} else if (strcasecmp(*encoding, "hex") == 0) {
return HEX;
Remove &#34;raw&#34; encoding. Rename &#34;raws&#34; to &#34;binary&#34;. Deprecation warnings have been added to help the conversion to this new API.
16 years ago
} else if (strcasecmp(*encoding, "raw") == 0) {
Add --no-deprecation and --trace-deprecation flags
13 years ago
if (!no_deprecation) {
fprintf(stderr, "'raw' (array of integers) has been removed. "
"Use 'binary'.\n");
}
Remove &#34;raw&#34; encoding. Rename &#34;raws&#34; to &#34;binary&#34;. Deprecation warnings have been added to help the conversion to this new API.
16 years ago
return BINARY;
} else if (strcasecmp(*encoding, "raws") == 0) {
Add --no-deprecation and --trace-deprecation flags
13 years ago
if (!no_deprecation) {
fprintf(stderr, "'raws' encoding has been renamed to 'binary'. "
"Please update your code.\n");
}
Remove &#34;raw&#34; encoding. Rename &#34;raws&#34; to &#34;binary&#34;. Deprecation warnings have been added to help the conversion to this new API.
16 years ago
return BINARY;
} else {
return _default;
cpplint.py node.cc and node.h
16 years ago
}
Remove &#34;raw&#34; encoding. Rename &#34;raws&#34; to &#34;binary&#34;. Deprecation warnings have been added to help the conversion to this new API.
16 years ago
}
src: remove `node_isolate` from source fix #6899
11 years ago
Local<Value> Encode(Isolate* isolate,
src: redo unaligned access workaround Introduce two-byte overloads of node::Encode() and StringBytes::Encode() that ensure that the input is suitably aligned. Revisits commit 535fec8 from yesterday.
10 years ago
const char* buf,
src: remove `node_isolate` from source fix #6899
11 years ago
size_t len,
enum encoding encoding) {
src: redo unaligned access workaround Introduce two-byte overloads of node::Encode() and StringBytes::Encode() that ensure that the input is suitably aligned. Revisits commit 535fec8 from yesterday.
10 years ago
CHECK_NE(encoding, UCS2);
return StringBytes::Encode(isolate, buf, len, encoding);
}
Local<Value> Encode(Isolate* isolate, const uint16_t* buf, size_t len) {
return StringBytes::Encode(isolate, buf, len);
Byte stream to V8 decoding and encoding. This does not (should not) change behavior. Pulls those two functions (encode/decode) out into node.cc.
16 years ago
}
cpplint.py node.cc and node.h
16 years ago
// Returns -1 if the handle was not valid for decoding
src: remove `node_isolate` from source fix #6899
11 years ago
ssize_t DecodeBytes(Isolate* isolate,
Handle<Value> val,
enum encoding encoding) {
HandleScope scope(isolate);
Byte stream to V8 decoding and encoding. This does not (should not) change behavior. Pulls those two functions (encode/decode) out into node.cc.
16 years ago
if (val->IsArray()) {
Revert &#34;Fix #3242 Actually deprecate &#39;binary&#39; buffer encoding&#34; This reverts commit 5979f096d1b702ca2ba95664a0bbc8210109775b. Related: - #3279 - #3278
13 years ago
fprintf(stderr, "'raw' encoding (array of integers) has been removed. "
"Use 'binary'.\n");
src: replace assert() with CHECK() Mechanically replace assert() statements with UNREACHABLE(), CHECK(), or CHECK_{EQ,NE,LT,GT,LE,GE}() statements. The exceptions are src/node.h and src/node_object_wrap.h because they are public headers. PR-URL: https://github.com/node-forward/node/pull/16 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
UNREACHABLE();
Remove &#34;raw&#34; encoding. Rename &#34;raws&#34; to &#34;binary&#34;. Deprecation warnings have been added to help the conversion to this new API.
16 years ago
return -1;
Byte stream to V8 decoding and encoding. This does not (should not) change behavior. Pulls those two functions (encode/decode) out into node.cc.
16 years ago
}
src: remove `node_isolate` from source fix #6899
11 years ago
return StringBytes::Size(isolate, val, encoding);
Byte stream to V8 decoding and encoding. This does not (should not) change behavior. Pulls those two functions (encode/decode) out into node.cc.
16 years ago
}
// Returns number of bytes written.
src: remove `node_isolate` from source fix #6899
11 years ago
ssize_t DecodeWrite(Isolate* isolate,
char* buf,
Fix test-http-chunked. Need to check for \0 at end of utf8 strings
15 years ago
size_t buflen,
src: remove `node_isolate` from source fix #6899
11 years ago
Handle<Value> val,
cpplint.py node.cc and node.h
16 years ago
enum encoding encoding) {
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
return StringBytes::Write(isolate, buf, buflen, val, encoding, nullptr);
Byte stream to V8 decoding and encoding. This does not (should not) change behavior. Pulls those two functions (encode/decode) out into node.cc.
16 years ago
}
node: do not print SyntaxError hints to stderr Try embedding the ` ... ^` lines inside the `SyntaxError` (or any other native error) object before giving up and printing them to the stderr. fix #6920 fix #1310
11 years ago
void AppendExceptionLine(Environment* env,
Handle<Value> er,
Handle<Message> message) {
if (message.IsEmpty())
cpplint: disallow if one-liners
11 years ago
return;
Report errors properly from --eval and stdin
13 years ago
node: do not print SyntaxError hints to stderr Try embedding the ` ... ^` lines inside the `SyntaxError` (or any other native error) object before giving up and printing them to the stderr. fix #6920 fix #1310
11 years ago
HandleScope scope(env->isolate());
Local<Object> err_obj;
if (!er.IsEmpty() && er->IsObject()) {
err_obj = er.As<Object>();
// Do it only once per message
if (!err_obj->GetHiddenValue(env->processed_string()).IsEmpty())
return;
err_obj->SetHiddenValue(env->processed_string(), True(env->isolate()));
}
src: turn two global vars into local vars Bring us a little closer to multi-isolate readiness by removing two global variables. Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt; PR-URL: https://github.com/node-forward/node/pull/58
10 years ago
char arrow[1024];
node: do not print SyntaxError hints to stderr Try embedding the ` ... ^` lines inside the `SyntaxError` (or any other native error) object before giving up and printing them to the stderr. fix #6920 fix #1310
11 years ago
// Print (filename):(line number): (message).
src: pass Isolate to node::Utf8Value constructor Initial attempt to remove all uses of Isolate::GetCurrent(). Still exists a few locations, but this works out a heavy usage. PR-URL: https://github.com/iojs/io.js/pull/244 Reviewed-by: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
node::Utf8Value filename(env->isolate(), message->GetScriptResourceName());
node: do not print SyntaxError hints to stderr Try embedding the ` ... ^` lines inside the `SyntaxError` (or any other native error) object before giving up and printing them to the stderr. fix #6920 fix #1310
11 years ago
const char* filename_string = *filename;
int linenum = message->GetLineNumber();
// Print line of source code.
src: pass Isolate to node::Utf8Value constructor Initial attempt to remove all uses of Isolate::GetCurrent(). Still exists a few locations, but this works out a heavy usage. PR-URL: https://github.com/iojs/io.js/pull/244 Reviewed-by: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
node::Utf8Value sourceline(env->isolate(), message->GetSourceLine());
node: do not print SyntaxError hints to stderr Try embedding the ` ... ^` lines inside the `SyntaxError` (or any other native error) object before giving up and printing them to the stderr. fix #6920 fix #1310
11 years ago
const char* sourceline_string = *sourceline;
// Because of how node modules work, all scripts are wrapped with a
// "function (module, exports, __filename, ...) {"
// to provide script local variables.
//
// When reporting errors on the first line of a script, this wrapper
// function is leaked to the user. There used to be a hack here to
// truncate off the first 62 characters, but it caused numerous other
// problems when vm.runIn*Context() methods were used for non-module
// code.
//
// If we ever decide to re-instate such a hack, the following steps
// must be taken:
//
// 1. Pass a flag around to say "this code was wrapped"
// 2. Update the stack frame output so that it is also correct.
//
// It would probably be simpler to add a line rather than add some
// number of characters to the first line, since V8 truncates the
// sourceline to 78 characters, and we end up not providing very much
// useful debugging info to the user if we remove 62 characters.
int start = message->GetStartColumn();
int end = message->GetEndColumn();
int off = snprintf(arrow,
sizeof(arrow),
"%s:%i\n%s\n",
filename_string,
linenum,
sourceline_string);
src: replace assert() with CHECK() Mechanically replace assert() statements with UNREACHABLE(), CHECK(), or CHECK_{EQ,NE,LT,GT,LE,GE}() statements. The exceptions are src/node.h and src/node_object_wrap.h because they are public headers. PR-URL: https://github.com/node-forward/node/pull/16 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
CHECK_GE(off, 0);
node: do not print SyntaxError hints to stderr Try embedding the ` ... ^` lines inside the `SyntaxError` (or any other native error) object before giving up and printing them to the stderr. fix #6920 fix #1310
11 years ago
// Print wavy underline (GetUnderline is deprecated).
for (int i = 0; i < start; i++) {
node: fix #7841 by overlooking the spare sourceline Signed-off-by: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
if (sourceline_string[i] == '\0' ||
static_cast<size_t>(off) >= sizeof(arrow)) {
break;
}
src: replace assert() with CHECK() Mechanically replace assert() statements with UNREACHABLE(), CHECK(), or CHECK_{EQ,NE,LT,GT,LE,GE}() statements. The exceptions are src/node.h and src/node_object_wrap.h because they are public headers. PR-URL: https://github.com/node-forward/node/pull/16 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
CHECK_LT(static_cast<size_t>(off), sizeof(arrow));
node: do not print SyntaxError hints to stderr Try embedding the ` ... ^` lines inside the `SyntaxError` (or any other native error) object before giving up and printing them to the stderr. fix #6920 fix #1310
11 years ago
arrow[off++] = (sourceline_string[i] == '\t') ? '\t' : ' ';
}
for (int i = start; i < end; i++) {
node: fix #7841 by overlooking the spare sourceline Signed-off-by: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
if (sourceline_string[i] == '\0' ||
static_cast<size_t>(off) >= sizeof(arrow)) {
break;
}
src: replace assert() with CHECK() Mechanically replace assert() statements with UNREACHABLE(), CHECK(), or CHECK_{EQ,NE,LT,GT,LE,GE}() statements. The exceptions are src/node.h and src/node_object_wrap.h because they are public headers. PR-URL: https://github.com/node-forward/node/pull/16 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
CHECK_LT(static_cast<size_t>(off), sizeof(arrow));
node: do not print SyntaxError hints to stderr Try embedding the ` ... ^` lines inside the `SyntaxError` (or any other native error) object before giving up and printing them to the stderr. fix #6920 fix #1310
11 years ago
arrow[off++] = '^';
}
src: replace assert() with CHECK() Mechanically replace assert() statements with UNREACHABLE(), CHECK(), or CHECK_{EQ,NE,LT,GT,LE,GE}() statements. The exceptions are src/node.h and src/node_object_wrap.h because they are public headers. PR-URL: https://github.com/node-forward/node/pull/16 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
CHECK_LE(static_cast<size_t>(off - 1), sizeof(arrow) - 1);
node: do not print SyntaxError hints to stderr Try embedding the ` ... ^` lines inside the `SyntaxError` (or any other native error) object before giving up and printing them to the stderr. fix #6920 fix #1310
11 years ago
arrow[off++] = '\n';
arrow[off] = '\0';
Local<String> arrow_str = String::NewFromUtf8(env->isolate(), arrow);
Local<Value> msg;
Local<Value> stack;
// Allocation failed, just print it out
if (arrow_str.IsEmpty() || err_obj.IsEmpty() || !err_obj->IsNativeError())
goto print;
msg = err_obj->Get(env->message_string());
stack = err_obj->Get(env->stack_string());
if (msg.IsEmpty() || stack.IsEmpty())
goto print;
err_obj->Set(env->message_string(),
src: pass Isolate to additional locations Due to a recent V8 upgrade, more methods require Isolate as an argument. PR-URL: https://github.com/iojs/io.js/pull/244 Reviewed-by: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
String::Concat(arrow_str, msg->ToString(env->isolate())));
node: do not print SyntaxError hints to stderr Try embedding the ` ... ^` lines inside the `SyntaxError` (or any other native error) object before giving up and printing them to the stderr. fix #6920 fix #1310
11 years ago
err_obj->Set(env->stack_string(),
src: pass Isolate to additional locations Due to a recent V8 upgrade, more methods require Isolate as an argument. PR-URL: https://github.com/iojs/io.js/pull/244 Reviewed-by: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
String::Concat(arrow_str, stack->ToString(env->isolate())));
node: do not print SyntaxError hints to stderr Try embedding the ` ... ^` lines inside the `SyntaxError` (or any other native error) object before giving up and printing them to the stderr. fix #6920 fix #1310
11 years ago
return;
print:
if (env->printed_error())
return;
env->set_printed_error(true);
Remove tty_legacy
13 years ago
uv_tty_reset_mode();
node: do not print SyntaxError hints to stderr Try embedding the ` ... ^` lines inside the `SyntaxError` (or any other native error) object before giving up and printing them to the stderr. fix #6920 fix #1310
11 years ago
fprintf(stderr, "\n%s", arrow);
Saner, yet still ugly, fix to displaying syntax errors
14 years ago
}
node: do not print SyntaxError hints to stderr Try embedding the ` ... ^` lines inside the `SyntaxError` (or any other native error) object before giving up and printing them to the stderr. fix #6920 fix #1310
11 years ago
static void ReportException(Environment* env,
Handle<Value> er,
Handle<Message> message) {
HandleScope scope(env->isolate());
Saner, yet still ugly, fix to displaying syntax errors
14 years ago
node: do not print SyntaxError hints to stderr Try embedding the ` ... ^` lines inside the `SyntaxError` (or any other native error) object before giving up and printing them to the stderr. fix #6920 fix #1310
11 years ago
AppendExceptionLine(env, er, message);
Simplify exception reporting
15 years ago
src: only access stack of defined errors Avoid segmentation fault when `undefined` is thrown
11 years ago
Local<Value> trace_value;
node: do not print SyntaxError hints to stderr Try embedding the ` ... ^` lines inside the `SyntaxError` (or any other native error) object before giving up and printing them to the stderr. fix #6920 fix #1310
11 years ago
if (er->IsUndefined() || er->IsNull())
trace_value = Undefined(env->isolate());
else
src: pass Isolate to additional locations Due to a recent V8 upgrade, more methods require Isolate as an argument. PR-URL: https://github.com/iojs/io.js/pull/244 Reviewed-by: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
trace_value = er->ToObject(env->isolate())->Get(env->stack_string());
src: only access stack of defined errors Avoid segmentation fault when `undefined` is thrown
11 years ago
src: pass Isolate to node::Utf8Value constructor Initial attempt to remove all uses of Isolate::GetCurrent(). Still exists a few locations, but this works out a heavy usage. PR-URL: https://github.com/iojs/io.js/pull/244 Reviewed-by: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
node::Utf8Value trace(env->isolate(), trace_value);
Simplify stack trace reporting using new V8 API
15 years ago
Close #974 Properly report traceless errors. Also, tests for the same.
14 years ago
// range errors have a trace member set to undefined
src: break on uncaught exception Most TryCatch blocks have SetVerbose flag on, this tells V8 to report uncaught exceptions to debugger. FatalException handler is called from V8 Message listener instead from the place where TryCatch was used. Otherwise uncaught exceptions are logged twice. See comment in `deps/v8/include/v8.h` for explanation of SetVerbose flag: &gt; By default, exceptions that are caught by an external exception &gt; handler are not reported. Call SetVerbose with true on an &gt; external exception handler to have exceptions caught by the &gt; handler reported as if they were not caught. The flag is used by `Isolate::ShouldReportException()`, which is called by `Isolate::DoThrow()` to decide whether an exception is considered uncaught.
12 years ago
if (trace.length() > 0 && !trace_value->IsUndefined()) {
Stack traces for mjsunit errors, better error reporting function. The error reporting function tries to look at the &#34;stack&#34; element of the exception.
16 years ago
fprintf(stderr, "%s\n", *trace);
Report &#34;weird&#34; errors a little better. There are a few kinds of errors that are very confusing. 1. Errors raised in nextTick 2. Errors emitted on the &#34;error&#34; event 3. RangeErrors that crash the program (or anything without a stack trace) Long traces will make make these better, of course. In the meantime, this adds a few handy signposts (in the form of better error reporting and comments on the otherwise inscrutable code printed to the terminal) that can help new users find the cause, or at least, ask for help more effectively.
14 years ago
} else {
// this really only happens for RangeErrors, since they're the only
Close #974 Properly report traceless errors. Also, tests for the same.
14 years ago
// kind that won't have all this info in the trace, or when non-Error
// objects are thrown manually.
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
Local<Value> message;
Local<Value> name;
Close #974 Properly report traceless errors. Also, tests for the same.
14 years ago
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
if (er->IsObject()) {
Local<Object> err_obj = er.As<Object>();
node: do not print SyntaxError hints to stderr Try embedding the ` ... ^` lines inside the `SyntaxError` (or any other native error) object before giving up and printing them to the stderr. fix #6920 fix #1310
11 years ago
message = err_obj->Get(env->message_string());
name = err_obj->Get(FIXED_ONE_BYTE_STRING(env->isolate(), "name"));
Close #974 Properly report traceless errors. Also, tests for the same.
14 years ago
}
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
if (message.IsEmpty() ||
message->IsUndefined() ||
name.IsEmpty() ||
name->IsUndefined()) {
// Not an error object. Just print as-is.
src: pass Isolate to node::Utf8Value constructor Initial attempt to remove all uses of Isolate::GetCurrent(). Still exists a few locations, but this works out a heavy usage. PR-URL: https://github.com/iojs/io.js/pull/244 Reviewed-by: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
node::Utf8Value message(env->isolate(), er);
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
fprintf(stderr, "%s\n", *message);
} else {
src: pass Isolate to node::Utf8Value constructor Initial attempt to remove all uses of Isolate::GetCurrent(). Still exists a few locations, but this works out a heavy usage. PR-URL: https://github.com/iojs/io.js/pull/244 Reviewed-by: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
node::Utf8Value name_string(env->isolate(), name);
node::Utf8Value message_string(env->isolate(), message);
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
fprintf(stderr, "%s: %s\n", *name_string, *message_string);
}
everything is changed. i&#39;ve waited much too long to commit. this is awful. i&#39;m sorry for being so messy.
16 years ago
}
Report &#34;weird&#34; errors a little better. There are a few kinds of errors that are very confusing. 1. Errors raised in nextTick 2. Errors emitted on the &#34;error&#34; event 3. RangeErrors that crash the program (or anything without a stack trace) Long traces will make make these better, of course. In the meantime, this adds a few handy signposts (in the form of better error reporting and comments on the otherwise inscrutable code printed to the terminal) that can help new users find the cause, or at least, ask for help more effectively.
14 years ago
Add a few fflush(stderr) calls to track down missing stacktraces.
16 years ago
fflush(stderr);
everything is changed. i&#39;ve waited much too long to commit. this is awful. i&#39;m sorry for being so messy.
16 years ago
}
src: break on uncaught exception Most TryCatch blocks have SetVerbose flag on, this tells V8 to report uncaught exceptions to debugger. FatalException handler is called from V8 Message listener instead from the place where TryCatch was used. Otherwise uncaught exceptions are logged twice. See comment in `deps/v8/include/v8.h` for explanation of SetVerbose flag: &gt; By default, exceptions that are caught by an external exception &gt; handler are not reported. Call SetVerbose with true on an &gt; external exception handler to have exceptions caught by the &gt; handler reported as if they were not caught. The flag is used by `Isolate::ShouldReportException()`, which is called by `Isolate::DoThrow()` to decide whether an exception is considered uncaught.
12 years ago
node: do not print SyntaxError hints to stderr Try embedding the ` ... ^` lines inside the `SyntaxError` (or any other native error) object before giving up and printing them to the stderr. fix #6920 fix #1310
11 years ago
static void ReportException(Environment* env, const TryCatch& try_catch) {
ReportException(env, try_catch.Exception(), try_catch.Message());
src: break on uncaught exception Most TryCatch blocks have SetVerbose flag on, this tells V8 to report uncaught exceptions to debugger. FatalException handler is called from V8 Message listener instead from the place where TryCatch was used. Otherwise uncaught exceptions are logged twice. See comment in `deps/v8/include/v8.h` for explanation of SetVerbose flag: &gt; By default, exceptions that are caught by an external exception &gt; handler are not reported. Call SetVerbose with true on an &gt; external exception handler to have exceptions caught by the &gt; handler reported as if they were not caught. The flag is used by `Isolate::ShouldReportException()`, which is called by `Isolate::DoThrow()` to decide whether an exception is considered uncaught.
12 years ago
}
cpplint.py node.cc and node.h
16 years ago
// Executes a str within the current v8 context.
node: do not print SyntaxError hints to stderr Try embedding the ` ... ^` lines inside the `SyntaxError` (or any other native error) object before giving up and printing them to the stderr. fix #6920 fix #1310
11 years ago
static Local<Value> ExecuteString(Environment* env,
Handle<String> source,
src: fix up after v8 upgrade The two biggest changes are that v8::Script::New() has been removed and that a v8::Script object now has to be explicitly bound to a context if you want to run it from another context. We can accommodate both changes without breaking the vm module&#39;s public API or even the internal JS API.
11 years ago
Handle<String> filename) {
src: update to v8 3.24 APIs
11 years ago
EscapableHandleScope scope(env->isolate());
debugging/improving the module framework
16 years ago
TryCatch try_catch;
src: break on uncaught exception Most TryCatch blocks have SetVerbose flag on, this tells V8 to report uncaught exceptions to debugger. FatalException handler is called from V8 Message listener instead from the place where TryCatch was used. Otherwise uncaught exceptions are logged twice. See comment in `deps/v8/include/v8.h` for explanation of SetVerbose flag: &gt; By default, exceptions that are caught by an external exception &gt; handler are not reported. Call SetVerbose with true on an &gt; external exception handler to have exceptions caught by the &gt; handler reported as if they were not caught. The flag is used by `Isolate::ShouldReportException()`, which is called by `Isolate::DoThrow()` to decide whether an exception is considered uncaught.
12 years ago
// try_catch must be nonverbose to disable FatalException() handler,
// we will handle exceptions ourself.
try_catch.SetVerbose(false);
Script class with eval-function-family in binding(&#39;evals&#39;) plus tests.
15 years ago
Local<v8::Script> script = v8::Script::Compile(source, filename);
everything is changed. i&#39;ve waited much too long to commit. this is awful. i&#39;m sorry for being so messy.
16 years ago
if (script.IsEmpty()) {
node: do not print SyntaxError hints to stderr Try embedding the ` ... ^` lines inside the `SyntaxError` (or any other native error) object before giving up and printing them to the stderr. fix #6920 fix #1310
11 years ago
ReportException(env, try_catch);
core: Mark exit() calls with status codes Also, exit with 128+n for signal exit n, as is The Unix Way.
12 years ago
exit(3);
everything is changed. i&#39;ve waited much too long to commit. this is awful. i&#39;m sorry for being so messy.
16 years ago
}
Reorganize the start-up process - assign &#39;GLOBAL&#39; (and now &#39;global&#39;) inside src/node.js - position for eventually allowing replacements to src/node.js for people like Kris Kowal who want the nice libev and libeio bindings but not necessarily node&#39;s choices of modules or promises.
15 years ago
Local<Value> result = script->Run();
everything is changed. i&#39;ve waited much too long to commit. this is awful. i&#39;m sorry for being so messy.
16 years ago
if (result.IsEmpty()) {
node: do not print SyntaxError hints to stderr Try embedding the ` ... ^` lines inside the `SyntaxError` (or any other native error) object before giving up and printing them to the stderr. fix #6920 fix #1310
11 years ago
ReportException(env, try_catch);
core: Mark exit() calls with status codes Also, exit with 128+n for signal exit n, as is The Unix Way.
12 years ago
exit(4);
everything is changed. i&#39;ve waited much too long to commit. this is awful. i&#39;m sorry for being so messy.
16 years ago
}
src: update to v8 3.24 APIs
11 years ago
return scope.Escape(result);
everything is changed. i&#39;ve waited much too long to commit. this is awful. i&#39;m sorry for being so messy.
16 years ago
}
Temporary function to determine str byte length Will need a better place later on
15 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
static void GetActiveRequests(const FunctionCallbackInfo<Value>& args) {
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
process: add _getActiveHandles(), _getActiveRequests() * process._getActiveHandles() returns a list containing all active handles (timers, sockets, etc.) that have not been unref&#39;d. * process._getActiveRequests() returns a list of active requests (in-flight actions like connecting to a remote host, writing data to a socket, etc.).
13 years ago
src: update to v8 3.24 APIs
11 years ago
Local<Array> ary = Array::New(args.GetIsolate());
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
QUEUE* q = nullptr;
process: add _getActiveHandles(), _getActiveRequests() * process._getActiveHandles() returns a list containing all active handles (timers, sockets, etc.) that have not been unref&#39;d. * process._getActiveRequests() returns a list of active requests (in-flight actions like connecting to a remote host, writing data to a socket, etc.).
13 years ago
int i = 0;
deps: re-implement debugger-agent Reviewed-By: Trevor Norris &lt;trevnorris@gmail.com&gt; PR-URL: https://github.com/joyent/node/pull/8476
10 years ago
QUEUE_FOREACH(q, env->req_wrap_queue()) {
src: replace CONTAINER_OF with type-safe function Replace the CONTAINER_OF macro with a template function that is as type-safe as a reinterpret_cast&lt;&gt; of an arbitrary pointer can be made. Signed-off-by: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
ReqWrap<uv_req_t>* w = ContainerOf(&ReqWrap<uv_req_t>::req_wrap_queue_, q);
cpplint: disallow if one-liners
11 years ago
if (w->persistent().IsEmpty())
continue;
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
ary->Set(i++, w->object());
process: add _getActiveHandles(), _getActiveRequests() * process._getActiveHandles() returns a list containing all active handles (timers, sockets, etc.) that have not been unref&#39;d. * process._getActiveRequests() returns a list of active requests (in-flight actions like connecting to a remote host, writing data to a socket, etc.).
13 years ago
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
args.GetReturnValue().Set(ary);
process: add _getActiveHandles(), _getActiveRequests() * process._getActiveHandles() returns a list containing all active handles (timers, sockets, etc.) that have not been unref&#39;d. * process._getActiveRequests() returns a list of active requests (in-flight actions like connecting to a remote host, writing data to a socket, etc.).
13 years ago
}
// Non-static, friend of HandleWrap. Could have been a HandleWrap method but
// implemented here for consistency with GetActiveRequests().
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void GetActiveHandles(const FunctionCallbackInfo<Value>& args) {
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
process: add _getActiveHandles(), _getActiveRequests() * process._getActiveHandles() returns a list containing all active handles (timers, sockets, etc.) that have not been unref&#39;d. * process._getActiveRequests() returns a list of active requests (in-flight actions like connecting to a remote host, writing data to a socket, etc.).
13 years ago
src: update to v8 3.24 APIs
11 years ago
Local<Array> ary = Array::New(env->isolate());
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
QUEUE* q = nullptr;
process: add _getActiveHandles(), _getActiveRequests() * process._getActiveHandles() returns a list containing all active handles (timers, sockets, etc.) that have not been unref&#39;d. * process._getActiveRequests() returns a list of active requests (in-flight actions like connecting to a remote host, writing data to a socket, etc.).
13 years ago
int i = 0;
src: remove `node_isolate` from source fix #6899
11 years ago
Local<String> owner_sym = env->owner_string();
node: make _getActiveHandles() return user objects Before this commit, process._getActiveHandles() returned a list of internal handles. Now, it returns the user objects that handles are attached to. For example, a tcp_wrap handle will now return its parent net.Socket object. It works for all handle types except timers because timer handles are shared across multiple user objects.
13 years ago
deps: re-implement debugger-agent Reviewed-By: Trevor Norris &lt;trevnorris@gmail.com&gt; PR-URL: https://github.com/joyent/node/pull/8476
10 years ago
QUEUE_FOREACH(q, env->handle_wrap_queue()) {
src: replace CONTAINER_OF with type-safe function Replace the CONTAINER_OF macro with a template function that is as type-safe as a reinterpret_cast&lt;&gt; of an arbitrary pointer can be made. Signed-off-by: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
HandleWrap* w = ContainerOf(&HandleWrap::handle_wrap_queue_, q);
cpplint: disallow if one-liners
11 years ago
if (w->persistent().IsEmpty() || (w->flags_ & HandleWrap::kUnref))
continue;
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
Local<Object> object = w->object();
Local<Value> owner = object->Get(owner_sym);
cpplint: disallow if one-liners
11 years ago
if (owner->IsUndefined())
owner = object;
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
ary->Set(i++, owner);
process: add _getActiveHandles(), _getActiveRequests() * process._getActiveHandles() returns a list containing all active handles (timers, sockets, etc.) that have not been unref&#39;d. * process._getActiveRequests() returns a list of active requests (in-flight actions like connecting to a remote host, writing data to a socket, etc.).
13 years ago
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
args.GetReturnValue().Set(ary);
process: add _getActiveHandles(), _getActiveRequests() * process._getActiveHandles() returns a list containing all active handles (timers, sockets, etc.) that have not been unref&#39;d. * process._getActiveRequests() returns a list of active requests (in-flight actions like connecting to a remote host, writing data to a socket, etc.).
13 years ago
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
static void Abort(const FunctionCallbackInfo<Value>& args) {
Add process.abort
13 years ago
abort();
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
static void Chdir(const FunctionCallbackInfo<Value>& args) {
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
Fix whitespace and warnings in node.cc
15 years ago
Added process.chdir()
15 years ago
if (args.Length() != 1 || !args[0]->IsString()) {
core: throw TypeError if chdir() args are wrong PR-URL: https://github.com/iojs/io.js/pull/274 Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
return env->ThrowTypeError("Bad argument.");
Added process.chdir()
15 years ago
}
Fix whitespace and warnings in node.cc
15 years ago
src: pass Isolate to node::Utf8Value constructor Initial attempt to remove all uses of Isolate::GetCurrent(). Still exists a few locations, but this works out a heavy usage. PR-URL: https://github.com/iojs/io.js/pull/244 Reviewed-by: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
node::Utf8Value path(args.GetIsolate(), args[0]);
src, lib: update after internal api change Libuv now returns errors directly. Make everything in src/ and lib/ follow suit. The changes to lib/ are not strictly necessary but they remove the need for the abominations that are process._errno and node::SetErrno().
12 years ago
int err = uv_chdir(*path);
if (err) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowUVException(err, "uv_chdir");
Added process.chdir()
15 years ago
}
}
Don&#39;t die when arguments are passed to process.cwd()
13 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
static void Cwd(const FunctionCallbackInfo<Value>& args) {
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
Win: make process.cwd and chdir support non-ansi characters Closes GH-2215
13 years ago
#ifdef _WIN32
/* MAX_PATH is in characters, not bytes. Make sure we have enough headroom. */
src: adapt to API change in uv_cwd
11 years ago
char buf[MAX_PATH * 4];
Win: make process.cwd and chdir support non-ansi characters Closes GH-2215
13 years ago
#else
src: adapt to API change in uv_cwd
11 years ago
char buf[PATH_MAX];
Win: make process.cwd and chdir support non-ansi characters Closes GH-2215
13 years ago
#endif
Feature: add node.cwd() to access the current working directory.
16 years ago
src: adapt to API change in uv_cwd
11 years ago
size_t cwd_len = sizeof(buf);
int err = uv_cwd(buf, &cwd_len);
src, lib: update after internal api change Libuv now returns errors directly. Make everything in src/ and lib/ follow suit. The changes to lib/ are not strictly necessary but they remove the need for the abominations that are process._errno and node::SetErrno().
12 years ago
if (err) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowUVException(err, "uv_cwd");
Feature: add node.cwd() to access the current working directory.
16 years ago
}
Coverity fixes: src/node.cc
15 years ago
src: adapt to API change in uv_cwd
11 years ago
Local<String> cwd = String::NewFromUtf8(env->isolate(),
buf,
String::kNormalString,
core: fix usage of uv_cwd It was modified in libuv to be consistent with uv_exepath and not include the trailing NULL byte in the returned size. PR-URL: https://github.com/joyent/node/pull/8566 Reviewed-by: Fedor Indutny &lt;fedor@indutny.com&gt; Reviewed-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
10 years ago
cwd_len);
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
args.GetReturnValue().Set(cwd);
Feature: add node.cwd() to access the current working directory.
16 years ago
}
Win: make process.cwd and chdir support non-ansi characters Closes GH-2215
13 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
static void Umask(const FunctionCallbackInfo<Value>& args) {
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
uint32_t old;
Support octal strings for modes This allows the various fs utilities and process.umask to be used in ECMAScript 5 Strict Mode, where the octal literal format is verboten, without requiring users to litter their code with a bunch of parseInt calls.
14 years ago
windows: fix test-umask
14 years ago
if (args.Length() < 1 || args[0]->IsUndefined()) {
Updated patch of node.cc for supporting reading of umask
15 years ago
old = umask(0);
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
umask(static_cast<mode_t>(old));
src: lint c++ code
12 years ago
} else if (!args[0]->IsInt32() && !args[0]->IsString()) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowTypeError("argument must be an integer or octal string.");
Support octal strings for modes This allows the various fs utilities and process.umask to be used in ECMAScript 5 Strict Mode, where the octal literal format is verboten, without requiring users to litter their code with a bunch of parseInt calls.
14 years ago
} else {
int oct;
src: lint c++ code
12 years ago
if (args[0]->IsInt32()) {
Support octal strings for modes This allows the various fs utilities and process.umask to be used in ECMAScript 5 Strict Mode, where the octal literal format is verboten, without requiring users to litter their code with a bunch of parseInt calls.
14 years ago
oct = args[0]->Uint32Value();
} else {
oct = 0;
src: pass Isolate to node::Utf8Value constructor Initial attempt to remove all uses of Isolate::GetCurrent(). Still exists a few locations, but this works out a heavy usage. PR-URL: https://github.com/iojs/io.js/pull/244 Reviewed-by: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
node::Utf8Value str(env->isolate(), args[0]);
Support octal strings for modes This allows the various fs utilities and process.umask to be used in ECMAScript 5 Strict Mode, where the octal literal format is verboten, without requiring users to litter their code with a bunch of parseInt calls.
14 years ago
// Parse the octal string.
Merge remote-tracking branch &#39;upstream/v0.10&#39; Conflicts: AUTHORS ChangeLog deps/v8/src/api.cc deps/v8/src/unicode-inl.h deps/v8/src/unicode.h lib/_stream_readable.js lib/http.js src/cares_wrap.cc src/node.cc src/node_crypto.cc src/node_dtrace.cc src/node_file.cc src/node_stat_watcher.cc src/node_version.h src/process_wrap.cc src/string_bytes.cc src/string_bytes.h src/udp_wrap.cc src/util.h test/simple/test-buffer.js test/simple/test-stream2-compatibility.js
11 years ago
for (size_t i = 0; i < str.length(); i++) {
Support octal strings for modes This allows the various fs utilities and process.umask to be used in ECMAScript 5 Strict Mode, where the octal literal format is verboten, without requiring users to litter their code with a bunch of parseInt calls.
14 years ago
char c = (*str)[i];
if (c > '7' || c < '0') {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowTypeError("invalid octal string");
Support octal strings for modes This allows the various fs utilities and process.umask to be used in ECMAScript 5 Strict Mode, where the octal literal format is verboten, without requiring users to litter their code with a bunch of parseInt calls.
14 years ago
}
oct *= 8;
oct += c - '0';
}
}
old = umask(static_cast<mode_t>(oct));
Updated patch of node.cc for supporting reading of umask
15 years ago
}
Support octal strings for modes This allows the various fs utilities and process.umask to be used in ECMAScript 5 Strict Mode, where the octal literal format is verboten, without requiring users to litter their code with a bunch of parseInt calls.
14 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
args.GetReturnValue().Set(old);
add process.umask()
15 years ago
}
Add process.setuid(), getuid()
15 years ago
build: add android support Resolves minor discrepancies between android and standard POSIX systems. In addition, some configure parameters were added, and a helper-script for android configuration. Ideally, this script should be merged into the standard configure script. To build for android, source the android-configure script with an NDK path: source ./android-configure ~/android-ndk-r8d This will create an android standalone toolchain and export the necessary environment parameters. After that, build as normal: make -j8 After the build, you should now have android-compatible NodeJS binaries.
12 years ago
#if defined(__POSIX__) && !defined(__ANDROID__)
windows: fix test-umask
14 years ago
process: add getgroups(), setgroups(), initgroups() DRY the getuid(), getgid(), etc. functions while we&#39;re at it.
12 years ago
static const uid_t uid_not_found = static_cast<uid_t>(-1);
static const gid_t gid_not_found = static_cast<gid_t>(-1);
static uid_t uid_by_name(const char* name) {
struct passwd pwd;
struct passwd* pp;
char buf[8192];
errno = 0;
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
pp = nullptr;
process: add getgroups(), setgroups(), initgroups() DRY the getuid(), getgid(), etc. functions while we&#39;re at it.
12 years ago
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (getpwnam_r(name, &pwd, buf, sizeof(buf), &pp) == 0 && pp != nullptr) {
process: add getgroups(), setgroups(), initgroups() DRY the getuid(), getgid(), etc. functions while we&#39;re at it.
12 years ago
return pp->pw_uid;
}
return uid_not_found;
}
static char* name_by_uid(uid_t uid) {
struct passwd pwd;
struct passwd* pp;
char buf[8192];
int rc;
errno = 0;
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
pp = nullptr;
process: add getgroups(), setgroups(), initgroups() DRY the getuid(), getgid(), etc. functions while we&#39;re at it.
12 years ago
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if ((rc = getpwuid_r(uid, &pwd, buf, sizeof(buf), &pp)) == 0 &&
pp != nullptr) {
process: add getgroups(), setgroups(), initgroups() DRY the getuid(), getgid(), etc. functions while we&#39;re at it.
12 years ago
return strdup(pp->pw_name);
}
if (rc == 0) {
errno = ENOENT;
}
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
return nullptr;
process: add getgroups(), setgroups(), initgroups() DRY the getuid(), getgid(), etc. functions while we&#39;re at it.
12 years ago
}
static gid_t gid_by_name(const char* name) {
struct group pwd;
struct group* pp;
char buf[8192];
errno = 0;
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
pp = nullptr;
process: add getgroups(), setgroups(), initgroups() DRY the getuid(), getgid(), etc. functions while we&#39;re at it.
12 years ago
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (getgrnam_r(name, &pwd, buf, sizeof(buf), &pp) == 0 && pp != nullptr) {
process: add getgroups(), setgroups(), initgroups() DRY the getuid(), getgid(), etc. functions while we&#39;re at it.
12 years ago
return pp->gr_gid;
}
return gid_not_found;
}
#if 0 // For future use.
static const char* name_by_gid(gid_t gid) {
struct group pwd;
struct group* pp;
char buf[8192];
int rc;
errno = 0;
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
pp = nullptr;
process: add getgroups(), setgroups(), initgroups() DRY the getuid(), getgid(), etc. functions while we&#39;re at it.
12 years ago
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if ((rc = getgrgid_r(gid, &pwd, buf, sizeof(buf), &pp)) == 0 &&
pp != nullptr) {
process: add getgroups(), setgroups(), initgroups() DRY the getuid(), getgid(), etc. functions while we&#39;re at it.
12 years ago
return strdup(pp->gr_name);
}
if (rc == 0) {
errno = ENOENT;
}
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
return nullptr;
process: add getgroups(), setgroups(), initgroups() DRY the getuid(), getgid(), etc. functions while we&#39;re at it.
12 years ago
}
#endif
static uid_t uid_by_name(Handle<Value> value) {
if (value->IsUint32()) {
return static_cast<uid_t>(value->Uint32Value());
} else {
src: pass Isolate to node::Utf8Value constructor Initial attempt to remove all uses of Isolate::GetCurrent(). Still exists a few locations, but this works out a heavy usage. PR-URL: https://github.com/iojs/io.js/pull/244 Reviewed-by: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
// TODO(trevnorris): Fix to not use GetCurrent().
node::Utf8Value name(Isolate::GetCurrent(), value);
process: add getgroups(), setgroups(), initgroups() DRY the getuid(), getgid(), etc. functions while we&#39;re at it.
12 years ago
return uid_by_name(*name);
}
}
static gid_t gid_by_name(Handle<Value> value) {
if (value->IsUint32()) {
return static_cast<gid_t>(value->Uint32Value());
} else {
src: pass Isolate to node::Utf8Value constructor Initial attempt to remove all uses of Isolate::GetCurrent(). Still exists a few locations, but this works out a heavy usage. PR-URL: https://github.com/iojs/io.js/pull/244 Reviewed-by: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
// TODO(trevnorris): Fix to not use GetCurrent().
node::Utf8Value name(Isolate::GetCurrent(), value);
process: add getgroups(), setgroups(), initgroups() DRY the getuid(), getgid(), etc. functions while we&#39;re at it.
12 years ago
return gid_by_name(*name);
}
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
static void GetUid(const FunctionCallbackInfo<Value>& args) {
src: fix solaris 10 build error Stop gcc from getting confused, explicitly cast the return value from getuid() and getgid() to uint32_t. Fixes the following build error: ../src/node.cc: In function &#39;void node::GetUid(const v8::FunctionCallbackInfo&lt;v8::Value&gt;&amp;)&#39;: ../src/node.cc:1552:37: error: call of overloaded &#39;Set(uid_t)&#39; is ambiguous ../src/node.cc:1552:37: note: candidates are: ../deps/v8/include/v8.h:5939:6: note: void v8::ReturnValue&lt;T&gt;::Set(bool) [with T = v8::Value] ../deps/v8/include/v8.h:5909:6: note: void v8::ReturnValue&lt;T&gt;::Set(double) [with T = v8::Value] ../deps/v8/include/v8.h:5915:6: note: void v8::ReturnValue&lt;T&gt;::Set(int32_t) [with T = v8::Value, int32_t = int] ../deps/v8/include/v8.h:5926:6: note: void v8::ReturnValue&lt;T&gt;::Set(uint32_t) [with T = v8::Value, uint32_t = unsigned int] Fixes #6182.
12 years ago
// uid_t is an uint32_t on all supported platforms.
args.GetReturnValue().Set(static_cast<uint32_t>(getuid()));
Add process.setuid(), getuid()
15 years ago
}
windows: fix test-umask
14 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
static void GetGid(const FunctionCallbackInfo<Value>& args) {
src: fix solaris 10 build error Stop gcc from getting confused, explicitly cast the return value from getuid() and getgid() to uint32_t. Fixes the following build error: ../src/node.cc: In function &#39;void node::GetUid(const v8::FunctionCallbackInfo&lt;v8::Value&gt;&amp;)&#39;: ../src/node.cc:1552:37: error: call of overloaded &#39;Set(uid_t)&#39; is ambiguous ../src/node.cc:1552:37: note: candidates are: ../deps/v8/include/v8.h:5939:6: note: void v8::ReturnValue&lt;T&gt;::Set(bool) [with T = v8::Value] ../deps/v8/include/v8.h:5909:6: note: void v8::ReturnValue&lt;T&gt;::Set(double) [with T = v8::Value] ../deps/v8/include/v8.h:5915:6: note: void v8::ReturnValue&lt;T&gt;::Set(int32_t) [with T = v8::Value, int32_t = int] ../deps/v8/include/v8.h:5926:6: note: void v8::ReturnValue&lt;T&gt;::Set(uint32_t) [with T = v8::Value, uint32_t = unsigned int] Fixes #6182.
12 years ago
// gid_t is an uint32_t on all supported platforms.
args.GetReturnValue().Set(static_cast<uint32_t>(getgid()));
Add setgid,getgid
15 years ago
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
static void SetGid(const FunctionCallbackInfo<Value>& args) {
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
Fix gcc warnings in node.cc
15 years ago
process: add getgroups(), setgroups(), initgroups() DRY the getuid(), getgid(), etc. functions while we&#39;re at it.
12 years ago
if (!args[0]->IsUint32() && !args[0]->IsString()) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowTypeError("setgid argument must be a number or a string");
Add setgid,getgid
15 years ago
}
process: add getgroups(), setgroups(), initgroups() DRY the getuid(), getgid(), etc. functions while we&#39;re at it.
12 years ago
gid_t gid = gid_by_name(args[0]);
Allow process.setuid() and process.setgid() to accept string names in lieu of numeric IDs
15 years ago
process: add getgroups(), setgroups(), initgroups() DRY the getuid(), getgid(), etc. functions while we&#39;re at it.
12 years ago
if (gid == gid_not_found) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowError("setgid group id does not exist");
Allow process.setuid() and process.setgid() to accept string names in lieu of numeric IDs
15 years ago
}
process: add getgroups(), setgroups(), initgroups() DRY the getuid(), getgid(), etc. functions while we&#39;re at it.
12 years ago
if (setgid(gid)) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowErrnoException(errno, "setgid");
Add setgid,getgid
15 years ago
}
}
Add process.setuid(), getuid()
15 years ago
windows: fix test-umask
14 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
static void SetUid(const FunctionCallbackInfo<Value>& args) {
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
Add process.setuid(), getuid()
15 years ago
process: add getgroups(), setgroups(), initgroups() DRY the getuid(), getgid(), etc. functions while we&#39;re at it.
12 years ago
if (!args[0]->IsUint32() && !args[0]->IsString()) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowTypeError("setuid argument must be a number or a string");
Add process.setuid(), getuid()
15 years ago
}
process: add getgroups(), setgroups(), initgroups() DRY the getuid(), getgid(), etc. functions while we&#39;re at it.
12 years ago
uid_t uid = uid_by_name(args[0]);
Allow process.setuid() and process.setgid() to accept string names in lieu of numeric IDs
15 years ago
process: add getgroups(), setgroups(), initgroups() DRY the getuid(), getgid(), etc. functions while we&#39;re at it.
12 years ago
if (uid == uid_not_found) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowError("setuid user id does not exist");
process: add getgroups(), setgroups(), initgroups() DRY the getuid(), getgid(), etc. functions while we&#39;re at it.
12 years ago
}
if (setuid(uid)) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowErrnoException(errno, "setuid");
process: add getgroups(), setgroups(), initgroups() DRY the getuid(), getgid(), etc. functions while we&#39;re at it.
12 years ago
}
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
static void GetGroups(const FunctionCallbackInfo<Value>& args) {
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
process: add getgroups(), setgroups(), initgroups() DRY the getuid(), getgid(), etc. functions while we&#39;re at it.
12 years ago
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
int ngroups = getgroups(0, nullptr);
process: add getgroups(), setgroups(), initgroups() DRY the getuid(), getgid(), etc. functions while we&#39;re at it.
12 years ago
if (ngroups == -1) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowErrnoException(errno, "getgroups");
process: add getgroups(), setgroups(), initgroups() DRY the getuid(), getgid(), etc. functions while we&#39;re at it.
12 years ago
}
gid_t* groups = new gid_t[ngroups];
ngroups = getgroups(ngroups, groups);
if (ngroups == -1) {
delete[] groups;
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowErrnoException(errno, "getgroups");
process: add getgroups(), setgroups(), initgroups() DRY the getuid(), getgid(), etc. functions while we&#39;re at it.
12 years ago
}
src: update to v8 3.24 APIs
11 years ago
Local<Array> groups_list = Array::New(env->isolate(), ngroups);
process: add getgroups(), setgroups(), initgroups() DRY the getuid(), getgid(), etc. functions while we&#39;re at it.
12 years ago
bool seen_egid = false;
gid_t egid = getegid();
for (int i = 0; i < ngroups; i++) {
src: update to v8 3.24 APIs
11 years ago
groups_list->Set(i, Integer::New(env->isolate(), groups[i]));
cpplint: disallow if one-liners
11 years ago
if (groups[i] == egid)
seen_egid = true;
process: add getgroups(), setgroups(), initgroups() DRY the getuid(), getgid(), etc. functions while we&#39;re at it.
12 years ago
}
delete[] groups;
if (seen_egid == false) {
src: update to v8 3.24 APIs
11 years ago
groups_list->Set(ngroups, Integer::New(env->isolate(), egid));
process: add getgroups(), setgroups(), initgroups() DRY the getuid(), getgid(), etc. functions while we&#39;re at it.
12 years ago
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
args.GetReturnValue().Set(groups_list);
process: add getgroups(), setgroups(), initgroups() DRY the getuid(), getgid(), etc. functions while we&#39;re at it.
12 years ago
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
static void SetGroups(const FunctionCallbackInfo<Value>& args) {
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
process: add getgroups(), setgroups(), initgroups() DRY the getuid(), getgid(), etc. functions while we&#39;re at it.
12 years ago
if (!args[0]->IsArray()) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowTypeError("argument 1 must be an array");
process: add getgroups(), setgroups(), initgroups() DRY the getuid(), getgid(), etc. functions while we&#39;re at it.
12 years ago
}
Local<Array> groups_list = args[0].As<Array>();
size_t size = groups_list->Length();
gid_t* groups = new gid_t[size];
for (size_t i = 0; i < size; i++) {
gid_t gid = gid_by_name(groups_list->Get(i));
if (gid == gid_not_found) {
delete[] groups;
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowError("group name not found");
Allow process.setuid() and process.setgid() to accept string names in lieu of numeric IDs
15 years ago
}
process: add getgroups(), setgroups(), initgroups() DRY the getuid(), getgid(), etc. functions while we&#39;re at it.
12 years ago
groups[i] = gid;
Allow process.setuid() and process.setgid() to accept string names in lieu of numeric IDs
15 years ago
}
process: add getgroups(), setgroups(), initgroups() DRY the getuid(), getgid(), etc. functions while we&#39;re at it.
12 years ago
int rc = setgroups(size, groups);
delete[] groups;
if (rc == -1) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowErrnoException(errno, "setgroups");
Add process.setuid(), getuid()
15 years ago
}
}
windows: fix test-umask
14 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
static void InitGroups(const FunctionCallbackInfo<Value>& args) {
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
process: add getgroups(), setgroups(), initgroups() DRY the getuid(), getgid(), etc. functions while we&#39;re at it.
12 years ago
if (!args[0]->IsUint32() && !args[0]->IsString()) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowTypeError("argument 1 must be a number or a string");
process: add getgroups(), setgroups(), initgroups() DRY the getuid(), getgid(), etc. functions while we&#39;re at it.
12 years ago
}
if (!args[1]->IsUint32() && !args[1]->IsString()) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowTypeError("argument 2 must be a number or a string");
process: add getgroups(), setgroups(), initgroups() DRY the getuid(), getgid(), etc. functions while we&#39;re at it.
12 years ago
}
src: pass Isolate to node::Utf8Value constructor Initial attempt to remove all uses of Isolate::GetCurrent(). Still exists a few locations, but this works out a heavy usage. PR-URL: https://github.com/iojs/io.js/pull/244 Reviewed-by: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
node::Utf8Value arg0(env->isolate(), args[0]);
process: add getgroups(), setgroups(), initgroups() DRY the getuid(), getgid(), etc. functions while we&#39;re at it.
12 years ago
gid_t extra_group;
bool must_free;
char* user;
if (args[0]->IsUint32()) {
user = name_by_uid(args[0]->Uint32Value());
must_free = true;
} else {
user = *arg0;
must_free = false;
}
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (user == nullptr) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowError("initgroups user not found");
process: add getgroups(), setgroups(), initgroups() DRY the getuid(), getgid(), etc. functions while we&#39;re at it.
12 years ago
}
extra_group = gid_by_name(args[1]);
if (extra_group == gid_not_found) {
cpplint: disallow if one-liners
11 years ago
if (must_free)
free(user);
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowError("initgroups extra group not found");
process: add getgroups(), setgroups(), initgroups() DRY the getuid(), getgid(), etc. functions while we&#39;re at it.
12 years ago
}
int rc = initgroups(user, extra_group);
if (must_free) {
free(user);
}
if (rc) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowErrnoException(errno, "initgroups");
process: add getgroups(), setgroups(), initgroups() DRY the getuid(), getgid(), etc. functions while we&#39;re at it.
12 years ago
}
}
src: lint c++ code
12 years ago
#endif // __POSIX__ && !defined(__ANDROID__)
Disable node.cc functions that are not supported on windows
14 years ago
Add process.setuid(), getuid()
15 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void Exit(const FunctionCallbackInfo<Value>& args) {
src: fix VC++ warning C4244 Reviewed-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
10 years ago
exit(args[0]->Int32Value());
remove process.{cc,h} process.exit() now exit() the process object might return in the future but for now it is going away.
16 years ago
}
Change GC idle notify so that it runs along side setInterval Doesn&#39;t appear any slower. Also checks for high memory usage and tries to force more notifications.
15 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
static void Uptime(const FunctionCallbackInfo<Value>& args) {
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
Remove platform files, and use uv platform api
13 years ago
double uptime;
Add process.uptime().
14 years ago
deps: re-implement debugger-agent Reviewed-By: Trevor Norris &lt;trevnorris@gmail.com&gt; PR-URL: https://github.com/joyent/node/pull/8476
10 years ago
uv_update_time(env->event_loop());
uptime = uv_now(env->event_loop()) - prog_start_time;
Add process.uptime().
14 years ago
Merge remote-tracking branch &#39;upstream/v0.10&#39; Reverted 9520adeb37f5ebe02a68669ec97770f4869705bb Conflicts: deps/cares/src/ares_parse_txt_reply.c deps/uv/.mailmap deps/uv/AUTHORS deps/uv/ChangeLog deps/uv/include/uv.h deps/uv/src/unix/error.c deps/uv/src/unix/process.c deps/uv/src/version.c deps/uv/src/win/pipe.c deps/uv/src/win/signal.c deps/uv/src/win/util.c deps/uv/test/test-spawn.c deps/uv/vcbuild.bat deps/v8/src/platform-posix.cc deps/v8/tools/gyp/v8.gyp lib/util.js src/node.cc test/simple/test-util-format.js test/simple/test-util.js
11 years ago
args.GetReturnValue().Set(Number::New(env->isolate(), uptime / 1000));
Add process.uptime().
14 years ago
}
Change GC idle notify so that it runs along side setInterval Doesn&#39;t appear any slower. Also checks for high memory usage and tries to force more notifications.
15 years ago
Add process.uvCounters() for debugging
13 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void MemoryUsage(const FunctionCallbackInfo<Value>& args) {
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
Move memoryUsage() into C on Linux
15 years ago
Remove process.memoryUsage().vsize Not meaningful cross platform; unused.
13 years ago
size_t rss;
src, lib: update after internal api change Libuv now returns errors directly. Make everything in src/ and lib/ follow suit. The changes to lib/ are not strictly necessary but they remove the need for the abominations that are process._errno and node::SetErrno().
12 years ago
int err = uv_resident_set_memory(&rss);
if (err) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowUVException(err, "uv_resident_set_memory");
Add sys.memoryUsage()
15 years ago
}
Add V8 heap info to process.memoryUsage()
15 years ago
// V8 memory usage
HeapStatistics v8_heap_stats;
src: remove `node_isolate` from source fix #6899
11 years ago
env->isolate()->GetHeapStatistics(&v8_heap_stats);
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
Local<Integer> heap_total =
src: update to v8 3.24 APIs
11 years ago
Integer::NewFromUnsigned(env->isolate(), v8_heap_stats.total_heap_size());
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
Local<Integer> heap_used =
src: update to v8 3.24 APIs
11 years ago
Integer::NewFromUnsigned(env->isolate(), v8_heap_stats.used_heap_size());
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
src: update to v8 3.24 APIs
11 years ago
Local<Object> info = Object::New(env->isolate());
src: remove `node_isolate` from source fix #6899
11 years ago
info->Set(env->rss_string(), Number::New(env->isolate(), rss));
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
info->Set(env->heap_total_string(), heap_total);
info->Set(env->heap_used_string(), heap_used);
Add V8 heap info to process.memoryUsage()
15 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
args.GetReturnValue().Set(info);
Add sys.memoryUsage()
15 years ago
}
Move memoryUsage() into C on Linux
15 years ago
Fix whitespace errors introduced by porting efforts
14 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void Kill(const FunctionCallbackInfo<Value>& args) {
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
Fix whitespace and warnings in node.cc
15 years ago
process.kill coerces args to integers
14 years ago
if (args.Length() != 2) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowError("Bad argument.");
Added external interface for signal handlers. Also process.pid and node.kill().
15 years ago
}
Fix whitespace and warnings in node.cc
15 years ago
src: fix VC++ warning C4244 Reviewed-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
10 years ago
int pid = args[0]->Int32Value();
Move constants out of process object
15 years ago
int sig = args[1]->Int32Value();
src, lib: update after internal api change Libuv now returns errors directly. Make everything in src/ and lib/ follow suit. The changes to lib/ are not strictly necessary but they remove the need for the abominations that are process._errno and node::SetErrno().
12 years ago
int err = uv_kill(pid, sig);
args.GetReturnValue().Set(err);
Added external interface for signal handlers. Also process.pid and node.kill().
15 years ago
}
process: add `process.hrtime()` This commit adds a high-resolution timer function.
13 years ago
// used in Hrtime() below
#define NANOS_PER_SEC 1000000000
// Hrtime exposes libuv's uv_hrtime() high-resolution timer.
// The value returned by uv_hrtime() is a 64-bit int representing nanoseconds,
// so this function instead returns an Array with 2 entries representing seconds
// and nanoseconds, to avoid any integer overflow possibility.
// Pass in an Array from a previous hrtime() call to instead get a time diff.
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void Hrtime(const FunctionCallbackInfo<Value>& args) {
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
process: add `process.hrtime()` This commit adds a high-resolution timer function.
13 years ago
uint64_t t = uv_hrtime();
if (args.Length() > 0) {
// return a time diff tuple
process: throw a TypeError when anything but an Array is passed to hrtime() Fixes #3664.
13 years ago
if (!args[0]->IsArray()) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowTypeError(
"process.hrtime() only accepts an Array tuple.");
process: throw a TypeError when anything but an Array is passed to hrtime() Fixes #3664.
13 years ago
}
process: add `process.hrtime()` This commit adds a high-resolution timer function.
13 years ago
Local<Array> inArray = Local<Array>::Cast(args[0]);
uint64_t seconds = inArray->Get(0)->Uint32Value();
uint64_t nanos = inArray->Get(1)->Uint32Value();
t -= (seconds * NANOS_PER_SEC) + nanos;
}
src: update to v8 3.24 APIs
11 years ago
Local<Array> tuple = Array::New(env->isolate(), 2);
tuple->Set(0, Integer::NewFromUnsigned(env->isolate(), t / NANOS_PER_SEC));
tuple->Set(1, Integer::NewFromUnsigned(env->isolate(), t % NANOS_PER_SEC));
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
args.GetReturnValue().Set(tuple);
process: add `process.hrtime()` This commit adds a high-resolution timer function.
13 years ago
}
node: register modules from DSO constructors Built-in modules should be automatically registered, replacing the static module list. Add-on modules should also be automatically registered via DSO constructors. This improves flexibility in adding built-in modules and is also a prerequisite to pure-C addon modules.
11 years ago
extern "C" void node_module_register(void* m) {
struct node_module* mp = reinterpret_cast<struct node_module*>(m);
if (mp->nm_flags & NM_F_BUILTIN) {
mp->nm_link = modlist_builtin;
modlist_builtin = mp;
modules: adding load linked modules feature - introduced NM_F_LINKED flag to identify linked modules - setting node_is_initialized after calling V8::Initialize in order to make the right decision during initial module registration - introduced modlist_linked in order to track modules that were pre-registered in order to complete it once node is initialized - completing registration of linked module similarly to the way it&#39;s done inside DLOpen PR-URL: https://github.com/iojs/io.js/pull/8 Reviewed-by: Trevor Norris &lt;trev.norris@gmail.com&gt; Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
} else if (!node_is_initialized) {
// "Linked" modules are included as part of the node project.
// Like builtins they are registered *before* node::Init runs.
mp->nm_flags = NM_F_LINKED;
mp->nm_link = modlist_linked;
modlist_linked = mp;
node: register modules from DSO constructors Built-in modules should be automatically registered, replacing the static module list. Add-on modules should also be automatically registered via DSO constructors. This improves flexibility in adding built-in modules and is also a prerequisite to pure-C addon modules.
11 years ago
} else {
modpending = mp;
}
}
struct node_module* get_builtin_module(const char* name) {
struct node_module* mp;
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
for (mp = modlist_builtin; mp != nullptr; mp = mp->nm_link) {
node: register modules from DSO constructors Built-in modules should be automatically registered, replacing the static module list. Add-on modules should also be automatically registered via DSO constructors. This improves flexibility in adding built-in modules and is also a prerequisite to pure-C addon modules.
11 years ago
if (strcmp(mp->nm_modname, name) == 0)
break;
}
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
CHECK(mp == nullptr || (mp->nm_flags & NM_F_BUILTIN) != 0);
node: register modules from DSO constructors Built-in modules should be automatically registered, replacing the static module list. Add-on modules should also be automatically registered via DSO constructors. This improves flexibility in adding built-in modules and is also a prerequisite to pure-C addon modules.
11 years ago
return (mp);
}
Move constants out of process object
15 years ago
modules: adding load linked modules feature - introduced NM_F_LINKED flag to identify linked modules - setting node_is_initialized after calling V8::Initialize in order to make the right decision during initial module registration - introduced modlist_linked in order to track modules that were pre-registered in order to complete it once node is initialized - completing registration of linked module similarly to the way it&#39;s done inside DLOpen PR-URL: https://github.com/iojs/io.js/pull/8 Reviewed-by: Trevor Norris &lt;trev.norris@gmail.com&gt; Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
struct node_module* get_linked_module(const char* name) {
struct node_module* mp;
node.cc: use nullptr instead of NULL PR-URL: https://github.com/iojs/io.js/pull/124 Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
for (mp = modlist_linked; mp != nullptr; mp = mp->nm_link) {
modules: adding load linked modules feature - introduced NM_F_LINKED flag to identify linked modules - setting node_is_initialized after calling V8::Initialize in order to make the right decision during initial module registration - introduced modlist_linked in order to track modules that were pre-registered in order to complete it once node is initialized - completing registration of linked module similarly to the way it&#39;s done inside DLOpen PR-URL: https://github.com/iojs/io.js/pull/8 Reviewed-by: Trevor Norris &lt;trev.norris@gmail.com&gt; Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
if (strcmp(mp->nm_modname, name) == 0)
break;
}
node.cc: use nullptr instead of NULL PR-URL: https://github.com/iojs/io.js/pull/124 Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
CHECK(mp == nullptr || (mp->nm_flags & NM_F_LINKED) != 0);
modules: adding load linked modules feature - introduced NM_F_LINKED flag to identify linked modules - setting node_is_initialized after calling V8::Initialize in order to make the right decision during initial module registration - introduced modlist_linked in order to track modules that were pre-registered in order to complete it once node is initialized - completing registration of linked module similarly to the way it&#39;s done inside DLOpen PR-URL: https://github.com/iojs/io.js/pull/8 Reviewed-by: Trevor Norris &lt;trev.norris@gmail.com&gt; Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
return mp;
}
Make node::DLOpen use uv_dlopen
13 years ago
typedef void (UV_DYNAMIC* extInit)(Handle<Object> exports);
First attempt at node.dlopen Compiled first working &#39;hello world&#39; module with this config
16 years ago
addon: Pass module object to NODE_MODULE init function mainly to allow native addons to export single functions on rather than being restricted to operating on an existing object. Init functions now receive exports as the first argument, like before, but also the module object as the second argument, if they support it. Related to #4634 cc: @rvagg
12 years ago
// DLOpen is process.dlopen(module, filename).
// Used to load 'module.node' dynamically shared objects.
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
//
// FIXME(bnoordhuis) Not multi-context ready. TBD how to resolve the conflict
// when two contexts try to load the same shared object. Maybe have a shadow
// cache that's a plain C list or hash table that's shared across contexts?
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void DLOpen(const FunctionCallbackInfo<Value>& args) {
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
Make node::DLOpen use uv_dlopen
13 years ago
uv_lib_t lib;
First attempt at node.dlopen Compiled first working &#39;hello world&#39; module with this config
16 years ago
src: fix addon loader regression Fix a regression that was introduced in commit a38b9178 by removing the bad check. Also rearrange the addon loading logic to ensure that the list of pending addons remains in a consistent state when the shared object fails to load; in particular, when an addon self-registers first, then hits a dynamic linker error in a later constructor. Fixes the following asserting when loading a .node shared object: node: ../src/node.cc:1944: void node::node_module_register(void*): Assertion `(modpending) != (nullptr)&#39; failed. Fixes strongloop/strongops#233. PR-URL: https://github.com/iojs/io.js/pull/154 Reviewed-By: Ryan Graham &lt;ryan@strongloop.com&gt;
10 years ago
CHECK_EQ(modpending, nullptr);
Make node::DLOpen use uv_dlopen
13 years ago
if (args.Length() < 2) {
src: remove `node_isolate` from source fix #6899
11 years ago
env->ThrowError("process.dlopen takes exactly 2 arguments.");
node: register modules from DSO constructors Built-in modules should be automatically registered, replacing the static module list. Add-on modules should also be automatically registered via DSO constructors. This improves flexibility in adding built-in modules and is also a prerequisite to pure-C addon modules.
11 years ago
return;
Make node::DLOpen use uv_dlopen
13 years ago
}
Build static executable. - Fix a few errors with node.dlopen() - Report errors to stderr (this should probably be a separate commit, but whatever)
16 years ago
src: pass Isolate to additional locations Due to a recent V8 upgrade, more methods require Isolate as an argument. PR-URL: https://github.com/iojs/io.js/pull/244 Reviewed-by: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
Local<Object> module = args[0]->ToObject(env->isolate()); // Cast
src: pass Isolate to node::Utf8Value constructor Initial attempt to remove all uses of Isolate::GetCurrent(). Still exists a few locations, but this works out a heavy usage. PR-URL: https://github.com/iojs/io.js/pull/244 Reviewed-by: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
node::Utf8Value filename(env->isolate(), args[1]); // Cast
src: fix addon loader regression Fix a regression that was introduced in commit a38b9178 by removing the bad check. Also rearrange the addon loading logic to ensure that the list of pending addons remains in a consistent state when the shared object fails to load; in particular, when an addon self-registers first, then hits a dynamic linker error in a later constructor. Fixes the following asserting when loading a .node shared object: node: ../src/node.cc:1944: void node::node_module_register(void*): Assertion `(modpending) != (nullptr)&#39; failed. Fixes strongloop/strongops#233. PR-URL: https://github.com/iojs/io.js/pull/154 Reviewed-By: Ryan Graham &lt;ryan@strongloop.com&gt;
10 years ago
const bool is_dlopen_error = uv_dlopen(*filename, &lib);
addon: Pass module object to NODE_MODULE init function mainly to allow native addons to export single functions on rather than being restricted to operating on an existing object. Init functions now receive exports as the first argument, like before, but also the module object as the second argument, if they support it. Related to #4634 cc: @rvagg
12 years ago
src: fix addon loader regression Fix a regression that was introduced in commit a38b9178 by removing the bad check. Also rearrange the addon loading logic to ensure that the list of pending addons remains in a consistent state when the shared object fails to load; in particular, when an addon self-registers first, then hits a dynamic linker error in a later constructor. Fixes the following asserting when loading a .node shared object: node: ../src/node.cc:1944: void node::node_module_register(void*): Assertion `(modpending) != (nullptr)&#39; failed. Fixes strongloop/strongops#233. PR-URL: https://github.com/iojs/io.js/pull/154 Reviewed-By: Ryan Graham &lt;ryan@strongloop.com&gt;
10 years ago
// Objects containing v14 or later modules will have registered themselves
// on the pending list. Activate all of them now. At present, only one
// module per object is supported.
node_module* const mp = modpending;
modpending = nullptr;
First attempt at node.dlopen Compiled first working &#39;hello world&#39; module with this config
16 years ago
src: fix addon loader regression Fix a regression that was introduced in commit a38b9178 by removing the bad check. Also rearrange the addon loading logic to ensure that the list of pending addons remains in a consistent state when the shared object fails to load; in particular, when an addon self-registers first, then hits a dynamic linker error in a later constructor. Fixes the following asserting when loading a .node shared object: node: ../src/node.cc:1944: void node::node_module_register(void*): Assertion `(modpending) != (nullptr)&#39; failed. Fixes strongloop/strongops#233. PR-URL: https://github.com/iojs/io.js/pull/154 Reviewed-By: Ryan Graham &lt;ryan@strongloop.com&gt;
10 years ago
if (is_dlopen_error) {
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
Local<String> errmsg = OneByteString(env->isolate(), uv_dlerror(&lib));
deps: upgrade libuv to a478847 The event loop&#39;s reference counting scheme in this version of libuv has changed. Update the libuv bindings to reflect that fact.
13 years ago
#ifdef _WIN32
// Windows needs to add the filename into the error message
src: pass Isolate to additional locations Due to a recent V8 upgrade, more methods require Isolate as an argument. PR-URL: https://github.com/iojs/io.js/pull/244 Reviewed-by: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
errmsg = String::Concat(errmsg, args[1]->ToString(env->isolate()));
src: lint c++ code
12 years ago
#endif // _WIN32
src: remove `node_isolate` from source fix #6899
11 years ago
env->isolate()->ThrowException(Exception::Error(errmsg));
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
return;
First attempt at node.dlopen Compiled first working &#39;hello world&#39; module with this config
16 years ago
}
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (mp == nullptr) {
src: remove `node_isolate` from source fix #6899
11 years ago
env->ThrowError("Module did not self-register.");
node: register modules from DSO constructors Built-in modules should be automatically registered, replacing the static module list. Add-on modules should also be automatically registered via DSO constructors. This improves flexibility in adding built-in modules and is also a prerequisite to pure-C addon modules.
11 years ago
return;
Add support for the module structure to process.dlopen.
15 years ago
}
node: register modules from DSO constructors Built-in modules should be automatically registered, replacing the static module list. Add-on modules should also be automatically registered via DSO constructors. This improves flexibility in adding built-in modules and is also a prerequisite to pure-C addon modules.
11 years ago
if (mp->nm_version != NODE_MODULE_VERSION) {
node: don&#39;t scan add-on for &#34;init&#34; symbol From this commit onwards, use of the NODE_MODULE macro is mandatory. This lets node guard against modules that are ABI incompatible.
13 years ago
char errmsg[1024];
snprintf(errmsg,
sizeof(errmsg),
"Module version mismatch. Expected %d, got %d.",
node: register modules from DSO constructors Built-in modules should be automatically registered, replacing the static module list. Add-on modules should also be automatically registered via DSO constructors. This improves flexibility in adding built-in modules and is also a prerequisite to pure-C addon modules.
11 years ago
NODE_MODULE_VERSION, mp->nm_version);
src: remove `node_isolate` from source fix #6899
11 years ago
env->ThrowError(errmsg);
node: register modules from DSO constructors Built-in modules should be automatically registered, replacing the static module list. Add-on modules should also be automatically registered via DSO constructors. This improves flexibility in adding built-in modules and is also a prerequisite to pure-C addon modules.
11 years ago
return;
First attempt at node.dlopen Compiled first working &#39;hello world&#39; module with this config
16 years ago
}
node: register modules from DSO constructors Built-in modules should be automatically registered, replacing the static module list. Add-on modules should also be automatically registered via DSO constructors. This improves flexibility in adding built-in modules and is also a prerequisite to pure-C addon modules.
11 years ago
if (mp->nm_flags & NM_F_BUILTIN) {
src: remove `node_isolate` from source fix #6899
11 years ago
env->ThrowError("Built-in module self-registered.");
node: register modules from DSO constructors Built-in modules should be automatically registered, replacing the static module list. Add-on modules should also be automatically registered via DSO constructors. This improves flexibility in adding built-in modules and is also a prerequisite to pure-C addon modules.
11 years ago
return;
}
mp->nm_dso_handle = lib.handle;
mp->nm_link = modlist_addon;
modlist_addon = mp;
First attempt at node.dlopen Compiled first working &#39;hello world&#39; module with this config
16 years ago
src: fix addon loader regression Fix a regression that was introduced in commit a38b9178 by removing the bad check. Also rearrange the addon loading logic to ensure that the list of pending addons remains in a consistent state when the shared object fails to load; in particular, when an addon self-registers first, then hits a dynamic linker error in a later constructor. Fixes the following asserting when loading a .node shared object: node: ../src/node.cc:1944: void node::node_module_register(void*): Assertion `(modpending) != (nullptr)&#39; failed. Fixes strongloop/strongops#233. PR-URL: https://github.com/iojs/io.js/pull/154 Reviewed-By: Ryan Graham &lt;ryan@strongloop.com&gt;
10 years ago
Local<String> exports_string = env->exports_string();
src: pass Isolate to additional locations Due to a recent V8 upgrade, more methods require Isolate as an argument. PR-URL: https://github.com/iojs/io.js/pull/244 Reviewed-by: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
Local<Object> exports = module->Get(exports_string)->ToObject(env->isolate());
src: fix addon loader regression Fix a regression that was introduced in commit a38b9178 by removing the bad check. Also rearrange the addon loading logic to ensure that the list of pending addons remains in a consistent state when the shared object fails to load; in particular, when an addon self-registers first, then hits a dynamic linker error in a later constructor. Fixes the following asserting when loading a .node shared object: node: ../src/node.cc:1944: void node::node_module_register(void*): Assertion `(modpending) != (nullptr)&#39; failed. Fixes strongloop/strongops#233. PR-URL: https://github.com/iojs/io.js/pull/154 Reviewed-By: Ryan Graham &lt;ryan@strongloop.com&gt;
10 years ago
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (mp->nm_context_register_func != nullptr) {
node: register modules from DSO constructors Built-in modules should be automatically registered, replacing the static module list. Add-on modules should also be automatically registered via DSO constructors. This improves flexibility in adding built-in modules and is also a prerequisite to pure-C addon modules.
11 years ago
mp->nm_context_register_func(exports, module, env->context(), mp->nm_priv);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
} else if (mp->nm_register_func != nullptr) {
node: register modules from DSO constructors Built-in modules should be automatically registered, replacing the static module list. Add-on modules should also be automatically registered via DSO constructors. This improves flexibility in adding built-in modules and is also a prerequisite to pure-C addon modules.
11 years ago
mp->nm_register_func(exports, module, mp->nm_priv);
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
} else {
src: remove `node_isolate` from source fix #6899
11 years ago
env->ThrowError("Module has no declared entry point.");
node: register modules from DSO constructors Built-in modules should be automatically registered, replacing the static module list. Add-on modules should also be automatically registered via DSO constructors. This improves flexibility in adding built-in modules and is also a prerequisite to pure-C addon modules.
11 years ago
return;
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
}
First attempt at node.dlopen Compiled first working &#39;hello world&#39; module with this config
16 years ago
Coverity fixes: src/node.cc
15 years ago
// Tell coverity that 'handle' should not be freed when we return.
// coverity[leaked_storage]
First attempt at node.dlopen Compiled first working &#39;hello world&#39; module with this config
16 years ago
}
Initial implementation of process.evalcx
15 years ago
cpplint.py node.cc and node.h
16 years ago
static void OnFatalError(const char* location, const char* message) {
Simplify exception reporting
15 years ago
if (location) {
fprintf(stderr, "FATAL ERROR: %s %s\n", location, message);
} else {
fprintf(stderr, "FATAL ERROR: %s\n", message);
}
src: abort() on fatal error in debug mode abort() generates a nice core dump and makes it easy to catch fatal errors in one&#39;s debugger of choice.
12 years ago
fflush(stderr);
abort();
exit program on top level exceptions (also lots of reorg.)
16 years ago
}
src: break on uncaught exception Most TryCatch blocks have SetVerbose flag on, this tells V8 to report uncaught exceptions to debugger. FatalException handler is called from V8 Message listener instead from the place where TryCatch was used. Otherwise uncaught exceptions are logged twice. See comment in `deps/v8/include/v8.h` for explanation of SetVerbose flag: &gt; By default, exceptions that are caught by an external exception &gt; handler are not reported. Call SetVerbose with true on an &gt; external exception handler to have exceptions caught by the &gt; handler reported as if they were not caught. The flag is used by `Isolate::ShouldReportException()`, which is called by `Isolate::DoThrow()` to decide whether an exception is considered uncaught.
12 years ago
smalloc: use malloc instead of new To use realloc the implementation had to be changed to use malloc/free.
12 years ago
NO_RETURN void FatalError(const char* location, const char* message) {
OnFatalError(location, message);
// to supress compiler warning
abort();
}
src: remove `node_isolate` from source fix #6899
11 years ago
void FatalException(Isolate* isolate,
Handle<Value> error,
Handle<Message> message) {
HandleScope scope(isolate);
Implement process &#34;uncaughtException&#34; event This event can be used to overwrite the default exception mechanism which reports the exception and kills the node process. See google group post: http://groups.google.com/group/nodejs/browse_thread/thread/9721dc3a2638446f
15 years ago
src: remove `node_isolate` from source fix #6899
11 years ago
Environment* env = Environment::GetCurrent(isolate);
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
Local<Object> process_object = env->process_object();
Local<String> fatal_exception_string = env->fatal_exception_string();
Local<Function> fatal_exception_function =
process_object->Get(fatal_exception_string).As<Function>();
Implement process &#34;uncaughtException&#34; event This event can be used to overwrite the default exception mechanism which reports the exception and kills the node process. See google group post: http://groups.google.com/group/nodejs/browse_thread/thread/9721dc3a2638446f
15 years ago
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
if (!fatal_exception_function->IsFunction()) {
domain: Do not use uncaughtException handler This adds a process._fatalException method which is called into from C++ in order to either emit the &#39;uncaughtException&#39; method, or emit &#39;error&#39; on the active domain. The &#39;uncaughtException&#39; event is an implementation detail that it would be nice to deprecate one day, so exposing it as part of the domain machinery is not ideal. Fix #4375
12 years ago
// failed before the process._fatalException function was added!
// this is probably pretty bad. Nothing to do but report and exit.
node: do not print SyntaxError hints to stderr Try embedding the ` ... ^` lines inside the `SyntaxError` (or any other native error) object before giving up and printing them to the stderr. fix #6920 fix #1310
11 years ago
ReportException(env, error, message);
core: Mark exit() calls with status codes Also, exit with 128+n for signal exit n, as is The Unix Way.
12 years ago
exit(6);
Implement process &#34;uncaughtException&#34; event This event can be used to overwrite the default exception mechanism which reports the exception and kills the node process. See google group post: http://groups.google.com/group/nodejs/browse_thread/thread/9721dc3a2638446f
15 years ago
}
domain: Do not use uncaughtException handler This adds a process._fatalException method which is called into from C++ in order to either emit the &#39;uncaughtException&#39; method, or emit &#39;error&#39; on the active domain. The &#39;uncaughtException&#39; event is an implementation detail that it would be nice to deprecate one day, so exposing it as part of the domain machinery is not ideal. Fix #4375
12 years ago
TryCatch fatal_try_catch;
Merge remote-tracking branch &#39;ry/v0.6&#39; into v0.6-merge Conflicts: Makefile lib/zlib.js src/node.cc src/node.js
13 years ago
src: break on uncaught exception Most TryCatch blocks have SetVerbose flag on, this tells V8 to report uncaught exceptions to debugger. FatalException handler is called from V8 Message listener instead from the place where TryCatch was used. Otherwise uncaught exceptions are logged twice. See comment in `deps/v8/include/v8.h` for explanation of SetVerbose flag: &gt; By default, exceptions that are caught by an external exception &gt; handler are not reported. Call SetVerbose with true on an &gt; external exception handler to have exceptions caught by the &gt; handler reported as if they were not caught. The flag is used by `Isolate::ShouldReportException()`, which is called by `Isolate::DoThrow()` to decide whether an exception is considered uncaught.
12 years ago
// Do not call FatalException when _fatalException handler throws
fatal_try_catch.SetVerbose(false);
domain: Do not use uncaughtException handler This adds a process._fatalException method which is called into from C++ in order to either emit the &#39;uncaughtException&#39; method, or emit &#39;error&#39; on the active domain. The &#39;uncaughtException&#39; event is an implementation detail that it would be nice to deprecate one day, so exposing it as part of the domain machinery is not ideal. Fix #4375
12 years ago
// this will return true if the JS layer handled it, false otherwise
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
Local<Value> caught =
fatal_exception_function->Call(process_object, 1, &error);
domain: Do not use uncaughtException handler This adds a process._fatalException method which is called into from C++ in order to either emit the &#39;uncaughtException&#39; method, or emit &#39;error&#39; on the active domain. The &#39;uncaughtException&#39; event is an implementation detail that it would be nice to deprecate one day, so exposing it as part of the domain machinery is not ideal. Fix #4375
12 years ago
if (fatal_try_catch.HasCaught()) {
// the fatal exception function threw, so we must exit
node: do not print SyntaxError hints to stderr Try embedding the ` ... ^` lines inside the `SyntaxError` (or any other native error) object before giving up and printing them to the stderr. fix #6920 fix #1310
11 years ago
ReportException(env, fatal_try_catch);
core: Mark exit() calls with status codes Also, exit with 128+n for signal exit n, as is The Unix Way.
12 years ago
exit(7);
domain: Do not use uncaughtException handler This adds a process._fatalException method which is called into from C++ in order to either emit the &#39;uncaughtException&#39; method, or emit &#39;error&#39; on the active domain. The &#39;uncaughtException&#39; event is an implementation detail that it would be nice to deprecate one day, so exposing it as part of the domain machinery is not ideal. Fix #4375
12 years ago
}
if (false == caught->BooleanValue()) {
node: do not print SyntaxError hints to stderr Try embedding the ` ... ^` lines inside the `SyntaxError` (or any other native error) object before giving up and printing them to the stderr. fix #6920 fix #1310
11 years ago
ReportException(env, error, message);
process: use exit 1 for uncaughtException Since it is Unix tradition to use exit code 1 for general-purpose script bail-out, and the way of doing that in Node is to throw an exception and not catch it, it makes the most sense to exit with 1 when an exception goes uncaught. Move the `Invalid Argument` exit to 9, so that it&#39;s something specific, and clear that it&#39;s a node internal error. Also, document the exit codes that we use.
11 years ago
exit(1);
Report errors thrown from uncaughtException handers
13 years ago
}
better error messages
16 years ago
}
enable support for the thread pool
16 years ago
src: remove `node_isolate` from source fix #6899
11 years ago
void FatalException(Isolate* isolate, const TryCatch& try_catch) {
HandleScope scope(isolate);
src: lint c++ code
12 years ago
// TODO(bajtos) do not call FatalException if try_catch is verbose
src: break on uncaught exception Most TryCatch blocks have SetVerbose flag on, this tells V8 to report uncaught exceptions to debugger. FatalException handler is called from V8 Message listener instead from the place where TryCatch was used. Otherwise uncaught exceptions are logged twice. See comment in `deps/v8/include/v8.h` for explanation of SetVerbose flag: &gt; By default, exceptions that are caught by an external exception &gt; handler are not reported. Call SetVerbose with true on an &gt; external exception handler to have exceptions caught by the &gt; handler reported as if they were not caught. The flag is used by `Isolate::ShouldReportException()`, which is called by `Isolate::DoThrow()` to decide whether an exception is considered uncaught.
12 years ago
// (requires V8 API to expose getter for try_catch.is_verbose_)
src: remove `node_isolate` from source fix #6899
11 years ago
FatalException(isolate, try_catch.Exception(), try_catch.Message());
src: break on uncaught exception Most TryCatch blocks have SetVerbose flag on, this tells V8 to report uncaught exceptions to debugger. FatalException handler is called from V8 Message listener instead from the place where TryCatch was used. Otherwise uncaught exceptions are logged twice. See comment in `deps/v8/include/v8.h` for explanation of SetVerbose flag: &gt; By default, exceptions that are caught by an external exception &gt; handler are not reported. Call SetVerbose with true on an &gt; external exception handler to have exceptions caught by the &gt; handler reported as if they were not caught. The flag is used by `Isolate::ShouldReportException()`, which is called by `Isolate::DoThrow()` to decide whether an exception is considered uncaught.
12 years ago
}
void OnMessage(Handle<Message> message, Handle<Value> error) {
// The current version of V8 sends messages for errors only
// (thus `error` is always set).
src: remove `node_isolate` from source fix #6899
11 years ago
FatalException(Isolate::GetCurrent(), error, message);
src: break on uncaught exception Most TryCatch blocks have SetVerbose flag on, this tells V8 to report uncaught exceptions to debugger. FatalException handler is called from V8 Message listener instead from the place where TryCatch was used. Otherwise uncaught exceptions are logged twice. See comment in `deps/v8/include/v8.h` for explanation of SetVerbose flag: &gt; By default, exceptions that are caught by an external exception &gt; handler are not reported. Call SetVerbose with true on an &gt; external exception handler to have exceptions caught by the &gt; handler reported as if they were not caught. The flag is used by `Isolate::ShouldReportException()`, which is called by `Isolate::DoThrow()` to decide whether an exception is considered uncaught.
12 years ago
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
static void Binding(const FunctionCallbackInfo<Value>& args) {
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
Load c++ modules on demand
15 years ago
src: pass Isolate to additional locations Due to a recent V8 upgrade, more methods require Isolate as an argument. PR-URL: https://github.com/iojs/io.js/pull/244 Reviewed-by: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
Local<String> module = args[0]->ToString(env->isolate());
src: pass Isolate to node::Utf8Value constructor Initial attempt to remove all uses of Isolate::GetCurrent(). Still exists a few locations, but this works out a heavy usage. PR-URL: https://github.com/iojs/io.js/pull/244 Reviewed-by: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
node::Utf8Value module_v(env->isolate(), module);
Load c++ modules on demand
15 years ago
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
Local<Object> cache = env->binding_cache_object();
Load c++ modules on demand
15 years ago
Local<Object> exports;
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
if (cache->Has(module)) {
src: pass Isolate to additional locations Due to a recent V8 upgrade, more methods require Isolate as an argument. PR-URL: https://github.com/iojs/io.js/pull/244 Reviewed-by: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
exports = cache->Get(module)->ToObject(env->isolate());
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
args.GetReturnValue().Set(exports);
return;
Add process.moduleLoadList for better startup transparency
14 years ago
}
// Append a string to process.moduleLoadList
char buf[1024];
src: lint c++ code
12 years ago
snprintf(buf, sizeof(buf), "Binding %s", *module_v);
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
Local<Array> modules = env->module_load_list_array();
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
uint32_t l = modules->Length();
src: remove `node_isolate` from source fix #6899
11 years ago
modules->Set(l, OneByteString(env->isolate(), buf));
Move constants out of process object
15 years ago
node: register modules from DSO constructors Built-in modules should be automatically registered, replacing the static module list. Add-on modules should also be automatically registered via DSO constructors. This improves flexibility in adding built-in modules and is also a prerequisite to pure-C addon modules.
11 years ago
node_module* mod = get_builtin_module(*module_v);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (mod != nullptr) {
src: update to v8 3.24 APIs
11 years ago
exports = Object::New(env->isolate());
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
// Internal bindings don't have a "module" object, only exports.
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
CHECK_EQ(mod->nm_register_func, nullptr);
CHECK_NE(mod->nm_context_register_func, nullptr);
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
Local<Value> unused = Undefined(env->isolate());
node: register modules from DSO constructors Built-in modules should be automatically registered, replacing the static module list. Add-on modules should also be automatically registered via DSO constructors. This improves flexibility in adding built-in modules and is also a prerequisite to pure-C addon modules.
11 years ago
mod->nm_context_register_func(exports, unused,
env->context(), mod->nm_priv);
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
cache->Set(module, exports);
Move constants out of process object
15 years ago
} else if (!strcmp(*module_v, "constants")) {
src: update to v8 3.24 APIs
11 years ago
exports = Object::New(env->isolate());
Move constants out of process object
15 years ago
DefineConstants(exports);
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
cache->Set(module, exports);
Move native js files into binding object
15 years ago
} else if (!strcmp(*module_v, "natives")) {
src: update to v8 3.24 APIs
11 years ago
exports = Object::New(env->isolate());
src: remove `node_isolate` from source fix #6899
11 years ago
DefineJavaScript(env, exports);
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
cache->Set(module, exports);
Load c++ modules on demand
15 years ago
} else {
process: improve process binding Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
char errmsg[1024];
snprintf(errmsg,
sizeof(errmsg),
"No such module: %s",
*module_v);
return env->ThrowError(errmsg);
Load c++ modules on demand
15 years ago
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
args.GetReturnValue().Set(exports);
Load c++ modules on demand
15 years ago
}
modules: adding load linked modules feature - introduced NM_F_LINKED flag to identify linked modules - setting node_is_initialized after calling V8::Initialize in order to make the right decision during initial module registration - introduced modlist_linked in order to track modules that were pre-registered in order to complete it once node is initialized - completing registration of linked module similarly to the way it&#39;s done inside DLOpen PR-URL: https://github.com/iojs/io.js/pull/8 Reviewed-by: Trevor Norris &lt;trev.norris@gmail.com&gt; Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
static void LinkedBinding(const FunctionCallbackInfo<Value>& args) {
Environment* env = Environment::GetCurrent(args.GetIsolate());
src: pass Isolate to additional locations Due to a recent V8 upgrade, more methods require Isolate as an argument. PR-URL: https://github.com/iojs/io.js/pull/244 Reviewed-by: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
Local<String> module = args[0]->ToString(env->isolate());
modules: adding load linked modules feature - introduced NM_F_LINKED flag to identify linked modules - setting node_is_initialized after calling V8::Initialize in order to make the right decision during initial module registration - introduced modlist_linked in order to track modules that were pre-registered in order to complete it once node is initialized - completing registration of linked module similarly to the way it&#39;s done inside DLOpen PR-URL: https://github.com/iojs/io.js/pull/8 Reviewed-by: Trevor Norris &lt;trev.norris@gmail.com&gt; Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
Local<Object> cache = env->binding_cache_object();
Local<Value> exports_v = cache->Get(module);
if (exports_v->IsObject())
return args.GetReturnValue().Set(exports_v.As<Object>());
src: pass Isolate to node::Utf8Value constructor Initial attempt to remove all uses of Isolate::GetCurrent(). Still exists a few locations, but this works out a heavy usage. PR-URL: https://github.com/iojs/io.js/pull/244 Reviewed-by: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
node::Utf8Value module_v(env->isolate(), module);
modules: adding load linked modules feature - introduced NM_F_LINKED flag to identify linked modules - setting node_is_initialized after calling V8::Initialize in order to make the right decision during initial module registration - introduced modlist_linked in order to track modules that were pre-registered in order to complete it once node is initialized - completing registration of linked module similarly to the way it&#39;s done inside DLOpen PR-URL: https://github.com/iojs/io.js/pull/8 Reviewed-by: Trevor Norris &lt;trev.norris@gmail.com&gt; Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
node_module* mod = get_linked_module(*module_v);
node.cc: use nullptr instead of NULL PR-URL: https://github.com/iojs/io.js/pull/124 Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
if (mod == nullptr) {
modules: adding load linked modules feature - introduced NM_F_LINKED flag to identify linked modules - setting node_is_initialized after calling V8::Initialize in order to make the right decision during initial module registration - introduced modlist_linked in order to track modules that were pre-registered in order to complete it once node is initialized - completing registration of linked module similarly to the way it&#39;s done inside DLOpen PR-URL: https://github.com/iojs/io.js/pull/8 Reviewed-by: Trevor Norris &lt;trev.norris@gmail.com&gt; Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
char errmsg[1024];
snprintf(errmsg,
sizeof(errmsg),
"No such module was linked: %s",
*module_v);
return env->ThrowError(errmsg);
}
Local<Object> exports = Object::New(env->isolate());
node.cc: use nullptr instead of NULL PR-URL: https://github.com/iojs/io.js/pull/124 Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
if (mod->nm_context_register_func != nullptr) {
modules: adding load linked modules feature - introduced NM_F_LINKED flag to identify linked modules - setting node_is_initialized after calling V8::Initialize in order to make the right decision during initial module registration - introduced modlist_linked in order to track modules that were pre-registered in order to complete it once node is initialized - completing registration of linked module similarly to the way it&#39;s done inside DLOpen PR-URL: https://github.com/iojs/io.js/pull/8 Reviewed-by: Trevor Norris &lt;trev.norris@gmail.com&gt; Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
mod->nm_context_register_func(exports,
module,
env->context(),
mod->nm_priv);
node.cc: use nullptr instead of NULL PR-URL: https://github.com/iojs/io.js/pull/124 Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
} else if (mod->nm_register_func != nullptr) {
modules: adding load linked modules feature - introduced NM_F_LINKED flag to identify linked modules - setting node_is_initialized after calling V8::Initialize in order to make the right decision during initial module registration - introduced modlist_linked in order to track modules that were pre-registered in order to complete it once node is initialized - completing registration of linked module similarly to the way it&#39;s done inside DLOpen PR-URL: https://github.com/iojs/io.js/pull/8 Reviewed-by: Trevor Norris &lt;trev.norris@gmail.com&gt; Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
mod->nm_register_func(exports, module, mod->nm_priv);
} else {
return env->ThrowError("Linked module has no declared entry point.");
}
cache->Set(module, exports);
args.GetReturnValue().Set(exports);
}
Enable debugging. Use the --debug command line flag to enable. It appears that d8 sucks. Luckily it can be rewritten rather easily with the repl and tcp client libraries. Node&#39;s CL option parsing is getting rather unwieldy - needs refactor.
15 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
static void ProcessTitleGetter(Local<String> property,
const PropertyCallbackInfo<Value>& info) {
src: remove `node_isolate` from source fix #6899
11 years ago
Environment* env = Environment::GetCurrent(info.GetIsolate());
HandleScope scope(env->isolate());
Remove platform files, and use uv platform api
13 years ago
char buffer[512];
uv_get_process_title(buffer, sizeof(buffer));
src: remove `node_isolate` from source fix #6899
11 years ago
info.GetReturnValue().Set(String::NewFromUtf8(env->isolate(), buffer));
Stub out process.title
15 years ago
}
static void ProcessTitleSetter(Local<String> property,
Local<Value> value,
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
const PropertyCallbackInfo<void>& info) {
src: remove `node_isolate` from source fix #6899
11 years ago
Environment* env = Environment::GetCurrent(info.GetIsolate());
HandleScope scope(env->isolate());
src: pass Isolate to node::Utf8Value constructor Initial attempt to remove all uses of Isolate::GetCurrent(). Still exists a few locations, but this works out a heavy usage. PR-URL: https://github.com/iojs/io.js/pull/244 Reviewed-by: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
node::Utf8Value title(env->isolate(), value);
src: lint c++ code
12 years ago
// TODO(piscisaureus): protect with a lock
Remove platform files, and use uv platform api
13 years ago
uv_set_process_title(*title);
Stub out process.title
15 years ago
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
static void EnvGetter(Local<String> property,
const PropertyCallbackInfo<Value>& info) {
src: remove `node_isolate` from source fix #6899
11 years ago
Environment* env = Environment::GetCurrent(info.GetIsolate());
HandleScope scope(env->isolate());
Windows: use unicode environment
13 years ago
#ifdef __POSIX__
src: pass Isolate to node::Utf8Value constructor Initial attempt to remove all uses of Isolate::GetCurrent(). Still exists a few locations, but this works out a heavy usage. PR-URL: https://github.com/iojs/io.js/pull/244 Reviewed-by: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
node::Utf8Value key(env->isolate(), property);
Make writes to process.env update the real environment. Tests included.
14 years ago
const char* val = getenv(*key);
if (val) {
src: remove `node_isolate` from source fix #6899
11 years ago
return info.GetReturnValue().Set(String::NewFromUtf8(env->isolate(), val));
Make writes to process.env update the real environment. Tests included.
14 years ago
}
Windows: use unicode environment
13 years ago
#else // _WIN32
String::Value key(property);
src: lint c++ code
12 years ago
WCHAR buffer[32767]; // The maximum size allowed for environment variables.
Windows: use unicode environment
13 years ago
DWORD result = GetEnvironmentVariableW(reinterpret_cast<WCHAR*>(*key),
buffer,
ARRAY_SIZE(buffer));
// If result >= sizeof buffer the buffer was too small. That should never
// happen. If result == 0 and result != ERROR_SUCCESS the variable was not
// not found.
if ((result > 0 || GetLastError() == ERROR_SUCCESS) &&
result < ARRAY_SIZE(buffer)) {
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
const uint16_t* two_byte_buffer = reinterpret_cast<const uint16_t*>(buffer);
src: remove `node_isolate` from source fix #6899
11 years ago
Local<String> rc = String::NewFromTwoByte(env->isolate(), two_byte_buffer);
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
return info.GetReturnValue().Set(rc);
Windows: use unicode environment
13 years ago
}
#endif
Re-apply commit e307468. The V8 assert got triggered by a missing HandleScope::Close().
13 years ago
// Not found. Fetch from prototype.
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
info.GetReturnValue().Set(
info.Data().As<Object>()->Get(property));
Make writes to process.env update the real environment. Tests included.
14 years ago
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
static void EnvSetter(Local<String> property,
Local<Value> value,
const PropertyCallbackInfo<Value>& info) {
src: remove `node_isolate` from source fix #6899
11 years ago
Environment* env = Environment::GetCurrent(info.GetIsolate());
HandleScope scope(env->isolate());
Windows: use unicode environment
13 years ago
#ifdef __POSIX__
src: pass Isolate to node::Utf8Value constructor Initial attempt to remove all uses of Isolate::GetCurrent(). Still exists a few locations, but this works out a heavy usage. PR-URL: https://github.com/iojs/io.js/pull/244 Reviewed-by: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
node::Utf8Value key(env->isolate(), property);
node::Utf8Value val(env->isolate(), value);
Make writes to process.env update the real environment. Tests included.
14 years ago
setenv(*key, *val, 1);
Windows: use unicode environment
13 years ago
#else // _WIN32
String::Value key(property);
String::Value val(value);
WCHAR* key_ptr = reinterpret_cast<WCHAR*>(*key);
// Environment variables that start with '=' are read-only.
if (key_ptr[0] != L'=') {
SetEnvironmentVariableW(key_ptr, reinterpret_cast<WCHAR*>(*val));
win: fix test-process-env Remove support for setting process.env.TZ as it doesn&#39;t seem we can do it x-platform without fixing V8.
14 years ago
}
Disable node.cc functions that are not supported on windows
14 years ago
#endif
Windows: use unicode environment
13 years ago
// Whether it worked or not, always return rval.
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
info.GetReturnValue().Set(value);
Make writes to process.env update the real environment. Tests included.
14 years ago
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
static void EnvQuery(Local<String> property,
const PropertyCallbackInfo<Integer>& info) {
src: remove `node_isolate` from source fix #6899
11 years ago
Environment* env = Environment::GetCurrent(info.GetIsolate());
HandleScope scope(env->isolate());
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
int32_t rc = -1; // Not found unless proven otherwise.
Windows: use unicode environment
13 years ago
#ifdef __POSIX__
src: pass Isolate to node::Utf8Value constructor Initial attempt to remove all uses of Isolate::GetCurrent(). Still exists a few locations, but this works out a heavy usage. PR-URL: https://github.com/iojs/io.js/pull/244 Reviewed-by: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
node::Utf8Value key(env->isolate(), property);
cpplint: disallow if one-liners
11 years ago
if (getenv(*key))
rc = 0;
Windows: use unicode environment
13 years ago
#else // _WIN32
String::Value key(property);
WCHAR* key_ptr = reinterpret_cast<WCHAR*>(*key);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (GetEnvironmentVariableW(key_ptr, nullptr, 0) > 0 ||
Windows: use unicode environment
13 years ago
GetLastError() == ERROR_SUCCESS) {
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
rc = 0;
Windows: use unicode environment
13 years ago
if (key_ptr[0] == L'=') {
// Environment variables that start with '=' are hidden and read-only.
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
rc = static_cast<int32_t>(v8::ReadOnly) |
static_cast<int32_t>(v8::DontDelete) |
static_cast<int32_t>(v8::DontEnum);
Windows: use unicode environment
13 years ago
}
}
#endif
cpplint: disallow if one-liners
11 years ago
if (rc != -1)
info.GetReturnValue().Set(rc);
Make writes to process.env update the real environment. Tests included.
14 years ago
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
static void EnvDeleter(Local<String> property,
const PropertyCallbackInfo<Boolean>& info) {
src: remove `node_isolate` from source fix #6899
11 years ago
Environment* env = Environment::GetCurrent(info.GetIsolate());
HandleScope scope(env->isolate());
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
bool rc = true;
Disable node.cc functions that are not supported on windows
14 years ago
#ifdef __POSIX__
src: pass Isolate to node::Utf8Value constructor Initial attempt to remove all uses of Isolate::GetCurrent(). Still exists a few locations, but this works out a heavy usage. PR-URL: https://github.com/iojs/io.js/pull/244 Reviewed-by: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
node::Utf8Value key(env->isolate(), property);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
rc = getenv(*key) != nullptr;
cpplint: disallow if one-liners
11 years ago
if (rc)
unsetenv(*key);
Disable node.cc functions that are not supported on windows
14 years ago
#else
Windows: use unicode environment
13 years ago
String::Value key(property);
WCHAR* key_ptr = reinterpret_cast<WCHAR*>(*key);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (key_ptr[0] == L'=' || !SetEnvironmentVariableW(key_ptr, nullptr)) {
Windows: use unicode environment
13 years ago
// Deletion failed. Return true if the key wasn't there in the first place,
// false if it is still there.
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
rc = GetEnvironmentVariableW(key_ptr, nullptr, 0) == 0 &&
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
GetLastError() != ERROR_SUCCESS;
Make writes to process.env update the real environment. Tests included.
14 years ago
}
Windows: use unicode environment
13 years ago
#endif
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
info.GetReturnValue().Set(rc);
Make writes to process.env update the real environment. Tests included.
14 years ago
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
static void EnvEnumerator(const PropertyCallbackInfo<Array>& info) {
src: remove `node_isolate` from source fix #6899
11 years ago
Environment* env = Environment::GetCurrent(info.GetIsolate());
HandleScope scope(env->isolate());
Windows: use unicode environment
13 years ago
#ifdef __POSIX__
Make writes to process.env update the real environment. Tests included.
14 years ago
int size = 0;
cpplint: disallow if one-liners
11 years ago
while (environ[size])
size++;
Make writes to process.env update the real environment. Tests included.
14 years ago
src: update to v8 3.24 APIs
11 years ago
Local<Array> envarr = Array::New(env->isolate(), size);
Make writes to process.env update the real environment. Tests included.
14 years ago
for (int i = 0; i < size; ++i) {
const char* var = environ[i];
const char* s = strchr(var, '=');
const int length = s ? s - var : strlen(var);
src: remove `node_isolate` from source fix #6899
11 years ago
Local<String> name = String::NewFromUtf8(env->isolate(),
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
var,
String::kNormalString,
length);
src: remove `node_isolate` from source fix #6899
11 years ago
envarr->Set(i, name);
Make writes to process.env update the real environment. Tests included.
14 years ago
}
Windows: use unicode environment
13 years ago
#else // _WIN32
WCHAR* environment = GetEnvironmentStringsW();
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (environment == nullptr)
cpplint: disallow if one-liners
11 years ago
return; // This should not happen.
src: update to v8 3.24 APIs
11 years ago
Local<Array> envarr = Array::New(env->isolate());
Windows: use unicode environment
13 years ago
WCHAR* p = environment;
int i = 0;
src: fix comparison of WCHAR with nullptr PR-URL: https://github.com/node-forward/node/pull/32 Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
while (*p) {
Windows: use unicode environment
13 years ago
WCHAR *s;
if (*p == L'=') {
// If the key starts with '=' it is a hidden environment variable.
p += wcslen(p) + 1;
continue;
} else {
s = wcschr(p, L'=');
}
if (!s) {
s = p + wcslen(p);
}
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
const uint16_t* two_byte_buffer = reinterpret_cast<const uint16_t*>(p);
src: fix windows build breakage from f674b09 The TWO_BYTE_BUFFER macro never made it into the final version of the patch that got landed in commit f674b09.
12 years ago
const size_t two_byte_buffer_len = s - p;
src: remove `node_isolate` from source fix #6899
11 years ago
Local<String> value = String::NewFromTwoByte(env->isolate(),
src: fix windows build breakage from f674b09 The TWO_BYTE_BUFFER macro never made it into the final version of the patch that got landed in commit f674b09.
12 years ago
two_byte_buffer,
String::kNormalString,
two_byte_buffer_len);
src: remove `node_isolate` from source fix #6899
11 years ago
envarr->Set(i++, value);
Windows: use unicode environment
13 years ago
p = s + wcslen(s) + 1;
}
FreeEnvironmentStringsW(environment);
#endif
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
src: remove `node_isolate` from source fix #6899
11 years ago
info.GetReturnValue().Set(envarr);
Make writes to process.env update the real environment. Tests included.
14 years ago
}
src: remove `node_isolate` from source fix #6899
11 years ago
static Handle<Object> GetFeatures(Environment* env) {
src: update to v8 3.24 APIs
11 years ago
EscapableHandleScope scope(env->isolate());
process: add process.features, remove process.useUV Partially fixes #1385.
14 years ago
src: update to v8 3.24 APIs
11 years ago
Local<Object> obj = Object::New(env->isolate());
Add process.features.debug; fixes simple/test-executable-path.js
14 years ago
#if defined(DEBUG) && DEBUG
src: remove `node_isolate` from source fix #6899
11 years ago
Local<Value> debug = True(env->isolate());
Add process.features.debug; fixes simple/test-executable-path.js
14 years ago
#else
src: remove `node_isolate` from source fix #6899
11 years ago
Local<Value> debug = False(env->isolate());
src: lint c++ code
12 years ago
#endif // defined(DEBUG) && DEBUG
src: remove `node_isolate` from source fix #6899
11 years ago
obj->Set(env->debug_string(), debug);
Add process.features.debug; fixes simple/test-executable-path.js
14 years ago
src: remove `node_isolate` from source fix #6899
11 years ago
obj->Set(env->uv_string(), True(env->isolate()));
src: lint c++ code
12 years ago
// TODO(bnoordhuis) ping libuv
src: remove `node_isolate` from source fix #6899
11 years ago
obj->Set(env->ipv6_lc_string(), True(env->isolate()));
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
src: remove two pointless globals from node.cc De-globalize use_npn and use_sni, they&#39;re only used in GetFeatures().
12 years ago
#ifdef OPENSSL_NPN_NEGOTIATED
src: remove `node_isolate` from source fix #6899
11 years ago
Local<Boolean> tls_npn = True(env->isolate());
src: remove two pointless globals from node.cc De-globalize use_npn and use_sni, they&#39;re only used in GetFeatures().
12 years ago
#else
src: remove `node_isolate` from source fix #6899
11 years ago
Local<Boolean> tls_npn = False(env->isolate());
src: remove two pointless globals from node.cc De-globalize use_npn and use_sni, they&#39;re only used in GetFeatures().
12 years ago
#endif
src: remove `node_isolate` from source fix #6899
11 years ago
obj->Set(env->tls_npn_string(), tls_npn);
src: remove two pointless globals from node.cc De-globalize use_npn and use_sni, they&#39;re only used in GetFeatures().
12 years ago
#ifdef SSL_CTRL_SET_TLSEXT_SERVERNAME_CB
src: remove `node_isolate` from source fix #6899
11 years ago
Local<Boolean> tls_sni = True(env->isolate());
src: remove two pointless globals from node.cc De-globalize use_npn and use_sni, they&#39;re only used in GetFeatures().
12 years ago
#else
src: remove `node_isolate` from source fix #6899
11 years ago
Local<Boolean> tls_sni = False(env->isolate());
src: remove two pointless globals from node.cc De-globalize use_npn and use_sni, they&#39;re only used in GetFeatures().
12 years ago
#endif
src: remove `node_isolate` from source fix #6899
11 years ago
obj->Set(env->tls_sni_string(), tls_sni);
src: remove two pointless globals from node.cc De-globalize use_npn and use_sni, they&#39;re only used in GetFeatures().
12 years ago
tls: support OCSP on client and server
11 years ago
#if !defined(OPENSSL_NO_TLSEXT) && defined(SSL_CTX_set_tlsext_status_cb)
Local<Boolean> tls_ocsp = True(env->isolate());
#else
Local<Boolean> tls_ocsp = False(env->isolate());
#endif // !defined(OPENSSL_NO_TLSEXT) && defined(SSL_CTX_set_tlsext_status_cb)
obj->Set(env->tls_ocsp_string(), tls_ocsp);
src: remove `node_isolate` from source fix #6899
11 years ago
obj->Set(env->tls_string(),
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
Boolean::New(env->isolate(),
get_builtin_module("crypto") != nullptr));
process: add process.features, remove process.useUV Partially fixes #1385.
14 years ago
src: update to v8 3.24 APIs
11 years ago
return scope.Escape(obj);
process: add process.features, remove process.useUV Partially fixes #1385.
14 years ago
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
static void DebugPortGetter(Local<String> property,
const PropertyCallbackInfo<Value>& info) {
src: remove `node_isolate` from source fix #6899
11 years ago
Environment* env = Environment::GetCurrent(info.GetIsolate());
HandleScope scope(env->isolate());
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
info.GetReturnValue().Set(debug_port);
debugger: export `debug_port` to `process` `process.debug_port` is useful for changing debugger port in runtime, before starting it (via SIGUSR1). Using `--port=` argument for debugger repl, tests will run debugger server on a `common.PORT` (as it usually does for any other servers). `process._debugEnd()` stops debugger and its server. * debugger: implemented process._debugEnd(), `node debug --port=5858 app.js` * test: start debugger repl on common.PORT * fixes #2613 * fixes #2614
13 years ago
}
static void DebugPortSetter(Local<String> property,
Local<Value> value,
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
const PropertyCallbackInfo<void>& info) {
src: remove `node_isolate` from source fix #6899
11 years ago
Environment* env = Environment::GetCurrent(info.GetIsolate());
HandleScope scope(env->isolate());
src: fix VC++ warning C4244 Reviewed-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
10 years ago
debug_port = value->Int32Value();
debugger: export `debug_port` to `process` `process.debug_port` is useful for changing debugger port in runtime, before starting it (via SIGUSR1). Using `--port=` argument for debugger repl, tests will run debugger server on a `common.PORT` (as it usually does for any other servers). `process._debugEnd()` stops debugger and its server. * debugger: implemented process._debugEnd(), `node debug --port=5858 app.js` * test: start debugger repl on common.PORT * fixes #2613 * fixes #2614
13 years ago
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
static void DebugProcess(const FunctionCallbackInfo<Value>& args);
static void DebugPause(const FunctionCallbackInfo<Value>& args);
static void DebugEnd(const FunctionCallbackInfo<Value>& args);
Implement process._debugProcess
13 years ago
timer: move setImmediate from timer to uv_check uv_check is the robust place to invoke setImmediate callbacks after process.nextTick and before timers(setTimeout/setInterval)
12 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void NeedImmediateCallbackGetter(Local<String> property,
const PropertyCallbackInfo<Value>& info) {
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
Environment* env = Environment::GetCurrent(info.GetIsolate());
const uv_check_t* immediate_check_handle = env->immediate_check_handle();
bool active = uv_is_active(
reinterpret_cast<const uv_handle_t*>(immediate_check_handle));
info.GetReturnValue().Set(active);
timer: move setImmediate from timer to uv_check uv_check is the robust place to invoke setImmediate callbacks after process.nextTick and before timers(setTimeout/setInterval)
12 years ago
}
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
static void NeedImmediateCallbackSetter(
Local<String> property,
Local<Value> value,
const PropertyCallbackInfo<void>& info) {
HandleScope handle_scope(info.GetIsolate());
src: fix Environment::GetCurrent() usage Create a HandleScope before calling the Environment::GetCurrent() that takes a v8::Isolate* as an argument because it creates a handle with the call to v8::Isolate::CurrentContext().
11 years ago
Environment* env = Environment::GetCurrent(info.GetIsolate());
timer: move setImmediate from timer to uv_check uv_check is the robust place to invoke setImmediate callbacks after process.nextTick and before timers(setTimeout/setInterval)
12 years ago
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
uv_check_t* immediate_check_handle = env->immediate_check_handle();
bool active = uv_is_active(
reinterpret_cast<const uv_handle_t*>(immediate_check_handle));
timer: move setImmediate from timer to uv_check uv_check is the robust place to invoke setImmediate callbacks after process.nextTick and before timers(setTimeout/setInterval)
12 years ago
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
if (active == value->BooleanValue())
return;
timer: move setImmediate from timer to uv_check uv_check is the robust place to invoke setImmediate callbacks after process.nextTick and before timers(setTimeout/setInterval)
12 years ago
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
uv_idle_t* immediate_idle_handle = env->immediate_idle_handle();
timer: move setImmediate from timer to uv_check uv_check is the robust place to invoke setImmediate callbacks after process.nextTick and before timers(setTimeout/setInterval)
12 years ago
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
if (active) {
uv_check_stop(immediate_check_handle);
uv_idle_stop(immediate_idle_handle);
timer: move setImmediate from timer to uv_check uv_check is the robust place to invoke setImmediate callbacks after process.nextTick and before timers(setTimeout/setInterval)
12 years ago
} else {
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
uv_check_start(immediate_check_handle, CheckImmediate);
// Idle handle is needed only to stop the event loop from blocking in poll.
uv_idle_start(immediate_idle_handle, IdleImmediateDummy);
timer: move setImmediate from timer to uv_check uv_check is the robust place to invoke setImmediate callbacks after process.nextTick and before timers(setTimeout/setInterval)
12 years ago
}
}
src: update uv callbacks after API changes async, timer, prepare, idle and check handles no longer get a status parameter since they can never fail.
11 years ago
void SetIdle(uv_prepare_t* handle) {
src: add JS start/stop methods for idle notifier The previous commit changes the profiler idle notifier so that it only gets started when a --prof or --prof_lazy argument is specified on the command line. This commit adds two internal methods to the process object that allows one to start and stop the idle notifier programmatically.
11 years ago
Environment* env = Environment::from_idle_prepare_handle(handle);
env->isolate()->GetCpuProfiler()->SetIdle(true);
}
src: update uv callbacks after API changes async, timer, prepare, idle and check handles no longer get a status parameter since they can never fail.
11 years ago
void ClearIdle(uv_check_t* handle) {
src: add JS start/stop methods for idle notifier The previous commit changes the profiler idle notifier so that it only gets started when a --prof or --prof_lazy argument is specified on the command line. This commit adds two internal methods to the process object that allows one to start and stop the idle notifier programmatically.
11 years ago
Environment* env = Environment::from_idle_check_handle(handle);
env->isolate()->GetCpuProfiler()->SetIdle(false);
}
void StartProfilerIdleNotifier(Environment* env) {
uv_prepare_start(env->idle_prepare_handle(), SetIdle);
uv_check_start(env->idle_check_handle(), ClearIdle);
}
void StopProfilerIdleNotifier(Environment* env) {
uv_prepare_stop(env->idle_prepare_handle());
uv_check_stop(env->idle_check_handle());
}
void StartProfilerIdleNotifier(const FunctionCallbackInfo<Value>& args) {
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
src: fix Environment::GetCurrent() usage Create a HandleScope before calling the Environment::GetCurrent() that takes a v8::Isolate* as an argument because it creates a handle with the call to v8::Isolate::CurrentContext().
11 years ago
StartProfilerIdleNotifier(env);
src: add JS start/stop methods for idle notifier The previous commit changes the profiler idle notifier so that it only gets started when a --prof or --prof_lazy argument is specified on the command line. This commit adds two internal methods to the process object that allows one to start and stop the idle notifier programmatically.
11 years ago
}
void StopProfilerIdleNotifier(const FunctionCallbackInfo<Value>& args) {
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
src: fix Environment::GetCurrent() usage Create a HandleScope before calling the Environment::GetCurrent() that takes a v8::Isolate* as an argument because it creates a handle with the call to v8::Isolate::CurrentContext().
11 years ago
StopProfilerIdleNotifier(env);
src: add JS start/stop methods for idle notifier The previous commit changes the profiler idle notifier so that it only gets started when a --prof or --prof_lazy argument is specified on the command line. This commit adds two internal methods to the process object that allows one to start and stop the idle notifier programmatically.
11 years ago
}
process: set key properties as ReadOnly
12 years ago
#define READONLY_PROPERTY(obj, str, var) \
do { \
src, test: fixup after v8 update Because of behavior change of some V8 APIs (they mostly became more strict), following modules needed to be fixed: * crypto: duplicate prototype methods are not allowed anymore * contextify: some TryCatch trickery, the binding was using it incorrectly * util: maximum call stack error is now crashing in a different place Reviewed-By: Trevor Norris &lt;trevnorris@gmail.com&gt; PR-URL: https://github.com/joyent/node/pull/8476
10 years ago
obj->ForceSet(OneByteString(env->isolate(), str), var, v8::ReadOnly); \
process: set key properties as ReadOnly
12 years ago
} while (0)
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
void SetupProcessObject(Environment* env,
int argc,
const char* const* argv,
int exec_argc,
const char* const* exec_argv) {
src: remove `node_isolate` from source fix #6899
11 years ago
HandleScope scope(env->isolate());
Add openssl version to process.versions
14 years ago
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
Local<Object> process = env->process_object();
Revert support for isolates. It was decided that the performance benefits that isolates offer (faster spin-up times for worker processes, faster inter-worker communication, possibly a lower memory footprint) are not actual bottlenecks for most people and do not outweigh the potential stability issues and intrusive changes to the code base that first-class support for isolates requires. Hence, this commit backs out all isolates-related changes. Good bye, isolates. We hardly knew ye.
13 years ago
src: remove `node_isolate` from source fix #6899
11 years ago
process->SetAccessor(env->title_string(),
Stub out process.title
15 years ago
ProcessTitleGetter,
ProcessTitleSetter);
Add process.platform
15 years ago
// process.version
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
READONLY_PROPERTY(process,
"version",
src: remove `node_isolate` from source fix #6899
11 years ago
FIXED_ONE_BYTE_STRING(env->isolate(), NODE_VERSION));
Add process.versions
15 years ago
Add process.moduleLoadList for better startup transparency
14 years ago
// process.moduleLoadList
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
READONLY_PROPERTY(process,
"moduleLoadList",
env->module_load_list_array());
Add process.moduleLoadList for better startup transparency
14 years ago
process: use NODE_STRINGIFY macro to set process.versions.uv
13 years ago
// process.versions
src: update to v8 3.24 APIs
11 years ago
Local<Object> versions = Object::New(env->isolate());
process: set key properties as ReadOnly
12 years ago
READONLY_PROPERTY(process, "versions", versions);
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
const char http_parser_version[] = NODE_STRINGIFY(HTTP_PARSER_VERSION_MAJOR)
"."
NODE_STRINGIFY(HTTP_PARSER_VERSION_MINOR);
READONLY_PROPERTY(versions,
"http_parser",
src: remove `node_isolate` from source fix #6899
11 years ago
FIXED_ONE_BYTE_STRING(env->isolate(), http_parser_version));
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
Add process.versions
15 years ago
// +1 to get rid of the leading 'v'
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
READONLY_PROPERTY(versions,
"node",
src: remove `node_isolate` from source fix #6899
11 years ago
OneByteString(env->isolate(), NODE_VERSION + 1));
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
READONLY_PROPERTY(versions,
"v8",
src: remove `node_isolate` from source fix #6899
11 years ago
OneByteString(env->isolate(), V8::GetVersion()));
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
READONLY_PROPERTY(versions,
"uv",
src: remove `node_isolate` from source fix #6899
11 years ago
OneByteString(env->isolate(), uv_version_string()));
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
READONLY_PROPERTY(versions,
"zlib",
src: remove `node_isolate` from source fix #6899
11 years ago
FIXED_ONE_BYTE_STRING(env->isolate(), ZLIB_VERSION));
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
const char node_modules_version[] = NODE_STRINGIFY(NODE_MODULE_VERSION);
src: remove `node_isolate` from source fix #6899
11 years ago
READONLY_PROPERTY(
versions,
"modules",
FIXED_ONE_BYTE_STRING(env->isolate(), node_modules_version));
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
Basic VC++ compatibility work.
14 years ago
#if HAVE_OPENSSL
Add openssl version to process.versions
14 years ago
// Stupid code to slice out the version string.
src: fix whitespace/braces lint error from 962686b Silly warning. One day I&#39;ll probably remove it altogether, see if I don&#39;t.
11 years ago
{ // NOLINT(whitespace/braces)
src: squelch unused variable warning |i| and |j| arent&#39;t used when building without crypto support. Hat tip to Brian White. Rename |l| to |k| while we&#39;re here because it&#39;s quite hard to discern from |i| or |j| with some fonts.
11 years ago
size_t i, j, k;
int c;
for (i = j = 0, k = sizeof(OPENSSL_VERSION_TEXT) - 1; i < k; ++i) {
c = OPENSSL_VERSION_TEXT[i];
if ('0' <= c && c <= '9') {
for (j = i + 1; j < k; ++j) {
c = OPENSSL_VERSION_TEXT[j];
if (c == ' ')
break;
}
break;
Add openssl version to process.versions
14 years ago
}
}
src: squelch unused variable warning |i| and |j| arent&#39;t used when building without crypto support. Hat tip to Brian White. Rename |l| to |k| while we&#39;re here because it&#39;s quite hard to discern from |i| or |j| with some fonts.
11 years ago
READONLY_PROPERTY(
versions,
"openssl",
src: remove `node_isolate` from source fix #6899
11 years ago
OneByteString(env->isolate(), &OPENSSL_VERSION_TEXT[i], j - i));
Add openssl version to process.versions
14 years ago
}
#endif
Add process.versions
15 years ago
Implement `process.arch` to get a String of the current processor architecture, with docs.
14 years ago
// process.arch
src: prefix ARCH and PLATFORM with NODE_ The PLATFORM preprocessor symbol is defined in node.gyp, and on Windows it&#39;s set to &#34;win&#34;. This conflicts with a built-in preprocessor symbol with a different value (&#34;win32&#34;), which makes the linker(!) complain. Resolve this by renaming these symbols to NODE_ARCH and NODE_PLATFORM. PR-URL: https://github.com/iojs/io.js/pull/261 Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
READONLY_PROPERTY(process, "arch", OneByteString(env->isolate(), NODE_ARCH));
Implement `process.arch` to get a String of the current processor architecture, with docs.
14 years ago
Add process.platform
15 years ago
// process.platform
build: fix `process.platform` e1fe270 introduces the NODE_PLATFORM macro which had to be redefined in node.gyp for `process.platform` to return expected values. PR-URL: https://github.com/iojs/io.js/pull/271 Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt; Reviewed-By: Bert Belder &lt;bertbelder@gmail.com&gt;
10 years ago
READONLY_PROPERTY(process,
"platform",
OneByteString(env->isolate(), NODE_PLATFORM));
Add process.platform
15 years ago
Downcase process.ARGV/ENV to process.argv/env
15 years ago
// process.argv
src: update to v8 3.24 APIs
11 years ago
Local<Array> arguments = Array::New(env->isolate(), argc);
src: clean up CLI argument parser * Exit with an error message when the option is not a node or V8 option. * Remove the option_end_index global. Needs to happen anyway for the multi-context work, might as well land it in master now. * Add a smidgen of const-correctness. * Pay off a few years of accrued technical debt.
12 years ago
for (int i = 0; i < argc; ++i) {
src: remove `node_isolate` from source fix #6899
11 years ago
arguments->Set(i, String::NewFromUtf8(env->isolate(), argv[i]));
everything is changed. i&#39;ve waited much too long to commit. this is awful. i&#39;m sorry for being so messy.
16 years ago
}
src: remove `node_isolate` from source fix #6899
11 years ago
process->Set(env->argv_string(), arguments);
everything is changed. i&#39;ve waited much too long to commit. this is awful. i&#39;m sorry for being so messy.
16 years ago
Expose original argv as process.execArgv for cluster and child_process.fork()
13 years ago
// process.execArgv
src: update to v8 3.24 APIs
11 years ago
Local<Array> exec_arguments = Array::New(env->isolate(), exec_argc);
src: clean up CLI argument parser * Exit with an error message when the option is not a node or V8 option. * Remove the option_end_index global. Needs to happen anyway for the multi-context work, might as well land it in master now. * Add a smidgen of const-correctness. * Pay off a few years of accrued technical debt.
12 years ago
for (int i = 0; i < exec_argc; ++i) {
src: remove `node_isolate` from source fix #6899
11 years ago
exec_arguments->Set(i, String::NewFromUtf8(env->isolate(), exec_argv[i]));
Expose original argv as process.execArgv for cluster and child_process.fork()
13 years ago
}
src: remove `node_isolate` from source fix #6899
11 years ago
process->Set(env->exec_argv_string(), exec_arguments);
Expose original argv as process.execArgv for cluster and child_process.fork()
13 years ago
Downcase process.ARGV/ENV to process.argv/env
15 years ago
// create process.env
src: update to v8 3.24 APIs
11 years ago
Local<ObjectTemplate> process_env_template =
ObjectTemplate::New(env->isolate());
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
process_env_template->SetNamedPropertyHandler(EnvGetter,
EnvSetter,
EnvQuery,
EnvDeleter,
EnvEnumerator,
src: update to v8 3.24 APIs
11 years ago
Object::New(env->isolate()));
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
Local<Object> process_env = process_env_template->NewInstance();
src: remove `node_isolate` from source fix #6899
11 years ago
process->Set(env->env_string(), process_env);
Downcase process.ARGV/ENV to process.argv/env
15 years ago
src: update to v8 3.24 APIs
11 years ago
READONLY_PROPERTY(process, "pid", Integer::New(env->isolate(), getpid()));
src: remove `node_isolate` from source fix #6899
11 years ago
READONLY_PROPERTY(process, "features", GetFeatures(env));
process->SetAccessor(env->need_imm_cb_string(),
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
NeedImmediateCallbackGetter,
NeedImmediateCallbackSetter);
Add access to user environment via ENV
16 years ago
Added -e, --eval
14 years ago
// -e, --eval
if (eval_string) {
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
READONLY_PROPERTY(process,
"_eval",
src: remove `node_isolate` from source fix #6899
11 years ago
String::NewFromUtf8(env->isolate(), eval_string));
process: set _print_eval even when --eval is not passed This is for scripts being fed from stdin: $ echo &#34;{ foo: &#39;bar&#39; }&#34; | node -p
13 years ago
}
// -p, --print
if (print_eval) {
src: remove `node_isolate` from source fix #6899
11 years ago
READONLY_PROPERTY(process, "_print_eval", True(env->isolate()));
Added -e, --eval
14 years ago
}
process: comment for consistency
13 years ago
// -i, --interactive
cmd: add a -i / --interactive flag to force the REPL This is the only way to spawn a node child process in REPL mode, and will also be needed to be able to use the REPL in MinTTY.
13 years ago
if (force_repl) {
src: remove `node_isolate` from source fix #6899
11 years ago
READONLY_PROPERTY(process, "_forceRepl", True(env->isolate()));
cmd: add a -i / --interactive flag to force the REPL This is the only way to spawn a node child process in REPL mode, and will also be needed to be able to use the REPL in MinTTY.
13 years ago
}
Add --no-deprecation and --trace-deprecation flags
13 years ago
// --no-deprecation
if (no_deprecation) {
src: remove `node_isolate` from source fix #6899
11 years ago
READONLY_PROPERTY(process, "noDeprecation", True(env->isolate()));
Add --no-deprecation and --trace-deprecation flags
13 years ago
}
node: Add --throw-deprecation Extremely handy when tracking down a flood of recursive nextTick warnings.
12 years ago
// --throw-deprecation
if (throw_deprecation) {
src: remove `node_isolate` from source fix #6899
11 years ago
READONLY_PROPERTY(process, "throwDeprecation", True(env->isolate()));
node: Add --throw-deprecation Extremely handy when tracking down a flood of recursive nextTick warnings.
12 years ago
}
Add --no-deprecation and --trace-deprecation flags
13 years ago
// --trace-deprecation
if (trace_deprecation) {
src: remove `node_isolate` from source fix #6899
11 years ago
READONLY_PROPERTY(process, "traceDeprecation", True(env->isolate()));
Add --no-deprecation and --trace-deprecation flags
13 years ago
}
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
size_t exec_path_len = 2 * PATH_MAX;
char* exec_path = new char[exec_path_len];
Local<String> exec_path_value;
if (uv_exepath(exec_path, &exec_path_len) == 0) {
src: remove `node_isolate` from source fix #6899
11 years ago
exec_path_value = String::NewFromUtf8(env->isolate(),
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
exec_path,
String::kNormalString,
exec_path_len);
Initial implementation of process.execPath Darwin, Linux, Solaris. FreeBSD still needs testing. TODO: Amend the tests where we use spawn with argv[0].
15 years ago
} else {
src: remove `node_isolate` from source fix #6899
11 years ago
exec_path_value = String::NewFromUtf8(env->isolate(), argv[0]);
Initial implementation of process.execPath Darwin, Linux, Solaris. FreeBSD still needs testing. TODO: Amend the tests where we use spawn with argv[0].
15 years ago
}
src: remove `node_isolate` from source fix #6899
11 years ago
process->Set(env->exec_path_string(), exec_path_value);
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
delete[] exec_path;
Initial implementation of process.execPath Darwin, Linux, Solaris. FreeBSD still needs testing. TODO: Amend the tests where we use spawn with argv[0].
15 years ago
src: remove `node_isolate` from source fix #6899
11 years ago
process->SetAccessor(env->debug_port_string(),
debugger: export `debug_port` to `process` `process.debug_port` is useful for changing debugger port in runtime, before starting it (via SIGUSR1). Using `--port=` argument for debugger repl, tests will run debugger server on a `common.PORT` (as it usually does for any other servers). `process._debugEnd()` stops debugger and its server. * debugger: implemented process._debugEnd(), `node debug --port=5858 app.js` * test: start debugger repl on common.PORT * fixes #2613 * fixes #2614
13 years ago
DebugPortGetter,
DebugPortSetter);
Add comments to node.cc
15 years ago
// define various internal methods
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
env->SetMethod(process,
"_startProfilerIdleNotifier",
StartProfilerIdleNotifier);
env->SetMethod(process,
"_stopProfilerIdleNotifier",
StopProfilerIdleNotifier);
env->SetMethod(process, "_getActiveRequests", GetActiveRequests);
env->SetMethod(process, "_getActiveHandles", GetActiveHandles);
env->SetMethod(process, "reallyExit", Exit);
env->SetMethod(process, "abort", Abort);
env->SetMethod(process, "chdir", Chdir);
env->SetMethod(process, "cwd", Cwd);
env->SetMethod(process, "umask", Umask);
windows: fix test-umask
14 years ago
build: add android support Resolves minor discrepancies between android and standard POSIX systems. In addition, some configure parameters were added, and a helper-script for android configuration. Ideally, this script should be merged into the standard configure script. To build for android, source the android-configure script with an NDK path: source ./android-configure ~/android-ndk-r8d This will create an android standalone toolchain and export the necessary environment parameters. After that, build as normal: make -j8 After the build, you should now have android-compatible NodeJS binaries.
12 years ago
#if defined(__POSIX__) && !defined(__ANDROID__)
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
env->SetMethod(process, "getuid", GetUid);
env->SetMethod(process, "setuid", SetUid);
Add setgid,getgid
15 years ago
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
env->SetMethod(process, "setgid", SetGid);
env->SetMethod(process, "getgid", GetGid);
process: add getgroups(), setgroups(), initgroups() DRY the getuid(), getgid(), etc. functions while we&#39;re at it.
12 years ago
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
env->SetMethod(process, "getgroups", GetGroups);
env->SetMethod(process, "setgroups", SetGroups);
env->SetMethod(process, "initgroups", InitGroups);
src: lint c++ code
12 years ago
#endif // __POSIX__ && !defined(__ANDROID__)
Add setgid,getgid
15 years ago
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
env->SetMethod(process, "_kill", Kill);
Disable node.cc functions that are not supported on windows
14 years ago
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
env->SetMethod(process, "_debugProcess", DebugProcess);
env->SetMethod(process, "_debugPause", DebugPause);
env->SetMethod(process, "_debugEnd", DebugEnd);
Implement process._debugProcess
13 years ago
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
env->SetMethod(process, "hrtime", Hrtime);
process: add `process.hrtime()` This commit adds a high-resolution timer function.
13 years ago
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
env->SetMethod(process, "dlopen", DLOpen);
Make node::DLOpen use uv_dlopen
13 years ago
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
env->SetMethod(process, "uptime", Uptime);
env->SetMethod(process, "memoryUsage", MemoryUsage);
Clean ups
16 years ago
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
env->SetMethod(process, "binding", Binding);
modules: adding load linked modules feature - introduced NM_F_LINKED flag to identify linked modules - setting node_is_initialized after calling V8::Initialize in order to make the right decision during initial module registration - introduced modlist_linked in order to track modules that were pre-registered in order to complete it once node is initialized - completing registration of linked module similarly to the way it&#39;s done inside DLOpen PR-URL: https://github.com/iojs/io.js/pull/8 Reviewed-by: Trevor Norris &lt;trev.norris@gmail.com&gt; Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
env->SetMethod(process, "_linkedBinding", LinkedBinding);
Load c++ modules on demand
15 years ago
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
env->SetMethod(process, "_setupNextTick", SetupNextTick);
env->SetMethod(process, "_setupDomainUse", SetupDomainUse);
domain: fix domain callback from MakeCallback Since _tickCallback and _tickDomainCallback were both called from MakeCallback, it was possible for a callback to be called that required a domain directly to _tickCallback. The fix was to implement process.usingDomains(). This will set all applicable functions to their domain counterparts, and set a flag in cc to let MakeCallback know domain callbacks always need to be checked. Added test in own file. It&#39;s important that the test remains isolated.
12 years ago
events: _events to object and undefined not null By making sure the _events is always an object there is one less check that needs to be performed by emit. Use undefined instead of null. typeof checks are a lot faster than isArray. There are a few places where the this._events check cannot be removed because it is possible for the user to call those methods after using utils.extend to create their own EventEmitter, but before it has actually been instantiated.
12 years ago
// pre-set _events object for faster emit checks
src: update to v8 3.24 APIs
11 years ago
process->Set(env->events_string(), Object::New(env->isolate()));
Export more functions for initializing and starting node. For greater flexibility in controlling node&#39;s initialization and startup, the following new functions are exported. - node::Init() - node::SetupProcessObject() - node::Load() - node::EmitExit() These are some of the major steps involved in node::Setup(). Exporting these functions allows an embedding program to write a replacement for node::Start(), and to have access to the node process object after it&#39;s created.
14 years ago
}
process: set key properties as ReadOnly
12 years ago
#undef READONLY_PROPERTY
Export more functions for initializing and starting node. For greater flexibility in controlling node&#39;s initialization and startup, the following new functions are exported. - node::Init() - node::SetupProcessObject() - node::Load() - node::EmitExit() These are some of the major steps involved in node::Setup(). Exporting these functions allows an embedding program to write a replacement for node::Start(), and to have access to the node process object after it&#39;s created.
14 years ago
static void AtExit() {
Fixes #1805. Reset TTY mode on exit.
13 years ago
uv_tty_reset_mode();
Export more functions for initializing and starting node. For greater flexibility in controlling node&#39;s initialization and startup, the following new functions are exported. - node::Init() - node::SetupProcessObject() - node::Load() - node::EmitExit() These are some of the major steps involved in node::Setup(). Exporting these functions allows an embedding program to write a replacement for node::Start(), and to have access to the node process object after it&#39;s created.
14 years ago
}
main: Handle SIGINT properly. As explained by http://www.cons.org/cracauer/sigint.html Signed-off-by: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
static void SignalExit(int signo) {
Fixes #1805. Reset TTY mode on exit.
13 years ago
uv_tty_reset_mode();
main: Handle SIGINT properly. As explained by http://www.cons.org/cracauer/sigint.html Signed-off-by: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
raise(signo);
Export more functions for initializing and starting node. For greater flexibility in controlling node&#39;s initialization and startup, the following new functions are exported. - node::Init() - node::SetupProcessObject() - node::Load() - node::EmitExit() These are some of the major steps involved in node::Setup(). Exporting these functions allows an embedding program to write a replacement for node::Start(), and to have access to the node process object after it&#39;s created.
14 years ago
}
process: Add internal _rawDebug() method This is useful when we need to push some debugging messages out to stderr, without going through the Writable class, or triggering any kind of nextTick or callback behavior.
12 years ago
// Most of the time, it's best to use `console.error` to write
// to the process.stderr stream. However, in some cases, such as
// when debugging the stream.Writable class or the process.nextTick
// function, it is useful to bypass JavaScript entirely.
static void RawDebug(const FunctionCallbackInfo<Value>& args) {
src: replace assert() with CHECK() Mechanically replace assert() statements with UNREACHABLE(), CHECK(), or CHECK_{EQ,NE,LT,GT,LE,GE}() statements. The exceptions are src/node.h and src/node_object_wrap.h because they are public headers. PR-URL: https://github.com/node-forward/node/pull/16 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
CHECK(args.Length() == 1 && args[0]->IsString() &&
"must be called with a single string");
src: pass Isolate to node::Utf8Value constructor Initial attempt to remove all uses of Isolate::GetCurrent(). Still exists a few locations, but this works out a heavy usage. PR-URL: https://github.com/iojs/io.js/pull/244 Reviewed-by: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
node::Utf8Value message(args.GetIsolate(), args[0]);
process: Add internal _rawDebug() method This is useful when we need to push some debugging messages out to stderr, without going through the Writable class, or triggering any kind of nextTick or callback behavior.
12 years ago
fprintf(stderr, "%s\n", *message);
fflush(stderr);
}
deps: re-implement debugger-agent Reviewed-By: Trevor Norris &lt;trevnorris@gmail.com&gt; PR-URL: https://github.com/joyent/node/pull/8476
10 years ago
void LoadEnvironment(Environment* env) {
src: remove `node_isolate` from source fix #6899
11 years ago
HandleScope handle_scope(env->isolate());
src: don&#39;t use NewExternal() with unaligned strings V8 3.20.9 enforces that external pointers are aligned on a two-byte boundary. We cannot portably guarantee that for the source code strings that tools/js2c.py generates so simply stop using String::NewExternal() altogether (and by extension String::ExternalAsciiStringResource). Fixes the following run-time assert: FATAL ERROR: v8::String::NewExternal() Pointer is not aligned
12 years ago
src: pass Isolate to additional locations Due to a recent V8 upgrade, more methods require Isolate as an argument. PR-URL: https://github.com/iojs/io.js/pull/244 Reviewed-by: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
env->isolate()->SetFatalErrorHandler(node::OnFatalError);
env->isolate()->AddMessageListener(OnMessage);
deps: re-implement debugger-agent Reviewed-By: Trevor Norris &lt;trevnorris@gmail.com&gt; PR-URL: https://github.com/joyent/node/pull/8476
10 years ago
Reorganize the start-up process - assign &#39;GLOBAL&#39; (and now &#39;global&#39;) inside src/node.js - position for eventually allowing replacements to src/node.js for people like Kris Kowal who want the nice libev and libeio bindings but not necessarily node&#39;s choices of modules or promises.
15 years ago
// Compile, execute the src/node.js file. (Which was included as static C
// string in node_natives.h. 'natve_node' is the string containing that
// source code.)
Fix whitespace and warnings in node.cc
15 years ago
Reorganize the start-up process - assign &#39;GLOBAL&#39; (and now &#39;global&#39;) inside src/node.js - position for eventually allowing replacements to src/node.js for people like Kris Kowal who want the nice libev and libeio bindings but not necessarily node&#39;s choices of modules or promises.
15 years ago
// The node.js file returns a function 'f'
Export more functions for initializing and starting node. For greater flexibility in controlling node&#39;s initialization and startup, the following new functions are exported. - node::Init() - node::SetupProcessObject() - node::Load() - node::EmitExit() These are some of the major steps involved in node::Setup(). Exporting these functions allows an embedding program to write a replacement for node::Start(), and to have access to the node process object after it&#39;s created.
14 years ago
atexit(AtExit);
Reorganize the start-up process - assign &#39;GLOBAL&#39; (and now &#39;global&#39;) inside src/node.js - position for eventually allowing replacements to src/node.js for people like Kris Kowal who want the nice libev and libeio bindings but not necessarily node&#39;s choices of modules or promises.
15 years ago
TryCatch try_catch;
src: break on uncaught exception Most TryCatch blocks have SetVerbose flag on, this tells V8 to report uncaught exceptions to debugger. FatalException handler is called from V8 Message listener instead from the place where TryCatch was used. Otherwise uncaught exceptions are logged twice. See comment in `deps/v8/include/v8.h` for explanation of SetVerbose flag: &gt; By default, exceptions that are caught by an external exception &gt; handler are not reported. Call SetVerbose with true on an &gt; external exception handler to have exceptions caught by the &gt; handler reported as if they were not caught. The flag is used by `Isolate::ShouldReportException()`, which is called by `Isolate::DoThrow()` to decide whether an exception is considered uncaught.
12 years ago
// Disable verbose mode to stop FatalException() handler from trying
// to handle the exception. Errors this early in the start-up phase
// are not safe to ignore.
try_catch.SetVerbose(false);
node: do not print SyntaxError hints to stderr Try embedding the ` ... ^` lines inside the `SyntaxError` (or any other native error) object before giving up and printing them to the stderr. fix #6920 fix #1310
11 years ago
Local<String> script_name = FIXED_ONE_BYTE_STRING(env->isolate(), "node.js");
src: remove `node_isolate` from source fix #6899
11 years ago
Local<Value> f_value = ExecuteString(env, MainSource(env), script_name);
Reorganize the start-up process - assign &#39;GLOBAL&#39; (and now &#39;global&#39;) inside src/node.js - position for eventually allowing replacements to src/node.js for people like Kris Kowal who want the nice libev and libeio bindings but not necessarily node&#39;s choices of modules or promises.
15 years ago
if (try_catch.HasCaught()) {
node: do not print SyntaxError hints to stderr Try embedding the ` ... ^` lines inside the `SyntaxError` (or any other native error) object before giving up and printing them to the stderr. fix #6920 fix #1310
11 years ago
ReportException(env, try_catch);
Reorganize the start-up process - assign &#39;GLOBAL&#39; (and now &#39;global&#39;) inside src/node.js - position for eventually allowing replacements to src/node.js for people like Kris Kowal who want the nice libev and libeio bindings but not necessarily node&#39;s choices of modules or promises.
15 years ago
exit(10);
}
src: replace assert() with CHECK() Mechanically replace assert() statements with UNREACHABLE(), CHECK(), or CHECK_{EQ,NE,LT,GT,LE,GE}() statements. The exceptions are src/node.h and src/node_object_wrap.h because they are public headers. PR-URL: https://github.com/node-forward/node/pull/16 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
CHECK(f_value->IsFunction());
Reorganize the start-up process - assign &#39;GLOBAL&#39; (and now &#39;global&#39;) inside src/node.js - position for eventually allowing replacements to src/node.js for people like Kris Kowal who want the nice libev and libeio bindings but not necessarily node&#39;s choices of modules or promises.
15 years ago
Local<Function> f = Local<Function>::Cast(f_value);
// Now we call 'f' with the 'process' variable that we've built up with
// all our bindings. Inside node.js we'll take care of assigning things to
// their places.
Fix whitespace and warnings in node.cc
15 years ago
Reorganize the start-up process - assign &#39;GLOBAL&#39; (and now &#39;global&#39;) inside src/node.js - position for eventually allowing replacements to src/node.js for people like Kris Kowal who want the nice libev and libeio bindings but not necessarily node&#39;s choices of modules or promises.
15 years ago
// We start the process this way in order to be more modular. Developers
// who do not like how 'src/node.js' setups the module system but do like
// Node's I/O bindings may want to replace 'f' with their own function.
Remove process.global
15 years ago
// Add a reference to the global object
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
Local<Object> global = env->context()->Global();
Configurable debug ports, and --debug-brk
15 years ago
build: use zero overhead systemtap probes Profiling suggested that on Linux sometimes over 10% of CPU time was being spent inside the systemtap probe entry points in the binding layer, even when the process was not actively being traced with the `stap` tool. That&#39;s why this commit makes it possible to use the *_ENABLED() macros and bail out early when we&#39;re not being traced, reducing the overhead of unused probes to (almost) zero. Said macros were already being generated by `dtrace -h` but were not usable because they rely on external definitions. To remedy that, we now generate the accompanying object files with `dtrace -G`. This commit includes a change to libuv that has been landed upstream in commit joyent/libuv@3c172ea.
11 years ago
#if defined HAVE_DTRACE || defined HAVE_ETW
src: remove `node_isolate` from source fix #6899
11 years ago
InitDTrace(env, global);
New DTrace probes from CA team
14 years ago
#endif
Land Cantrill&#39;s DTrace patch only works on solaris
14 years ago
windows: add tracing with performance counters Patch by Henry Rawas and Scott Blomquist.
12 years ago
#if defined HAVE_PERFCTR
src: remove `node_isolate` from source fix #6899
11 years ago
InitPerfCounters(env, global);
windows: add tracing with performance counters Patch by Henry Rawas and Scott Blomquist.
12 years ago
#endif
src: break on uncaught exception Most TryCatch blocks have SetVerbose flag on, this tells V8 to report uncaught exceptions to debugger. FatalException handler is called from V8 Message listener instead from the place where TryCatch was used. Otherwise uncaught exceptions are logged twice. See comment in `deps/v8/include/v8.h` for explanation of SetVerbose flag: &gt; By default, exceptions that are caught by an external exception &gt; handler are not reported. Call SetVerbose with true on an &gt; external exception handler to have exceptions caught by the &gt; handler reported as if they were not caught. The flag is used by `Isolate::ShouldReportException()`, which is called by `Isolate::DoThrow()` to decide whether an exception is considered uncaught.
12 years ago
// Enable handling of uncaught exceptions
// (FatalException(), break on uncaught exception in debugger)
//
// This is not strictly necessary since it's almost impossible
// to attach the debugger fast enought to break on exception
// thrown during process startup.
try_catch.SetVerbose(true);
Reorganize the start-up process - assign &#39;GLOBAL&#39; (and now &#39;global&#39;) inside src/node.js - position for eventually allowing replacements to src/node.js for people like Kris Kowal who want the nice libev and libeio bindings but not necessarily node&#39;s choices of modules or promises.
15 years ago
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
env->SetMethod(env->process_object(), "_rawDebug", RawDebug);
process: Add internal _rawDebug() method This is useful when we need to push some debugging messages out to stderr, without going through the Writable class, or triggering any kind of nextTick or callback behavior.
12 years ago
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
Local<Value> arg = env->process_object();
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
f->Call(global, 1, &arg);
Clean ups
16 years ago
}
Major refactoring: program name now &#34;node&#34; Trying to make a more moduler design. Two libraries currently &#34;TCP&#34; and &#34;HTTP&#34; each have their own file. Other major feature added here is multiple web servers! excitement.
16 years ago
Configurable debug ports, and --debug-brk
15 years ago
static void PrintHelp();
debugger: pass on v8 debug switches Before this commit, passing --debugger and other V8 debug switches to node.js made node print a usage message and exit. Rewrite the debug argument parser so it only consumes switches that we understand and pass everything else as-is to V8. A side effect of this change is that switches like --debugger_agent and --debugger_port now work. That kind of obsoletes our debugger switches because they implement pretty much the same functionality but let&#39;s leave them in for now for the sake of convenience and backwards compatibility. Fixes #6526.
11 years ago
static bool ParseDebugOpt(const char* arg) {
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
const char* port = nullptr;
Configurable debug ports, and --debug-brk
15 years ago
debugger: pass on v8 debug switches Before this commit, passing --debugger and other V8 debug switches to node.js made node print a usage message and exit. Rewrite the debug argument parser so it only consumes switches that we understand and pass everything else as-is to V8. A side effect of this change is that switches like --debugger_agent and --debugger_port now work. That kind of obsoletes our debugger switches because they implement pretty much the same functionality but let&#39;s leave them in for now for the sake of convenience and backwards compatibility. Fixes #6526.
11 years ago
if (!strcmp(arg, "--debug")) {
debugger, cluster: each worker has new debug port Implement support for debugging cluster workers. Each worker process is assigned a new debug port in an increasing sequence. I.e. when master process uses port 5858, then worker 1 uses port 5859, worker 2 uses port 5860, and so on. Introduce new command-line parameter &#39;--debug-port=&#39; which sets debug_port but does not start debugger. This option works for all node processes, it is not specific to cluster workers. Fixes joyent/node#5318.
12 years ago
use_debug_agent = true;
debugger: pass on v8 debug switches Before this commit, passing --debugger and other V8 debug switches to node.js made node print a usage message and exit. Rewrite the debug argument parser so it only consumes switches that we understand and pass everything else as-is to V8. A side effect of this change is that switches like --debugger_agent and --debugger_port now work. That kind of obsoletes our debugger switches because they implement pretty much the same functionality but let&#39;s leave them in for now for the sake of convenience and backwards compatibility. Fixes #6526.
11 years ago
} else if (!strncmp(arg, "--debug=", sizeof("--debug=") - 1)) {
use_debug_agent = true;
port = arg + sizeof("--debug=") - 1;
} else if (!strcmp(arg, "--debug-brk")) {
use_debug_agent = true;
debug_wait_connect = true;
} else if (!strncmp(arg, "--debug-brk=", sizeof("--debug-brk=") - 1)) {
use_debug_agent = true;
debug_wait_connect = true;
port = arg + sizeof("--debug-brk=") - 1;
} else if (!strncmp(arg, "--debug-port=", sizeof("--debug-port=") - 1)) {
port = arg + sizeof("--debug-port=") - 1;
} else {
return false;
Configurable debug ports, and --debug-brk
15 years ago
}
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (port != nullptr) {
debugger: pass on v8 debug switches Before this commit, passing --debugger and other V8 debug switches to node.js made node print a usage message and exit. Rewrite the debug argument parser so it only consumes switches that we understand and pass everything else as-is to V8. A side effect of this change is that switches like --debugger_agent and --debugger_port now work. That kind of obsoletes our debugger switches because they implement pretty much the same functionality but let&#39;s leave them in for now for the sake of convenience and backwards compatibility. Fixes #6526.
11 years ago
debug_port = atoi(port);
if (debug_port < 1024 || debug_port > 65535) {
fprintf(stderr, "Debug port must be in range 1024 to 65535.\n");
PrintHelp();
exit(12);
}
}
Configurable debug ports, and --debug-brk
15 years ago
debugger: pass on v8 debug switches Before this commit, passing --debugger and other V8 debug switches to node.js made node print a usage message and exit. Rewrite the debug argument parser so it only consumes switches that we understand and pass everything else as-is to V8. A side effect of this change is that switches like --debugger_agent and --debugger_port now work. That kind of obsoletes our debugger switches because they implement pretty much the same functionality but let&#39;s leave them in for now for the sake of convenience and backwards compatibility. Fixes #6526.
11 years ago
return true;
Configurable debug ports, and --debug-brk
15 years ago
}
cpplint.py node.cc and node.h
16 years ago
static void PrintHelp() {
Improve --help message and Fix -e/--eval switch --help should at least give some hint that node takes the -e switch Update help message to include -e and swap eval block with module load block so argv works correctly [steve@sane node](master)$ ./node -e &#39;process.argv&#39; foo bar [ &#39;/home/steve/code/node/node&#39;, &#39;foo&#39;, &#39;bar&#39; ] :) Add simple test for -e option. Fixes #1311.
14 years ago
printf("Usage: node [options] [ -e script | script.js ] [arguments] \n"
introduce node cluster
13 years ago
" node debug script.js [arguments] \n"
debugger: error out without script TODO: debug&gt; run script.js
14 years ago
"\n"
Add environmental varibles to help text
15 years ago
"Options:\n"
Add --max-stack-size flag. v8 doesn&#39;t expose a command-line flag to set the stack size, so this adds a new flag that node understands how to handle and uses v8&#39;s ResourceConstraints API.
14 years ago
" -v, --version print node's version\n"
Improve --help message and Fix -e/--eval switch --help should at least give some hint that node takes the -e switch Update help message to include -e and swap eval block with module load block so argv works correctly [steve@sane node](master)$ ./node -e &#39;process.argv&#39; foo bar [ &#39;/home/steve/code/node/node&#39;, &#39;foo&#39;, &#39;bar&#39; ] :) Add simple test for -e option. Fixes #1311.
14 years ago
" -e, --eval script evaluate script\n"
node: update description of --print
12 years ago
" -p, --print evaluate script and print result\n"
cmd: add a -i / --interactive flag to force the REPL This is the only way to spawn a node child process in REPL mode, and will also be needed to be able to use the REPL in MinTTY.
13 years ago
" -i, --interactive always enter the REPL even if stdin\n"
" does not appear to be a terminal\n"
Add --no-deprecation and --trace-deprecation flags
13 years ago
" --no-deprecation silence deprecation warnings\n"
src: add --throw-deprecation entry to --help
11 years ago
" --throw-deprecation throw an exception anytime a deprecated "
"function is used\n"
Add --no-deprecation and --trace-deprecation flags
13 years ago
" --trace-deprecation show stack traces on deprecations\n"
Add --max-stack-size flag. v8 doesn&#39;t expose a command-line flag to set the stack size, so this adds a new flag that node understands how to handle and uses v8&#39;s ResourceConstraints API.
14 years ago
" --v8-options print v8 command line options\n"
" --max-stack-size=val set max v8 stack size (bytes)\n"
build, i18n: improve Intl build, add &#34;--with-intl&#34; The two main goals of this change are: - To make it easier to build the Intl option using ICU (particularly, using a newer ICU than v8/Chromium&#39;s version) - To enable a much smaller ICU build with only English support The goal here is to get node.js binaries built this way by default so that the Intl API can be used. Additional data can be added at execution time (see Readme and wiki) More details are at https://github.com/joyent/node/pull/7719 In particular, this change adds the &#34;--with-intl=&#34; configure option to provide more ways of building &#34;Intl&#34;: - &#34;full-icu&#34; picks up an ICU from deps/icu - &#34;small-icu&#34; is similar, but builds only English - &#34;system-icu&#34; uses pkg-config to find an installed ICU - &#34;none&#34; does nothing (no Intl) For Windows builds, the &#34;full-icu&#34; or &#34;small-icu&#34; options are added to vcbuild.bat. Note that the existing &#34;--with-icu-path&#34; option is not removed from configure, but may not be used alongside the new option. Wiki changes have already been made on https://github.com/joyent/node/wiki/Installation and a new page created at https://github.com/joyent/node/wiki/Intl (marked as provisional until this change lands.) Summary of changes: * README.md : doc updates * .gitignore : added &#34;deps/icu&#34; as this is the location where ICU is unpacked to. * Makefile : added the tools/icu/* files to cpplint, but excluded a problematic file. * configure : added the &#34;--with-intl&#34; option mentioned above. Calculate at config time the list of ICU source files to use and data packaging options. * node.gyp : add the new files src/node_i18n.cc/.h as well as ICU linkage. * src/node.cc : add call into node::i18n::InitializeICUDirectory(icu_data_dir) as well as new --icu-data-dir option and NODE_ICU_DATA env variable to configure ICU data loading. This loading is only relevant in the &#34;small&#34; configuration. * src/node_i18n.cc : new source file for the above Initialize.. function, to setup ICU as needed. * tools/icu : new directory with some tools needed for this build. * tools/icu/icu-generic.gyp : new .gyp file that builds ICU in some new ways, both on unix/mac and windows. * tools/icu/icu-system.gyp : new .gyp file to build node against a pkg-config detected ICU. * tools/icu/icu_small.json : new config file for the &#34;English-only&#34; small build. * tools/icu/icutrim.py : new tool for trimming down ICU data. Reads the above .json file. * tools/icu/iculslocs.cc : new tool for repairing ICU data manifests after trim operation. * tools/icu/no-op.cc : dummy file to force .gyp into using a C++ linker. * vcbuild.bat : added small-icu and full-icu options, to call into configure. * Fixed toolset dependencies, see https://github.com/joyent/node/pull/7719#issuecomment-54641687 Note that because of a bug in gyp {CC,CXX}_host must also be set. Otherwise gcc/g++ will be used by default for part of the build. Reviewed-by: Trevor Norris &lt;trev.norris@gmail.com&gt; Reviewed-by: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
#if defined(NODE_HAVE_I18N_SUPPORT)
" --icu-data-dir=dir set ICU data load path to dir\n"
" (overrides NODE_ICU_DATA)\n"
#if !defined(NODE_HAVE_SMALL_ICU)
" Note: linked-in ICU data is\n"
" present.\n"
#endif
#endif
Add environmental varibles to help text
15 years ago
"\n"
cli: fix output of --help
13 years ago
"Environment variables:\n"
#ifdef _WIN32
"NODE_PATH ';'-separated list of directories\n"
#else
Add --max-stack-size flag. v8 doesn&#39;t expose a command-line flag to set the stack size, so this adds a new flag that node understands how to handle and uses v8&#39;s ResourceConstraints API.
14 years ago
"NODE_PATH ':'-separated list of directories\n"
cli: fix output of --help
13 years ago
#endif
Finish removing require.paths Fix require() completion bug in repl, and correct man output
14 years ago
" prefixed to the module search path.\n"
Add --max-stack-size flag. v8 doesn&#39;t expose a command-line flag to set the stack size, so this adds a new flag that node understands how to handle and uses v8&#39;s ResourceConstraints API.
14 years ago
"NODE_MODULE_CONTEXTS Set to 1 to load modules in their own\n"
" global contexts.\n"
debugger: error out without script TODO: debug&gt; run script.js
14 years ago
"NODE_DISABLE_COLORS Set to 1 to disable colors in the REPL\n"
build, i18n: improve Intl build, add &#34;--with-intl&#34; The two main goals of this change are: - To make it easier to build the Intl option using ICU (particularly, using a newer ICU than v8/Chromium&#39;s version) - To enable a much smaller ICU build with only English support The goal here is to get node.js binaries built this way by default so that the Intl API can be used. Additional data can be added at execution time (see Readme and wiki) More details are at https://github.com/joyent/node/pull/7719 In particular, this change adds the &#34;--with-intl=&#34; configure option to provide more ways of building &#34;Intl&#34;: - &#34;full-icu&#34; picks up an ICU from deps/icu - &#34;small-icu&#34; is similar, but builds only English - &#34;system-icu&#34; uses pkg-config to find an installed ICU - &#34;none&#34; does nothing (no Intl) For Windows builds, the &#34;full-icu&#34; or &#34;small-icu&#34; options are added to vcbuild.bat. Note that the existing &#34;--with-icu-path&#34; option is not removed from configure, but may not be used alongside the new option. Wiki changes have already been made on https://github.com/joyent/node/wiki/Installation and a new page created at https://github.com/joyent/node/wiki/Intl (marked as provisional until this change lands.) Summary of changes: * README.md : doc updates * .gitignore : added &#34;deps/icu&#34; as this is the location where ICU is unpacked to. * Makefile : added the tools/icu/* files to cpplint, but excluded a problematic file. * configure : added the &#34;--with-intl&#34; option mentioned above. Calculate at config time the list of ICU source files to use and data packaging options. * node.gyp : add the new files src/node_i18n.cc/.h as well as ICU linkage. * src/node.cc : add call into node::i18n::InitializeICUDirectory(icu_data_dir) as well as new --icu-data-dir option and NODE_ICU_DATA env variable to configure ICU data loading. This loading is only relevant in the &#34;small&#34; configuration. * src/node_i18n.cc : new source file for the above Initialize.. function, to setup ICU as needed. * tools/icu : new directory with some tools needed for this build. * tools/icu/icu-generic.gyp : new .gyp file that builds ICU in some new ways, both on unix/mac and windows. * tools/icu/icu-system.gyp : new .gyp file to build node against a pkg-config detected ICU. * tools/icu/icu_small.json : new config file for the &#34;English-only&#34; small build. * tools/icu/icutrim.py : new tool for trimming down ICU data. Reads the above .json file. * tools/icu/iculslocs.cc : new tool for repairing ICU data manifests after trim operation. * tools/icu/no-op.cc : dummy file to force .gyp into using a C++ linker. * vcbuild.bat : added small-icu and full-icu options, to call into configure. * Fixed toolset dependencies, see https://github.com/joyent/node/pull/7719#issuecomment-54641687 Note that because of a bug in gyp {CC,CXX}_host must also be set. Otherwise gcc/g++ will be used by default for part of the build. Reviewed-by: Trevor Norris &lt;trev.norris@gmail.com&gt; Reviewed-by: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
#if defined(NODE_HAVE_I18N_SUPPORT)
"NODE_ICU_DATA Data path for ICU (Intl object) data\n"
#if !defined(NODE_HAVE_SMALL_ICU)
" (will extend linked-in data)\n"
#endif
#endif
Add environmental varibles to help text
15 years ago
"\n"
debugger: error out without script TODO: debug&gt; run script.js
14 years ago
"Documentation can be found at http://nodejs.org/\n");
Add simple command line switches
16 years ago
}
debugger, cluster: each worker has new debug port Implement support for debugging cluster workers. Each worker process is assigned a new debug port in an increasing sequence. I.e. when master process uses port 5858, then worker 1 uses port 5859, worker 2 uses port 5860, and so on. Introduce new command-line parameter &#39;--debug-port=&#39; which sets debug_port but does not start debugger. This option works for all node processes, it is not specific to cluster workers. Fixes joyent/node#5318.
12 years ago
src: clean up CLI argument parser * Exit with an error message when the option is not a node or V8 option. * Remove the option_end_index global. Needs to happen anyway for the multi-context work, might as well land it in master now. * Add a smidgen of const-correctness. * Pay off a few years of accrued technical debt.
12 years ago
// Parse command line arguments.
//
// argv is modified in place. exec_argv and v8_argv are out arguments that
// ParseArgs() allocates memory for and stores a pointer to the output
// vector in. The caller should free them with delete[].
//
// On exit:
//
// * argv contains the arguments with node and V8 options filtered out.
// * exec_argv contains both node and V8 options and nothing else.
// * v8_argv contains argv[0] plus any V8 options
static void ParseArgs(int* argc,
const char** argv,
int* exec_argc,
const char*** exec_argv,
int* v8_argc,
const char*** v8_argv) {
const unsigned int nargs = static_cast<unsigned int>(*argc);
const char** new_exec_argv = new const char*[nargs];
const char** new_v8_argv = new const char*[nargs];
const char** new_argv = new const char*[nargs];
for (unsigned int i = 0; i < nargs; ++i) {
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
new_exec_argv[i] = nullptr;
new_v8_argv[i] = nullptr;
new_argv[i] = nullptr;
src: clean up CLI argument parser * Exit with an error message when the option is not a node or V8 option. * Remove the option_end_index global. Needs to happen anyway for the multi-context work, might as well land it in master now. * Add a smidgen of const-correctness. * Pay off a few years of accrued technical debt.
12 years ago
}
// exec_argv starts with the first option, the other two start with argv[0].
unsigned int new_exec_argc = 0;
unsigned int new_v8_argc = 1;
unsigned int new_argc = 1;
new_v8_argv[0] = argv[0];
new_argv[0] = argv[0];
unsigned int index = 1;
while (index < nargs && argv[index][0] == '-') {
const char* const arg = argv[index];
unsigned int args_consumed = 1;
Fix options parsing The current node has a bug where it will fail to pass the option argument immediately preceding the first non-option argument to V8. That is the --perf flag will be ignored by V8 when running &#39;node --perf script.js&#39;.
15 years ago
debugger: pass on v8 debug switches Before this commit, passing --debugger and other V8 debug switches to node.js made node print a usage message and exit. Rewrite the debug argument parser so it only consumes switches that we understand and pass everything else as-is to V8. A side effect of this change is that switches like --debugger_agent and --debugger_port now work. That kind of obsoletes our debugger switches because they implement pretty much the same functionality but let&#39;s leave them in for now for the sake of convenience and backwards compatibility. Fixes #6526.
11 years ago
if (ParseDebugOpt(arg)) {
// Done, consumed by ParseDebugOpt().
Add &#39;--&#39; to seperate v8 args from program args
16 years ago
} else if (strcmp(arg, "--version") == 0 || strcmp(arg, "-v") == 0) {
Add simple command line switches
16 years ago
printf("%s\n", NODE_VERSION);
exit(0);
} else if (strcmp(arg, "--help") == 0 || strcmp(arg, "-h") == 0) {
PrintHelp();
exit(0);
src: clean up CLI argument parser * Exit with an error message when the option is not a node or V8 option. * Remove the option_end_index global. Needs to happen anyway for the multi-context work, might as well land it in master now. * Add a smidgen of const-correctness. * Pay off a few years of accrued technical debt.
12 years ago
} else if (strcmp(arg, "--eval") == 0 ||
strcmp(arg, "-e") == 0 ||
strcmp(arg, "--print") == 0 ||
strcmp(arg, "-pe") == 0 ||
cli: make -p equivalent to -pe Fixes #3938.
13 years ago
strcmp(arg, "-p") == 0) {
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
bool is_eval = strchr(arg, 'e') != nullptr;
bool is_print = strchr(arg, 'p') != nullptr;
cli: make argument to -p optional
13 years ago
print_eval = print_eval || is_print;
src: clean up CLI argument parser * Exit with an error message when the option is not a node or V8 option. * Remove the option_end_index global. Needs to happen anyway for the multi-context work, might as well land it in master now. * Add a smidgen of const-correctness. * Pay off a few years of accrued technical debt.
12 years ago
// --eval, -e and -pe always require an argument.
cli: make argument to -p optional
13 years ago
if (is_eval == true) {
src: clean up CLI argument parser * Exit with an error message when the option is not a node or V8 option. * Remove the option_end_index global. Needs to happen anyway for the multi-context work, might as well land it in master now. * Add a smidgen of const-correctness. * Pay off a few years of accrued technical debt.
12 years ago
args_consumed += 1;
eval_string = argv[index + 1];
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (eval_string == nullptr) {
src: clean up CLI argument parser * Exit with an error message when the option is not a node or V8 option. * Remove the option_end_index global. Needs to happen anyway for the multi-context work, might as well land it in master now. * Add a smidgen of const-correctness. * Pay off a few years of accrued technical debt.
12 years ago
fprintf(stderr, "%s: %s requires an argument\n", argv[0], arg);
process: use exit 1 for uncaughtException Since it is Unix tradition to use exit code 1 for general-purpose script bail-out, and the way of doing that in Node is to throw an exception and not catch it, it makes the most sense to exit with 1 when an exception goes uncaught. Move the `Invalid Argument` exit to 9, so that it&#39;s something specific, and clear that it&#39;s a node internal error. Also, document the exit codes that we use.
11 years ago
exit(9);
src: clean up CLI argument parser * Exit with an error message when the option is not a node or V8 option. * Remove the option_end_index global. Needs to happen anyway for the multi-context work, might as well land it in master now. * Add a smidgen of const-correctness. * Pay off a few years of accrued technical debt.
12 years ago
}
node: fix argument parsing with -p arg node -p would cause an access violation. Fixes test\message\stdin_messages.js on Windows.
11 years ago
} else if ((index + 1 < nargs) &&
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
argv[index + 1] != nullptr &&
node: fix argument parsing with -p arg node -p would cause an access violation. Fixes test\message\stdin_messages.js on Windows.
11 years ago
argv[index + 1][0] != '-') {
src: clean up CLI argument parser * Exit with an error message when the option is not a node or V8 option. * Remove the option_end_index global. Needs to happen anyway for the multi-context work, might as well land it in master now. * Add a smidgen of const-correctness. * Pay off a few years of accrued technical debt.
12 years ago
args_consumed += 1;
eval_string = argv[index + 1];
if (strncmp(eval_string, "\\-", 2) == 0) {
// Starts with "\\-": escaped expression, drop the backslash.
eval_string += 1;
}
cli: make argument to -p optional
13 years ago
}
cmd: add a -i / --interactive flag to force the REPL This is the only way to spawn a node child process in REPL mode, and will also be needed to be able to use the REPL in MinTTY.
13 years ago
} else if (strcmp(arg, "--interactive") == 0 || strcmp(arg, "-i") == 0) {
force_repl = true;
Add --no-deprecation and --trace-deprecation flags
13 years ago
} else if (strcmp(arg, "--no-deprecation") == 0) {
no_deprecation = true;
} else if (strcmp(arg, "--trace-deprecation") == 0) {
trace_deprecation = true;
node: Add --throw-deprecation Extremely handy when tracking down a flood of recursive nextTick warnings.
12 years ago
} else if (strcmp(arg, "--throw-deprecation") == 0) {
throw_deprecation = true;
src: clean up CLI argument parser * Exit with an error message when the option is not a node or V8 option. * Remove the option_end_index global. Needs to happen anyway for the multi-context work, might as well land it in master now. * Add a smidgen of const-correctness. * Pay off a few years of accrued technical debt.
12 years ago
} else if (strcmp(arg, "--v8-options") == 0) {
new_v8_argv[new_v8_argc] = "--help";
new_v8_argc += 1;
build, i18n: improve Intl build, add &#34;--with-intl&#34; The two main goals of this change are: - To make it easier to build the Intl option using ICU (particularly, using a newer ICU than v8/Chromium&#39;s version) - To enable a much smaller ICU build with only English support The goal here is to get node.js binaries built this way by default so that the Intl API can be used. Additional data can be added at execution time (see Readme and wiki) More details are at https://github.com/joyent/node/pull/7719 In particular, this change adds the &#34;--with-intl=&#34; configure option to provide more ways of building &#34;Intl&#34;: - &#34;full-icu&#34; picks up an ICU from deps/icu - &#34;small-icu&#34; is similar, but builds only English - &#34;system-icu&#34; uses pkg-config to find an installed ICU - &#34;none&#34; does nothing (no Intl) For Windows builds, the &#34;full-icu&#34; or &#34;small-icu&#34; options are added to vcbuild.bat. Note that the existing &#34;--with-icu-path&#34; option is not removed from configure, but may not be used alongside the new option. Wiki changes have already been made on https://github.com/joyent/node/wiki/Installation and a new page created at https://github.com/joyent/node/wiki/Intl (marked as provisional until this change lands.) Summary of changes: * README.md : doc updates * .gitignore : added &#34;deps/icu&#34; as this is the location where ICU is unpacked to. * Makefile : added the tools/icu/* files to cpplint, but excluded a problematic file. * configure : added the &#34;--with-intl&#34; option mentioned above. Calculate at config time the list of ICU source files to use and data packaging options. * node.gyp : add the new files src/node_i18n.cc/.h as well as ICU linkage. * src/node.cc : add call into node::i18n::InitializeICUDirectory(icu_data_dir) as well as new --icu-data-dir option and NODE_ICU_DATA env variable to configure ICU data loading. This loading is only relevant in the &#34;small&#34; configuration. * src/node_i18n.cc : new source file for the above Initialize.. function, to setup ICU as needed. * tools/icu : new directory with some tools needed for this build. * tools/icu/icu-generic.gyp : new .gyp file that builds ICU in some new ways, both on unix/mac and windows. * tools/icu/icu-system.gyp : new .gyp file to build node against a pkg-config detected ICU. * tools/icu/icu_small.json : new config file for the &#34;English-only&#34; small build. * tools/icu/icutrim.py : new tool for trimming down ICU data. Reads the above .json file. * tools/icu/iculslocs.cc : new tool for repairing ICU data manifests after trim operation. * tools/icu/no-op.cc : dummy file to force .gyp into using a C++ linker. * vcbuild.bat : added small-icu and full-icu options, to call into configure. * Fixed toolset dependencies, see https://github.com/joyent/node/pull/7719#issuecomment-54641687 Note that because of a bug in gyp {CC,CXX}_host must also be set. Otherwise gcc/g++ will be used by default for part of the build. Reviewed-by: Trevor Norris &lt;trev.norris@gmail.com&gt; Reviewed-by: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
#if defined(NODE_HAVE_I18N_SUPPORT)
} else if (strncmp(arg, "--icu-data-dir=", 15) == 0) {
icu_data_dir = arg + 15;
#endif
src: clean up CLI argument parser * Exit with an error message when the option is not a node or V8 option. * Remove the option_end_index global. Needs to happen anyway for the multi-context work, might as well land it in master now. * Add a smidgen of const-correctness. * Pay off a few years of accrued technical debt.
12 years ago
} else {
// V8 option. Pass through as-is.
new_v8_argv[new_v8_argc] = arg;
new_v8_argc += 1;
Add simple command line switches
16 years ago
}
src: clean up CLI argument parser * Exit with an error message when the option is not a node or V8 option. * Remove the option_end_index global. Needs to happen anyway for the multi-context work, might as well land it in master now. * Add a smidgen of const-correctness. * Pay off a few years of accrued technical debt.
12 years ago
memcpy(new_exec_argv + new_exec_argc,
argv + index,
args_consumed * sizeof(*argv));
new_exec_argc += args_consumed;
index += args_consumed;
Add simple command line switches
16 years ago
}
Fix options parsing The current node has a bug where it will fail to pass the option argument immediately preceding the first non-option argument to V8. That is the --perf flag will be ignored by V8 when running &#39;node --perf script.js&#39;.
15 years ago
src: clean up CLI argument parser * Exit with an error message when the option is not a node or V8 option. * Remove the option_end_index global. Needs to happen anyway for the multi-context work, might as well land it in master now. * Add a smidgen of const-correctness. * Pay off a few years of accrued technical debt.
12 years ago
// Copy remaining arguments.
const unsigned int args_left = nargs - index;
memcpy(new_argv + new_argc, argv + index, args_left * sizeof(*argv));
new_argc += args_left;
*exec_argc = new_exec_argc;
*exec_argv = new_exec_argv;
*v8_argc = new_v8_argc;
*v8_argv = new_v8_argv;
// Copy new_argv over argv and update argc.
memcpy(argv, new_argv, new_argc * sizeof(*argv));
delete[] new_argv;
*argc = static_cast<int>(new_argc);
Add simple command line switches
16 years ago
}
Implement process._debugProcess
13 years ago
debugger: wake up the event loop when a debugger command is dispatched When the event loop was blocked in epoll / kqueue or similar, debugger commands wouldn&#39;t be processed. This patch fixes that by adding an uv_async handle which is triggered when a debugger command is dispatched. The async handle&#39;s callback makes sure that V8 is entered. Closes GH-3626 Closes GH-3718
13 years ago
// Called from V8 Debug Agent TCP thread.
deps: re-implement debugger-agent Reviewed-By: Trevor Norris &lt;trevnorris@gmail.com&gt; PR-URL: https://github.com/joyent/node/pull/8476
10 years ago
static void DispatchMessagesDebugAgentCallback(Environment* env) {
// TODO(indutny): move async handle to environment
debugger: wake up the event loop when a debugger command is dispatched When the event loop was blocked in epoll / kqueue or similar, debugger commands wouldn&#39;t be processed. This patch fixes that by adding an uv_async handle which is triggered when a debugger command is dispatched. The async handle&#39;s callback makes sure that V8 is entered. Closes GH-3626 Closes GH-3718
13 years ago
uv_async_send(&dispatch_debug_messages_async);
}
deps: re-implement debugger-agent Reviewed-By: Trevor Norris &lt;trevnorris@gmail.com&gt; PR-URL: https://github.com/joyent/node/pull/8476
10 years ago
static void StartDebug(Environment* env, bool wait) {
CHECK(!debugger_running);
env->debugger_agent()->set_dispatch_handler(
DispatchMessagesDebugAgentCallback);
debugger_running = env->debugger_agent()->Start(debug_port, wait);
debugger: make busy loops SIGUSR1-interruptible Commit 30e5366b (&#34;core: Use a uv_signal for debug listener&#34;) changed SIGUSR1 handling from a signal handler to libuv&#39;s uv_signal_*() functionality to fix a race condition (and possible hang) in the signal handler. While a good change in itself, it made it impossible to interrupt long running scripts. When a script is stuck in a busy loop, control never returns to the event loop, which in turn means the signal callback - and therefore the debugger - is never invoked. This commit changes SIGUSR1 handling back to a normal signal handler but one that treads _very_ carefully.
11 years ago
if (debugger_running == false) {
fprintf(stderr, "Starting debugger on port %d failed\n", debug_port);
fflush(stderr);
return;
}
deps: re-implement debugger-agent Reviewed-By: Trevor Norris &lt;trevnorris@gmail.com&gt; PR-URL: https://github.com/joyent/node/pull/8476
10 years ago
}
debugger: make busy loops SIGUSR1-interruptible Commit 30e5366b (&#34;core: Use a uv_signal for debug listener&#34;) changed SIGUSR1 handling from a signal handler to libuv&#39;s uv_signal_*() functionality to fix a race condition (and possible hang) in the signal handler. While a good change in itself, it made it impossible to interrupt long running scripts. When a script is stuck in a busy loop, control never returns to the event loop, which in turn means the signal callback - and therefore the debugger - is never invoked. This commit changes SIGUSR1 handling back to a normal signal handler but one that treads _very_ carefully.
11 years ago
deps: re-implement debugger-agent Reviewed-By: Trevor Norris &lt;trevnorris@gmail.com&gt; PR-URL: https://github.com/joyent/node/pull/8476
10 years ago
// Called from the main thread.
static void EnableDebug(Environment* env) {
CHECK(debugger_running);
// Send message to enable debug in workers
HandleScope handle_scope(env->isolate());
debugger: assign Environment to DebugContext too fix #7517
11 years ago
src: update to v8 3.24 APIs
11 years ago
Local<Object> message = Object::New(env->isolate());
debugger: make busy loops SIGUSR1-interruptible Commit 30e5366b (&#34;core: Use a uv_signal for debug listener&#34;) changed SIGUSR1 handling from a signal handler to libuv&#39;s uv_signal_*() functionality to fix a race condition (and possible hang) in the signal handler. While a good change in itself, it made it impossible to interrupt long running scripts. When a script is stuck in a busy loop, control never returns to the event loop, which in turn means the signal callback - and therefore the debugger - is never invoked. This commit changes SIGUSR1 handling back to a normal signal handler but one that treads _very_ carefully.
11 years ago
message->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "cmd"),
FIXED_ONE_BYTE_STRING(env->isolate(), "NODE_DEBUG_ENABLED"));
Local<Value> argv[] = {
FIXED_ONE_BYTE_STRING(env->isolate(), "internalMessage"),
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
message
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
};
debugger: make busy loops SIGUSR1-interruptible Commit 30e5366b (&#34;core: Use a uv_signal for debug listener&#34;) changed SIGUSR1 handling from a signal handler to libuv&#39;s uv_signal_*() functionality to fix a race condition (and possible hang) in the signal handler. While a good change in itself, it made it impossible to interrupt long running scripts. When a script is stuck in a busy loop, control never returns to the event loop, which in turn means the signal callback - and therefore the debugger - is never invoked. This commit changes SIGUSR1 handling back to a normal signal handler but one that treads _very_ carefully.
11 years ago
MakeCallback(env, env->process_object(), "emit", ARRAY_SIZE(argv), argv);
deps: re-implement debugger-agent Reviewed-By: Trevor Norris &lt;trevnorris@gmail.com&gt; PR-URL: https://github.com/joyent/node/pull/8476
10 years ago
// Enabled debugger, possibly making it wait on a semaphore
env->debugger_agent()->Enable();
debugger, cluster: each worker has new debug port Implement support for debugging cluster workers. Each worker process is assigned a new debug port in an increasing sequence. I.e. when master process uses port 5858, then worker 1 uses port 5859, worker 2 uses port 5860, and so on. Introduce new command-line parameter &#39;--debug-port=&#39; which sets debug_port but does not start debugger. This option works for all node processes, it is not specific to cluster workers. Fixes joyent/node#5318.
12 years ago
}
debugger: make busy loops SIGUSR1-interruptible Commit 30e5366b (&#34;core: Use a uv_signal for debug listener&#34;) changed SIGUSR1 handling from a signal handler to libuv&#39;s uv_signal_*() functionality to fix a race condition (and possible hang) in the signal handler. While a good change in itself, it made it impossible to interrupt long running scripts. When a script is stuck in a busy loop, control never returns to the event loop, which in turn means the signal callback - and therefore the debugger - is never invoked. This commit changes SIGUSR1 handling back to a normal signal handler but one that treads _very_ carefully.
11 years ago
// Called from the main thread.
src: update uv callbacks after API changes async, timer, prepare, idle and check handles no longer get a status parameter since they can never fail.
11 years ago
static void DispatchDebugMessagesAsyncCallback(uv_async_t* handle) {
debugger: make busy loops SIGUSR1-interruptible Commit 30e5366b (&#34;core: Use a uv_signal for debug listener&#34;) changed SIGUSR1 handling from a signal handler to libuv&#39;s uv_signal_*() functionality to fix a race condition (and possible hang) in the signal handler. While a good change in itself, it made it impossible to interrupt long running scripts. When a script is stuck in a busy loop, control never returns to the event loop, which in turn means the signal callback - and therefore the debugger - is never invoked. This commit changes SIGUSR1 handling back to a normal signal handler but one that treads _very_ carefully.
11 years ago
if (debugger_running == false) {
fprintf(stderr, "Starting debugger agent.\n");
deps: re-implement debugger-agent Reviewed-By: Trevor Norris &lt;trevnorris@gmail.com&gt; PR-URL: https://github.com/joyent/node/pull/8476
10 years ago
Environment* env = Environment::GetCurrent(node_isolate);
Context::Scope context_scope(env->context());
StartDebug(env, false);
EnableDebug(env);
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
}
debugger: make busy loops SIGUSR1-interruptible Commit 30e5366b (&#34;core: Use a uv_signal for debug listener&#34;) changed SIGUSR1 handling from a signal handler to libuv&#39;s uv_signal_*() functionality to fix a race condition (and possible hang) in the signal handler. While a good change in itself, it made it impossible to interrupt long running scripts. When a script is stuck in a busy loop, control never returns to the event loop, which in turn means the signal callback - and therefore the debugger - is never invoked. This commit changes SIGUSR1 handling back to a normal signal handler but one that treads _very_ carefully.
11 years ago
Isolate::Scope isolate_scope(node_isolate);
v8::Debug::ProcessDebugMessages();
start debug agent on SIGUSR1
14 years ago
}
Ctrl+Break on windows starts debugger server
13 years ago
#ifdef __POSIX__
debugger: fix SIGUSR1 bootstrap race condition Before this commit, the SIGUSR1 signal handler wasn&#39;t installed until late in the bootstrapping process and we were prone to miss signals sent by other processes. This commit installs an early-boot signal handler that merely records the fact that we received a signal. Once the debugger infrastructure is in place, the signal is re-raised, kickstarting the debugger. Among other things, this means that simple/test-debugger-client is now _much_ less likely to fail.
11 years ago
static volatile sig_atomic_t caught_early_debug_signal;
static void EarlyDebugSignalHandler(int signo) {
caught_early_debug_signal = 1;
}
static void InstallEarlyDebugSignalHandler() {
struct sigaction sa;
memset(&sa, 0, sizeof(sa));
sa.sa_handler = EarlyDebugSignalHandler;
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
sigaction(SIGUSR1, &sa, nullptr);
debugger: fix SIGUSR1 bootstrap race condition Before this commit, the SIGUSR1 signal handler wasn&#39;t installed until late in the bootstrapping process and we were prone to miss signals sent by other processes. This commit installs an early-boot signal handler that merely records the fact that we received a signal. Once the debugger infrastructure is in place, the signal is re-raised, kickstarting the debugger. Among other things, this means that simple/test-debugger-client is now _much_ less likely to fail.
11 years ago
}
debugger: make busy loops SIGUSR1-interruptible Commit 30e5366b (&#34;core: Use a uv_signal for debug listener&#34;) changed SIGUSR1 handling from a signal handler to libuv&#39;s uv_signal_*() functionality to fix a race condition (and possible hang) in the signal handler. While a good change in itself, it made it impossible to interrupt long running scripts. When a script is stuck in a busy loop, control never returns to the event loop, which in turn means the signal callback - and therefore the debugger - is never invoked. This commit changes SIGUSR1 handling back to a normal signal handler but one that treads _very_ carefully.
11 years ago
static void EnableDebugSignalHandler(int signo) {
// Call only async signal-safe functions here!
v8::Debug::DebugBreak(*static_cast<Isolate* volatile*>(&node_isolate));
uv_async_send(&dispatch_debug_messages_async);
start debug agent on SIGUSR1
14 years ago
}
Implement process._debugProcess
13 years ago
main: Handle SIGINT properly. As explained by http://www.cons.org/cracauer/sigint.html Signed-off-by: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
static void RegisterSignalHandler(int signal,
void (*handler)(int signal),
bool reset_handler = false) {
Implement process._debugProcess
13 years ago
struct sigaction sa;
memset(&sa, 0, sizeof(sa));
sa.sa_handler = handler;
main: Handle SIGINT properly. As explained by http://www.cons.org/cracauer/sigint.html Signed-off-by: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
sa.sa_flags = reset_handler ? SA_RESETHAND : 0;
Implement process._debugProcess
13 years ago
sigfillset(&sa.sa_mask);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
CHECK_EQ(sigaction(signal, &sa, nullptr), 0);
Implement process._debugProcess
13 years ago
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
void DebugProcess(const FunctionCallbackInfo<Value>& args) {
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
Implement process._debugProcess
13 years ago
if (args.Length() != 1) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowError("Invalid number of arguments.");
Implement process._debugProcess
13 years ago
}
pid_t pid;
int r;
pid = args[0]->IntegerValue();
r = kill(pid, SIGUSR1);
if (r != 0) {
src: remove `node_isolate` from source fix #6899
11 years ago
return env->ThrowErrnoException(errno, "kill");
Implement process._debugProcess
13 years ago
}
}
debugger: make busy loops SIGUSR1-interruptible Commit 30e5366b (&#34;core: Use a uv_signal for debug listener&#34;) changed SIGUSR1 handling from a signal handler to libuv&#39;s uv_signal_*() functionality to fix a race condition (and possible hang) in the signal handler. While a good change in itself, it made it impossible to interrupt long running scripts. When a script is stuck in a busy loop, control never returns to the event loop, which in turn means the signal callback - and therefore the debugger - is never invoked. This commit changes SIGUSR1 handling back to a normal signal handler but one that treads _very_ carefully.
11 years ago
static int RegisterDebugSignalHandler() {
// FIXME(bnoordhuis) Should be per-isolate or per-context, not global.
RegisterSignalHandler(SIGUSR1, EnableDebugSignalHandler);
debugger: fix SIGUSR1 bootstrap race condition Before this commit, the SIGUSR1 signal handler wasn&#39;t installed until late in the bootstrapping process and we were prone to miss signals sent by other processes. This commit installs an early-boot signal handler that merely records the fact that we received a signal. Once the debugger infrastructure is in place, the signal is re-raised, kickstarting the debugger. Among other things, this means that simple/test-debugger-client is now _much_ less likely to fail.
11 years ago
// If we caught a SIGUSR1 during the bootstrap process, re-raise it
// now that the debugger infrastructure is in place.
cpplint: disallow if one-liners
11 years ago
if (caught_early_debug_signal)
raise(SIGUSR1);
debugger: make busy loops SIGUSR1-interruptible Commit 30e5366b (&#34;core: Use a uv_signal for debug listener&#34;) changed SIGUSR1 handling from a signal handler to libuv&#39;s uv_signal_*() functionality to fix a race condition (and possible hang) in the signal handler. While a good change in itself, it made it impossible to interrupt long running scripts. When a script is stuck in a busy loop, control never returns to the event loop, which in turn means the signal callback - and therefore the debugger - is never invoked. This commit changes SIGUSR1 handling back to a normal signal handler but one that treads _very_ carefully.
11 years ago
return 0;
}
src: lint c++ code
12 years ago
#endif // __POSIX__
Ctrl+Break on windows starts debugger server
13 years ago
Implement process._debugProcess
13 years ago
#ifdef _WIN32
DWORD WINAPI EnableDebugThreadProc(void* arg) {
debugger: make busy loops SIGUSR1-interruptible Commit 30e5366b (&#34;core: Use a uv_signal for debug listener&#34;) changed SIGUSR1 handling from a signal handler to libuv&#39;s uv_signal_*() functionality to fix a race condition (and possible hang) in the signal handler. While a good change in itself, it made it impossible to interrupt long running scripts. When a script is stuck in a busy loop, control never returns to the event loop, which in turn means the signal callback - and therefore the debugger - is never invoked. This commit changes SIGUSR1 handling back to a normal signal handler but one that treads _very_ carefully.
11 years ago
v8::Debug::DebugBreak(*static_cast<Isolate* volatile*>(&node_isolate));
uv_async_send(&dispatch_debug_messages_async);
Implement process._debugProcess
13 years ago
return 0;
}
Make win32 ansi api usage explicit Use widechar versions in a couple of places. Don&#39;t use C-style cast in C++ code.
13 years ago
static int GetDebugSignalHandlerMappingName(DWORD pid, wchar_t* buf,
size_t buf_len) {
return _snwprintf(buf, buf_len, L"node-debug-handler-%u", pid);
Implement process._debugProcess
13 years ago
}
static int RegisterDebugSignalHandler() {
Make win32 ansi api usage explicit Use widechar versions in a couple of places. Don&#39;t use C-style cast in C++ code.
13 years ago
wchar_t mapping_name[32];
Implement process._debugProcess
13 years ago
HANDLE mapping_handle;
DWORD pid;
LPTHREAD_START_ROUTINE* handler;
pid = GetCurrentProcessId();
if (GetDebugSignalHandlerMappingName(pid,
mapping_name,
Make win32 ansi api usage explicit Use widechar versions in a couple of places. Don&#39;t use C-style cast in C++ code.
13 years ago
ARRAY_SIZE(mapping_name)) < 0) {
Implement process._debugProcess
13 years ago
return -1;
}
Make win32 ansi api usage explicit Use widechar versions in a couple of places. Don&#39;t use C-style cast in C++ code.
13 years ago
mapping_handle = CreateFileMappingW(INVALID_HANDLE_VALUE,
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
nullptr,
Implement process._debugProcess
13 years ago
PAGE_READWRITE,
0,
sizeof *handler,
mapping_name);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (mapping_handle == nullptr) {
Implement process._debugProcess
13 years ago
return -1;
Ctrl+Break on windows starts debugger server
13 years ago
}
Make win32 ansi api usage explicit Use widechar versions in a couple of places. Don&#39;t use C-style cast in C++ code.
13 years ago
handler = reinterpret_cast<LPTHREAD_START_ROUTINE*>(
MapViewOfFile(mapping_handle,
FILE_MAP_ALL_ACCESS,
0,
0,
sizeof *handler));
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (handler == nullptr) {
Implement process._debugProcess
13 years ago
CloseHandle(mapping_handle);
return -1;
}
*handler = EnableDebugThreadProc;
src: lint c++ code
12 years ago
UnmapViewOfFile(static_cast<void*>(handler));
Implement process._debugProcess
13 years ago
return 0;
Ctrl+Break on windows starts debugger server
13 years ago
}
start debug agent on SIGUSR1
14 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
static void DebugProcess(const FunctionCallbackInfo<Value>& args) {
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
src: node.cc use isolate-&gt;ThrowException Environment doesn&#39;t have ThrowException, we meant isolate here. Introduced in commit 75adde07f9a2de7f38a67bec72bd377d450bdb52.
11 years ago
Isolate* isolate = args.GetIsolate();
Implement process._debugProcess
13 years ago
DWORD pid;
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
HANDLE process = nullptr;
HANDLE thread = nullptr;
HANDLE mapping = nullptr;
Make win32 ansi api usage explicit Use widechar versions in a couple of places. Don&#39;t use C-style cast in C++ code.
13 years ago
wchar_t mapping_name[32];
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
LPTHREAD_START_ROUTINE* handler = nullptr;
start debug agent on SIGUSR1
14 years ago
Implement process._debugProcess
13 years ago
if (args.Length() != 1) {
src: remove `node_isolate` from source fix #6899
11 years ago
env->ThrowError("Invalid number of arguments.");
Implement process._debugProcess
13 years ago
goto out;
}
Add signal handlers so we clean up before exiting. Add SIGTERM and SIGINT signal handlers so that we run the exit handlers before exiting when getting these signals. Fixes an issue where we couldn&#39;t run vi after CTRL+C&#39;ing node because the stdin fd was left non-blocking.
14 years ago
Implement process._debugProcess
13 years ago
pid = (DWORD) args[0]->IntegerValue();
Rename some occurrences of `process_1` back to `process`
13 years ago
process = OpenProcess(PROCESS_CREATE_THREAD | PROCESS_QUERY_INFORMATION |
Implement process._debugProcess
13 years ago
PROCESS_VM_OPERATION | PROCESS_VM_WRITE |
PROCESS_VM_READ,
FALSE,
pid);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (process == nullptr) {
src: node.cc use isolate-&gt;ThrowException Environment doesn&#39;t have ThrowException, we meant isolate here. Introduced in commit 75adde07f9a2de7f38a67bec72bd377d450bdb52.
11 years ago
isolate->ThrowException(
WinapiErrnoException(isolate, GetLastError(), "OpenProcess"));
Implement process._debugProcess
13 years ago
goto out;
}
if (GetDebugSignalHandlerMappingName(pid,
mapping_name,
Make win32 ansi api usage explicit Use widechar versions in a couple of places. Don&#39;t use C-style cast in C++ code.
13 years ago
ARRAY_SIZE(mapping_name)) < 0) {
src: remove `node_isolate` from source fix #6899
11 years ago
env->ThrowErrnoException(errno, "sprintf");
Implement process._debugProcess
13 years ago
goto out;
}
Make win32 ansi api usage explicit Use widechar versions in a couple of places. Don&#39;t use C-style cast in C++ code.
13 years ago
mapping = OpenFileMappingW(FILE_MAP_READ, FALSE, mapping_name);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (mapping == nullptr) {
src: node.cc use isolate-&gt;ThrowException Environment doesn&#39;t have ThrowException, we meant isolate here. Introduced in commit 75adde07f9a2de7f38a67bec72bd377d450bdb52.
11 years ago
isolate->ThrowException(WinapiErrnoException(isolate,
src: remove `node_isolate` from source fix #6899
11 years ago
GetLastError(),
"OpenFileMappingW"));
Implement process._debugProcess
13 years ago
goto out;
}
Make win32 ansi api usage explicit Use widechar versions in a couple of places. Don&#39;t use C-style cast in C++ code.
13 years ago
handler = reinterpret_cast<LPTHREAD_START_ROUTINE*>(
MapViewOfFile(mapping,
FILE_MAP_READ,
0,
0,
sizeof *handler));
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (handler == nullptr || *handler == nullptr) {
src: node.cc use isolate-&gt;ThrowException Environment doesn&#39;t have ThrowException, we meant isolate here. Introduced in commit 75adde07f9a2de7f38a67bec72bd377d450bdb52.
11 years ago
isolate->ThrowException(
WinapiErrnoException(isolate, GetLastError(), "MapViewOfFile"));
Implement process._debugProcess
13 years ago
goto out;
}
Rename some occurrences of `process_1` back to `process`
13 years ago
thread = CreateRemoteThread(process,
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
nullptr,
Implement process._debugProcess
13 years ago
0,
*handler,
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
nullptr,
Implement process._debugProcess
13 years ago
0,
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
nullptr);
if (thread == nullptr) {
src: node.cc use isolate-&gt;ThrowException Environment doesn&#39;t have ThrowException, we meant isolate here. Introduced in commit 75adde07f9a2de7f38a67bec72bd377d450bdb52.
11 years ago
isolate->ThrowException(WinapiErrnoException(isolate,
GetLastError(),
"CreateRemoteThread"));
Implement process._debugProcess
13 years ago
goto out;
}
// Wait for the thread to terminate
if (WaitForSingleObject(thread, INFINITE) != WAIT_OBJECT_0) {
src: node.cc use isolate-&gt;ThrowException Environment doesn&#39;t have ThrowException, we meant isolate here. Introduced in commit 75adde07f9a2de7f38a67bec72bd377d450bdb52.
11 years ago
isolate->ThrowException(WinapiErrnoException(isolate,
GetLastError(),
"WaitForSingleObject"));
Implement process._debugProcess
13 years ago
goto out;
}
out:
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (process != nullptr)
src: lint c++ code
12 years ago
CloseHandle(process);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (thread != nullptr)
Implement process._debugProcess
13 years ago
CloseHandle(thread);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (handler != nullptr)
Implement process._debugProcess
13 years ago
UnmapViewOfFile(handler);
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (mapping != nullptr)
Implement process._debugProcess
13 years ago
CloseHandle(mapping);
Add signal handlers so we clean up before exiting. Add SIGTERM and SIGINT signal handlers so that we run the exit handlers before exiting when getting these signals. Fixes an issue where we couldn&#39;t run vi after CTRL+C&#39;ing node because the stdin fd was left non-blocking.
14 years ago
}
src: lint c++ code
12 years ago
#endif // _WIN32
Add signal handlers so we clean up before exiting. Add SIGTERM and SIGINT signal handlers so that we run the exit handlers before exiting when getting these signals. Fixes an issue where we couldn&#39;t run vi after CTRL+C&#39;ing node because the stdin fd was left non-blocking.
14 years ago
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
static void DebugPause(const FunctionCallbackInfo<Value>& args) {
src: remove `node_isolate` from source fix #6899
11 years ago
v8::Debug::DebugBreak(args.GetIsolate());
pause command
13 years ago
}
lib, src: upgrade after v8 api change This is a big commit that touches just about every file in the src/ directory. The V8 API has changed in significant ways. The most important changes are: * Binding functions take a const v8::FunctionCallbackInfo&lt;T&gt;&amp; argument rather than a const v8::Arguments&amp; argument. * Binding functions return void rather than v8::Handle&lt;v8::Value&gt;. The return value is returned with the args.GetReturnValue().Set() family of functions. * v8::Persistent&lt;T&gt; no longer derives from v8::Handle&lt;T&gt; and no longer allows you to directly dereference the object that the persistent handle points to. This means that the common pattern of caching oft-used JS values in a persistent handle no longer quite works, you first need to reconstruct a v8::Local&lt;T&gt; from the persistent handle with the Local&lt;T&gt;::New(isolate, persistent) factory method. A handful of (internal) convenience classes and functions have been added to make dealing with the new API a little easier. The most visible one is node::Cached&lt;T&gt;, which wraps a v8::Persistent&lt;T&gt; with some template sugar. It can hold arbitrary types but so far it&#39;s exclusively used for v8::Strings (which was by far the most commonly cached handle type.)
12 years ago
static void DebugEnd(const FunctionCallbackInfo<Value>& args) {
debugger: export `debug_port` to `process` `process.debug_port` is useful for changing debugger port in runtime, before starting it (via SIGUSR1). Using `--port=` argument for debugger repl, tests will run debugger server on a `common.PORT` (as it usually does for any other servers). `process._debugEnd()` stops debugger and its server. * debugger: implemented process._debugEnd(), `node debug --port=5858 app.js` * test: start debugger repl on common.PORT * fixes #2613 * fixes #2614
13 years ago
if (debugger_running) {
src: attach env directly to api functions Attach the per-context execution environment directly to API functions. Rationale: * Gets node one step closer to multi-isolate readiness. * Avoids multi-context confusion, e.g. when the caller and callee live in different contexts. * Avoids expensive calls to pthread_getspecific() on platforms where V8 does not know how to use the thread-local storage directly. (Linux, the BSDs.) PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
Environment* env = Environment::GetCurrent(args);
deps: re-implement debugger-agent Reviewed-By: Trevor Norris &lt;trevnorris@gmail.com&gt; PR-URL: https://github.com/joyent/node/pull/8476
10 years ago
env->debugger_agent()->Stop();
debugger: export `debug_port` to `process` `process.debug_port` is useful for changing debugger port in runtime, before starting it (via SIGUSR1). Using `--port=` argument for debugger repl, tests will run debugger server on a `common.PORT` (as it usually does for any other servers). `process._debugEnd()` stops debugger and its server. * debugger: implemented process._debugEnd(), `node debug --port=5858 app.js` * test: start debugger repl on common.PORT * fixes #2613 * fixes #2614
13 years ago
debugger_running = false;
}
}
src: clean up CLI argument parser * Exit with an error message when the option is not a node or V8 option. * Remove the option_end_index global. Needs to happen anyway for the multi-context work, might as well land it in master now. * Add a smidgen of const-correctness. * Pay off a few years of accrued technical debt.
12 years ago
void Init(int* argc,
const char** argv,
int* exec_argc,
const char*** exec_argv) {
Revert support for isolates. It was decided that the performance benefits that isolates offer (faster spin-up times for worker processes, faster inter-worker communication, possibly a lower memory footprint) are not actual bottlenecks for most people and do not outweigh the potential stability issues and intrusive changes to the code base that first-class support for isolates requires. Hence, this commit backs out all isolates-related changes. Good bye, isolates. We hardly knew ye.
13 years ago
// Initialize prog_start_time to get relative uptime.
src: fix VC++ warning C4244 Reviewed-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
10 years ago
prog_start_time = static_cast<double>(uv_now(uv_default_loop()));
Revert support for isolates. It was decided that the performance benefits that isolates offer (faster spin-up times for worker processes, faster inter-worker communication, possibly a lower memory footprint) are not actual bottlenecks for most people and do not outweigh the potential stability issues and intrusive changes to the code base that first-class support for isolates requires. Hence, this commit backs out all isolates-related changes. Good bye, isolates. We hardly knew ye.
13 years ago
Inherited FDs should not accidentally be inherited by child processes This makes test-child-process-detached pass on Windows.
13 years ago
// Make inherited handles noninheritable.
uv_disable_stdio_inheritance();
src: initialize debug-related uv_async_t handles uv_async_t handles for dispatching of debug messages and emitting NODE_DEBUG_ENABLED used to be initialized every time node::EnableDebug() was called, which happened every time user sends a SIGUSR1. Now they are initialized only once from node::Init() during application start.
12 years ago
// init async debug messages dispatching
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
// FIXME(bnoordhuis) Should be per-isolate or per-context, not global.
src: initialize debug-related uv_async_t handles uv_async_t handles for dispatching of debug messages and emitting NODE_DEBUG_ENABLED used to be initialized every time node::EnableDebug() was called, which happened every time user sends a SIGUSR1. Now they are initialized only once from node::Init() during application start.
12 years ago
uv_async_init(uv_default_loop(),
&dispatch_debug_messages_async,
DispatchDebugMessagesAsyncCallback);
uv_unref(reinterpret_cast<uv_handle_t*>(&dispatch_debug_messages_async));
src: disable harmony classes The V8 development branch has unshipped ES6 classes pending resolution of a number of inheritance edge cases. Disable classes in io.js for the sake of feature parity. See https://github.com/iojs/io.js/issues/251 for background and discussion. PR-URL: https://github.com/iojs/io.js/pull/272 Reviewed-By: Colin Ihrig &lt;cjihrig@gmail.com&gt; Reviewed-By: Domenic Denicola &lt;domenic@domenicdenicola.com&gt;
10 years ago
// TODO(bnoordhuis) V8 3.32 is unshipping Harmony classes for the moment.
// We're currently at 3.31, disable classes for feature parity. Remove
// again when we upgrade.
V8::SetFlagsFromString("--noharmony_classes",
sizeof("--noharmony_classes") - 1);
src: disable harmony object literals Per the discussion in https://github.com/iojs/io.js/pull/272, upstream V8 has disabled Harmony object literals for the time being. Do the same for feature parity. PR-URL: https://github.com/iojs/io.js/pull/272 Reviewed-By: Colin Ihrig &lt;cjihrig@gmail.com&gt; Reviewed-By: Domenic Denicola &lt;domenic@domenicdenicola.com&gt;
10 years ago
V8::SetFlagsFromString("--noharmony_object_literals",
sizeof("--noharmony_object_literals") - 1);
src: disable harmony classes The V8 development branch has unshipped ES6 classes pending resolution of a number of inheritance edge cases. Disable classes in io.js for the sake of feature parity. See https://github.com/iojs/io.js/issues/251 for background and discussion. PR-URL: https://github.com/iojs/io.js/pull/272 Reviewed-By: Colin Ihrig &lt;cjihrig@gmail.com&gt; Reviewed-By: Domenic Denicola &lt;domenic@domenicdenicola.com&gt;
10 years ago
configure: make --v8-options switch more robust Improve on commit b55c9d6 by not requiring that switches are comma separated. This commit makes `./configure --v8-options=&#34;--foo --bar&#34;` work and takes special care to properly escape quotes in the options string.
11 years ago
#if defined(NODE_V8_OPTIONS)
// Should come before the call to V8::SetFlagsFromCommandLine()
// so the user can disable a flag --foo at run-time by passing
// --no_foo from the command line.
V8::SetFlagsFromString(NODE_V8_OPTIONS, sizeof(NODE_V8_OPTIONS) - 1);
#endif
configure: --v8-options option Introduce a way to set some v8 flags at compile time, the values should be separated by comma.
11 years ago
Add comments to node.cc
15 years ago
// Parse a few arguments which are specific to Node.
src: clean up CLI argument parser * Exit with an error message when the option is not a node or V8 option. * Remove the option_end_index global. Needs to happen anyway for the multi-context work, might as well land it in master now. * Add a smidgen of const-correctness. * Pay off a few years of accrued technical debt.
12 years ago
int v8_argc;
const char** v8_argv;
ParseArgs(argc, argv, exec_argc, exec_argv, &v8_argc, &v8_argv);
remove node::CheckBreak in favor of using the v8 debugger js object
15 years ago
src: only start idle notifier when profiling The previous commit adds a notifier that tells the V8 profiler when node.js is idle, i.e. when it&#39;s about to start sleeping in the platform&#39;s equivalent of epoll_wait(). This commit adds a heuristic that only starts the notifier when the V8 profiler is started from the command line.
11 years ago
// TODO(bnoordhuis) Intercept --prof arguments and start the CPU profiler
// manually? That would give us a little more control over its runtime
// behavior but it could also interfere with the user's intentions in ways
// we fail to anticipate. Dillema.
for (int i = 1; i < v8_argc; ++i) {
if (strncmp(v8_argv[i], "--prof", sizeof("--prof") - 1) == 0) {
v8_is_profiling = true;
break;
}
}
build, i18n: improve Intl build, add &#34;--with-intl&#34; The two main goals of this change are: - To make it easier to build the Intl option using ICU (particularly, using a newer ICU than v8/Chromium&#39;s version) - To enable a much smaller ICU build with only English support The goal here is to get node.js binaries built this way by default so that the Intl API can be used. Additional data can be added at execution time (see Readme and wiki) More details are at https://github.com/joyent/node/pull/7719 In particular, this change adds the &#34;--with-intl=&#34; configure option to provide more ways of building &#34;Intl&#34;: - &#34;full-icu&#34; picks up an ICU from deps/icu - &#34;small-icu&#34; is similar, but builds only English - &#34;system-icu&#34; uses pkg-config to find an installed ICU - &#34;none&#34; does nothing (no Intl) For Windows builds, the &#34;full-icu&#34; or &#34;small-icu&#34; options are added to vcbuild.bat. Note that the existing &#34;--with-icu-path&#34; option is not removed from configure, but may not be used alongside the new option. Wiki changes have already been made on https://github.com/joyent/node/wiki/Installation and a new page created at https://github.com/joyent/node/wiki/Intl (marked as provisional until this change lands.) Summary of changes: * README.md : doc updates * .gitignore : added &#34;deps/icu&#34; as this is the location where ICU is unpacked to. * Makefile : added the tools/icu/* files to cpplint, but excluded a problematic file. * configure : added the &#34;--with-intl&#34; option mentioned above. Calculate at config time the list of ICU source files to use and data packaging options. * node.gyp : add the new files src/node_i18n.cc/.h as well as ICU linkage. * src/node.cc : add call into node::i18n::InitializeICUDirectory(icu_data_dir) as well as new --icu-data-dir option and NODE_ICU_DATA env variable to configure ICU data loading. This loading is only relevant in the &#34;small&#34; configuration. * src/node_i18n.cc : new source file for the above Initialize.. function, to setup ICU as needed. * tools/icu : new directory with some tools needed for this build. * tools/icu/icu-generic.gyp : new .gyp file that builds ICU in some new ways, both on unix/mac and windows. * tools/icu/icu-system.gyp : new .gyp file to build node against a pkg-config detected ICU. * tools/icu/icu_small.json : new config file for the &#34;English-only&#34; small build. * tools/icu/icutrim.py : new tool for trimming down ICU data. Reads the above .json file. * tools/icu/iculslocs.cc : new tool for repairing ICU data manifests after trim operation. * tools/icu/no-op.cc : dummy file to force .gyp into using a C++ linker. * vcbuild.bat : added small-icu and full-icu options, to call into configure. * Fixed toolset dependencies, see https://github.com/joyent/node/pull/7719#issuecomment-54641687 Note that because of a bug in gyp {CC,CXX}_host must also be set. Otherwise gcc/g++ will be used by default for part of the build. Reviewed-by: Trevor Norris &lt;trev.norris@gmail.com&gt; Reviewed-by: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
#if defined(NODE_HAVE_I18N_SUPPORT)
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (icu_data_dir == nullptr) {
build, i18n: improve Intl build, add &#34;--with-intl&#34; The two main goals of this change are: - To make it easier to build the Intl option using ICU (particularly, using a newer ICU than v8/Chromium&#39;s version) - To enable a much smaller ICU build with only English support The goal here is to get node.js binaries built this way by default so that the Intl API can be used. Additional data can be added at execution time (see Readme and wiki) More details are at https://github.com/joyent/node/pull/7719 In particular, this change adds the &#34;--with-intl=&#34; configure option to provide more ways of building &#34;Intl&#34;: - &#34;full-icu&#34; picks up an ICU from deps/icu - &#34;small-icu&#34; is similar, but builds only English - &#34;system-icu&#34; uses pkg-config to find an installed ICU - &#34;none&#34; does nothing (no Intl) For Windows builds, the &#34;full-icu&#34; or &#34;small-icu&#34; options are added to vcbuild.bat. Note that the existing &#34;--with-icu-path&#34; option is not removed from configure, but may not be used alongside the new option. Wiki changes have already been made on https://github.com/joyent/node/wiki/Installation and a new page created at https://github.com/joyent/node/wiki/Intl (marked as provisional until this change lands.) Summary of changes: * README.md : doc updates * .gitignore : added &#34;deps/icu&#34; as this is the location where ICU is unpacked to. * Makefile : added the tools/icu/* files to cpplint, but excluded a problematic file. * configure : added the &#34;--with-intl&#34; option mentioned above. Calculate at config time the list of ICU source files to use and data packaging options. * node.gyp : add the new files src/node_i18n.cc/.h as well as ICU linkage. * src/node.cc : add call into node::i18n::InitializeICUDirectory(icu_data_dir) as well as new --icu-data-dir option and NODE_ICU_DATA env variable to configure ICU data loading. This loading is only relevant in the &#34;small&#34; configuration. * src/node_i18n.cc : new source file for the above Initialize.. function, to setup ICU as needed. * tools/icu : new directory with some tools needed for this build. * tools/icu/icu-generic.gyp : new .gyp file that builds ICU in some new ways, both on unix/mac and windows. * tools/icu/icu-system.gyp : new .gyp file to build node against a pkg-config detected ICU. * tools/icu/icu_small.json : new config file for the &#34;English-only&#34; small build. * tools/icu/icutrim.py : new tool for trimming down ICU data. Reads the above .json file. * tools/icu/iculslocs.cc : new tool for repairing ICU data manifests after trim operation. * tools/icu/no-op.cc : dummy file to force .gyp into using a C++ linker. * vcbuild.bat : added small-icu and full-icu options, to call into configure. * Fixed toolset dependencies, see https://github.com/joyent/node/pull/7719#issuecomment-54641687 Note that because of a bug in gyp {CC,CXX}_host must also be set. Otherwise gcc/g++ will be used by default for part of the build. Reviewed-by: Trevor Norris &lt;trev.norris@gmail.com&gt; Reviewed-by: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
// if the parameter isn't given, use the env variable.
src: ignore risky env vars when setuid root On POSIX platforms, check that the uid and gid match the euid and egid respectively before looking up the environment variable. Before this commit, an i18n-enabled suid node would cheerfully load attacker-controlled ICU data through the NODE_ICU_DATA environment variable. This commit is not a complete fix. For example, it&#39;s up for debate what to do with the NODE_CHANNEL_FD environment variable. PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
icu_data_dir = secure_getenv("NODE_ICU_DATA");
build, i18n: improve Intl build, add &#34;--with-intl&#34; The two main goals of this change are: - To make it easier to build the Intl option using ICU (particularly, using a newer ICU than v8/Chromium&#39;s version) - To enable a much smaller ICU build with only English support The goal here is to get node.js binaries built this way by default so that the Intl API can be used. Additional data can be added at execution time (see Readme and wiki) More details are at https://github.com/joyent/node/pull/7719 In particular, this change adds the &#34;--with-intl=&#34; configure option to provide more ways of building &#34;Intl&#34;: - &#34;full-icu&#34; picks up an ICU from deps/icu - &#34;small-icu&#34; is similar, but builds only English - &#34;system-icu&#34; uses pkg-config to find an installed ICU - &#34;none&#34; does nothing (no Intl) For Windows builds, the &#34;full-icu&#34; or &#34;small-icu&#34; options are added to vcbuild.bat. Note that the existing &#34;--with-icu-path&#34; option is not removed from configure, but may not be used alongside the new option. Wiki changes have already been made on https://github.com/joyent/node/wiki/Installation and a new page created at https://github.com/joyent/node/wiki/Intl (marked as provisional until this change lands.) Summary of changes: * README.md : doc updates * .gitignore : added &#34;deps/icu&#34; as this is the location where ICU is unpacked to. * Makefile : added the tools/icu/* files to cpplint, but excluded a problematic file. * configure : added the &#34;--with-intl&#34; option mentioned above. Calculate at config time the list of ICU source files to use and data packaging options. * node.gyp : add the new files src/node_i18n.cc/.h as well as ICU linkage. * src/node.cc : add call into node::i18n::InitializeICUDirectory(icu_data_dir) as well as new --icu-data-dir option and NODE_ICU_DATA env variable to configure ICU data loading. This loading is only relevant in the &#34;small&#34; configuration. * src/node_i18n.cc : new source file for the above Initialize.. function, to setup ICU as needed. * tools/icu : new directory with some tools needed for this build. * tools/icu/icu-generic.gyp : new .gyp file that builds ICU in some new ways, both on unix/mac and windows. * tools/icu/icu-system.gyp : new .gyp file to build node against a pkg-config detected ICU. * tools/icu/icu_small.json : new config file for the &#34;English-only&#34; small build. * tools/icu/icutrim.py : new tool for trimming down ICU data. Reads the above .json file. * tools/icu/iculslocs.cc : new tool for repairing ICU data manifests after trim operation. * tools/icu/no-op.cc : dummy file to force .gyp into using a C++ linker. * vcbuild.bat : added small-icu and full-icu options, to call into configure. * Fixed toolset dependencies, see https://github.com/joyent/node/pull/7719#issuecomment-54641687 Note that because of a bug in gyp {CC,CXX}_host must also be set. Otherwise gcc/g++ will be used by default for part of the build. Reviewed-by: Trevor Norris &lt;trev.norris@gmail.com&gt; Reviewed-by: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
}
// Initialize ICU.
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
// If icu_data_dir is nullptr here, it will load the 'minimal' data.
build, i18n: improve Intl build, add &#34;--with-intl&#34; The two main goals of this change are: - To make it easier to build the Intl option using ICU (particularly, using a newer ICU than v8/Chromium&#39;s version) - To enable a much smaller ICU build with only English support The goal here is to get node.js binaries built this way by default so that the Intl API can be used. Additional data can be added at execution time (see Readme and wiki) More details are at https://github.com/joyent/node/pull/7719 In particular, this change adds the &#34;--with-intl=&#34; configure option to provide more ways of building &#34;Intl&#34;: - &#34;full-icu&#34; picks up an ICU from deps/icu - &#34;small-icu&#34; is similar, but builds only English - &#34;system-icu&#34; uses pkg-config to find an installed ICU - &#34;none&#34; does nothing (no Intl) For Windows builds, the &#34;full-icu&#34; or &#34;small-icu&#34; options are added to vcbuild.bat. Note that the existing &#34;--with-icu-path&#34; option is not removed from configure, but may not be used alongside the new option. Wiki changes have already been made on https://github.com/joyent/node/wiki/Installation and a new page created at https://github.com/joyent/node/wiki/Intl (marked as provisional until this change lands.) Summary of changes: * README.md : doc updates * .gitignore : added &#34;deps/icu&#34; as this is the location where ICU is unpacked to. * Makefile : added the tools/icu/* files to cpplint, but excluded a problematic file. * configure : added the &#34;--with-intl&#34; option mentioned above. Calculate at config time the list of ICU source files to use and data packaging options. * node.gyp : add the new files src/node_i18n.cc/.h as well as ICU linkage. * src/node.cc : add call into node::i18n::InitializeICUDirectory(icu_data_dir) as well as new --icu-data-dir option and NODE_ICU_DATA env variable to configure ICU data loading. This loading is only relevant in the &#34;small&#34; configuration. * src/node_i18n.cc : new source file for the above Initialize.. function, to setup ICU as needed. * tools/icu : new directory with some tools needed for this build. * tools/icu/icu-generic.gyp : new .gyp file that builds ICU in some new ways, both on unix/mac and windows. * tools/icu/icu-system.gyp : new .gyp file to build node against a pkg-config detected ICU. * tools/icu/icu_small.json : new config file for the &#34;English-only&#34; small build. * tools/icu/icutrim.py : new tool for trimming down ICU data. Reads the above .json file. * tools/icu/iculslocs.cc : new tool for repairing ICU data manifests after trim operation. * tools/icu/no-op.cc : dummy file to force .gyp into using a C++ linker. * vcbuild.bat : added small-icu and full-icu options, to call into configure. * Fixed toolset dependencies, see https://github.com/joyent/node/pull/7719#issuecomment-54641687 Note that because of a bug in gyp {CC,CXX}_host must also be set. Otherwise gcc/g++ will be used by default for part of the build. Reviewed-by: Trevor Norris &lt;trev.norris@gmail.com&gt; Reviewed-by: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
if (!i18n::InitializeICUDirectory(icu_data_dir)) {
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
FatalError(nullptr, "Could not initialize ICU "
build, i18n: improve Intl build, add &#34;--with-intl&#34; The two main goals of this change are: - To make it easier to build the Intl option using ICU (particularly, using a newer ICU than v8/Chromium&#39;s version) - To enable a much smaller ICU build with only English support The goal here is to get node.js binaries built this way by default so that the Intl API can be used. Additional data can be added at execution time (see Readme and wiki) More details are at https://github.com/joyent/node/pull/7719 In particular, this change adds the &#34;--with-intl=&#34; configure option to provide more ways of building &#34;Intl&#34;: - &#34;full-icu&#34; picks up an ICU from deps/icu - &#34;small-icu&#34; is similar, but builds only English - &#34;system-icu&#34; uses pkg-config to find an installed ICU - &#34;none&#34; does nothing (no Intl) For Windows builds, the &#34;full-icu&#34; or &#34;small-icu&#34; options are added to vcbuild.bat. Note that the existing &#34;--with-icu-path&#34; option is not removed from configure, but may not be used alongside the new option. Wiki changes have already been made on https://github.com/joyent/node/wiki/Installation and a new page created at https://github.com/joyent/node/wiki/Intl (marked as provisional until this change lands.) Summary of changes: * README.md : doc updates * .gitignore : added &#34;deps/icu&#34; as this is the location where ICU is unpacked to. * Makefile : added the tools/icu/* files to cpplint, but excluded a problematic file. * configure : added the &#34;--with-intl&#34; option mentioned above. Calculate at config time the list of ICU source files to use and data packaging options. * node.gyp : add the new files src/node_i18n.cc/.h as well as ICU linkage. * src/node.cc : add call into node::i18n::InitializeICUDirectory(icu_data_dir) as well as new --icu-data-dir option and NODE_ICU_DATA env variable to configure ICU data loading. This loading is only relevant in the &#34;small&#34; configuration. * src/node_i18n.cc : new source file for the above Initialize.. function, to setup ICU as needed. * tools/icu : new directory with some tools needed for this build. * tools/icu/icu-generic.gyp : new .gyp file that builds ICU in some new ways, both on unix/mac and windows. * tools/icu/icu-system.gyp : new .gyp file to build node against a pkg-config detected ICU. * tools/icu/icu_small.json : new config file for the &#34;English-only&#34; small build. * tools/icu/icutrim.py : new tool for trimming down ICU data. Reads the above .json file. * tools/icu/iculslocs.cc : new tool for repairing ICU data manifests after trim operation. * tools/icu/no-op.cc : dummy file to force .gyp into using a C++ linker. * vcbuild.bat : added small-icu and full-icu options, to call into configure. * Fixed toolset dependencies, see https://github.com/joyent/node/pull/7719#issuecomment-54641687 Note that because of a bug in gyp {CC,CXX}_host must also be set. Otherwise gcc/g++ will be used by default for part of the build. Reviewed-by: Trevor Norris &lt;trev.norris@gmail.com&gt; Reviewed-by: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
"(check NODE_ICU_DATA or --icu-data-dir parameters)");
}
#endif
src: clean up CLI argument parser * Exit with an error message when the option is not a node or V8 option. * Remove the option_end_index global. Needs to happen anyway for the multi-context work, might as well land it in master now. * Add a smidgen of const-correctness. * Pay off a few years of accrued technical debt.
12 years ago
// The const_cast doesn't violate conceptual const-ness. V8 doesn't modify
// the argv array or the elements it points to.
V8::SetFlagsFromCommandLine(&v8_argc, const_cast<char**>(v8_argv), true);
// Anything that's still in v8_argv is not a V8 or a node option.
for (int i = 1; i < v8_argc; i++) {
fprintf(stderr, "%s: bad option: %s\n", argv[0], v8_argv[i]);
Revert &#34;Expose the V8 debug object process.debug&#34; This reverts commit d9fbb8a58071e339711e8c0ceeb31de5a645fd42.
15 years ago
}
src: clean up CLI argument parser * Exit with an error message when the option is not a node or V8 option. * Remove the option_end_index global. Needs to happen anyway for the multi-context work, might as well land it in master now. * Add a smidgen of const-correctness. * Pay off a few years of accrued technical debt.
12 years ago
delete[] v8_argv;
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
v8_argv = nullptr;
Add --max-stack-size flag. v8 doesn&#39;t expose a command-line flag to set the stack size, so this adds a new flag that node understands how to handle and uses v8&#39;s ResourceConstraints API.
14 years ago
src: clean up CLI argument parser * Exit with an error message when the option is not a node or V8 option. * Remove the option_end_index global. Needs to happen anyway for the multi-context work, might as well land it in master now. * Add a smidgen of const-correctness. * Pay off a few years of accrued technical debt.
12 years ago
if (v8_argc > 1) {
process: use exit 1 for uncaughtException Since it is Unix tradition to use exit code 1 for general-purpose script bail-out, and the way of doing that in Node is to throw an exception and not catch it, it makes the most sense to exit with 1 when an exception goes uncaught. Move the `Invalid Argument` exit to 9, so that it&#39;s something specific, and clear that it&#39;s a node internal error. Also, document the exit codes that we use.
11 years ago
exit(9);
src: clean up CLI argument parser * Exit with an error message when the option is not a node or V8 option. * Remove the option_end_index global. Needs to happen anyway for the multi-context work, might as well land it in master now. * Add a smidgen of const-correctness. * Pay off a few years of accrued technical debt.
12 years ago
}
if (debug_wait_connect) {
const char expose_debug_as[] = "--expose_debug_as=v8debug";
V8::SetFlagsFromString(expose_debug_as, sizeof(expose_debug_as) - 1);
}
Move arg parsing to beginning of main() For faster &#34;./node -v&#34;
16 years ago
src: enable native v8 typed arrays This commit removes our homegrown typed arrays implementation and enables V8&#39;s built-in typed arrays implementation.
12 years ago
V8::SetArrayBufferAllocator(&ArrayBufferAllocator::the_singleton);
Disable node.cc functions that are not supported on windows
14 years ago
#ifdef __POSIX__
src: raise maximum file descriptor limit Do a binary search for the maximum RLIMIT_NOFILE. Works around the low, low limits on certain high, high-priced devices from Cupertino, CA.
11 years ago
// Raise the open file descriptor limit.
lint: fix a cpplint error Added a NOLINT so that cpplint won&#39;t complain about some code.
11 years ago
{ // NOLINT (whitespace/braces)
src: raise maximum file descriptor limit Do a binary search for the maximum RLIMIT_NOFILE. Works around the low, low limits on certain high, high-priced devices from Cupertino, CA.
11 years ago
struct rlimit lim;
if (getrlimit(RLIMIT_NOFILE, &lim) == 0 && lim.rlim_cur != lim.rlim_max) {
// Do a binary search for the limit.
rlim_t min = lim.rlim_cur;
rlim_t max = 1 << 20;
// But if there's a defined upper bound, don't search, just set it.
if (lim.rlim_max != RLIM_INFINITY) {
min = lim.rlim_max;
max = lim.rlim_max;
}
do {
lim.rlim_cur = min + (max - min) / 2;
if (setrlimit(RLIMIT_NOFILE, &lim)) {
max = lim.rlim_cur;
} else {
min = lim.rlim_cur;
}
} while (min + 1 < max);
}
}
Ignore SIGPIPE Was inadvertently removed with evcom, http://github.com/ry/node/commit/c72967d3351c4a28c3f2434748598017aa0126d5#L10L1900
15 years ago
// Ignore SIGPIPE
Add signal handlers so we clean up before exiting. Add SIGTERM and SIGINT signal handlers so that we run the exit handlers before exiting when getting these signals. Fixes an issue where we couldn&#39;t run vi after CTRL+C&#39;ing node because the stdin fd was left non-blocking.
14 years ago
RegisterSignalHandler(SIGPIPE, SIG_IGN);
main: Handle SIGINT properly. As explained by http://www.cons.org/cracauer/sigint.html Signed-off-by: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
RegisterSignalHandler(SIGINT, SignalExit, true);
RegisterSignalHandler(SIGTERM, SignalExit, true);
src: lint c++ code
12 years ago
#endif // __POSIX__
Ignore SIGPIPE Was inadvertently removed with evcom, http://github.com/ry/node/commit/c72967d3351c4a28c3f2434748598017aa0126d5#L10L1900
15 years ago
deps: re-implement debugger-agent Reviewed-By: Trevor Norris &lt;trevnorris@gmail.com&gt; PR-URL: https://github.com/joyent/node/pull/8476
10 years ago
if (!use_debug_agent) {
Revert support for isolates. It was decided that the performance benefits that isolates offer (faster spin-up times for worker processes, faster inter-worker communication, possibly a lower memory footprint) are not actual bottlenecks for most people and do not outweigh the potential stability issues and intrusive changes to the code base that first-class support for isolates requires. Hence, this commit backs out all isolates-related changes. Good bye, isolates. We hardly knew ye.
13 years ago
RegisterDebugSignalHandler();
Enable debugging. Use the --debug command line flag to enable. It appears that d8 sucks. Luckily it can be rewritten rather easily with the repl and tcp client libraries. Node&#39;s CL option parsing is getting rather unwieldy - needs refactor.
15 years ago
}
Revert support for isolates. It was decided that the performance benefits that isolates offer (faster spin-up times for worker processes, faster inter-worker communication, possibly a lower memory footprint) are not actual bottlenecks for most people and do not outweigh the potential stability issues and intrusive changes to the code base that first-class support for isolates requires. Hence, this commit backs out all isolates-related changes. Good bye, isolates. We hardly knew ye.
13 years ago
}
isolates: add process.tid property, pass args to isolate
13 years ago
ref isolate loop
13 years ago
addon: add AtExit() function Lets native addons register exit hooks that run after the event loop has quit but before the VM is killed. Fixes #3147.
13 years ago
struct AtExitCallback {
AtExitCallback* next_;
void (*cb_)(void* arg);
void* arg_;
};
static AtExitCallback* at_exit_functions_;
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
// TODO(bnoordhuis) Turn into per-context event.
void RunAtExit(Environment* env) {
addon: add AtExit() function Lets native addons register exit hooks that run after the event loop has quit but before the VM is killed. Fixes #3147.
13 years ago
AtExitCallback* p = at_exit_functions_;
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
at_exit_functions_ = nullptr;
addon: add AtExit() function Lets native addons register exit hooks that run after the event loop has quit but before the VM is killed. Fixes #3147.
13 years ago
while (p) {
AtExitCallback* q = p->next_;
p->cb_(p->arg_);
delete p;
p = q;
}
}
void AtExit(void (*cb)(void* arg), void* arg) {
AtExitCallback* p = new AtExitCallback;
p->cb_ = cb;
p->arg_ = arg;
p->next_ = at_exit_functions_;
at_exit_functions_ = p;
}
src: emit &#39;beforeExit&#39; event on process object Unlike the &#39;exit&#39; event, this event allows the user to schedule more work and thereby postpone the exit. That also means that the &#39;beforeExit&#39; event may be emitted many times, see the attached test case for an example. Refs #6305.
11 years ago
void EmitBeforeExit(Environment* env) {
Context::Scope context_scope(env->context());
HandleScope handle_scope(env->isolate());
Local<Object> process_object = env->process_object();
Local<String> exit_code = FIXED_ONE_BYTE_STRING(env->isolate(), "exitCode");
Local<Value> args[] = {
FIXED_ONE_BYTE_STRING(env->isolate(), "beforeExit"),
src: pass Isolate to additional locations Due to a recent V8 upgrade, more methods require Isolate as an argument. PR-URL: https://github.com/iojs/io.js/pull/244 Reviewed-by: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
process_object->Get(exit_code)->ToInteger(env->isolate())
src: emit &#39;beforeExit&#39; event on process object Unlike the &#39;exit&#39; event, this event allows the user to schedule more work and thereby postpone the exit. That also means that the &#39;beforeExit&#39; event may be emitted many times, see the attached test case for an example. Refs #6305.
11 years ago
};
MakeCallback(env, process_object, "emit", ARRAY_SIZE(args), args);
}
node: `EmitExit` should not call `exit()` Before this commit `RunAtExit` and `env-&gt;Dispose()` were never reached, because `EmitExit` was always colling `exit`.
11 years ago
int EmitExit(Environment* env) {
Revert support for isolates. It was decided that the performance benefits that isolates offer (faster spin-up times for worker processes, faster inter-worker communication, possibly a lower memory footprint) are not actual bottlenecks for most people and do not outweigh the potential stability issues and intrusive changes to the code base that first-class support for isolates requires. Hence, this commit backs out all isolates-related changes. Good bye, isolates. We hardly knew ye.
13 years ago
// process.emit('exit')
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
HandleScope handle_scope(env->isolate());
src: fix Context::Scope usage env-&gt;context() may or may not create a new Local. It currently does not but don&#39;t depend on that behavior, create a HandleScope first.
11 years ago
Context::Scope context_scope(env->context());
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
Local<Object> process_object = env->process_object();
src: remove `node_isolate` from source fix #6899
11 years ago
process_object->Set(env->exiting_string(), True(env->isolate()));
process: Add exitCode property This allows one to set a specific status code, while still letting the process exit gracefully once all async operations are completed.
11 years ago
src: remove `node_isolate` from source fix #6899
11 years ago
Handle<String> exitCode = env->exit_code_string();
src: fix VC++ warning C4244 Reviewed-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
10 years ago
int code = process_object->Get(exitCode)->Int32Value();
process: Add exitCode property This allows one to set a specific status code, while still letting the process exit gracefully once all async operations are completed.
11 years ago
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
Local<Value> args[] = {
src: remove `node_isolate` from source fix #6899
11 years ago
env->exit_string(),
src: update to v8 3.24 APIs
11 years ago
Integer::New(env->isolate(), code)
src: use v8::String::NewFrom*() functions * Change calls to String::New() and String::NewSymbol() to their respective one-byte, two-byte and UTF-8 counterparts. * Add a FIXED_ONE_BYTE_STRING macro that takes a string literal and turns it into a v8::Local&lt;v8::String&gt;. * Add helper functions that make v8::String::NewFromOneByte() easier to work with. Said function expects a `const uint8_t*` but almost every call site deals with `const char*` or `const unsigned char*`. Helps us avoid doing reinterpret_casts all over the place. * Code that handles file system paths keeps using UTF-8 for backwards compatibility reasons. At least now the use of UTF-8 is explicit. * Remove v8::String::NewSymbol() entirely. Almost all call sites were effectively minor de-optimizations. If you create a string only once, there is no point in making it a symbol. If you are create the same string repeatedly, it should probably be cached in a persistent handle.
12 years ago
};
process: Add exitCode property This allows one to set a specific status code, while still letting the process exit gracefully once all async operations are completed.
11 years ago
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
MakeCallback(env, process_object, "emit", ARRAY_SIZE(args), args);
process: allow changing `exitCode` in `on(&#39;exit&#39;)` fix #7081
11 years ago
// Reload exit code, it may be changed by `emit('exit')`
src: fix VC++ warning C4244 Reviewed-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
10 years ago
return process_object->Get(exitCode)->Int32Value();
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
}
deps: re-implement debugger-agent Reviewed-By: Trevor Norris &lt;trevnorris@gmail.com&gt; PR-URL: https://github.com/joyent/node/pull/8476
10 years ago
// Just a convenience method
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
Environment* CreateEnvironment(Isolate* isolate,
src: pass the v8::Context to CreateEnvironment Pass in the v8::Context, instead of creating it within CreateEnvironment. This allows callers to use a pre-existing context. Signed-off-by: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
Handle<Context> context,
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
int argc,
const char* const* argv,
int exec_argc,
const char* const* exec_argv) {
deps: re-implement debugger-agent Reviewed-By: Trevor Norris &lt;trevnorris@gmail.com&gt; PR-URL: https://github.com/joyent/node/pull/8476
10 years ago
Environment* env;
Context::Scope context_scope(context);
env = CreateEnvironment(isolate,
uv_default_loop(),
context,
argc,
argv,
exec_argc,
exec_argv);
LoadEnvironment(env);
return env;
}
static void HandleCloseCb(uv_handle_t* handle) {
Environment* env = reinterpret_cast<Environment*>(handle->data);
env->FinishHandleCleanup(handle);
}
static void HandleCleanup(Environment* env,
uv_handle_t* handle,
void* arg) {
handle->data = env;
uv_close(handle, HandleCloseCb);
}
Environment* CreateEnvironment(Isolate* isolate,
uv_loop_t* loop,
Handle<Context> context,
int argc,
const char* const* argv,
int exec_argc,
const char* const* exec_argv) {
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
HandleScope handle_scope(isolate);
Context::Scope context_scope(context);
deps: re-implement debugger-agent Reviewed-By: Trevor Norris &lt;trevnorris@gmail.com&gt; PR-URL: https://github.com/joyent/node/pull/8476
10 years ago
Environment* env = Environment::New(context, loop);
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
node: avoid automatic microtask runs Since we are taking control of the microtask queue it makes sense to disable autorun and only run microtasks when necessary. Just setting isolate-&gt;SetAutorunMicrotasks(false) would cause _tickCallback() not to be called. Automatically running the microtask queue will cause it to run: * After callback invocation * Inside _tickCallback() * After _tickCallback() invocation The third one is unnecessary as the microtask queue is guaranteed to be empty at this point. The first only needs to be run manually when _tickCallback() isn&#39;t going to be called by MakeCallback(). Reviewed-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
10 years ago
isolate->SetAutorunMicrotasks(false);
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
uv_check_init(env->event_loop(), env->immediate_check_handle());
uv_unref(
reinterpret_cast<uv_handle_t*>(env->immediate_check_handle()));
deps: re-implement debugger-agent Reviewed-By: Trevor Norris &lt;trevnorris@gmail.com&gt; PR-URL: https://github.com/joyent/node/pull/8476
10 years ago
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
uv_idle_init(env->event_loop(), env->immediate_idle_handle());
src: notify V8 profiler when we&#39;re idle Inform V8&#39;s CPU profiler when we&#39;re idle. The profiler is sampling-based but not all samples are created equal; mark the wall clock time spent in epoll_wait() and friends so profiling tools can filter it out. The samples still end up in v8.log but with state=IDLE rather than state=EXTERNAL.
11 years ago
// Inform V8's CPU profiler when we're idle. The profiler is sampling-based
// but not all samples are created equal; mark the wall clock time spent in
// epoll_wait() and friends so profiling tools can filter it out. The samples
// still end up in v8.log but with state=IDLE rather than state=EXTERNAL.
// TODO(bnoordhuis) Depends on a libuv implementation detail that we should
// probably fortify in the API contract, namely that the last started prepare
// or check watcher runs first. It's not 100% foolproof; if an add-on starts
// a prepare or check watcher after us, any samples attributed to its callback
// will be recorded with state=IDLE.
uv_prepare_init(env->event_loop(), env->idle_prepare_handle());
src: fix up after botched merge conflict Mea culpa, I didn&#39;t properly resolve a merge conflict in the last two commits. The resulting segmentation fault only happened on Linux and only sometimes. Fixes #6306.
11 years ago
uv_check_init(env->event_loop(), env->idle_check_handle());
src: notify V8 profiler when we&#39;re idle Inform V8&#39;s CPU profiler when we&#39;re idle. The profiler is sampling-based but not all samples are created equal; mark the wall clock time spent in epoll_wait() and friends so profiling tools can filter it out. The samples still end up in v8.log but with state=IDLE rather than state=EXTERNAL.
11 years ago
uv_unref(reinterpret_cast<uv_handle_t*>(env->idle_prepare_handle()));
uv_unref(reinterpret_cast<uv_handle_t*>(env->idle_check_handle()));
deps: re-implement debugger-agent Reviewed-By: Trevor Norris &lt;trevnorris@gmail.com&gt; PR-URL: https://github.com/joyent/node/pull/8476
10 years ago
// Register handle cleanups
env->RegisterHandleCleanup(
reinterpret_cast<uv_handle_t*>(env->immediate_check_handle()),
HandleCleanup,
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
nullptr);
deps: re-implement debugger-agent Reviewed-By: Trevor Norris &lt;trevnorris@gmail.com&gt; PR-URL: https://github.com/joyent/node/pull/8476
10 years ago
env->RegisterHandleCleanup(
reinterpret_cast<uv_handle_t*>(env->immediate_idle_handle()),
HandleCleanup,
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
nullptr);
deps: re-implement debugger-agent Reviewed-By: Trevor Norris &lt;trevnorris@gmail.com&gt; PR-URL: https://github.com/joyent/node/pull/8476
10 years ago
env->RegisterHandleCleanup(
reinterpret_cast<uv_handle_t*>(env->idle_prepare_handle()),
HandleCleanup,
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
nullptr);
deps: re-implement debugger-agent Reviewed-By: Trevor Norris &lt;trevnorris@gmail.com&gt; PR-URL: https://github.com/joyent/node/pull/8476
10 years ago
env->RegisterHandleCleanup(
reinterpret_cast<uv_handle_t*>(env->idle_check_handle()),
HandleCleanup,
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
nullptr);
deps: re-implement debugger-agent Reviewed-By: Trevor Norris &lt;trevnorris@gmail.com&gt; PR-URL: https://github.com/joyent/node/pull/8476
10 years ago
src: only start idle notifier when profiling The previous commit adds a notifier that tells the V8 profiler when node.js is idle, i.e. when it&#39;s about to start sleeping in the platform&#39;s equivalent of epoll_wait(). This commit adds a heuristic that only starts the notifier when the V8 profiler is started from the command line.
11 years ago
if (v8_is_profiling) {
src: fix up after botched merge conflict Mea culpa, I didn&#39;t properly resolve a merge conflict in the last two commits. The resulting segmentation fault only happened on Linux and only sometimes. Fixes #6306.
11 years ago
StartProfilerIdleNotifier(env);
src: only start idle notifier when profiling The previous commit adds a notifier that tells the V8 profiler when node.js is idle, i.e. when it&#39;s about to start sleeping in the platform&#39;s equivalent of epoll_wait(). This commit adds a heuristic that only starts the notifier when the V8 profiler is started from the command line.
11 years ago
}
src: update to v8 3.24 APIs
11 years ago
Local<FunctionTemplate> process_template = FunctionTemplate::New(isolate);
src: add JS start/stop methods for idle notifier The previous commit changes the profiler idle notifier so that it only gets started when a --prof or --prof_lazy argument is specified on the command line. This commit adds two internal methods to the process object that allows one to start and stop the idle notifier programmatically.
11 years ago
process_template->SetClassName(FIXED_ONE_BYTE_STRING(isolate, "process"));
Local<Object> process_object = process_template->GetFunction()->NewInstance();
env->set_process_object(process_object);
SetupProcessObject(env, argc, argv, exec_argc, exec_argv);
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
return env;
Revert support for isolates. It was decided that the performance benefits that isolates offer (faster spin-up times for worker processes, faster inter-worker communication, possibly a lower memory footprint) are not actual bottlenecks for most people and do not outweigh the potential stability issues and intrusive changes to the code base that first-class support for isolates requires. Hence, this commit backs out all isolates-related changes. Good bye, isolates. We hardly knew ye.
13 years ago
}
isolates: implement message passing Parent and child isolates can now pass arbitrary binary messages between each other. The messages are sent and received through a thread-safe queue that wakes up the event loop of the receiving thread.
13 years ago
Expose original argv as process.execArgv for cluster and child_process.fork()
13 years ago
src: clean up CLI argument parser * Exit with an error message when the option is not a node or V8 option. * Remove the option_end_index global. Needs to happen anyway for the multi-context work, might as well land it in master now. * Add a smidgen of const-correctness. * Pay off a few years of accrued technical debt.
12 years ago
int Start(int argc, char** argv) {
src: ignore risky env vars when setuid root On POSIX platforms, check that the uid and gid match the euid and egid respectively before looking up the environment variable. Before this commit, an i18n-enabled suid node would cheerfully load attacker-controlled ICU data through the NODE_ICU_DATA environment variable. This commit is not a complete fix. For example, it&#39;s up for debate what to do with the NODE_CHANNEL_FD environment variable. PR-URL: https://github.com/node-forward/node/pull/18 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
const char* replaceInvalid = secure_getenv("NODE_INVALID_UTF8");
string_bytes: Guarantee valid utf-8 output Previously v8&#39;s WriteUtf8 function would produce invalid utf-8 output when encountering unmatched surrogate code units [1]. The new REPLACE_INVALID_UTF8 option fixes that by replacing invalid code points with the unicode replacement character. [1]: JS Strings are defined as arrays of 16 bit unsigned integers. There is no unicode enforcement, so one can easily end up with invalid unicode code unit sequences inside a string.
11 years ago
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
if (replaceInvalid == nullptr)
string_bytes: Guarantee valid utf-8 output Previously v8&#39;s WriteUtf8 function would produce invalid utf-8 output when encountering unmatched surrogate code units [1]. The new REPLACE_INVALID_UTF8 option fixes that by replacing invalid code points with the unicode replacement character. [1]: JS Strings are defined as arrays of 16 bit unsigned integers. There is no unicode enforcement, so one can easily end up with invalid unicode code unit sequences inside a string.
11 years ago
WRITE_UTF8_FLAGS |= String::REPLACE_INVALID_UTF8;
debugger: fix SIGUSR1 bootstrap race condition Before this commit, the SIGUSR1 signal handler wasn&#39;t installed until late in the bootstrapping process and we were prone to miss signals sent by other processes. This commit installs an early-boot signal handler that merely records the fact that we received a signal. Once the debugger infrastructure is in place, the signal is re-raised, kickstarting the debugger. Among other things, this means that simple/test-debugger-client is now _much_ less likely to fail.
11 years ago
#if !defined(_WIN32)
// Try hard not to lose SIGUSR1 signals during the bootstrap process.
InstallEarlyDebugSignalHandler();
#endif
src: replace assert() with CHECK() Mechanically replace assert() statements with UNREACHABLE(), CHECK(), or CHECK_{EQ,NE,LT,GT,LE,GE}() statements. The exceptions are src/node.h and src/node_object_wrap.h because they are public headers. PR-URL: https://github.com/node-forward/node/pull/16 Reviewed-By: Fedor Indutny &lt;fedor@indutny.com&gt;
10 years ago
CHECK_GT(argc, 0);
Expose original argv as process.execArgv for cluster and child_process.fork()
13 years ago
src: clean up CLI argument parser * Exit with an error message when the option is not a node or V8 option. * Remove the option_end_index global. Needs to happen anyway for the multi-context work, might as well land it in master now. * Add a smidgen of const-correctness. * Pay off a few years of accrued technical debt.
12 years ago
// Hack around with the argv pointer. Used for process.title = "blah".
process: fix process.title setter Commit 19fd530 broke the argv initialization logic that&#39;s used on linux and freebsd to update the process name (as displayed in tools like `top`). Fixes test/simple/test-setproctitle.js.
13 years ago
argv = uv_setup_args(argc, argv);
src: clean up CLI argument parser * Exit with an error message when the option is not a node or V8 option. * Remove the option_end_index global. Needs to happen anyway for the multi-context work, might as well land it in master now. * Add a smidgen of const-correctness. * Pay off a few years of accrued technical debt.
12 years ago
// This needs to run *before* V8::Initialize(). The const_cast is not
// optional, in case you're wondering.
int exec_argc;
const char** exec_argv;
Init(&argc, const_cast<const char**>(argv), &exec_argc, &exec_argv);
Revert support for isolates. It was decided that the performance benefits that isolates offer (faster spin-up times for worker processes, faster inter-worker communication, possibly a lower memory footprint) are not actual bottlenecks for most people and do not outweigh the potential stability issues and intrusive changes to the code base that first-class support for isolates requires. Hence, this commit backs out all isolates-related changes. Good bye, isolates. We hardly knew ye.
13 years ago
src: seed V8&#39;s random number generator at startup The default entropy source is /dev/urandom on UNIX platforms, which is okay but we can do better by seeding it from OpenSSL&#39;s entropy pool. On Windows we can certainly do better; on that platform, V8 seeds the random number generator using only the current system time. Fixes #6250.
11 years ago
#if HAVE_OPENSSL
// V8 on Windows doesn't have a good source of entropy. Seed it from
// OpenSSL's pool.
V8::SetEntropySource(crypto::EntropySource);
#endif
v8_platform: provide default v8::Platform impl Provide default Platform implementation for v8&#39;s purposes.
10 years ago
V8::InitializePlatform(new Platform(4));
node: `EmitExit` should not call `exit()` Before this commit `RunAtExit` and `env-&gt;Dispose()` were never reached, because `EmitExit` was always colling `exit`.
11 years ago
int code;
src: fix v8 PRNG entropy seeding It was pointed out by a member of the V8 team that the call to V8::SetEntropySource() should come before V8::Initialize(). See also commit 7ac2391.
11 years ago
V8::Initialize();
modules: adding load linked modules feature - introduced NM_F_LINKED flag to identify linked modules - setting node_is_initialized after calling V8::Initialize in order to make the right decision during initial module registration - introduced modlist_linked in order to track modules that were pre-registered in order to complete it once node is initialized - completing registration of linked module similarly to the way it&#39;s done inside DLOpen PR-URL: https://github.com/iojs/io.js/pull/8 Reviewed-by: Trevor Norris &lt;trev.norris@gmail.com&gt; Reviewed-By: Ben Noordhuis &lt;info@bnoordhuis.nl&gt;
10 years ago
node_is_initialized = true;
v8_platform: provide default v8::Platform impl Provide default Platform implementation for v8&#39;s purposes.
10 years ago
// Fetch a reference to the main isolate, so we have a reference to it
// even when we need it to access it from another (debugger) thread.
node_isolate = Isolate::New();
node: un-revert 9a6012e The crashes in debug mode after adding Locker are *not* caused by Locker. Locker is merely exposing issues that already existed. Some of these issues have since been fixed in 70635753. This reverts commit 407181538b5193f6810bf06a2056a200265c0e93. This reapplies commit 9a6012edd9330296b7476bc6b7fbda2cd5c8165d. Conflicts: src/node.cc
13 years ago
{
bindings: update api All compile time warnings about using deprecated APIs have been suppressed by updating node&#39;s API. Though there are still many function calls that can accept Isolate, and still need to be updated. node_isolate had to be added as an extern variable in node.h and node_object_wrap.h Also a couple small fixes for Error handling. Before v8 3.16.6 the error stack message was lazily written when it was needed, which allowed you to change the message after instantiation. Then the stack would be written with the new message the first time it was accessed. Though that has changed. Now it creates the stack message on instantiation. So setting a different message afterwards won&#39;t be displayed. This is not a complete fix for the problem. Getting error without any message isn&#39;t very useful.
12 years ago
Locker locker(node_isolate);
node: add missing Isolate::Scope at startup Reviewed-by: Trevor Norris &lt;trev.norris@gmail.com&gt;
11 years ago
Isolate::Scope isolate_scope(node_isolate);
src: pass the v8::Context to CreateEnvironment Pass in the v8::Context, instead of creating it within CreateEnvironment. This allows callers to use a pre-existing context. Signed-off-by: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
HandleScope handle_scope(node_isolate);
Local<Context> context = Context::New(node_isolate);
Environment* env = CreateEnvironment(
deps: re-implement debugger-agent Reviewed-By: Trevor Norris &lt;trevnorris@gmail.com&gt; PR-URL: https://github.com/joyent/node/pull/8476
10 years ago
node_isolate,
uv_default_loop(),
context,
argc,
argv,
exec_argc,
exec_argv);
Context::Scope context_scope(context);
// Start debug agent when argv has --debug
if (use_debug_agent)
StartDebug(env, debug_wait_connect);
LoadEnvironment(env);
// Enable debugger
if (use_debug_agent)
EnableDebug(env);
bool more;
do {
more = uv_run(env->event_loop(), UV_RUN_ONCE);
if (more == false) {
EmitBeforeExit(env);
// Emit `beforeExit` if the loop became alive either after emitting
// event, or after running some callbacks.
more = uv_loop_alive(env->event_loop());
if (uv_run(env->event_loop(), UV_RUN_NOWAIT) != 0)
more = true;
}
} while (more == true);
code = EmitExit(env);
RunAtExit(env);
src: add multi-context support This commit makes it possible to use multiple V8 execution contexts within a single event loop. Put another way, handle and request wrap objects now &#34;remember&#34; the context they belong to and switch back to that context when the time comes to call into JS land. This could have been done in a quick and hacky way by calling v8::Object::GetCreationContext() on the wrap object right before making a callback but that leaves a fairly wide margin for bugs. Instead, we make the context explicit through a new Environment class that encapsulates everything (or almost everything) that belongs to the context. Variables that used to be a static or a global are now members of the aforementioned class. An additional benefit is that this approach should make it relatively straightforward to add full isolate support in due course. There is no JavaScript API yet but that will be added in the near future. This work was graciously sponsored by GitHub, Inc.
12 years ago
env->Dispose();
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
env = nullptr;
node: un-revert 9a6012e The crashes in debug mode after adding Locker are *not* caused by Locker. Locker is merely exposing issues that already existed. Some of these issues have since been fixed in 70635753. This reverts commit 407181538b5193f6810bf06a2056a200265c0e93. This reapplies commit 9a6012edd9330296b7476bc6b7fbda2cd5c8165d. Conflicts: src/node.cc
13 years ago
}
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
CHECK_NE(node_isolate, nullptr);
src: kill isolate on exit Otherwise it&#39;s not possible to check from inside a destructor if V8 is still alive with v8::V8::IsDead(). In V8 3.25, that function returns true until the last isolate is destroyed. This used to work in v0.10 and is a standard trick to dispose persistent handles conditionally. Signed-off-by: Fedor Indutny &lt;fedor@indutny.com&gt;
11 years ago
node_isolate->Dispose();
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
node_isolate = nullptr;
Clean ups
16 years ago
V8::Dispose();
Statically link in dependencies for node.exe
14 years ago
src: clean up CLI argument parser * Exit with an error message when the option is not a node or V8 option. * Remove the option_end_index global. Needs to happen anyway for the multi-context work, might as well land it in master now. * Add a smidgen of const-correctness. * Pay off a few years of accrued technical debt.
12 years ago
delete[] exec_argv;
src: replace NULL with nullptr Now that we are building with C++11 features enabled, replace use of NULL with nullptr. The benefit of using nullptr is that it can never be confused for an integral type because it does not support implicit conversions to integral types except boolean - unlike NULL, which is defined as a literal `0`.
10 years ago
exec_argv = nullptr;
Expose original argv as process.execArgv for cluster and child_process.fork()
13 years ago
node: `EmitExit` should not call `exit()` Before this commit `RunAtExit` and `env-&gt;Dispose()` were never reached, because `EmitExit` was always colling `exit`.
11 years ago
return code;
Major refactoring: program name now &#34;node&#34; Trying to make a more moduler design. Two libraries currently &#34;TCP&#34; and &#34;HTTP&#34; each have their own file. Other major feature added here is multiple web servers! excitement.
16 years ago
}
Add node::Start() first step towards building a libnode.a
15 years ago
} // namespace node