[wasm] s/NULL/nullptr/g

src/wasm/asm-wasm-builder.cc

 // Copyright 2015 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/v8.h"
 
 #include "src/wasm/asm-wasm-builder.h"
 #include "src/wasm/wasm-macro-gen.h"
 #include "src/wasm/wasm-opcodes.h"
 
@@ skipping 22 matching lines @@
                          ZoneAllocationPolicy(zone)),
         functions_(HashMap::PointersMatch, ZoneHashMap::kDefaultHashMapCapacity,
                    ZoneAllocationPolicy(zone)),
         global_variables_(HashMap::PointersMatch,
                           ZoneHashMap::kDefaultHashMapCapacity,
                           ZoneAllocationPolicy(zone)),
         in_function_(false),
         is_set_op_(false),
         marking_exported(false),
         builder_(new (zone) WasmModuleBuilder(zone)),
-        current_function_builder_(NULL),
+        current_function_builder_(nullptr),
         literal_(literal),
         isolate_(isolate),
         zone_(zone),
         cache_(TypeCache::Get()),
         breakable_blocks_(zone),
         block_size_(0),
         init_function_initialized(false),
         init_function_index(0) {
     InitializeAstVisitor(isolate);
   }
 
   void Compile() { RECURSE(VisitFunctionLiteral(literal_)); }
 
   void VisitVariableDeclaration(VariableDeclaration* decl) {}
 
   void VisitFunctionDeclaration(FunctionDeclaration* decl) {
     DCHECK(!in_function_);
-    DCHECK(current_function_builder_ == NULL);
+    DCHECK(current_function_builder_ == nullptr);
     uint16_t index = LookupOrInsertFunction(decl->proxy()->var());
     current_function_builder_ = builder_->FunctionAt(index);
     in_function_ = true;
     RECURSE(Visit(decl->fun()));
     in_function_ = false;
-    current_function_builder_ = NULL;
+    current_function_builder_ = nullptr;
     local_variables_.Clear();
   }
 
   void VisitImportDeclaration(ImportDeclaration* decl) {}
 
   void VisitExportDeclaration(ExportDeclaration* decl) {}
 
   void VisitStatements(ZoneList<Statement*>* stmts) {
     for (int i = 0; i < stmts->length(); ++i) {
       Statement* stmt = stmts->at(i);
       RECURSE(Visit(stmt));
       if (stmt->IsJump()) break;
     }
   }
 
   void VisitBlock(Block* stmt) {
     if (stmt->statements()->length() == 1) {
       ExpressionStatement* expr =
           stmt->statements()->at(0)->AsExpressionStatement();
-      if (expr != NULL) {
+      if (expr != nullptr) {
         if (expr->expression()->IsAssignment()) {
           RECURSE(VisitExpressionStatement(expr));
           return;
         }
       }
     }
     DCHECK(in_function_);
     BlockVisitor visitor(this, stmt->AsBreakableStatement(), kExprBlock, false);
     block_size_ = static_cast<byte>(stmt->statements()->length());
     RECURSE(VisitStatements(stmt->statements()));
@@ skipping 139 matching lines @@
     BlockVisitor visitor(this, stmt->AsBreakableStatement(), kExprLoop, true);
     block_size_ = 1;
     current_function_builder_->Emit(kExprIf);
     RECURSE(Visit(stmt->cond()));
     current_function_builder_->EmitWithU8(kExprBr, 0);
     RECURSE(Visit(stmt->body()));
   }
 
   void VisitForStatement(ForStatement* stmt) {
     DCHECK(in_function_);
-    if (stmt->init() != NULL) {
+    if (stmt->init() != nullptr) {
       block_size_++;
       RECURSE(Visit(stmt->init()));
     }
     BlockVisitor visitor(this, stmt->AsBreakableStatement(), kExprLoop, true);
     block_size_ = 0;
-    if (stmt->cond() != NULL) {
+    if (stmt->cond() != nullptr) {
       block_size_++;
       current_function_builder_->Emit(kExprIf);
       current_function_builder_->Emit(kExprBoolNot);
       RECURSE(Visit(stmt->cond()));
       current_function_builder_->EmitWithU8(kExprBr, 1);
       current_function_builder_->Emit(kExprNop);
     }
-    if (stmt->body() != NULL) {
+    if (stmt->body() != nullptr) {
       block_size_++;
       RECURSE(Visit(stmt->body()));
     }
-    if (stmt->next() != NULL) {
+    if (stmt->next() != nullptr) {
       block_size_++;
       RECURSE(Visit(stmt->next()));
     }
     block_size_++;
     current_function_builder_->EmitWithU8(kExprBr, 0);
     current_function_builder_->Emit(kExprNop);
   }
 
   void VisitForInStatement(ForInStatement* stmt) { UNREACHABLE(); }
 
@@ skipping 130 matching lines @@
       current_function_builder_->Exported(1);
       in_function_ = true;
     } else {
       current_function_builder_ = builder_->FunctionAt(init_function_index);
       in_function_ = true;
     }
   }
 
   void UnLoadInitFunction() {
     in_function_ = false;
-    current_function_builder_ = NULL;
+    current_function_builder_ = nullptr;
   }
 
   void VisitAssignment(Assignment* expr) {
     bool in_init = false;
     if (!in_function_) {
       // TODO(bradnelson): Get rid of this.
       if (TypeOf(expr->value()) == kAstStmt) {
         return;
       }
       in_init = true;
       LoadInitFunction();
     }
     BinaryOperation* value_op = expr->value()->AsBinaryOperation();
-    if (value_op != NULL && MatchBinaryOperation(value_op) == kAsIs) {
+    if (value_op != nullptr && MatchBinaryOperation(value_op) == kAsIs) {
       VariableProxy* target_var = expr->target()->AsVariableProxy();
       VariableProxy* effective_value_var = GetLeft(value_op)->AsVariableProxy();
       // TODO(aseemgarg): simplify block_size_ or replace with a kNop
-      if (target_var != NULL && effective_value_var != NULL &&
+      if (target_var != nullptr && effective_value_var != nullptr &&
           target_var->var() == effective_value_var->var()) {
         block_size_--;
         return;
       }
     }
     is_set_op_ = true;
     RECURSE(Visit(expr->target()));
     DCHECK(!is_set_op_);
     RECURSE(Visit(expr->value()));
     if (in_init) {
@@ skipping 105 matching lines @@
       default:
         UNREACHABLE();
     }
     RECURSE(Visit(expr->expression()));
   }
 
   void VisitCountOperation(CountOperation* expr) { UNREACHABLE(); }
 
   bool MatchIntBinaryOperation(BinaryOperation* expr, Token::Value op,
                                int32_t val) {
-    DCHECK(expr->right() != NULL);
+    DCHECK(expr->right() != nullptr);
     if (expr->op() == op && expr->right()->IsLiteral() &&
         TypeOf(expr) == kAstI32) {
       Literal* right = expr->right()->AsLiteral();
       DCHECK(right->raw_value()->IsNumber());
       if (static_cast<int32_t>(right->raw_value()->AsNumber()) == val) {
         return true;
       }
     }
     return false;
   }
 
   bool MatchDoubleBinaryOperation(BinaryOperation* expr, Token::Value op,
                                   double val) {
-    DCHECK(expr->right() != NULL);
+    DCHECK(expr->right() != nullptr);
     if (expr->op() == op && expr->right()->IsLiteral() &&
         TypeOf(expr) == kAstF64) {
       Literal* right = expr->right()->AsLiteral();
       DCHECK(right->raw_value()->IsNumber());
       if (right->raw_value()->AsNumber() == val) {
         return true;
       }
     }
     return false;
   }
@@ skipping 18 matching lines @@
     } else {
       return kNone;
     }
   }
 
   ConvertOperation MatchXor(BinaryOperation* expr) {
     if (MatchIntBinaryOperation(expr, Token::BIT_XOR, 0xffffffff)) {
       DCHECK(TypeOf(expr->left()) == kAstI32);
       DCHECK(TypeOf(expr->right()) == kAstI32);
       BinaryOperation* op = expr->left()->AsBinaryOperation();
-      if (op != NULL) {
+      if (op != nullptr) {
         if (MatchIntBinaryOperation(op, Token::BIT_XOR, 0xffffffff)) {
           DCHECK(TypeOf(op->right()) == kAstI32);
           if (TypeOf(op->left()) != kAstI32) {
             return kToInt;
           } else {
             return kAsIs;
           }
         }
       }
     }
@@ skipping 268 matching lines @@
   void VisitRewritableAssignmentExpression(
       RewritableAssignmentExpression* expr) {
     UNREACHABLE();
   }
 
   struct IndexContainer : public ZoneObject {
     uint16_t index;
   };
 
   uint16_t LookupOrInsertLocal(Variable* v, LocalType type) {
-    DCHECK(current_function_builder_ != NULL);
+    DCHECK(current_function_builder_ != nullptr);
     ZoneHashMap::Entry* entry =
         local_variables_.Lookup(v, ComputePointerHash(v));
-    if (entry == NULL) {
+    if (entry == nullptr) {
       uint16_t index;
       if (v->IsParameter()) {
         index = current_function_builder_->AddParam(type);
       } else {
         index = current_function_builder_->AddLocal(type);
       }
       IndexContainer* container = new (zone()) IndexContainer();
       container->index = index;
       entry = local_variables_.LookupOrInsert(v, ComputePointerHash(v),
                                               ZoneAllocationPolicy(zone()));
       entry->value = container;
     }
     return (reinterpret_cast<IndexContainer*>(entry->value))->index;
   }
 
   uint16_t LookupOrInsertGlobal(Variable* v, LocalType type) {
     ZoneHashMap::Entry* entry =
         global_variables_.Lookup(v, ComputePointerHash(v));
-    if (entry == NULL) {
+    if (entry == nullptr) {
       uint16_t index =
           builder_->AddGlobal(WasmOpcodes::MachineTypeFor(type), 0);
       IndexContainer* container = new (zone()) IndexContainer();
       container->index = index;
       entry = global_variables_.LookupOrInsert(v, ComputePointerHash(v),
                                                ZoneAllocationPolicy(zone()));
       entry->value = container;
     }
     return (reinterpret_cast<IndexContainer*>(entry->value))->index;
   }
 
   uint16_t LookupOrInsertFunction(Variable* v) {
-    DCHECK(builder_ != NULL);
+    DCHECK(builder_ != nullptr);
     ZoneHashMap::Entry* entry = functions_.Lookup(v, ComputePointerHash(v));
-    if (entry == NULL) {
+    if (entry == nullptr) {
       uint16_t index = builder_->AddFunction(v->raw_name()->raw_data(),
                                              v->raw_name()->length());
       IndexContainer* container = new (zone()) IndexContainer();
       container->index = index;
       entry = functions_.LookupOrInsert(v, ComputePointerHash(v),
                                         ZoneAllocationPolicy(zone()));
       entry->value = container;
     }
     return (reinterpret_cast<IndexContainer*>(entry->value))->index;
   }
@@ skipping 48 matching lines @@
 // that zone in constructor may be thrown away once wasm module is written.
 WasmModuleIndex* AsmWasmBuilder::Run() {
   AsmWasmBuilderImpl impl(isolate_, zone_, literal_);
   impl.Compile();
   WasmModuleWriter* writer = impl.builder_->Build(zone_);
   return writer->WriteTo(zone_);
 }
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8