Embrace the C++11 spelling of NULL.

Author: cscott

src/asyncmessageworker.h

@@ -122,7 +122,7 @@ class AsyncMapperChannel : public MapperChannel {
     // PHP-side shutdown is complete by the time the destructor is called.
     // Tear down JS-side queue.  (Completion is async, but that's okay.)
     uv_async_t *async = js_queue_.async();
-    async->data = NULL;  // can't touch asyncmessageworker after we return.
+    async->data = nullptr;  // can't touch asyncmessageworker after we return.
     uv_close(reinterpret_cast<uv_handle_t*>(async), AsyncClose_);
     TRACE("<");
   }
@@ -162,7 +162,7 @@ class AsyncMapperChannel : public MapperChannel {
   };
 
   virtual void HandleOKCallback(JsObjectMapper *m) {
-    callback->Call(0, NULL);
+    callback->Call(0, nullptr);
   }
 
  private:
@@ -174,13 +174,13 @@ class AsyncMapperChannel : public MapperChannel {
   class JsCleanupSyncMsg : MessageToJs {
     friend class AsyncMessageWorker;
     explicit JsCleanupSyncMsg(AsyncMessageWorker *that)
-        : MessageToJs(&(that->channel_), NULL, true), that_(that) { }
+        : MessageToJs(&(that->channel_), nullptr, true), that_(that) { }
     void InJs(JsObjectMapper *m) override {
       TRACE("> JsCleanupSyncMsg");
       // All previous PHP requests should have been serviced by now.
       objid_t last = that_->channel_.ClearAllJsIds();
       // Empty the JS side queue.
-      that_->ProcessJs(NULL, false /* we're inside a ProcessJs already */);
+      that_->ProcessJs(nullptr, false /* we're inside a ProcessJs already */);
       // Ok, return to tell PHP the queues are empty.
       retval_.SetInt(last);
       TRACE("< JsCleanupSyncMsg");
@@ -226,8 +226,8 @@ class AsyncMapperChannel : public MapperChannel {
       last = msg.GetLastId(&channel_ TSRMLS_CC);
       // Exit this scope to dealloc msg before proceeding.
     }
-    ProcessPhp(NULL TSRMLS_CC);  // A precaution; shouldn't be necessary.
-    a->data = NULL;
+    ProcessPhp(nullptr TSRMLS_CC);  // A precaution; shouldn't be necessary.
+    a->data = nullptr;
     js_queue_.Shutdown();
     /* OK, queues are empty now, we can start tearing things down. */
     for (objid_t id = 1; id < last; id++) {
@@ -292,14 +292,14 @@ class AsyncMapperChannel : public MapperChannel {
     // Kick the tick.  See:
     // https://github.com/nodejs/nan/issues/284#issuecomment-150887627
     if (kickNextTick) {
-      kick_next_tick_.Call(0, NULL);
+      kick_next_tick_.Call(0, nullptr);
     }
   }
 
   NAN_INLINE static NAUV_WORK_CB(JsAsyncMessage_) {
     AsyncMessageWorker *worker = static_cast<AsyncMessageWorker*>(async->data);
     if (worker) {
-      worker->ProcessJs(NULL, true /* from uv loop, kick next tick */);
+      worker->ProcessJs(nullptr, true /* from uv loop, kick next tick */);
     } else {
       NPE_ERROR("! JsAsyncMessage after shutdown");  // Shouldn't happen.
     }
@@ -333,7 +333,7 @@ class AsyncMapperChannel : public MapperChannel {
     AsyncMessageWorker *worker = static_cast<AsyncMessageWorker*>(async->data);
     if (worker) {
       TSRMLS_FETCH();
-      worker->ProcessPhp(NULL TSRMLS_CC);
+      worker->ProcessPhp(nullptr TSRMLS_CC);
     } else {
       NPE_ERROR("! PhpAsyncMessage after shutdown");  // Shouldn't happen.
     }
@@ -392,7 +392,7 @@ v8::Local<v8::Object> amw::AsyncMapperChannel::JsObjForId(objid_t id) {
   }
   if (!IsValid()) {
     // This happens when we return an object at the tail of the request.
-    return scope.Escape(PhpObject::Create(NULL, 0));
+    return scope.Escape(PhpObject::Create(nullptr, 0));
   }
   // Make a wrapper!
   v8::Local<v8::NativeWeakMap> jsObjToId = Nan::New(js_obj_to_id_);
@@ -466,10 +466,10 @@ zval *amw::AsyncMapperChannel::PhpObjForId(objid_t id TSRMLS_DC) {
 
 // Free PHP references associated with an id.
 void amw::AsyncMapperChannel::ClearPhpId(objid_t id TSRMLS_DC) {
-  zval *z = (id < php_obj_list_.size()) ? php_obj_list_[id] : NULL;
+  zval *z = (id < php_obj_list_.size()) ? php_obj_list_[id] : nullptr;
   if (z) {
     node_php_jsobject_maybe_neuter(z TSRMLS_CC);
-    php_obj_list_[id] = NULL;
+    php_obj_list_[id] = nullptr;
     php_obj_to_id_.erase(Z_OBJ_HANDLE_P(z));
     zval_ptr_dtor(&z);
   }

src/macros.h

@@ -124,7 +124,7 @@ static NAN_INLINE v8::Local<v8::String> CAST_STRING(
 #if ZEND_MODULE_API_NO >= 20100409
 # define ZEND_HASH_KEY_DC , const zend_literal *key
 # define ZEND_HASH_KEY_CC , key
-# define ZEND_HASH_KEY_NULL , NULL
+# define ZEND_HASH_KEY_NULL , nullptr
 #else
 # define ZEND_HASH_KEY_DC
 # define ZEND_HASH_KEY_CC

src/messagequeue.h

@@ -33,7 +33,7 @@ class MessageQueue {
     _Push(m);
   }
   void Notify() {
-    _Push(NULL);
+    _Push(nullptr);
   }
   // Processes all messages on the queue.
   // Returns true if at least one message was processed.
@@ -50,7 +50,7 @@ class MessageQueue {
       // a recursive processing loop.
       uv_mutex_lock(&lock_);
       if (data_.empty()) {
-        m = NULL;
+        m = nullptr;
         if (match) {
           // We're blocking for a particular message, and there's nothing here.
           // Block to wait for some data.

src/messages.h

@@ -84,7 +84,7 @@ class Message {
 // in PHP and the response is handled in JavaScript.
 class MessageToPhp : public Message {
  public:
-  // Constructed in JS thread.  The callback may be NULL for
+  // Constructed in JS thread.  The callback may be nullptr for
   // fire-and-forget methods.  If provided, it will be invoked
   // nodejs-style, with exception as first arg and retval as second.
   // The callback will be owned by the message, and deleted after use.
@@ -110,7 +110,7 @@ class MessageToPhp : public Message {
     if (retval_.IsEmpty() && exception_.IsEmpty()) {
       // If no result, throw an exception.
       const char *msg = (!mapper_->IsValid()) ? "shutdown" :
-        (!IsEmptyRetvalOk()) ? "no return value" : NULL;
+        (!IsEmptyRetvalOk()) ? "no return value" : nullptr;
       if (msg) {
         exception_.SetString(msg, strlen(msg));
       }
@@ -178,16 +178,16 @@ class MessageToPhp : public Message {
 // in JS and the response is handled in PHP.
 class MessageToJs : public Message {
  public:
-  // Constructed in PHP thread. The php_callback may be NULL for
+  // Constructed in PHP thread. The php_callback may be nullptr for
   // fire-and-forget methods.  If provided, it will be invoked
   // as a closure, with the exception as the first arg and the
   // return value as the second.  The MessageToJs will ref the
   // zval and unref it after use.  For sync calls, the php_callback
   // should be null and is_sync should be true.
   MessageToJs(ObjectMapper *m, zval *php_callback, bool is_sync)
       : Message(m), php_callback_(php_callback ZEND_FILE_LINE_CC),
-    is_sync_(is_sync), js_callback_data_(NULL), local_flag_ptr_(NULL),
-        stashedChannel_(NULL) {
+    is_sync_(is_sync), js_callback_data_(nullptr), local_flag_ptr_(nullptr),
+        stashedChannel_(nullptr) {
     assert(is_sync ? php_callback_.IsNull() : true);
   }
   virtual ~MessageToJs() {}
@@ -221,7 +221,7 @@ class MessageToJs : public Message {
       }
       // We're out of danger now; reset local_flag_ptr_ so that any async
       // exeuctions of ExecuteJs don't use our stack pointer after it's popped.
-      local_flag_ptr_ = NULL;
+      local_flag_ptr_ = nullptr;
       // If an exception was thrown, set exception_
       if (tryCatch.HasCaught()) {
         exception_.Set(mapper_, tryCatch.Exception());
@@ -245,7 +245,7 @@ class MessageToJs : public Message {
     if (retval_.IsEmpty() && exception_.IsEmpty()) {
       // If no result, throw an exception.
       const char *msg = (!mapper_->IsValid()) ? "shutdown" :
-        (!IsEmptyRetvalOk()) ? "no return value" : NULL;
+        (!IsEmptyRetvalOk()) ? "no return value" : nullptr;
       if (msg) {
         exception_.Set(mapper_, Nan::TypeError(msg));
       }

src/node_php_embed.cc

@@ -86,7 +86,7 @@ class node_php_embed::PhpRequestWorker : public AsyncMessageWorker {
           // Can't call zend_clear_exception because there isn't a current
           // execution stack (ie, `EG(current_execute_data)`)
           zval *e = EG(exception);
-          EG(exception) = NULL;
+          EG(exception) = nullptr;
           convert_to_string(e);
           SetErrorMessage(Z_STRVAL_P(e));
           zval_ptr_dtor(&e);
@@ -113,10 +113,10 @@ class node_php_embed::PhpRequestWorker : public AsyncMessageWorker {
   }
   void AfterExecute(TSRMLS_D) override {
     TRACE("> PhpRequestWorker");
-    NODE_PHP_EMBED_G(worker) = NULL;
-    NODE_PHP_EMBED_G(channel) = NULL;
+    NODE_PHP_EMBED_G(worker) = nullptr;
+    NODE_PHP_EMBED_G(channel) = nullptr;
     TRACE("- request shutdown");
-    php_request_shutdown(NULL);
+    php_request_shutdown(nullptr);
     TRACE("< PhpRequestWorker");
   }
   // Executed when the async work is complete.
@@ -261,10 +261,10 @@ static void node_php_embed_register_server_variables(
   // Allow the JS function to be asynchronous.
   node_php_embed::node_php_jswait_create(wait.Ptr() TSRMLS_CC);
   // Now invoke the JS function, passing in the wrapper
-  zval *r = NULL;
+  zval *r = nullptr;
   zend_call_method_with_2_params(init_func.PtrPtr(),
-                                 Z_OBJCE_P(init_func.Ptr()), NULL, "__invoke",
-                                 &r, server.Ptr(), wait.Ptr());
+                                 Z_OBJCE_P(init_func.Ptr()), nullptr,
+                                 "__invoke", &r, server.Ptr(), wait.Ptr());
   if (EG(exception)) {
     NPE_ERROR("Exception in server init function");
     zend_clear_exception(TSRMLS_C);
@@ -279,7 +279,8 @@ NAN_METHOD(setIniPath) {
   if (php_embed_module.php_ini_path_override) {
     free(php_embed_module.php_ini_path_override);
   }
-  php_embed_module.php_ini_path_override = (*iniPath) ? strdup(*iniPath) : NULL;
+  php_embed_module.php_ini_path_override =
+    (*iniPath) ? strdup(*iniPath) : nullptr;
   TRACE("<");
 }
 
@@ -318,8 +319,8 @@ PHP_MINFO_FUNCTION(node_php_embed) {
 
 static void node_php_embed_globals_ctor(
     zend_node_php_embed_globals *node_php_embed_globals TSRMLS_DC) {
-  node_php_embed_globals->worker = NULL;
-  node_php_embed_globals->channel = NULL;
+  node_php_embed_globals->worker = nullptr;
+  node_php_embed_globals->channel = nullptr;
 }
 static void node_php_embed_globals_dtor(
     zend_node_php_embed_globals *node_php_embed_globals TSRMLS_DC) {
@@ -339,17 +340,17 @@ PHP_MINIT_FUNCTION(node_php_embed) {
 zend_module_entry node_php_embed_module_entry = {
   STANDARD_MODULE_HEADER,
   "node-php-embed", /* extension name */
-  NULL, /* function entries */
+  nullptr, /* function entries */
   PHP_MINIT(node_php_embed), /* MINIT */
-  NULL, /* MSHUTDOWN */
-  NULL, /* RINIT */
-  NULL, /* RSHUTDOWN */
+  nullptr, /* MSHUTDOWN */
+  nullptr, /* RINIT */
+  nullptr, /* RSHUTDOWN */
   PHP_MINFO(node_php_embed), /* MINFO */
   NODE_PHP_EMBED_VERSION,
   ZEND_MODULE_GLOBALS(node_php_embed),
   (void(*)(void* TSRMLS_DC))node_php_embed_globals_ctor,
   (void(*)(void* TSRMLS_DC))node_php_embed_globals_dtor,
-  NULL, /* post deactivate func */
+  nullptr, /* post deactivate func */
   STANDARD_MODULE_PROPERTIES_EX
 };
 
@@ -366,22 +367,22 @@ static void node_php_embed_ensure_init(void) {
   }
   TRACE(">");
   node_php_embed_inited = true;
-  char *argv[] = { NULL };
+  char *argv[] = { nullptr };
   int argc = 0;
   php_embed_init(argc, argv PTSRMLS_CC);
   // Shutdown the initially-created request; we'll create our own request
   // objects inside PhpRequestWorker.
-  php_request_shutdown(NULL);
-  node::AtExit(ModuleShutdown, NULL);
+  php_request_shutdown(nullptr);
+  node::AtExit(ModuleShutdown, nullptr);
   TRACE("<");
 }
 
 NAN_MODULE_INIT(ModuleInit) {
   TRACE(">");
-  php_embed_module.php_ini_path_override = NULL;
+  php_embed_module.php_ini_path_override = nullptr;
   php_embed_module.php_ini_ignore = true;
   php_embed_module.php_ini_ignore_cwd = true;
-  php_embed_module.ini_defaults = NULL;
+  php_embed_module.ini_defaults = nullptr;
   php_embed_module.startup = node_php_embed_startup;
   php_embed_module.send_header = node_php_embed_send_header;
   php_embed_module.ub_write = node_php_embed_ub_write;

src/node_php_jsbuffer_class.cc

@@ -62,9 +62,9 @@ static zend_object_value node_php_jsbuffer_new(zend_class_entry *ce TSRMLS_DC) {
   zend_object_std_init(&c->std, ce TSRMLS_CC);
 
   retval.handle = zend_objects_store_put(
-      c, NULL,
+      c, nullptr,
       (zend_objects_free_object_storage_t) node_php_jsbuffer_free_storage,
-      NULL TSRMLS_CC);
+      nullptr TSRMLS_CC);
   retval.handlers = &node_php_jsbuffer_handlers;
 
   TRACE("<");
@@ -91,7 +91,7 @@ void node_php_embed::node_php_jsbuffer_create(zval *res,
   c->data = data;
   c->length = length;
   c->owner = owner;
-  c->z = NULL;
+  c->z = nullptr;
 
   TRACE("<");
 }
@@ -165,9 +165,9 @@ STUB_METHOD(__wakeup)
 static const zend_function_entry node_php_jsbuffer_methods[] = {
   PHP_ME(JsBuffer, __construct, node_php_jsbuffer_construct_args,
          ZEND_ACC_PUBLIC|ZEND_ACC_CTOR)
-  PHP_ME(JsBuffer, __sleep,     NULL,
+  PHP_ME(JsBuffer, __sleep,     nullptr,
          ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
-  PHP_ME(JsBuffer, __wakeup,    NULL,
+  PHP_ME(JsBuffer, __wakeup,    nullptr,
          ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
   PHP_ME(JsBuffer, __toString, node_php_jsbuffer_toString_args,
          ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
@@ -188,9 +188,9 @@ PHP_MINIT_FUNCTION(node_php_jsbuffer_class) {
   /* JsBuffer handlers */
   memcpy(&node_php_jsbuffer_handlers, zend_get_std_object_handlers(),
          sizeof(zend_object_handlers));
-  node_php_jsbuffer_handlers.clone_obj = NULL;
-  node_php_jsbuffer_handlers.cast_object = NULL;
-  node_php_jsbuffer_handlers.get_property_ptr_ptr = NULL;
+  node_php_jsbuffer_handlers.clone_obj = nullptr;
+  node_php_jsbuffer_handlers.cast_object = nullptr;
+  node_php_jsbuffer_handlers.get_property_ptr_ptr = nullptr;
 
   TRACE("< PHP_MINIT_FUNCTION");
   return SUCCESS;