restructure node vendoring, add includes and waf

bin/compile

@@ -24,11 +24,12 @@ VENDORED_NPM="$LP_DIR/vendor/npm/npm-$NPM_VERSION"
 PATH="$BUILD_DIR/bin:$PATH"
 echo "-----> Vendoring node $NODE_VERSION"
 mkdir -p "$BUILD_DIR/bin"
-cp "$VENDORED_NODE" "$BUILD_DIR/bin/node"
+cp "$VENDORED_NODE/node" "$BUILD_DIR/bin/node"
 
 # setting up paths for building
 PATH="$LP_DIR/vendor/scons/scons-${SCONS_VERSION}:$PATH"
 PATH="$VENDORED_NODE:$PATH"
+export INCLUDE_PATH="$VENDORED_NODE/include"
 
 # unpack existing cache
 rm -rf $CACHE_TARGET_DIR
@@ -39,7 +40,7 @@ fi
 # install dependencies with npm
 echo "-----> Installing dependencies with npm $NPM_VERSION"
 cd $BUILD_DIR
-HOME="$BUILD_DIR" $VENDORED_NODE $VENDORED_NPM/cli.js install 2>&1 | sed -u 's/^/       /'
+HOME="$BUILD_DIR" $VENDORED_NODE/node $VENDORED_NPM/cli.js install 2>&1 | sed -u 's/^/       /'
 if [ "${PIPESTATUS[*]}" != "0 0" ]; then
   echo " !     Failed to install dependencies with npm"
   exit 1

vendor/node/node-0.4.7/include/config.h

+/* Configuration header created by Waf - do not edit */
+#ifndef _CONFIG_H_WAF
+#define _CONFIG_H_WAF
+
+#define HAVE_OPENSSL 1
+#define HAVE_PTHREAD_CREATE 1
+#define HAVE_PTHREAD_ATFORK 1
+#define HAVE_FUTIMES 1
+/* #undef HAVE_READAHEAD */
+#define HAVE_FDATASYNC 1
+#define HAVE_PREADWRITE 1
+#define HAVE_SENDFILE 1
+/* #undef HAVE_SYNC_FILE_RANGE */
+/* #undef HAVE_SYS_INOTIFY_H */
+/* #undef HAVE_SYS_EPOLL_H */
+/* #undef HAVE_PORT_H */
+#define HAVE_POLL_H 1
+#define HAVE_POLL 1
+#define HAVE_SYS_EVENT_H 1
+#define HAVE_SYS_QUEUE_H 1
+#define HAVE_KQUEUE 1
+#define HAVE_SYS_SELECT_H 1
+#define HAVE_SELECT 1
+/* #undef HAVE_SYS_EVENTFD_H */
+/* #undef HAVE_CLOCK_SYSCALL */
+#define HAVE_NANOSLEEP 1
+#define HAVE_CEIL 1
+#define HAVE_CONFIG_H 1
+#endif /* _CONFIG_H_WAF */

vendor/node/node-0.4.7/include/node.h

+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+#ifndef SRC_NODE_H_
+#define SRC_NODE_H_
+
+#include <ev.h>
+#include <eio.h>
+#include <v8.h>
+#include <sys/types.h> /* struct stat */
+#include <sys/stat.h>
+
+#include <node_object_wrap.h>
+
+#ifndef NODE_STRINGIFY
+#define NODE_STRINGIFY(n) NODE_STRINGIFY_HELPER(n)
+#define NODE_STRINGIFY_HELPER(n) #n
+#endif
+
+namespace node {
+
+int Start (int argc, char *argv[]);
+
+#define NODE_PSYMBOL(s) Persistent<String>::New(String::NewSymbol(s))
+
+/* Converts a unixtime to V8 Date */
+#define NODE_UNIXTIME_V8(t) v8::Date::New(1000*static_cast<double>(t))
+#define NODE_V8_UNIXTIME(v) (static_cast<double>((v)->NumberValue())/1000.0);
+
+#define NODE_DEFINE_CONSTANT(target, constant)                            \
+  (target)->Set(v8::String::NewSymbol(#constant),                         \
+                v8::Integer::New(constant),                               \
+                static_cast<v8::PropertyAttribute>(v8::ReadOnly|v8::DontDelete))
+
+#define NODE_SET_METHOD(obj, name, callback)                              \
+  obj->Set(v8::String::NewSymbol(name),                                   \
+           v8::FunctionTemplate::New(callback)->GetFunction())
+
+#define NODE_SET_PROTOTYPE_METHOD(templ, name, callback)                  \
+do {                                                                      \
+  v8::Local<v8::Signature> __callback##_SIG = v8::Signature::New(templ);  \
+  v8::Local<v8::FunctionTemplate> __callback##_TEM =                      \
+    v8::FunctionTemplate::New(callback, v8::Handle<v8::Value>(),          \
+                          __callback##_SIG);                              \
+  templ->PrototypeTemplate()->Set(v8::String::NewSymbol(name),            \
+                                  __callback##_TEM);                      \
+} while (0)
+
+enum encoding {ASCII, UTF8, BASE64, UCS2, BINARY};
+enum encoding ParseEncoding(v8::Handle<v8::Value> encoding_v,
+                            enum encoding _default = BINARY);
+void FatalException(v8::TryCatch &try_catch);
+void DisplayExceptionLine(v8::TryCatch &try_catch); // hack
+
+v8::Local<v8::Value> Encode(const void *buf, size_t len,
+                            enum encoding encoding = BINARY);
+
+// Returns -1 if the handle was not valid for decoding
+ssize_t DecodeBytes(v8::Handle<v8::Value>,
+                    enum encoding encoding = BINARY);
+
+// returns bytes written.
+ssize_t DecodeWrite(char *buf,
+                    size_t buflen,
+                    v8::Handle<v8::Value>,
+                    enum encoding encoding = BINARY);
+
+// Use different stat structs & calls on windows and posix;
+// on windows, _stati64 is utf-8 and big file aware.
+#if __POSIX__
+# define NODE_STAT        stat
+# define NODE_FSTAT       fstat
+# define NODE_STAT_STRUCT struct stat
+#else // __MINGW32__
+# define NODE_STAT        _stati64
+# define NODE_FSTAT       _fstati64
+# define NODE_STAT_STRUCT struct _stati64
+#endif
+
+v8::Local<v8::Object> BuildStatsObject(NODE_STAT_STRUCT *s);
+
+
+/**
+ * Call this when your constructor is invoked as a regular function, e.g. Buffer(10) instead of new Buffer(10).
+ * @param constructorTemplate Constructor template to instantiate from.
+ * @param args The arguments object passed to your constructor.
+ * @see v8::Arguments::IsConstructCall
+ */
+v8::Handle<v8::Value> FromConstructorTemplate(v8::Persistent<v8::FunctionTemplate>& constructorTemplate, const v8::Arguments& args);
+
+
+static inline v8::Persistent<v8::Function>* cb_persist(
+    const v8::Local<v8::Value> &v) {
+  v8::Persistent<v8::Function> *fn = new v8::Persistent<v8::Function>();
+  *fn = v8::Persistent<v8::Function>::New(v8::Local<v8::Function>::Cast(v));
+  return fn;
+}
+
+static inline v8::Persistent<v8::Function>* cb_unwrap(void *data) {
+  v8::Persistent<v8::Function> *cb =
+    reinterpret_cast<v8::Persistent<v8::Function>*>(data);
+  assert((*cb)->IsFunction());
+  return cb;
+}
+
+static inline void cb_destroy(v8::Persistent<v8::Function> * cb) {
+  cb->Dispose();
+  delete cb;
+}
+
+v8::Local<v8::Value> ErrnoException(int errorno,
+                                    const char *syscall = NULL,
+                                    const char *msg = "",
+                                    const char *path = NULL);
+
+const char *signo_string(int errorno);
+
+struct node_module_struct {
+  int version;
+  void *dso_handle;
+  const char *filename;
+  void (*register_func) (v8::Handle<v8::Object> target);
+  const char *modname;
+};
+
+node_module_struct* get_builtin_module(const char *name);
+
+/**
+ * When this version number is changed, node.js will refuse
+ * to load older modules.  This should be done whenever
+ * an API is broken in the C++ side, including in v8 or
+ * other dependencies
+ */
+#define NODE_MODULE_VERSION (1)
+
+#define NODE_STANDARD_MODULE_STUFF \
+          NODE_MODULE_VERSION,     \
+          NULL,                    \
+          __FILE__
+
+#define NODE_MODULE(modname, regfunc)   \
+  node::node_module_struct modname ## _module =    \
+  {                                     \
+      NODE_STANDARD_MODULE_STUFF,       \
+      regfunc,                          \
+      NODE_STRINGIFY(modname)           \
+  };
+
+#define NODE_MODULE_DECL(modname) \
+  extern node::node_module_struct modname ## _module;
+
+
+}  // namespace node
+#endif  // SRC_NODE_H_

vendor/node/node-0.4.7/include/node_buffer.h

+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+#ifndef NODE_BUFFER_H_
+#define NODE_BUFFER_H_
+
+#include <node.h>
+#include <node_object_wrap.h>
+#include <v8.h>
+#include <assert.h>
+
+namespace node {
+
+/* A buffer is a chunk of memory stored outside the V8 heap, mirrored by an
+ * object in javascript. The object is not totally opaque, one can access
+ * individual bytes with [] and slice it into substrings or sub-buffers
+ * without copying memory.
+ *
+ * // return an ascii encoded string - no memory is copied
+ * buffer.asciiSlice(0, 3)
+ */
+
+/*
+   The C++ API for Buffer changed radically between v0.2 and v0.3, in fact
+   it was the reason for bumping the version. In v0.2 JavaScript Buffers and
+   C++ Buffers were in one-to-one correspondence via ObjectWrap. We found
+   that it was faster to expose the C++ Buffers to JavaScript as a
+   "SlowBuffer" which is used as a private backend to pure JavaScript
+   "Buffer" objects - a 'Buffer' in v0.3 might look like this:
+
+   { _parent: s,
+     _offset: 520,
+     length: 5 }
+
+   Migrating code C++ Buffer code from v0.2 to v0.3 is difficult. Here are
+   some tips:
+    - buffer->data() calls should become Buffer::Data(buffer) calls.
+    - buffer->length() calls should become Buffer::Length(buffer) calls. 
+    - There should not be any ObjectWrap::Unwrap<Buffer>() calls. You should
+      not be storing pointers to Buffer objects at all - as they are
+      now considered internal structures. Instead consider making a
+      JavaScript reference to the buffer.
+
+   See the source code node-png as an example of a module which successfully
+   compiles on both v0.2 and v0.3 while making heavy use of the C++ Buffer
+   API.
+
+ */
+
+
+class Buffer : public ObjectWrap {
+ public:
+
+  static bool HasInstance(v8::Handle<v8::Value> val);
+
+  static inline char* Data(v8::Handle<v8::Object> obj) {
+    return (char*)obj->GetIndexedPropertiesExternalArrayData();
+  }
+
+  static inline char* Data(Buffer *b) {
+    return Buffer::Data(b->handle_);
+  }
+
+  static inline size_t Length(v8::Handle<v8::Object> obj) {
+    return (size_t)obj->GetIndexedPropertiesExternalArrayDataLength();
+  }
+
+  static inline size_t Length(Buffer *b) {
+    return Buffer::Length(b->handle_);
+  }
+
+
+  ~Buffer();
+
+  typedef void (*free_callback)(char *data, void *hint);
+
+  // C++ API for constructing fast buffer
+  static v8::Handle<v8::Object> New(v8::Handle<v8::String> string);
+
+  static void Initialize(v8::Handle<v8::Object> target);
+  static Buffer* New(size_t length); // public constructor
+  static Buffer* New(char *data, size_t len); // public constructor
+  static Buffer* New(char *data, size_t length,
+                     free_callback callback, void *hint); // public constructor
+
+  private:
+  static v8::Persistent<v8::FunctionTemplate> constructor_template;
+
+  static v8::Handle<v8::Value> New(const v8::Arguments &args);
+  static v8::Handle<v8::Value> BinarySlice(const v8::Arguments &args);
+  static v8::Handle<v8::Value> AsciiSlice(const v8::Arguments &args);
+  static v8::Handle<v8::Value> Base64Slice(const v8::Arguments &args);
+  static v8::Handle<v8::Value> Utf8Slice(const v8::Arguments &args);
+  static v8::Handle<v8::Value> Ucs2Slice(const v8::Arguments &args);
+  static v8::Handle<v8::Value> BinaryWrite(const v8::Arguments &args);
+  static v8::Handle<v8::Value> Base64Write(const v8::Arguments &args);
+  static v8::Handle<v8::Value> AsciiWrite(const v8::Arguments &args);
+  static v8::Handle<v8::Value> Utf8Write(const v8::Arguments &args);
+  static v8::Handle<v8::Value> Ucs2Write(const v8::Arguments &args);
+  static v8::Handle<v8::Value> ByteLength(const v8::Arguments &args);
+  static v8::Handle<v8::Value> MakeFastBuffer(const v8::Arguments &args);
+  static v8::Handle<v8::Value> Copy(const v8::Arguments &args);
+
+  Buffer(v8::Handle<v8::Object> wrapper, size_t length);
+  void Replace(char *data, size_t length, free_callback callback, void *hint);
+
+  size_t length_;
+  char* data_;
+  free_callback callback_;
+  void* callback_hint_;
+};
+
+
+}  // namespace node buffer
+
+#endif  // NODE_BUFFER_H_

vendor/node/node-0.4.7/include/node_config.h

+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+#ifndef NODE_CONFIG_H
+#define NODE_CONFIG_H
+
+#define NODE_CFLAGS "-rdynamic -D_GNU_SOURCE -DHAVE_CONFIG_H=1 -pthread -arch x86_64 -g -O3 -DHAVE_OPENSSL=1 -DEV_FORK_ENABLE=0 -DEV_EMBED_ENABLE=0 -DEV_MULTIPLICITY=0 -DX_STACKSIZE=65536 -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64 -DEV_MULTIPLICITY=0 -DHAVE_FDATASYNC=0 -DPLATFORM=\"darwin\" -D__POSIX__=1 -Wno-unused-parameter -D_FORTIFY_SOURCE=2 -DNDEBUG -I/tmp/n47/include/node"
+#define NODE_PREFIX "/tmp/n47"
+
+#endif /* NODE_CONFIG_H */

vendor/node/node-0.4.7/include/node_events.h

+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+#ifndef SRC_EVENTS_H_
+#define SRC_EVENTS_H_
+
+#include <node_object_wrap.h>
+#include <v8.h>
+
+namespace node {
+
+class EventEmitter : public ObjectWrap {
+ public:
+  static void Initialize(v8::Local<v8::FunctionTemplate> ctemplate);
+  static v8::Persistent<v8::FunctionTemplate> constructor_template;
+
+  bool Emit(v8::Handle<v8::String> event,
+            int argc,
+            v8::Handle<v8::Value> argv[]);
+
+ protected:
+  EventEmitter() : ObjectWrap () { }
+};
+
+}  // namespace node
+#endif  // SRC_EVENTS_H_

vendor/node/node-0.4.7/include/node_object_wrap.h

+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+#ifndef object_wrap_h
+#define object_wrap_h
+
+#include <v8.h>
+#include <assert.h>
+
+namespace node {
+
+class ObjectWrap {
+ public:
+  ObjectWrap ( ) {
+    refs_ = 0;
+  }
+
+
+  virtual ~ObjectWrap ( ) {
+    if (!handle_.IsEmpty()) {
+      assert(handle_.IsNearDeath());
+      handle_.ClearWeak();
+      handle_->SetInternalField(0, v8::Undefined());
+      handle_.Dispose();
+      handle_.Clear();
+    }
+  }
+
+
+  template <class T>
+  static inline T* Unwrap (v8::Handle<v8::Object> handle) {
+    assert(!handle.IsEmpty());
+    assert(handle->InternalFieldCount() > 0);
+    return static_cast<T*>(handle->GetPointerFromInternalField(0));
+  }
+
+
+  v8::Persistent<v8::Object> handle_; // ro
+
+ protected:
+  inline void Wrap (v8::Handle<v8::Object> handle) {
+    assert(handle_.IsEmpty());
+    assert(handle->InternalFieldCount() > 0);
+    handle_ = v8::Persistent<v8::Object>::New(handle);
+    handle_->SetPointerInInternalField(0, this);
+    MakeWeak();
+  }
+
+
+  inline void MakeWeak (void) {
+    handle_.MakeWeak(this, WeakCallback);
+  }
+
+  /* Ref() marks the object as being attached to an event loop.
+   * Refed objects will not be garbage collected, even if
+   * all references are lost.
+   */
+  virtual void Ref() {
+    assert(!handle_.IsEmpty());
+    refs_++;
+    handle_.ClearWeak();
+  }
+
+  /* Unref() marks an object as detached from the event loop.  This is its
+   * default state.  When an object with a "weak" reference changes from
+   * attached to detached state it will be freed. Be careful not to access
+   * the object after making this call as it might be gone!
+   * (A "weak reference" means an object that only has a
+   * persistant handle.)
+   *
+   * DO NOT CALL THIS FROM DESTRUCTOR
+   */
+  virtual void Unref() {
+    assert(!handle_.IsEmpty());
+    assert(!handle_.IsWeak());
+    assert(refs_ > 0);
+    if (--refs_ == 0) { MakeWeak(); }
+  }
+
+
+  int refs_; // ro
+
+
+ private:
+  static void WeakCallback (v8::Persistent<v8::Value> value, void *data) {
+    ObjectWrap *obj = static_cast<ObjectWrap*>(data);
+    assert(value == obj->handle_);
+    assert(!obj->refs_);
+    assert(value.IsNearDeath());
+    delete obj;
+  }
+};
+
+} // namespace node
+#endif // object_wrap_h

vendor/node/node-0.4.7/include/node_version.h

+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+#include "node_config.h"
+
+#ifndef NODE_VERSION_H
+#define NODE_VERSION_H
+
+#define NODE_MAJOR_VERSION 0
+#define NODE_MINOR_VERSION 4
+#define NODE_PATCH_VERSION 7
+#define NODE_VERSION_IS_RELEASE 1
+
+#ifndef NODE_STRINGIFY
+#define NODE_STRINGIFY(n) NODE_STRINGIFY_HELPER(n)
+#define NODE_STRINGIFY_HELPER(n) #n
+#endif
+
+#if NODE_VERSION_IS_RELEASE
+# define NODE_VERSION_STRING  NODE_STRINGIFY(NODE_MAJOR_VERSION) "." \
+                              NODE_STRINGIFY(NODE_MINOR_VERSION) "." \
+                              NODE_STRINGIFY(NODE_PATCH_VERSION)
+#else
+# define NODE_VERSION_STRING  NODE_STRINGIFY(NODE_MAJOR_VERSION) "." \
+                              NODE_STRINGIFY(NODE_MINOR_VERSION) "." \
+                              NODE_STRINGIFY(NODE_PATCH_VERSION) "-pre"
+#endif
+
+#define NODE_VERSION "v" NODE_VERSION_STRING
+
+
+#define NODE_VERSION_AT_LEAST(major, minor, patch) \
+  (( (major) < NODE_MAJOR_VERSION) \
+  || ((major) == NODE_MAJOR_VERSION && (minor) < NODE_MINOR_VERSION) \
+  || ((major) == NODE_MAJOR_VERSION && (minor) == NODE_MINOR_VERSION && (patch) <= NODE_PATCH_VERSION))
+
+#endif /* NODE_VERSION_H */

vendor/node/node-0.4.7/include/v8-preparser.h

+// Copyright 2010 the V8 project authors. All rights reserved.
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+//       notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+//       copyright notice, this list of conditions and the following
+//       disclaimer in the documentation and/or other materials provided
+//       with the distribution.
+//     * Neither the name of Google Inc. nor the names of its
+//       contributors may be used to endorse or promote products derived
+//       from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef PREPARSER_H
+#define PREPARSER_H
+
+#include "v8stdint.h"
+
+#ifdef _WIN32
+
+// Setup for Windows DLL export/import. When building the V8 DLL the
+// BUILDING_V8_SHARED needs to be defined. When building a program which uses
+// the V8 DLL USING_V8_SHARED needs to be defined. When either building the V8
+// static library or building a program which uses the V8 static library neither
+// BUILDING_V8_SHARED nor USING_V8_SHARED should be defined.
+#if defined(BUILDING_V8_SHARED) && defined(USING_V8_SHARED)
+#error both BUILDING_V8_SHARED and USING_V8_SHARED are set - please check the\
+  build configuration to ensure that at most one of these is set
+#endif
+
+#ifdef BUILDING_V8_SHARED
+#define V8EXPORT __declspec(dllexport)
+#elif USING_V8_SHARED
+#define V8EXPORT __declspec(dllimport)
+#else
+#define V8EXPORT
+#endif  // BUILDING_V8_SHARED
+
+#else  // _WIN32
+
+// Setup for Linux shared library export. There is no need to distinguish
+// between building or using the V8 shared library, but we should not
+// export symbols when we are building a static library.
+#if defined(__GNUC__) && (__GNUC__ >= 4) && defined(V8_SHARED)
+#define V8EXPORT __attribute__ ((visibility("default")))
+#else  // defined(__GNUC__) && (__GNUC__ >= 4)
+#define V8EXPORT
+#endif  // defined(__GNUC__) && (__GNUC__ >= 4)
+
+#endif  // _WIN32
+
+
+namespace v8 {
+
+
+class PreParserData {
+ public:
+  PreParserData(size_t size, const uint8_t* data)
+      : data_(data), size_(size) { }
+
+  // Create a PreParserData value where stack_overflow reports true.
+  static PreParserData StackOverflow() { return PreParserData(NULL, 0); }
+  // Whether the pre-parser stopped due to a stack overflow.
+  // If this is the case, size() and data() should not be used.
+
+  bool stack_overflow() { return size_ == 0u; }
+
+  // The size of the data in bytes.
+  size_t size() const { return size_; }
+
+  // Pointer to the data.
+  const uint8_t* data() const { return data_; }
+
+ private:
+  const uint8_t* const data_;
+  const size_t size_;
+};
+
+
+// Interface for a stream of Unicode characters.
+class UnicodeInputStream {
+ public:
+  virtual ~UnicodeInputStream();
+
+  // Returns the next Unicode code-point in the input, or a negative value when
+  // there is no more input in the stream.
+  virtual int32_t Next() = 0;
+};
+
+
+// Preparse a JavaScript program. The source code is provided as a
+// UnicodeInputStream. The max_stack_size limits the amount of stack
+// space that the preparser is allowed to use. If the preparser uses
+// more stack space than the limit provided, the result's stack_overflow()
+// method will return true. Otherwise the result contains preparser
+// data that can be used by the V8 parser to speed up parsing.
+PreParserData V8EXPORT Preparse(UnicodeInputStream* input,
+                                size_t max_stack_size);
+
+}  // namespace v8.
+
+#endif  // PREPARSER_H

vendor/node/node-0.4.7/include/v8-testing.h

+// Copyright 2010 the V8 project authors. All rights reserved.
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+//       notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+//       copyright notice, this list of conditions and the following
+//       disclaimer in the documentation and/or other materials provided
+//       with the distribution.
+//     * Neither the name of Google Inc. nor the names of its
+//       contributors may be used to endorse or promote products derived
+//       from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef V8_V8_TEST_H_
+#define V8_V8_TEST_H_
+
+#include "v8.h"
+
+#ifdef _WIN32
+// Setup for Windows DLL export/import. See v8.h in this directory for
+// information on how to build/use V8 as a DLL.
+#if defined(BUILDING_V8_SHARED) && defined(USING_V8_SHARED)
+#error both BUILDING_V8_SHARED and USING_V8_SHARED are set - please check the\
+  build configuration to ensure that at most one of these is set
+#endif
+
+#ifdef BUILDING_V8_SHARED
+#define V8EXPORT __declspec(dllexport)
+#elif USING_V8_SHARED
+#define V8EXPORT __declspec(dllimport)
+#else
+#define V8EXPORT
+#endif
+
+#else  // _WIN32
+
+// Setup for Linux shared library export. See v8.h in this directory for
+// information on how to build/use V8 as shared library.
+#if defined(__GNUC__) && (__GNUC__ >= 4) && defined(V8_SHARED)
+#define V8EXPORT __attribute__ ((visibility("default")))
+#else  // defined(__GNUC__) && (__GNUC__ >= 4)
+#define V8EXPORT
+#endif  // defined(__GNUC__) && (__GNUC__ >= 4)
+
+#endif  // _WIN32
+
+
+/**
+ * Testing support for the V8 JavaScript engine.
+ */
+namespace v8 {
+
+class V8EXPORT Testing {
+ public:
+  enum StressType {
+    kStressTypeOpt,
+    kStressTypeDeopt
+  };
+
+  /**
+   * Set the type of stressing to do. The default if not set is kStressTypeOpt.
+   */
+  static void SetStressRunType(StressType type);
+
+  /**
+   * Get the number of runs of a given test that is required to get the full
+   * stress coverage.
+   */
+  static int GetStressRuns();
+
+  /**
+   * Indicate the number of the run which is about to start. The value of run
+   * should be between 0 and one less than the result from GetStressRuns()
+   */
+  static void PrepareStressRun(int run);
+};
+
+
+}  // namespace v8
+
+
+#undef V8EXPORT
+
+
+#endif  // V8_V8_TEST_H_

vendor/node/node-0.4.7/include/v8stdint.h

+// Copyright 2010 the V8 project authors. All rights reserved.
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+//       notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+//       copyright notice, this list of conditions and the following
+//       disclaimer in the documentation and/or other materials provided
+//       with the distribution.
+//     * Neither the name of Google Inc. nor the names of its
+//       contributors may be used to endorse or promote products derived
+//       from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Load definitions of standard types.
+
+#ifndef V8STDINT_H_
+#define V8STDINT_H_
+
+#include <stdio.h>
+
+#if defined(_WIN32) && !defined(__MINGW32__)
+
+typedef signed char int8_t;
+typedef unsigned char uint8_t;
+typedef short int16_t;  // NOLINT
+typedef unsigned short uint16_t;  // NOLINT
+typedef int int32_t;
+typedef unsigned int uint32_t;
+typedef __int64 int64_t;
+typedef unsigned __int64 uint64_t;
+// intptr_t and friends are defined in crtdefs.h through stdio.h.
+
+#else
+
+#include <stdint.h>
+
+#endif
+
+#endif  // V8STDINT_H_

vendor/node/node-0.4.7/node-waf

+#!/usr/bin/env python
+import os, sys
+
+
+join = os.path.join
+wafdir = os.path.dirname(__file__)
+
+w = join(wafdir, 'wafadmin')
+t = join(w, 'Tools')
+sys.path = [w, t] + sys.path
+
+import Scripting
+VERSION="1.5.16"
+Scripting.prepare(t, os.getcwd(), VERSION, wafdir)
+sys.exit(0)

vendor/node/node-0.4.7/wafadmin/Constants.py

+#!/usr/bin/env python
+# encoding: utf-8
+# Yinon dot me gmail 2008
+
+"""
+these constants are somewhat public, try not to mess them
+
+maintainer: the version number is updated from the top-level wscript file
+"""
+
+# do not touch these three lines, they are updated automatically
+HEXVERSION=0x105016
+WAFVERSION="1.5.16"
+WAFREVISION = "7610:7647M"
+ABI = 7
+
+# permissions
+O644 = 420
+O755 = 493
+
+MAXJOBS = 99999999
+
+CACHE_DIR          = 'c4che'
+CACHE_SUFFIX       = '.cache.py'
+DBFILE             = '.wafpickle-%d' % ABI
+WSCRIPT_FILE       = 'wscript'
+WSCRIPT_BUILD_FILE = 'wscript_build'
+WAF_CONFIG_LOG     = 'config.log'
+WAF_CONFIG_H       = 'config.h'
+
+SIG_NIL = 'iluvcuteoverload'
+
+VARIANT = '_VARIANT_'
+DEFAULT = 'default'
+
+SRCDIR  = 'srcdir'
+BLDDIR  = 'blddir'
+APPNAME = 'APPNAME'
+VERSION = 'VERSION'
+
+DEFINES = 'defines'
+UNDEFINED = ()
+
+BREAK = "break"
+CONTINUE = "continue"
+
+# task scheduler options
+JOBCONTROL = "JOBCONTROL"
+MAXPARALLEL = "MAXPARALLEL"
+NORMAL = "NORMAL"
+
+# task state
+NOT_RUN = 0
+MISSING = 1
+CRASHED = 2
+EXCEPTION = 3
+SKIPPED = 8
+SUCCESS = 9
+
+ASK_LATER = -1
+SKIP_ME = -2
+RUN_ME = -3
+
+
+LOG_FORMAT = "%(asctime)s %(c1)s%(zone)s%(c2)s %(message)s"
+HOUR_FORMAT = "%H:%M:%S"
+
+TEST_OK = True
+
+CFG_FILES = 'cfg_files'
+
+# positive '->' install
+# negative '<-' uninstall
+INSTALL = 1337
+UNINSTALL = -1337
+

vendor/node/node-0.4.7/wafadmin/Environment.py

+#!/usr/bin/env python
+# encoding: utf-8
+# Thomas Nagy, 2005 (ita)
+
+"""Environment representation
+
+There is one gotcha: getitem returns [] if the contents evals to False
+This means env['foo'] = {}; print env['foo'] will print [] not {}
+"""
+
+import os, copy, re
+import Logs, Options, Utils
+from Constants import *
+re_imp = re.compile('^(#)*?([^#=]*?)\ =\ (.*?)$', re.M)
+
+class Environment(object):
+	"""A safe-to-use dictionary, but do not attach functions to it please (break cPickle)
+	An environment instance can be stored into a file and loaded easily
+	"""
+	__slots__ = ("table", "parent")
+	def __init__(self, filename=None):
+		self.table = {}
+		#self.parent = None
+
+		if filename:
+			self.load(filename)
+
+	def __contains__(self, key):
+		if key in self.table: return True
+		try: return self.parent.__contains__(key)
+		except AttributeError: return False # parent may not exist
+
+	def __str__(self):
+		keys = set()
+		cur = self
+		while cur:
+			keys.update(cur.table.keys())
+			cur = getattr(cur, 'parent', None)
+		keys = list(keys)
+		keys.sort()
+		return "\n".join(["%r %r" % (x, self.__getitem__(x)) for x in keys])
+
+	def __getitem__(self, key):
+		try:
+			while 1:
+				x = self.table.get(key, None)
+				if not x is None:
+					return x
+				self = self.parent
+		except AttributeError:
+			return []
+
+	def __setitem__(self, key, value):
+		self.table[key] = value
+
+	def __delitem__(self, key):
+		del self.table[key]
+	
+	def pop(self, key, *args):
+		if len(args):
+			return self.table.pop(key, *args)
+		return self.table.pop(key)
+
+	def set_variant(self, name):
+		self.table[VARIANT] = name
+
+	def variant(self):
+		try:
+			while 1:
+				x = self.table.get(VARIANT, None)
+				if not x is None:
+					return x
+				self = self.parent
+		except AttributeError:
+			return DEFAULT
+
+	def copy(self):
+		# TODO waf 1.6 rename this method derive, #368
+		newenv = Environment()
+		newenv.parent = self
+		return newenv
+
+	def detach(self):
+		"""TODO try it
+		modifying the original env will not change the copy"""
+		tbl = self.get_merged_dict()
+		try:
+			delattr(self, 'parent')
+		except AttributeError:
+			pass
+		else:
+			keys = tbl.keys()
+			for x in keys:
+				tbl[x] = copy.deepcopy(tbl[x])
+			self.table = tbl
+
+	def get_flat(self, key):
+		s = self[key]
+		if isinstance(s, str): return s
+		return ' '.join(s)
+
+	def _get_list_value_for_modification(self, key):
+		"""Gets a value that must be a list for further modification.  The
+		list may be modified inplace and there is no need to
+		"self.table[var] = value" afterwards.
+		"""
+		try:
+			value = self.table[key]
+		except KeyError:
+			try: value = self.parent[key]
+			except AttributeError: value = []
+			if isinstance(value, list):
+				value = value[:]
+			else:
+				value = [value]
+		else:
+			if not isinstance(value, list):
+				value = [value]
+		self.table[key] = value
+		return value
+
+	def append_value(self, var, value):
+		current_value = self._get_list_value_for_modification(var)
+
+		if isinstance(value, list):
+			current_value.extend(value)
+		else:
+			current_value.append(value)
+
+	def prepend_value(self, var, value):
+		current_value = self._get_list_value_for_modification(var)
+
+		if isinstance(value, list):
+			current_value = value + current_value
+			# a new list: update the dictionary entry
+			self.table[var] = current_value
+		else:
+			current_value.insert(0, value)
+
+	# prepend unique would be ambiguous
+	def append_unique(self, var, value):
+		current_value = self._get_list_value_for_modification(var)
+
+		if isinstance(value, list):
+			for value_item in value:
+				if value_item not in current_value:
+					current_value.append(value_item)
+		else:
+			if value not in current_value:
+				current_value.append(value)
+
+	def get_merged_dict(self):
+		"""compute a merged table"""
+		table_list = []
+		env = self
+		while 1:
+			table_list.insert(0, env.table)
+			try: env = env.parent
+			except AttributeError: break
+		merged_table = {}
+		for table in table_list:
+			merged_table.update(table)
+		return merged_table
+
+	def store(self, filename):
+		"Write the variables into a file"
+		file = open(filename, 'w')
+		merged_table = self.get_merged_dict()
+		keys = list(merged_table.keys())
+		keys.sort()
+		for k in keys: file.write('%s = %r\n' % (k, merged_table[k]))
+		file.close()
+
+	def load(self, filename):
+		"Retrieve the variables from a file"
+		tbl = self.table
+		code = Utils.readf(filename)
+		for m in re_imp.finditer(code):
+			g = m.group
+			tbl[g(2)] = eval(g(3))
+		Logs.debug('env: %s', self.table)
+
+	def get_destdir(self):
+		"return the destdir, useful for installing"
+		if self.__getitem__('NOINSTALL'): return ''
+		return Options.options.destdir
+
+	def update(self, d):
+		for k, v in d.iteritems():
+			self[k] = v
+
+
+	def __getattr__(self, name):
+		if name in self.__slots__:
+			return object.__getattr__(self, name)
+		else:
+			return self[name]
+
+	def __setattr__(self, name, value):
+		if name in self.__slots__:
+			object.__setattr__(self, name, value)
+		else:
+			self[name] = value
+
+	def __delattr__(self, name):
+		if name in self.__slots__:
+			object.__delattr__(self, name)
+		else:
+			del self[name]
+

vendor/node/node-0.4.7/wafadmin/Logs.py

+#!/usr/bin/env python
+# encoding: utf-8
+# Thomas Nagy, 2005 (ita)
+
+import ansiterm
+import os, re, logging, traceback, sys
+from Constants import *
+
+zones = ''
+verbose = 0
+
+colors_lst = {
+'USE' : True,
+'BOLD'  :'\x1b[01;1m',
+'RED'   :'\x1b[01;31m',
+'GREEN' :'\x1b[32m',
+'YELLOW':'\x1b[33m',
+'PINK'  :'\x1b[35m',
+'BLUE'  :'\x1b[01;34m',
+'CYAN'  :'\x1b[36m',
+'NORMAL':'\x1b[0m',
+'cursor_on'  :'\x1b[?25h',
+'cursor_off' :'\x1b[?25l',
+}
+
+got_tty = False
+term = os.environ.get('TERM', 'dumb')
+if not term in ['dumb', 'emacs']:
+	try:
+		got_tty = sys.stderr.isatty() or (sys.platform == 'win32' and term in ['xterm', 'msys'])
+	except AttributeError:
+		pass
+
+import Utils
+
+if not got_tty or 'NOCOLOR' in os.environ:
+	colors_lst['USE'] = False
+
+# test
+#if sys.platform == 'win32':
+#	colors_lst['USE'] = True
+
+def get_color(cl):
+	if not colors_lst['USE']: return ''
+	return colors_lst.get(cl, '')
+
+class foo(object):
+	def __getattr__(self, a):
+		return get_color(a)
+	def __call__(self, a):
+		return get_color(a)
+
+colors = foo()
+
+re_log = re.compile(r'(\w+): (.*)', re.M)
+class log_filter(logging.Filter):
+	def __init__(self, name=None):
+		pass
+
+	def filter(self, rec):
+		rec.c1 = colors.PINK
+		rec.c2 = colors.NORMAL
+		rec.zone = rec.module
+		if rec.levelno >= logging.INFO:
+			if rec.levelno >= logging.ERROR:
+				rec.c1 = colors.RED
+			elif rec.levelno >= logging.WARNING:
+				rec.c1 = colors.YELLOW
+			else:
+				rec.c1 = colors.GREEN
+			return True
+
+		zone = ''
+		m = re_log.match(rec.msg)
+		if m:
+			zone = rec.zone = m.group(1)
+			rec.msg = m.group(2)
+
+		if zones:
+			return getattr(rec, 'zone', '') in zones or '*' in zones
+		elif not verbose > 2:
+			return False
+		return True
+
+class formatter(logging.Formatter):
+	def __init__(self):
+		logging.Formatter.__init__(self, LOG_FORMAT, HOUR_FORMAT)
+
+	def format(self, rec):
+		if rec.levelno >= logging.WARNING or rec.levelno == logging.INFO:
+			try:
+				return '%s%s%s' % (rec.c1, rec.msg.decode('utf-8'), rec.c2)
+			except:
+				return rec.c1+rec.msg+rec.c2
+		return logging.Formatter.format(self, rec)
+
+def debug(*k, **kw):
+	if verbose:
+		k = list(k)
+		k[0] = k[0].replace('\n', ' ')
+		logging.debug(*k, **kw)
+
+def error(*k, **kw):
+	logging.error(*k, **kw)
+	if verbose > 1:
+		if isinstance(k[0], Utils.WafError):
+			st = k[0].stack
+		else:
+			st = traceback.extract_stack()
+		if st:
+			st = st[:-1]
+			buf = []
+			for filename, lineno, name, line in st:
+				buf.append('  File "%s", line %d, in %s' % (filename, lineno, name))
+				if line:
+					buf.append('	%s' % line.strip())
+			if buf: logging.error("\n".join(buf))
+
+warn = logging.warn
+info = logging.info
+
+def init_log():
+	log = logging.getLogger()
+	log.handlers = []
+	log.filters = []
+	hdlr = logging.StreamHandler()
+	hdlr.setFormatter(formatter())
+	log.addHandler(hdlr)
+	log.addFilter(log_filter())
+	log.setLevel(logging.DEBUG)
+
+# may be initialized more than once
+init_log()
+

vendor/node/node-0.4.7/wafadmin/Options.py

+#!/usr/bin/env python
+# encoding: utf-8
+# Scott Newton, 2005 (scottn)
+# Thomas Nagy, 2006 (ita)
+
+"Custom command-line options"
+
+import os, sys, imp, types, tempfile, optparse
+import Logs, Utils
+from Constants import *
+
+cmds = 'distclean configure build install clean uninstall check dist distcheck'.split()
+
+# TODO remove in waf 1.6 the following two
+commands = {}
+is_install = False
+
+options = {}
+arg_line = []
+launch_dir = ''
+tooldir = ''
+lockfile = os.environ.get('WAFLOCK', '.lock-wscript')
+try: cache_global = os.path.abspath(os.environ['WAFCACHE'])
+except KeyError: cache_global = ''
+platform = Utils.unversioned_sys_platform()
+conf_file = 'conf-runs-%s-%d.pickle' % (platform, ABI)
+
+remote_repo = ['http://waf.googlecode.com/svn/']
+"""remote directory for the plugins"""
+
+
+# Such a command-line should work:  JOBS=4 PREFIX=/opt/ DESTDIR=/tmp/ahoj/ waf configure
+default_prefix = os.environ.get('PREFIX')
+if not default_prefix:
+	if platform == 'win32': default_prefix = tempfile.gettempdir()
+	else: default_prefix = '/usr/local/'
+
+default_jobs = os.environ.get('JOBS', -1)
+if default_jobs < 1:
+	try:
+		if 'SC_NPROCESSORS_ONLN' in os.sysconf_names:
+			default_jobs = os.sysconf('SC_NPROCESSORS_ONLN')
+		else:
+			default_jobs = int(Utils.cmd_output(['sysctl', '-n', 'hw.ncpu']))
+	except:
+		if os.name == 'java': # platform.system() == 'Java'
+			from java.lang import Runtime
+			default_jobs = Runtime.getRuntime().availableProcessors()
+		else:
+			# environment var defined on win32
+			default_jobs = int(os.environ.get('NUMBER_OF_PROCESSORS', 1))
+
+default_destdir = os.environ.get('DESTDIR', '')
+
+def get_usage(self):
+	cmds_str = []
+	module = Utils.g_module
+	if module:
+		# create the help messages for commands
+		tbl = module.__dict__
+		keys = list(tbl.keys())
+		keys.sort()
+
+		if 'build' in tbl:
+			if not module.build.__doc__:
+				module.build.__doc__ = 'builds the project'
+		if 'configure' in tbl:
+			if not module.configure.__doc__:
+				module.configure.__doc__ = 'configures the project'
+
+		ban = ['set_options', 'init', 'shutdown']
+
+		optlst = [x for x in keys if not x in ban
+			and type(tbl[x]) is type(parse_args_impl)
+			and tbl[x].__doc__
+			and not x.startswith('_')]
+
+		just = max([len(x) for x in optlst])
+
+		for x in optlst:
+			cmds_str.append('  %s: %s' % (x.ljust(just), tbl[x].__doc__))
+		ret = '\n'.join(cmds_str)
+	else:
+		ret = ' '.join(cmds)
+	return '''waf [command] [options]
+
+Main commands (example: ./waf build -j4)
+%s
+''' % ret
+
+
+setattr(optparse.OptionParser, 'get_usage', get_usage)
+
+def create_parser(module=None):
+	Logs.debug('options: create_parser is called')
+	parser = optparse.OptionParser(conflict_handler="resolve", version = 'waf %s (%s)' % (WAFVERSION, WAFREVISION))
+
+	parser.formatter.width = Utils.get_term_cols()
+	p = parser.add_option
+
+	p('-j', '--jobs',
+		type    = 'int',
+		default = default_jobs,
+		help    = 'amount of parallel jobs (%r)' % default_jobs,
+		dest    = 'jobs')
+
+	p('-k', '--keep',
+		action  = 'store_true',
+		default = False,
+		help    = 'keep running happily on independent task groups',
+		dest    = 'keep')
+
+	p('-v', '--verbose',
+		action  = 'count',
+		default = 0,
+		help    = 'verbosity level -v -vv or -vvv [default: 0]',
+		dest    = 'verbose')
+
+	p('--nocache',
+		action  = 'store_true',
+		default = False,
+		help    = 'ignore the WAFCACHE (if set)',
+		dest    = 'nocache')
+
+	p('--zones',
+		action  = 'store',
+		default = '',
+		help    = 'debugging zones (task_gen, deps, tasks, etc)',
+		dest    = 'zones')
+
+	p('-p', '--progress',
+		action  = 'count',
+		default = 0,
+		help    = '-p: progress bar; -pp: ide output',
+		dest    = 'progress_bar')
+
+	p('--targets',
+		action  = 'store',
+		default = '',
+		help    = 'build given task generators, e.g. "target1,target2"',
+		dest    = 'compile_targets')
+
+	gr = optparse.OptionGroup(parser, 'configuration options')
+	parser.add_option_group(gr)
+	gr.add_option('-b', '--blddir',
+		action  = 'store',
+		default = '',
+		help    = 'build dir for the project (configuration)',
+		dest    = 'blddir')
+	gr.add_option('-s', '--srcdir',
+		action  = 'store',
+		default = '',
+		help    = 'src dir for the project (configuration)',
+		dest    = 'srcdir')
+	gr.add_option('--prefix',
+		help    = 'installation prefix (configuration) [default: %r]' % default_prefix,
+		default = default_prefix,
+		dest    = 'prefix')
+
+	gr = optparse.OptionGroup(parser, 'installation options')
+	parser.add_option_group(gr)
+	gr.add_option('--destdir',
+		help    = 'installation root [default: %r]' % default_destdir,
+		default = default_destdir,
+		dest    = 'destdir')
+	gr.add_option('-f', '--force',
+		action  = 'store_true',
+		default = False,
+		help    = 'force file installation',
+		dest    = 'force')
+
+	return parser
+
+def parse_args_impl(parser, _args=None):
+	global options, commands, arg_line
+	(options, args) = parser.parse_args(args=_args)
+
+	arg_line = args
+	#arg_line = args[:] # copy
+
+	# By default, 'waf' is equivalent to 'waf build'
+	commands = {}
+	for var in cmds: commands[var] = 0
+	if not args:
+		commands['build'] = 1
+		args.append('build')
+
+	# Parse the command arguments
+	for arg in args:
+		commands[arg] = True
+
+	# the check thing depends on the build
+	if 'check' in args:
+		idx = args.index('check')
+		try:
+			bidx = args.index('build')
+			if bidx > idx:
+				raise ValueError('build before check')
+		except ValueError, e:
+			args.insert(idx, 'build')
+
+	if args[0] != 'init':
+		args.insert(0, 'init')
+
+	# TODO -k => -j0
+	if options.keep: options.jobs = 1
+	if options.jobs < 1: options.jobs = 1
+
+	if 'install' in sys.argv or 'uninstall' in sys.argv:
+		# absolute path only if set
+		options.destdir = options.destdir and os.path.abspath(os.path.expanduser(options.destdir))
+
+	Logs.verbose = options.verbose
+	Logs.init_log()
+
+	if options.zones:
+		Logs.zones = options.zones.split(',')
+		if not Logs.verbose: Logs.verbose = 1
+	elif Logs.verbose > 0:
+		Logs.zones = ['runner']
+	if Logs.verbose > 2:
+		Logs.zones = ['*']
+
+# TODO waf 1.6
+# 1. rename the class to OptionsContext
+# 2. instead of a class attribute, use a module (static 'parser')
+# 3. parse_args_impl was made in times when we did not know about binding new methods to classes
+
+class Handler(Utils.Context):
+	"""loads wscript modules in folders for adding options
+	This class should be named 'OptionsContext'
+	A method named 'recurse' is bound when used by the module Scripting"""
+
+	parser = None
+	# make it possible to access the reference, like Build.bld
+
+	def __init__(self, module=None):
+		self.parser = create_parser(module)
+		self.cwd = os.getcwd()
+		Handler.parser = self
+
+	def add_option(self, *k, **kw):
+		self.parser.add_option(*k, **kw)
+
+	def add_option_group(self, *k, **kw):
+		return self.parser.add_option_group(*k, **kw)
+
+	def get_option_group(self, opt_str):
+		return self.parser.get_option_group(opt_str)
+
+	def sub_options(self, *k, **kw):
+		if not k: raise Utils.WscriptError('folder expected')
+		self.recurse(k[0], name='set_options')
+
+	def tool_options(self, *k, **kw):
+		Utils.python_24_guard()
+
+		if not k[0]:
+			raise Utils.WscriptError('invalid tool_options call %r %r' % (k, kw))
+		tools = Utils.to_list(k[0])
+
+		# TODO waf 1.6 remove the global variable tooldir
+		path = Utils.to_list(kw.get('tdir', kw.get('tooldir', tooldir)))
+
+		for tool in tools:
+			tool = tool.replace('++', 'xx')
+			if tool == 'java': tool = 'javaw'
+			if tool.lower() == 'unittest': tool = 'unittestw'
+			module = Utils.load_tool(tool, path)
+			try:
+				fun = module.set_options
+			except AttributeError:
+				pass
+			else:
+				fun(kw.get('option_group', self))
+
+	def parse_args(self, args=None):
+		parse_args_impl(self.parser, args)
+

vendor/node/node-0.4.7/wafadmin/Tools/__init__.py

+#!/usr/bin/env python
+# encoding: utf-8
+# Thomas Nagy, 2006 (ita)
+