VM: Remove unnecessary explicit keywords

diff --git a/vm/aging_space.hpp b/vm/aging_space.hpp
index e559fd4d39bfb186af591a8b8a0dfd3f0606f6a4..54ae44f34fbbc4a25e2ebaa3fd93896df2cf8eef 100644 (file)
--- a/vm/aging_space.hpp
+++ b/vm/aging_space.hpp
@@ -3,7 +3,7 @@ namespace factor {
 struct aging_space : bump_allocator<object> {
   object_start_map starts;
 
-  explicit aging_space(cell size, cell start)
+  aging_space(cell size, cell start)
       : bump_allocator<object>(size, start), starts(size, start) {}
 
   object* allot(cell size) {

diff --git a/vm/arrays.hpp b/vm/arrays.hpp
index e863b5504f55a2234cc338fba8971fb214914bdc..5c039ad2c2b54d3508fb64420ddd68f8210286c5 100644 (file)
--- a/vm/arrays.hpp
+++ b/vm/arrays.hpp
@@ -22,7 +22,7 @@ struct growable_array {
   cell count;
   data_root<array> elements;
 
-  explicit growable_array(factor_vm* parent, cell capacity = 10)
+  growable_array(factor_vm* parent, cell capacity = 10)
       : count(0),
         elements(parent->allot_array(capacity, false_object), parent) {}
 

diff --git a/vm/bump_allocator.hpp b/vm/bump_allocator.hpp
index d33ce801022a39bb1e7883ba08b28449d02ef551..136198ea111facf20b6c154efa14faac0859fddf 100644 (file)
--- a/vm/bump_allocator.hpp
+++ b/vm/bump_allocator.hpp
@@ -7,7 +7,7 @@ template <typename Block> struct bump_allocator {
   cell end;
   cell size;
 
-  explicit bump_allocator(cell size_, cell start_)
+  bump_allocator(cell size_, cell start_)
       : here(start_), start(start_), end(start_ + size_), size(size_) {}
 
   bool contains_p(Block* block) { return ((cell) block - start) < size; }

diff --git a/vm/byte_arrays.hpp b/vm/byte_arrays.hpp
index 3a388f0dd69158e84434cdc33d94ff0c484d1442..e3cbf520ce340193e30b43a99a3763558cb42cb6 100644 (file)
--- a/vm/byte_arrays.hpp
+++ b/vm/byte_arrays.hpp
@@ -4,7 +4,7 @@ struct growable_byte_array {
   cell count;
   data_root<byte_array> elements;
 
-  explicit growable_byte_array(factor_vm* parent, cell capacity = 40)
+  growable_byte_array(factor_vm* parent, cell capacity = 40)
       : count(0), elements(parent->allot_byte_array(capacity), parent) {}
 
   void grow_bytes(cell len);

diff --git a/vm/callbacks.hpp b/vm/callbacks.hpp
index 5ab06d3d665bf8f78e967b465299d794e04e236a..1368b0d17119182afc54aaa0abc9d4071b945628 100644 (file)
--- a/vm/callbacks.hpp
+++ b/vm/callbacks.hpp
@@ -28,7 +28,7 @@ struct callback_heap {
   cell here;
   factor_vm* parent;
 
-  explicit callback_heap(cell size, factor_vm* parent);
+  callback_heap(cell size, factor_vm* parent);
   ~callback_heap();
 
   void* callback_entry_point(code_block* stub) {

diff --git a/vm/code_block_visitor.hpp b/vm/code_block_visitor.hpp
index 3e4cb53a9eb39867c77af92b40092b0f251a04fb..42d271c04f3f7f1ca2cd93b9184c2b50247c3265 100644 (file)
--- a/vm/code_block_visitor.hpp
+++ b/vm/code_block_visitor.hpp
@@ -15,7 +15,7 @@ template <typename Fixup> struct code_block_visitor {
   factor_vm* parent;
   Fixup fixup;
 
-  explicit code_block_visitor(factor_vm* parent_, Fixup fixup_)
+  code_block_visitor(factor_vm* parent_, Fixup fixup_)
       : parent(parent_), fixup(fixup_) {}
 
   code_block* visit_code_block(code_block* compiled);
@@ -36,7 +36,7 @@ template <typename Fixup> struct call_frame_code_block_visitor {
   factor_vm* parent;
   Fixup fixup;
 
-  explicit call_frame_code_block_visitor(factor_vm* parent_, Fixup fixup_)
+  call_frame_code_block_visitor(factor_vm* parent_, Fixup fixup_)
       : parent(parent_), fixup(fixup_) {}
 
   void operator()(void* frame_top, cell frame_size, code_block* owner,

diff --git a/vm/code_blocks.cpp b/vm/code_blocks.cpp
index a4c6f6cee3e7f2bb0307a62d7d37009ff57fdeef..17ba93ce7e80636f9bb90c1fdfa3c720dc465e1c 100644 (file)
--- a/vm/code_blocks.cpp
+++ b/vm/code_blocks.cpp
@@ -296,7 +296,7 @@ struct initial_code_block_visitor {
   cell literals;
   cell literal_index;
 
-  explicit initial_code_block_visitor(factor_vm* parent_, cell literals_)
+  initial_code_block_visitor(factor_vm* parent_, cell literals_)
       : parent(parent_), literals(literals_), literal_index(0) {}
 
   cell next_literal() {

diff --git a/vm/code_heap.cpp b/vm/code_heap.cpp
index 71cb71d7c8d8aaf5baa448f78ec3b0eab2c3189d..1f5e59f784be058dd4fa26e836a67be5dc7d4bd1 100644 (file)
--- a/vm/code_heap.cpp
+++ b/vm/code_heap.cpp
@@ -234,7 +234,7 @@ void factor_vm::primitive_code_room() {
 }
 
 struct stack_trace_stripper {
-  explicit stack_trace_stripper() {}
+  stack_trace_stripper() {}
 
   void operator()(code_block* compiled, cell size) {
     compiled->owner = false_object;

diff --git a/vm/code_roots.hpp b/vm/code_roots.hpp
index fe1f29b3d8e731d7eb4d8f5e70e548da6ded99d7..8065c939c1452a17cc3774fb44710fc010f5b229 100644 (file)
--- a/vm/code_roots.hpp
+++ b/vm/code_roots.hpp
@@ -7,7 +7,7 @@ struct code_root {
 
   void push() { parent->code_roots.push_back(this); }
 
-  explicit code_root(cell value_, factor_vm* parent_)
+  code_root(cell value_, factor_vm* parent_)
       : value(value_), valid(true), parent(parent_) {
     push();
   }

diff --git a/vm/collector.hpp b/vm/collector.hpp
index f19d165f5887db926d10f34463b34e0241b33b33..ae5813a0e769ca461dcb0675244f67c5dacdab6b 100644 (file)
--- a/vm/collector.hpp
+++ b/vm/collector.hpp
@@ -12,8 +12,7 @@ struct gc_workhorse : no_fixup {
   Policy policy;
   code_heap* code;
 
-  explicit gc_workhorse(factor_vm* parent_, TargetGeneration* target_,
-                        Policy policy_)
+  gc_workhorse(factor_vm* parent_, TargetGeneration* target_, Policy policy_)
       : parent(parent_), target(target_), policy(policy_), code(parent->code) {}
 
   object* resolve_forwarding(object* untagged) {
@@ -82,7 +81,7 @@ struct simple_unmarker {
 };
 
 struct full_unmarker {
-  explicit full_unmarker() {}
+  full_unmarker() {}
   void operator()(card* ptr) { *ptr = 0; }
 };
 
@@ -97,8 +96,7 @@ template <typename TargetGeneration, typename Policy> struct collector {
   cell decks_scanned;
   cell code_blocks_scanned;
 
-  explicit collector(factor_vm* parent_, TargetGeneration* target_,
-                     Policy policy_)
+  collector(factor_vm* parent_, TargetGeneration* target_, Policy policy_)
       : parent(parent_),
         data(parent_->data),
         code(parent_->code),

diff --git a/vm/compaction.cpp b/vm/compaction.cpp
index b9fcdbd294ffc71d50f59f4f55b482856dd62f79..f058e80eb4487b6c787e04ba57d54376d1b23202 100644 (file)
--- a/vm/compaction.cpp
+++ b/vm/compaction.cpp
@@ -10,10 +10,10 @@ struct compaction_fixup {
   const object** data_finger;
   const code_block** code_finger;
 
-  explicit compaction_fixup(mark_bits<object>* data_forwarding_map_,
-                            mark_bits<code_block>* code_forwarding_map_,
-                            const object** data_finger_,
-                            const code_block** code_finger_)
+  compaction_fixup(mark_bits<object>* data_forwarding_map_,
+                   mark_bits<code_block>* code_forwarding_map_,
+                   const object** data_finger_,
+                   const code_block** code_finger_)
       : data_forwarding_map(data_forwarding_map_),
         code_forwarding_map(code_forwarding_map_),
         data_finger(data_finger_),
@@ -61,8 +61,7 @@ struct object_compaction_updater {
   compaction_fixup fixup;
   object_start_map* starts;
 
-  explicit object_compaction_updater(factor_vm* parent_,
-                                     compaction_fixup fixup_)
+  object_compaction_updater(factor_vm* parent_, compaction_fixup fixup_)
       : parent(parent_),
         fixup(fixup_),
         starts(&parent->data->tenured->starts) {}
@@ -83,9 +82,9 @@ template <typename Fixup> struct code_block_compaction_relocation_visitor {
   code_block* old_address;
   Fixup fixup;
 
-  explicit code_block_compaction_relocation_visitor(factor_vm* parent_,
-                                                    code_block* old_address_,
-                                                    Fixup fixup_)
+  code_block_compaction_relocation_visitor(factor_vm* parent_,
+                                           code_block* old_address_,
+                                           Fixup fixup_)
       : parent(parent_), old_address(old_address_), fixup(fixup_) {}
 
   void operator()(instruction_operand op) {
@@ -129,7 +128,7 @@ template <typename Fixup> struct code_block_compaction_updater {
   slot_visitor<Fixup> data_forwarder;
   code_block_visitor<Fixup> code_forwarder;
 
-  explicit code_block_compaction_updater(
+  code_block_compaction_updater(
       factor_vm* parent_, Fixup fixup_, slot_visitor<Fixup> data_forwarder_,
       code_block_visitor<Fixup> code_forwarder_)
       : parent(parent_),
@@ -234,8 +233,8 @@ struct code_compaction_fixup {
   mark_bits<code_block>* code_forwarding_map;
   const code_block** code_finger;
 
-  explicit code_compaction_fixup(mark_bits<code_block>* code_forwarding_map_,
-                                 const code_block** code_finger_)
+  code_compaction_fixup(mark_bits<code_block>* code_forwarding_map_,
+                        const code_block** code_finger_)
       : code_forwarding_map(code_forwarding_map_), code_finger(code_finger_) {}
 
   object* fixup_data(object* obj) { return obj; }

diff --git a/vm/copying_collector.hpp b/vm/copying_collector.hpp
index b4ff541d967968a418a268a8fda6e010aca9aba6..644baff8e84b7e3f74f60c2333445c9da383be93 100644 (file)
--- a/vm/copying_collector.hpp
+++ b/vm/copying_collector.hpp
@@ -4,8 +4,8 @@ template <typename TargetGeneration, typename Policy>
 struct copying_collector : collector<TargetGeneration, Policy> {
   cell scan;
 
-  explicit copying_collector(factor_vm* parent_, TargetGeneration* target_,
-                             Policy policy_)
+  copying_collector(factor_vm* parent_, TargetGeneration* target_,
+                    Policy policy_)
       : collector<TargetGeneration, Policy>(parent_, target_, policy_),
         scan(target_->here) {}
 

diff --git a/vm/data_heap.hpp b/vm/data_heap.hpp
index b2e8dfb9308f279ab8b904e725ace48ca1e6f8e1..47ed2731346d3e60d3dd58d3bc633a0c46bde7bb 100644 (file)
--- a/vm/data_heap.hpp
+++ b/vm/data_heap.hpp
@@ -20,7 +20,7 @@ struct data_heap {
   card_deck* decks;
   card_deck* decks_end;
 
-  explicit data_heap(cell young_size, cell aging_size, cell tenured_size);
+  data_heap(cell young_size, cell aging_size, cell tenured_size);
   ~data_heap();
   data_heap* grow(cell requested_size);
   template <typename Generation> void clear_cards(Generation* gen);

diff --git a/vm/data_heap_checker.cpp b/vm/data_heap_checker.cpp
index a659ac5f2de86939165e5534d0172cfc032c8a15..6b9f6dab2b6bd80a3383c4d23d817ce9a02a9a5f 100644 (file)
--- a/vm/data_heap_checker.cpp
+++ b/vm/data_heap_checker.cpp
@@ -29,7 +29,7 @@ struct slot_checker {
   object* obj;
   generation gen;
 
-  explicit slot_checker(factor_vm* parent_, object* obj_, generation gen_)
+  slot_checker(factor_vm* parent_, object* obj_, generation gen_)
       : parent(parent_), obj(obj_), gen(gen_) {}
 
   void check_write_barrier(cell* slot_ptr, generation target, char mask) {

diff --git a/vm/data_roots.hpp b/vm/data_roots.hpp
index 15dc5f320376490bbe666f50e93e6179bdfd25a6..e2f6982630a4089d685fba8421cd89e620fa40a7 100644 (file)
--- a/vm/data_roots.hpp
+++ b/vm/data_roots.hpp
@@ -7,12 +7,12 @@ template <typename Type> struct data_root : public tagged<Type> {
     parent->data_roots.push_back(data_root_range(&this->value_, 1));
   }
 
-  explicit data_root(cell value_, factor_vm* parent_)
+  data_root(cell value_, factor_vm* parent_)
       : tagged<Type>(value_), parent(parent_) {
     push();
   }
 
-  explicit data_root(Type* value_, factor_vm* parent_)
+  data_root(Type* value_, factor_vm* parent_)
       : tagged<Type>(value_), parent(parent_) {
     push();
   }

diff --git a/vm/debug.cpp b/vm/debug.cpp
index b5ee85a69a7aea65e93529c49c584786bd75e72d..02fdb434dece82950963de842f118dd92b88ea19 100644 (file)
--- a/vm/debug.cpp
+++ b/vm/debug.cpp
@@ -280,7 +280,7 @@ struct object_dumper {
   factor_vm* parent;
   cell type;
 
-  explicit object_dumper(factor_vm* parent_, cell type_)
+  object_dumper(factor_vm* parent_, cell type_)
       : parent(parent_), type(type_) {}
 
   void operator()(object* obj) {
@@ -303,8 +303,8 @@ struct find_data_reference_slot_visitor {
   object* obj;
   factor_vm* parent;
 
-  explicit find_data_reference_slot_visitor(cell look_for_, object* obj_,
-                                            factor_vm* parent_)
+  find_data_reference_slot_visitor(cell look_for_, object* obj_,
+                                   factor_vm* parent_)
       : look_for(look_for_), obj(obj_), parent(parent_) {}
 
   void operator()(cell* scan) {
@@ -320,7 +320,7 @@ struct dump_edges_slot_visitor {
   object* obj;
   factor_vm* parent;
 
-  explicit dump_edges_slot_visitor(cell, object* obj_, factor_vm* parent_)
+  dump_edges_slot_visitor(cell, object* obj_, factor_vm* parent_)
       : obj(obj_), parent(parent_) {}
 
   void operator()(cell* scan) {
@@ -334,7 +334,7 @@ template <typename SlotVisitor> struct data_reference_object_visitor {
   cell look_for;
   factor_vm* parent;
 
-  explicit data_reference_object_visitor(cell look_for_, factor_vm* parent_)
+  data_reference_object_visitor(cell look_for_, factor_vm* parent_)
       : look_for(look_for_), parent(parent_) {}
 
   void operator()(object* obj) {

diff --git a/vm/free_list_allocator.hpp b/vm/free_list_allocator.hpp
index a935802508b2e407ccacd577ef4a8bf8a10bd175..0c85248a8626d7bf27126acf31f1c6ecbe03beae 100644 (file)
--- a/vm/free_list_allocator.hpp
+++ b/vm/free_list_allocator.hpp
@@ -7,7 +7,7 @@ template <typename Block> struct free_list_allocator {
   free_list free_blocks;
   mark_bits<Block> state;
 
-  explicit free_list_allocator(cell size, cell start);
+  free_list_allocator(cell size, cell start);
   void initial_free_list(cell occupied);
   bool contains_p(Block* block);
   Block* first_block();
@@ -156,8 +156,8 @@ template <typename Block, typename Iterator> struct heap_compactor {
   Iterator& iter;
   const Block** finger;
 
-  explicit heap_compactor(mark_bits<Block>* state_, Block* address_,
-                          Iterator& iter_, const Block** finger_)
+  heap_compactor(mark_bits<Block>* state_, Block* address_,
+                 Iterator& iter_, const Block** finger_)
       : state(state_), address((char*)address_), iter(iter_), finger(finger_) {}
 
   void operator()(Block* block, cell size) {

diff --git a/vm/gc.cpp b/vm/gc.cpp
index 8303741c88b11396ad79a41846cf35bb1e9c377d..8e1e3b08fb68797278d6b242c2bb4aa8f96e766a 100644 (file)
--- a/vm/gc.cpp
+++ b/vm/gc.cpp
@@ -194,7 +194,7 @@ struct call_frame_scrubber {
   factor_vm* parent;
   context* ctx;
 
-  explicit call_frame_scrubber(factor_vm* parent_, context* ctx_)
+  call_frame_scrubber(factor_vm* parent_, context* ctx_)
       : parent(parent_), ctx(ctx_) {}
 
   void operator()(void* frame_top, cell frame_size, code_block* owner,

diff --git a/vm/gc.hpp b/vm/gc.hpp
index 58b0a033054243037e232fd295335dbb1d6685ab..d4a4f1f19b7e3dc03c5555bd4ac13c0f17c2a94c 100644 (file)
--- a/vm/gc.hpp
+++ b/vm/gc.hpp
@@ -46,7 +46,7 @@ struct gc_state {
   u64 start_time;
   gc_event* event;
 
-  explicit gc_state(gc_op op_, factor_vm* parent);
+  gc_state(gc_op op_, factor_vm* parent);
   ~gc_state();
   void start_again(gc_op op_, factor_vm* parent);
 };

diff --git a/vm/image.cpp b/vm/image.cpp
index e37b49e0d8215dd7f45238cf7da20da16d55e2ba..fcb8f6e06d0613f6b9754c09928860fb70991441 100644 (file)
--- a/vm/image.cpp
+++ b/vm/image.cpp
@@ -55,7 +55,7 @@ struct startup_fixup {
   cell data_offset;
   cell code_offset;
 
-  explicit startup_fixup(cell data_offset_, cell code_offset_)
+  startup_fixup(cell data_offset_, cell code_offset_)
       : data_offset(data_offset_), code_offset(code_offset_) {}
 
   object* fixup_data(object* obj) {

diff --git a/vm/inline_cache.cpp b/vm/inline_cache.cpp
index 1c83ead7efae5e1c3dfea4c4bfd683224cad9301..2a9395e70d8e55fcb96c18b629694eca694918b0 100644 (file)
--- a/vm/inline_cache.cpp
+++ b/vm/inline_cache.cpp
@@ -43,7 +43,7 @@ void factor_vm::update_pic_count(cell type) {
 struct inline_cache_jit : public jit {
   fixnum index;
 
-  explicit inline_cache_jit(cell generic_word_, factor_vm* vm)
+  inline_cache_jit(cell generic_word_, factor_vm* vm)
       : jit(code_block_pic, generic_word_, vm) {}
   ;
 

diff --git a/vm/jit.hpp b/vm/jit.hpp
index a3f835c06c3cd1ecba42c0fa06cd5cf8e7e0854a..a2247e5b1cbfb1c150678e01407882396ab926b5 100644 (file)
--- a/vm/jit.hpp
+++ b/vm/jit.hpp
@@ -12,7 +12,7 @@ struct jit {
   cell offset;
   factor_vm* parent;
 
-  explicit jit(code_block_type type, cell owner, factor_vm* parent);
+  jit(code_block_type type, cell owner, factor_vm* parent);
   ~jit();
 
   void compute_position(cell offset);

diff --git a/vm/layouts.hpp b/vm/layouts.hpp
index a79ab1d229bd7359af9c17f74e45ac3680a9366a..945cb773dc6410fcb1e90f4fee3805eab4362585 100644 (file)
--- a/vm/layouts.hpp
+++ b/vm/layouts.hpp
@@ -343,7 +343,7 @@ struct data_root_range {
   cell* start;
   cell len;
 
-  explicit data_root_range(cell* start_, cell len_)
+  data_root_range(cell* start_, cell len_)
       : start(start_), len(len_) {}
 };
 

diff --git a/vm/mark_bits.hpp b/vm/mark_bits.hpp
index d1dd7e180871efa799289645a3d1ade92eeef4fe..21ff9a5a66cad8053241f6a13bd68de4fc62e40f 100644 (file)
--- a/vm/mark_bits.hpp
+++ b/vm/mark_bits.hpp
@@ -14,7 +14,7 @@ template <typename Block> struct mark_bits {
 
   void clear_forwarding() { memset(forwarding, 0, bits_size * sizeof(cell)); }
 
-  explicit mark_bits(cell size_, cell start_)
+  mark_bits(cell size_, cell start_)
       : size(size_),
         start(start_),
         bits_size(size / data_alignment / mark_bits_granularity),

diff --git a/vm/nursery_space.hpp b/vm/nursery_space.hpp
index e4a905bd4e0f04f1391b214842d0ece73d2fe02d..d293b680d19018032605864f78ddc502669c2516 100644 (file)
--- a/vm/nursery_space.hpp
+++ b/vm/nursery_space.hpp
@@ -1,7 +1,7 @@
 namespace factor {
 
 struct nursery_space : bump_allocator<object> {
-  explicit nursery_space(cell size, cell start)
+  nursery_space(cell size, cell start)
       : bump_allocator<object>(size, start) {}
 };
 

diff --git a/vm/object_start_map.hpp b/vm/object_start_map.hpp
index 8f52ef3eb9099a93682952cd40e3246d6a1a04ac..102df293bb61bb7eddacffadb1942ec4a629f4e1 100644 (file)
--- a/vm/object_start_map.hpp
+++ b/vm/object_start_map.hpp
@@ -7,7 +7,7 @@ struct object_start_map {
   card* object_start_offsets;
   card* object_start_offsets_end;
 
-  explicit object_start_map(cell size_, cell start_);
+  object_start_map(cell size_, cell start_);
   ~object_start_map();
 
   cell first_object_in_card(cell card_index);

diff --git a/vm/objects.cpp b/vm/objects.cpp
index b03f39563c2372be376f78d0528941be063f8905..549b5cbaef98fa6ee477ed49d04d429236a72258 100644 (file)
--- a/vm/objects.cpp
+++ b/vm/objects.cpp
@@ -75,7 +75,7 @@ void factor_vm::primitive_size() {
 struct slot_become_fixup : no_fixup {
   std::map<object*, object*>* become_map;
 
-  explicit slot_become_fixup(std::map<object*, object*>* become_map_)
+  slot_become_fixup(std::map<object*, object*>* become_map_)
       : become_map(become_map_) {}
 
   object* fixup_data(object* old) {

diff --git a/vm/quotations.hpp b/vm/quotations.hpp
index 64272d26edb3eaece0f6005b05dbaa0f38908133..e6bed95202e2346a5896a4d7b1d03b4d99173408 100644 (file)
--- a/vm/quotations.hpp
+++ b/vm/quotations.hpp
@@ -4,8 +4,7 @@ struct quotation_jit : public jit {
   data_root<array> elements;
   bool compiling, relocate;
 
-  explicit quotation_jit(cell owner, bool compiling_, bool relocate_,
-                         factor_vm* vm)
+  quotation_jit(cell owner, bool compiling_, bool relocate_, factor_vm* vm)
       : jit(code_block_unoptimized, owner, vm),
         elements(false_object, vm),
         compiling(compiling_),

diff --git a/vm/segments.hpp b/vm/segments.hpp
index 63fd5de3734701919dd9164e1f67b63e47f06012..3e8a4b748fba4d3b45368da6f6c0341b4c6e1cfc 100644 (file)
--- a/vm/segments.hpp
+++ b/vm/segments.hpp
@@ -9,7 +9,7 @@ struct segment {
   cell size;
   cell end;
 
-  explicit segment(cell size, bool executable_p);
+  segment(cell size, bool executable_p);
   ~segment();
 
   bool underflow_p(cell addr) {

diff --git a/vm/slot_visitor.hpp b/vm/slot_visitor.hpp
index 033a332d8c425cceba29c9044c6641271c9cd252..6e84022f4701a92b0f4c5db74e8935f4c7863d3f 100644 (file)
--- a/vm/slot_visitor.hpp
+++ b/vm/slot_visitor.hpp
@@ -109,7 +109,7 @@ template <typename Fixup> struct slot_visitor {
   factor_vm* parent;
   Fixup fixup;
 
-  explicit slot_visitor<Fixup>(factor_vm* parent_, Fixup fixup_)
+  slot_visitor<Fixup>(factor_vm* parent_, Fixup fixup_)
       : parent(parent_), fixup(fixup_) {}
 
   cell visit_pointer(cell pointer);
@@ -199,8 +199,8 @@ template <typename Fixup> struct callback_slot_visitor {
   callback_heap* callbacks;
   slot_visitor<Fixup>* visitor;
 
-  explicit callback_slot_visitor(callback_heap* callbacks_,
-                                 slot_visitor<Fixup>* visitor_)
+  callback_slot_visitor(callback_heap* callbacks_,
+                        slot_visitor<Fixup>* visitor_)
       : callbacks(callbacks_), visitor(visitor_) {}
 
   void operator()(code_block* stub) { visitor->visit_handle(&stub->owner); }
@@ -263,8 +263,8 @@ template <typename Fixup> struct call_frame_slot_visitor {
   factor_vm* parent;
   slot_visitor<Fixup>* visitor;
 
-  explicit call_frame_slot_visitor(factor_vm* parent_,
-                                   slot_visitor<Fixup>* visitor_)
+  call_frame_slot_visitor(factor_vm* parent_,
+                          slot_visitor<Fixup>* visitor_)
       : parent(parent_), visitor(visitor_) {}
 
   /*

diff --git a/vm/tenured_space.hpp b/vm/tenured_space.hpp
index e7d3bd47c4a461c59a4d778695ba688a128fa1fc..62745df9ecdeabad73a9f261ce2be28b25c0e266 100644 (file)
--- a/vm/tenured_space.hpp
+++ b/vm/tenured_space.hpp
@@ -3,7 +3,7 @@ namespace factor {
 struct tenured_space : free_list_allocator<object> {
   object_start_map starts;
 
-  explicit tenured_space(cell size, cell start)
+  tenured_space(cell size, cell start)
       : free_list_allocator<object>(size, start), starts(size, start) {}
 
   object* allot(cell size) {