VM: Fixup cast formatting after clang-format

clang-format doesn't recognize casts to non-pointer/non-template types
so it winds up adding a space between the right paren and the expression
and then failing to recognize prefix operators in the process
(e.g. foo = (cell) & bar; should be foo = (cell)&bar;). This commit
manually fixes up the major cases (fixnum, cell, all types ending in _t).

vm/alien.cpp

@@ -48,7 +48,7 @@ cell factor_vm::allot_alien(cell delegate_, cell displacement) {
 
 /* Allocates memory */
 cell factor_vm::allot_alien(void* address) {
-  return allot_alien(false_object, (cell) address);
+  return allot_alien(false_object, (cell)address);
 }
 
 /* make an alien pointing at an offset of another alien */
@@ -73,7 +73,7 @@ void factor_vm::primitive_displaced_alien() {
 if the object is a byte array, as a sanity check. */
 /* Allocates memory (from_unsigned_cell can allocate) */
 void factor_vm::primitive_alien_address() {
-  ctx->replace(from_unsigned_cell((cell) pinned_alien_offset(ctx->peek())));
+  ctx->replace(from_unsigned_cell((cell)pinned_alien_offset(ctx->peek())));
 }
 
 /* pop ( alien n ) from datastack, return alien's address plus n */
@@ -89,7 +89,7 @@ void* factor_vm::alien_pointer() {
   }                                                                     \
   VM_C_API void primitive_set_alien_##name(factor_vm * parent) {        \
     type* ptr = (type*)parent->alien_pointer();                         \
-    type value = (type) parent->to(parent->ctx->pop());                 \
+    type value = (type)parent->to(parent->ctx->pop());                  \
     *ptr = value;                                                       \
   }
 

vm/assert.hpp

@@ -3,10 +3,10 @@ namespace factor { void abort(); }
 #ifdef FACTOR_DEBUG
 #define FACTOR_ASSERT(condition)                                               \
   ((condition)                                                                 \
-       ? (void) 0                                                              \
+       ? (void)0                                                               \
        : (::fprintf(stderr, "assertion \"%s\" failed: file \"%s\", line %d\n", \
                     #condition, __FILE__, __LINE__),                           \
           ::factor::abort()))
 #else
-#define FACTOR_ASSERT(condition) ((void) 0)
+#define FACTOR_ASSERT(condition) ((void)0)
 #endif

vm/atomic-cl-32.hpp

@@ -15,21 +15,21 @@ __forceinline static bool cas(volatile fixnum* ptr, fixnum old_val,
 }
 
 __forceinline static cell fetch_add(volatile cell* ptr, cell val) {
-  return (cell)
+  return (cell)InterlockedExchangeAdd(reinterpret_cast<volatile LONG*>(ptr),
-      InterlockedExchangeAdd(reinterpret_cast<volatile LONG*>(ptr), (LONG) val);
+                                      (LONG) val);
 }
 __forceinline static fixnum fetch_add(volatile fixnum* ptr, fixnum val) {
-  return (fixnum)
+  return (fixnum)InterlockedExchangeAdd(reinterpret_cast<volatile LONG*>(ptr),
-      InterlockedExchangeAdd(reinterpret_cast<volatile LONG*>(ptr), (LONG) val);
+                                        (LONG) val);
 }
 
 __forceinline static cell fetch_subtract(volatile cell* ptr, cell val) {
-  return (cell) InterlockedExchangeAdd(reinterpret_cast<volatile LONG*>(ptr),
+  return (cell)InterlockedExchangeAdd(reinterpret_cast<volatile LONG*>(ptr),
-                                       -(LONG) val);
+                                      -(LONG)val);
 }
 __forceinline static fixnum fetch_subtract(volatile fixnum* ptr, fixnum val) {
-  return (fixnum) InterlockedExchangeAdd(reinterpret_cast<volatile LONG*>(ptr),
+  return (fixnum)InterlockedExchangeAdd(reinterpret_cast<volatile LONG*>(ptr),
-                                         -(LONG) val);
+                                        -(LONG)val);
 }
 
 __forceinline static void fence() { MemoryBarrier(); }

vm/atomic-cl-64.hpp

@@ -4,32 +4,32 @@ namespace factor {
 namespace atomic {
 __forceinline static bool cas(volatile cell* ptr, cell old_val, cell new_val) {
   return InterlockedCompareExchange64(reinterpret_cast<volatile LONG64*>(ptr),
-                                      (LONG64) old_val, (LONG64) new_val) ==
+                                      (LONG64)old_val, (LONG64)new_val) ==
-         (LONG64) old_val;
+         (LONG64)old_val;
 }
 __forceinline static bool cas(volatile fixnum* ptr, fixnum old_val,
                               fixnum new_val) {
   return InterlockedCompareExchange64(reinterpret_cast<volatile LONG64*>(ptr),
-                                      (LONG64) old_val, (LONG64) new_val) ==
+                                      (LONG64)old_val, (LONG64)new_val) ==
-         (LONG64) old_val;
+         (LONG64)old_val;
 }
 
 __forceinline static cell fetch_add(volatile cell* ptr, cell val) {
-  return (cell) InterlockedExchangeAdd64(
+  return (cell)InterlockedExchangeAdd64(
-      reinterpret_cast<volatile LONG64*>(ptr), (LONG64) val);
+      reinterpret_cast<volatile LONG64*>(ptr), (LONG64)val);
 }
 __forceinline static fixnum fetch_add(volatile fixnum* ptr, fixnum val) {
-  return (fixnum) InterlockedExchangeAdd64(
+  return (fixnum)InterlockedExchangeAdd64(
-      reinterpret_cast<volatile LONG64*>(ptr), (LONG64) val);
+      reinterpret_cast<volatile LONG64*>(ptr), (LONG64)val);
 }
 
 __forceinline static cell fetch_subtract(volatile cell* ptr, cell val) {
-  return (cell) InterlockedExchangeAdd64(
+  return (cell)InterlockedExchangeAdd64(
-      reinterpret_cast<volatile LONG64*>(ptr), -(LONG64) val);
+      reinterpret_cast<volatile LONG64*>(ptr), -(LONG64)val);
 }
 __forceinline static fixnum fetch_subtract(volatile fixnum* ptr, fixnum val) {
-  return (fixnum) InterlockedExchangeAdd64(
+  return (fixnum)InterlockedExchangeAdd64(
-      reinterpret_cast<volatile LONG64*>(ptr), -(LONG64) val);
+      reinterpret_cast<volatile LONG64*>(ptr), -(LONG64)val);
 }
 
 __forceinline static void fence() { MemoryBarrier(); }

vm/bignum.cpp

@@ -330,7 +330,7 @@ BIGNUM_TO_FOO(ulong_long, uint64_t, int64_t, uint64_t)
     significand *= (factor);                   \
     digit = ((bignum_digit_type) significand); \
     (*--scan) = digit;                         \
-    significand -= ((double) digit);           \
+    significand -= ((double)digit);            \
   }
 
 #define inf std::numeric_limits<double>::infinity()
@@ -355,7 +355,7 @@ bignum* factor_vm::double_to_bignum(double x) {
     bignum_digit_type digit;
     int odd_bits = (exponent % BIGNUM_DIGIT_LENGTH);
     if (odd_bits > 0)
-      DTB_WRITE_DIGIT((fixnum) 1 << odd_bits);
+      DTB_WRITE_DIGIT((fixnum)1 << odd_bits);
     while (start < scan) {
       if (significand == 0) {
         while (start < scan)
@@ -924,7 +924,7 @@ void factor_vm::bignum_destructive_normalization(bignum* source, bignum* target,
   bignum_digit_type* end_source = (scan_source + (BIGNUM_LENGTH(source)));
   bignum_digit_type* end_target = (scan_target + (BIGNUM_LENGTH(target)));
   int shift_right = (BIGNUM_DIGIT_LENGTH - shift_left);
-  bignum_digit_type mask = (((cell) 1 << shift_right) - 1);
+  bignum_digit_type mask = (((cell)1 << shift_right) - 1);
   while (scan_source < end_source) {
     digit = (*scan_source++);
     (*scan_target++) = (((digit & mask) << shift_left) | carry);
@@ -944,7 +944,7 @@ void factor_vm::bignum_destructive_unnormalization(bignum* bignum,
   bignum_digit_type digit;
   bignum_digit_type carry = 0;
   int shift_left = (BIGNUM_DIGIT_LENGTH - shift_right);
-  bignum_digit_type mask = (((fixnum) 1 << shift_right) - 1);
+  bignum_digit_type mask = (((fixnum)1 << shift_right) - 1);
   while (start < scan) {
     digit = (*--scan);
     (*scan) = ((digit >> shift_right) | carry);
@@ -1605,7 +1605,7 @@ int factor_vm::bignum_unsigned_logbitp(int shift, bignum* bignum) {
     return 0;
   bignum_digit_type digit = (BIGNUM_REF(bignum, index));
   int p = shift % BIGNUM_DIGIT_LENGTH;
-  bignum_digit_type mask = ((fixnum) 1) << p;
+  bignum_digit_type mask = ((fixnum)1) << p;
   return (digit & mask) ? 1 : 0;
 }
 

vm/bignumint.hpp

@@ -63,7 +63,7 @@ typedef int64_t bignum_twodigit_type;
 
 #define BIGNUM_DIGIT_LENGTH (((sizeof(bignum_digit_type)) * CHAR_BIT) - 2)
 #define BIGNUM_HALF_DIGIT_LENGTH (BIGNUM_DIGIT_LENGTH / 2)
-#define BIGNUM_RADIX (bignum_digit_type)(((cell) 1) << BIGNUM_DIGIT_LENGTH)
+#define BIGNUM_RADIX (bignum_digit_type)(((cell)1) << BIGNUM_DIGIT_LENGTH)
 #define BIGNUM_RADIX_ROOT (((bignum_digit_type) 1) << BIGNUM_HALF_DIGIT_LENGTH)
 #define BIGNUM_DIGIT_MASK (BIGNUM_RADIX - 1)
 #define BIGNUM_HALF_DIGIT_MASK (BIGNUM_RADIX_ROOT - 1)

vm/bump_allocator.hpp

@@ -10,7 +10,7 @@ template <typename Block> struct bump_allocator {
   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; }
+  bool contains_p(Block* block) { return ((cell)block - start) < size; }
 
   Block* allot(cell size) {
     cell h = here;

vm/callbacks.cpp

@@ -51,7 +51,7 @@ void callback_heap::store_callback_operand(code_block* stub, cell index,
 
 void callback_heap::update(code_block* stub) {
   store_callback_operand(stub, setup_seh_p() ? 2 : 1,
-                         (cell) callback_entry_point(stub));
+                         (cell)callback_entry_point(stub));
   stub->flush_icache();
 }
 
@@ -76,7 +76,7 @@ code_block* callback_heap::add(cell owner, cell return_rewind) {
   memcpy(stub->entry_point(), insns->data<void>(), size);
 
   /* Store VM pointer */
-  store_callback_operand(stub, 0, (cell) parent);
+  store_callback_operand(stub, 0, (cell)parent);
 
   cell index;
 

vm/callbacks.hpp

@@ -49,7 +49,7 @@ struct callback_heap {
   void update();
 
   code_block* next(code_block* stub) {
-    return (code_block*)((cell) stub + stub->size());
+    return (code_block*)((cell)stub + stub->size());
   }
 
   template <typename Iterator> void each_callback(Iterator& iter) {

vm/callstack.cpp

@@ -31,7 +31,7 @@ cell factor_vm::capture_callstack(context* ctx) {
   void* top = second_from_top_stack_frame(ctx);
   void* bottom = ctx->callstack_bottom;
 
-  fixnum size = std::max((fixnum) 0, (fixnum) bottom - (fixnum) top);
+  fixnum size = std::max((fixnum)0, (fixnum)bottom - (fixnum)top);
 
   callstack* stack = allot_callstack(size);
   memcpy(stack->top(), top, size);
@@ -48,8 +48,8 @@ void factor_vm::primitive_callstack_for() {
 void* factor_vm::frame_predecessor(void* frame_top) {
   void* addr = frame_return_address((void*)frame_top);
   FACTOR_ASSERT(addr != 0);
-  code_block* owner = code->code_block_for_address((cell) addr);
+  code_block* owner = code->code_block_for_address((cell)addr);
-  cell frame_size = owner->stack_frame_size_for_address((cell) addr);
+  cell frame_size = owner->stack_frame_size_for_address((cell)addr);
   return (void*)((char*)frame_top + frame_size);
 }
 
@@ -99,14 +99,14 @@ void factor_vm::primitive_innermost_stack_frame_executing() {
   callstack* stack = untag_check<callstack>(ctx->peek());
   void* frame = stack->top();
   void* addr = frame_return_address(frame);
-  ctx->replace(code->code_block_for_address((cell) addr)->owner_quot());
+  ctx->replace(code->code_block_for_address((cell)addr)->owner_quot());
 }
 
 void factor_vm::primitive_innermost_stack_frame_scan() {
   callstack* stack = untag_check<callstack>(ctx->peek());
   void* frame = stack->top();
   void* addr = frame_return_address(frame);
-  ctx->replace(code->code_block_for_address((cell) addr)->scan(this, addr));
+  ctx->replace(code->code_block_for_address((cell)addr)->scan(this, addr));
 }
 
 void factor_vm::primitive_set_innermost_stack_frame_quot() {
@@ -120,7 +120,7 @@ void factor_vm::primitive_set_innermost_stack_frame_quot() {
 
   void* inner = stack->top();
   void* addr = frame_return_address(inner);
-  code_block* block = code->code_block_for_address((cell) addr);
+  code_block* block = code->code_block_for_address((cell)addr);
   cell offset = block->offset(addr);
   set_frame_return_address(inner, (char*)quot->entry_point + offset);
 }

vm/callstack.hpp

@@ -21,8 +21,8 @@ inline void factor_vm::iterate_callstack_object(callstack* stack_,
     void* fixed_addr = Fixup::translated_code_block_map
                            ? (void*)fixup.translate_code((code_block*)addr)
                            : addr;
-    code_block* owner = code->code_block_for_address((cell) fixed_addr);
+    code_block* owner = code->code_block_for_address((cell)fixed_addr);
-    cell frame_size = owner->stack_frame_size_for_address((cell) fixed_addr);
+    cell frame_size = owner->stack_frame_size_for_address((cell)fixed_addr);
 
     iterator(frame_top, frame_size, owner, fixed_addr);
     frame_offset += frame_size;
@@ -51,12 +51,12 @@ inline void factor_vm::iterate_callstack(context* ctx, Iterator& iterator,
                            ? (void*)fixup.translate_code((code_block*)addr)
                            : addr;
 
-    code_block* owner = code->code_block_for_address((cell) fixed_addr);
+    code_block* owner = code->code_block_for_address((cell)fixed_addr);
     code_block* fixed_owner =
         Fixup::translated_code_block_map ? owner : fixup.translate_code(owner);
 
     cell frame_size =
-        fixed_owner->stack_frame_size_for_address((cell) fixed_addr);
+        fixed_owner->stack_frame_size_for_address((cell)fixed_addr);
 
     void* fixed_addr_for_iter =
         Fixup::translated_code_block_map ? fixed_addr : addr;

vm/code_blocks.cpp

@@ -34,9 +34,9 @@ cell code_block::scan(factor_vm* vm, void* addr) const {
 cell factor_vm::compute_entry_point_address(cell obj) {
   switch (tagged<object>(obj).type()) {
     case WORD_TYPE:
-      return (cell) untag<word>(obj)->entry_point;
+      return (cell)untag<word>(obj)->entry_point;
     case QUOTATION_TYPE:
-      return (cell) untag<quotation>(obj)->entry_point;
+      return (cell)untag<quotation>(obj)->entry_point;
     default:
       critical_error("Expected word or quotation", obj);
       return 0;
@@ -45,13 +45,13 @@ cell factor_vm::compute_entry_point_address(cell obj) {
 
 cell factor_vm::compute_entry_point_pic_address(word* w, cell tagged_quot) {
   if (!to_boolean(tagged_quot) || max_pic_size == 0)
-    return (cell) w->entry_point;
+    return (cell)w->entry_point;
   else {
     quotation* quot = untag<quotation>(tagged_quot);
     if (quot_compiled_p(quot))
-      return (cell) quot->entry_point;
+      return (cell)quot->entry_point;
     else
-      return (cell) w->entry_point;
+      return (cell)w->entry_point;
   }
 }
 
@@ -162,7 +162,7 @@ cell factor_vm::compute_dlsym_address(array* parameters, cell index) {
   void* undefined_symbol = (void*)factor::undefined_symbol;
   undefined_symbol = FUNCTION_CODE_POINTER(undefined_symbol);
   if (d != NULL && !d->handle)
-    return (cell) undefined_symbol;
+    return (cell)undefined_symbol;
 
   switch (tagged<object>(symbol).type()) {
     case BYTE_ARRAY_TYPE: {
@@ -170,9 +170,9 @@ cell factor_vm::compute_dlsym_address(array* parameters, cell index) {
       void* sym = ffi_dlsym(d, name);
 
       if (sym)
-        return (cell) sym;
+        return (cell)sym;
       else
-        return (cell) undefined_symbol;
+        return (cell)undefined_symbol;
     }
     case ARRAY_TYPE: {
       array* names = untag<array>(symbol);
@@ -181,13 +181,13 @@ cell factor_vm::compute_dlsym_address(array* parameters, cell index) {
         void* sym = ffi_dlsym(d, name);
 
         if (sym)
-          return (cell) sym;
+          return (cell)sym;
       }
-      return (cell) undefined_symbol;
+      return (cell)undefined_symbol;
     }
     default:
       critical_error("Bad symbol specifier", symbol);
-      return (cell) undefined_symbol;
+      return (cell)undefined_symbol;
   }
 }
 
@@ -201,16 +201,16 @@ cell factor_vm::compute_dlsym_toc_address(array* parameters, cell index) {
   void* undefined_toc = (void*)factor::undefined_symbol;
   undefined_toc = FUNCTION_TOC_POINTER(undefined_toc);
   if (d != NULL && !d->handle)
-    return (cell) undefined_toc;
+    return (cell)undefined_toc;
 
   switch (tagged<object>(symbol).type()) {
     case BYTE_ARRAY_TYPE: {
       symbol_char* name = alien_offset(symbol);
       void* toc = ffi_dlsym_toc(d, name);
       if (toc)
-        return (cell) toc;
+        return (cell)toc;
       else
-        return (cell) undefined_toc;
+        return (cell)undefined_toc;
     }
     case ARRAY_TYPE: {
       array* names = untag<array>(symbol);
@@ -219,19 +219,19 @@ cell factor_vm::compute_dlsym_toc_address(array* parameters, cell index) {
         void* toc = ffi_dlsym_toc(d, name);
 
         if (toc)
-          return (cell) toc;
+          return (cell)toc;
       }
-      return (cell) undefined_toc;
+      return (cell)undefined_toc;
     }
     default:
       critical_error("Bad symbol specifier", symbol);
-      return (cell) undefined_toc;
+      return (cell)undefined_toc;
   }
 }
 #endif
 
 cell factor_vm::compute_vm_address(cell arg) {
-  return (cell) this + untag_fixnum(arg);
+  return (cell)this + untag_fixnum(arg);
 }
 
 void factor_vm::store_external_address(instruction_operand op) {
@@ -246,10 +246,10 @@ void factor_vm::store_external_address(instruction_operand op) {
       op.store_value(compute_dlsym_address(parameters, index));
       break;
     case RT_THIS:
-      op.store_value((cell) compiled->entry_point());
+      op.store_value((cell)compiled->entry_point());
       break;
     case RT_MEGAMORPHIC_CACHE_HITS:
-      op.store_value((cell) & dispatch_stats.megamorphic_cache_hits);
+      op.store_value((cell)&dispatch_stats.megamorphic_cache_hits);
       break;
     case RT_VM:
       op.store_value(compute_vm_address(array_nth(parameters, index)));
@@ -262,7 +262,7 @@ void factor_vm::store_external_address(instruction_operand op) {
       break;
 #ifdef WINDOWS
     case RT_EXCEPTION_HANDLER:
-      op.store_value((cell) & factor::exception_handler);
+      op.store_value((cell)&factor::exception_handler);
       break;
 #endif
 #ifdef FACTOR_PPC
@@ -271,10 +271,10 @@ void factor_vm::store_external_address(instruction_operand op) {
       break;
 #endif
     case RT_INLINE_CACHE_MISS:
-      op.store_value((cell) & factor::inline_cache_miss);
+      op.store_value((cell)&factor::inline_cache_miss);
       break;
     case RT_SAFEPOINT:
-      op.store_value((cell) code->safepoint_page);
+      op.store_value((cell)code->safepoint_page);
       break;
     default:
       critical_error("Bad rel type in store_external_address()", op.rel_type());
@@ -286,9 +286,9 @@ cell factor_vm::compute_here_address(cell arg, cell offset,
                                      code_block* compiled) {
   fixnum n = untag_fixnum(arg);
   if (n >= 0)
-    return (cell) compiled->entry_point() + offset + n;
+    return (cell)compiled->entry_point() + offset + n;
   else
-    return (cell) compiled->entry_point() - n;
+    return (cell)compiled->entry_point() - n;
 }
 
 struct initial_code_block_visitor {
@@ -364,7 +364,7 @@ void factor_vm::fixup_labels(array* labels, code_block* compiled) {
     relocation_entry new_entry(RT_HERE, rel_class, offset);
 
     instruction_operand op(new_entry, compiled, 0);
-    op.store_value(target + (cell) compiled->entry_point());
+    op.store_value(target + (cell)compiled->entry_point());
   }
 }
 
@@ -440,9 +440,9 @@ code_block* factor_vm::add_code_block(code_block_type type, cell code_,
      block's instruction operands. In most cases this is done right after this
      method returns, except when compiling words with the non-optimizing
      compiler at the beginning of bootstrap */
-  this->code->uninitialized_blocks
+  this->code->uninitialized_blocks.insert(
-      .insert(std::make_pair(compiled, literals.value()));
+      std::make_pair(compiled, literals.value()));
-  this->code->all_blocks.insert((cell) compiled);
+  this->code->all_blocks.insert((cell)compiled);
 
   /* next time we do a minor GC, we have to trace this code block, since
      the fields of the code_block struct might point into nursery or aging */
@@ -480,12 +480,12 @@ struct find_symbol_at_address_visitor {
 void factor_vm::undefined_symbol() {
   void* frame = ctx->callstack_top;
   void* return_address = frame_return_address(frame);
-  code_block* compiled = code->code_block_for_address((cell) return_address);
+  code_block* compiled = code->code_block_for_address((cell)return_address);
-  find_symbol_at_address_visitor visitor(this, (cell) return_address);
+  find_symbol_at_address_visitor visitor(this, (cell)return_address);
   compiled->each_instruction_operand(visitor);
   if (!to_boolean(visitor.symbol))
     critical_error("Can't find RT_DLSYM at return address",
-                   (cell) return_address);
+                   (cell)return_address);
   else
     general_error(ERROR_UNDEFINED_SYMBOL, visitor.symbol, visitor.library);
 }

vm/code_blocks.hpp

@@ -75,7 +75,7 @@ struct code_block {
     return (gc_info*)((uint8_t*)this + size() - sizeof(gc_info));
   }
 
-  void flush_icache() { factor::flush_icache((cell) this, size()); }
+  void flush_icache() { factor::flush_icache((cell)this, size()); }
 
   template <typename Iterator> void each_instruction_operand(Iterator& iter) {
     if (to_boolean(relocation)) {

vm/code_heap.cpp

@@ -53,7 +53,7 @@ void code_heap::free(code_block* compiled) {
   FACTOR_ASSERT(!uninitialized_p(compiled));
   points_to_nursery.erase(compiled);
   points_to_aging.erase(compiled);
-  all_blocks.erase((cell) compiled);
+  all_blocks.erase((cell)compiled);
   allocator->free(compiled);
 }
 
@@ -66,9 +66,9 @@ struct clear_free_blocks_from_all_blocks_iterator {
 
   void operator()(code_block* free_block, cell size) {
     std::set<cell>::iterator erase_from =
-        code->all_blocks.lower_bound((cell) free_block);
+        code->all_blocks.lower_bound((cell)free_block);
     std::set<cell>::iterator erase_to =
-        code->all_blocks.lower_bound((cell) free_block + size);
+        code->all_blocks.lower_bound((cell)free_block + size);
 
     code->all_blocks.erase(erase_from, erase_to);
   }
@@ -89,7 +89,7 @@ struct all_blocks_set_verifier {
       : all_blocks(all_blocks) {}
 
   void operator()(code_block* block, cell size) {
-    FACTOR_ASSERT(all_blocks->find((cell) block) != all_blocks->end());
+    FACTOR_ASSERT(all_blocks->find((cell)block) != all_blocks->end());
   }
 };
 
@@ -103,7 +103,7 @@ code_block* code_heap::code_block_for_address(cell address) {
   FACTOR_ASSERT(blocki != all_blocks.begin());
   --blocki;
   code_block* found_block = (code_block*)*blocki;
-  FACTOR_ASSERT((cell) found_block->entry_point() <=
+  FACTOR_ASSERT((cell)found_block->entry_point() <=
                 address /* XXX this isn't valid during fixup. should store the
                                size in the map
                               && address - (cell)found_block->entry_point() <
@@ -117,7 +117,7 @@ struct all_blocks_set_inserter {
   all_blocks_set_inserter(code_heap* code) : code(code) {}
 
   void operator()(code_block* block, cell size) {
-    code->all_blocks.insert((cell) block);
+    code->all_blocks.insert((cell)block);
   }
 };
 
@@ -263,7 +263,7 @@ struct code_block_accumulator {
        from_unsigned_cell() here. It is OK, however, to add it as
        if it were a fixnum, and have library code shift it to the
        left by 4. */
-    cell entry_point = (cell) compiled->entry_point();
+    cell entry_point = (cell)compiled->entry_point();
     FACTOR_ASSERT((entry_point & (data_alignment - 1)) == 0);
     FACTOR_ASSERT((entry_point & TAG_MASK) == FIXNUM_TYPE);
     objects.push_back(entry_point);

vm/code_heap.hpp

@@ -53,7 +53,7 @@ struct code_heap {
 
   bool safepoint_p(cell addr) {
     cell page_mask = ~(getpagesize() - 1);
-    return (addr & page_mask) == (cell) safepoint_page;
+    return (addr & page_mask) == (cell)safepoint_page;
   }
 };
 

vm/collector.hpp

@@ -63,7 +63,7 @@ struct gc_workhorse : no_fixup {
   code_block* fixup_code(code_block* compiled) {
     if (!code->marked_p(compiled)) {
       code->set_marked_p(compiled);
-      parent->mark_stack.push_back((cell) compiled + 1);
+      parent->mark_stack.push_back((cell)compiled + 1);
     }
 
     return compiled;

vm/compaction.cpp

@@ -88,7 +88,7 @@ template <typename Fixup> struct code_block_compaction_relocation_visitor {
       : parent(parent), old_address(old_address), fixup(fixup) {}
 
   void operator()(instruction_operand op) {
-    cell old_offset = op.rel_offset() + (cell) old_address->entry_point();
+    cell old_offset = op.rel_offset() + (cell)old_address->entry_point();
 
     switch (op.rel_type()) {
       case RT_LITERAL: {
@@ -107,7 +107,7 @@ template <typename Fixup> struct code_block_compaction_relocation_visitor {
         cell value = op.load_value(old_offset);
         cell offset = TAG(value);
         code_block* compiled = (code_block*)UNTAG(value);
-        op.store_value((cell) fixup.fixup_code(compiled) + offset);
+        op.store_value((cell)fixup.fixup_code(compiled) + offset);
         break;
       }
       case RT_THIS:
@@ -159,11 +159,11 @@ void factor_vm::update_code_roots_for_compaction() {
     code_block* block = (code_block*)(root->value & (~data_alignment + 1));
 
     /* Offset of return address within 16-byte allocation line */
-    cell offset = root->value - (cell) block;
+    cell offset = root->value - (cell)block;
 
     if (root->valid && state->marked_p(block)) {
       block = state->forward_block(block);
-      root->value = (cell) block + offset;
+      root->value = (cell)block + offset;
     } else
       root->valid = false;
   }

vm/cpu-ppc.hpp

@@ -43,7 +43,7 @@ inline static void set_call_target(cell return_address, void* target) {
 
   uint32_t insn = *(uint32_t*)return_address;
 
-  fixnum relative_address = ((cell) target - return_address);
+  fixnum relative_address = ((cell)target - return_address);
   insn = ((insn & ~b_mask) | (relative_address & b_mask));
   *(uint32_t*)return_address = insn;
 

vm/cpu-x86.cpp

@@ -14,11 +14,11 @@ void factor_vm::dispatch_signal_handler(cell* sp, cell* pc, cell handler) {
     void* frame_top = (void*)ctx->callstack_top;
 
     while (frame_top < ctx->callstack_bottom &&
-           (cell) frame_top < ctx->callstack_seg->start + stack_reserved) {
+           (cell)frame_top < ctx->callstack_seg->start + stack_reserved) {
       frame_top = frame_predecessor(frame_top);
     }
 
-    *sp = (cell) frame_top;
+    *sp = (cell)frame_top;
     ctx->callstack_top = frame_top;
     *pc = handler;
   } else {
@@ -53,7 +53,7 @@ void factor_vm::dispatch_signal_handler(cell* sp, cell* pc, cell handler) {
     } else
       FACTOR_ASSERT(false);
 
-    *pc = (cell) handler_word->entry_point;
+    *pc = (cell)handler_word->entry_point;
   }
 }
 

vm/cpu-x86.hpp

@@ -34,7 +34,7 @@ inline static unsigned char call_site_opcode(cell return_address) {
 inline static void check_call_site(cell return_address) {
   unsigned char opcode = call_site_opcode(return_address);
   FACTOR_ASSERT(opcode == call_opcode || opcode == jmp_opcode);
-  (void) opcode;  // suppress warning when compiling without assertions
+  (void)opcode; // suppress warning when compiling without assertions
 }
 
 inline static void* get_call_target(cell return_address) {
@@ -44,7 +44,7 @@ inline static void* get_call_target(cell return_address) {
 
 inline static void set_call_target(cell return_address, void* target) {
   check_call_site(return_address);
-  *(int*)(return_address - 4) = (uint32_t)((cell) target - return_address);
+  *(int*)(return_address - 4) = (uint32_t)((cell)target - return_address);
 }
 
 inline static bool tail_call_site_p(cell return_address) {

vm/data_heap.cpp

@@ -3,8 +3,8 @@
 namespace factor {
 
 void factor_vm::init_card_decks() {
-  cards_offset = (cell) data->cards - addr_to_card(data->start);
+  cards_offset = (cell)data->cards - addr_to_card(data->start);
-  decks_offset = (cell) data->decks - addr_to_deck(data->start);
+  decks_offset = (cell)data->decks - addr_to_deck(data->start);
 }
 
 data_heap::data_heap(cell young_size_, cell aging_size_, cell tenured_size_) {

vm/data_heap_checker.cpp

@@ -19,8 +19,8 @@ inline generation generation_of(factor_vm* parent, object* obj) {
   else if (parent->data->tenured->contains_p(obj))
     return tenured_generation;
   else {
-    critical_error("Bad object", (cell) obj);
+    critical_error("Bad object", (cell)obj);
-    return (generation) - 1;
+    return (generation)-1;
   }
 }
 
@@ -33,9 +33,9 @@ struct slot_checker {
       : parent(parent), obj(obj), gen(gen) {}
 
   void check_write_barrier(cell* slot_ptr, generation target, char mask) {
-    cell object_card_pointer = parent->cards_offset + ((cell) obj >> card_bits);
+    cell object_card_pointer = parent->cards_offset + ((cell)obj >> card_bits);
     cell slot_card_pointer =
-        parent->cards_offset + ((cell) slot_ptr >> card_bits);
+        parent->cards_offset + ((cell)slot_ptr >> card_bits);
     char slot_card_value = *(char*)slot_card_pointer;
     if ((slot_card_value & mask) != mask) {
       std::cout << "card not marked" << std::endl;

vm/data_roots.hpp

@@ -37,11 +37,11 @@ struct gc_bignum {
   gc_bignum(bignum** addr, factor_vm* parent) : addr(addr), parent(parent) {
     if (*addr)
       parent->check_data_pointer(*addr);
-    parent->bignum_roots.push_back((cell) addr);
+    parent->bignum_roots.push_back((cell)addr);
   }
 
   ~gc_bignum() {
-    FACTOR_ASSERT(parent->bignum_roots.back() == (cell) addr);
+    FACTOR_ASSERT(parent->bignum_roots.back() == (cell)addr);
     parent->bignum_roots.pop_back();
   }
 };

vm/debug.cpp

@@ -4,7 +4,7 @@ namespace factor {
 
 std::ostream& operator<<(std::ostream& out, const string* str) {
   for (cell i = 0; i < string_capacity(str); i++)
-    out << (char) str->data()[i];
+    out << (char)str->data()[i];
   return out;
 }
 
@@ -201,13 +201,13 @@ struct stack_frame_printer {
     parent->print_obj(owner->scan(parent, addr));
     std::cout << std::endl;
     std::cout << "word/quot addr: ";
-    std::cout << std::hex << (cell) owner->owner << std::dec;
+    std::cout << std::hex << (cell)owner->owner << std::dec;
     std::cout << std::endl;
     std::cout << "word/quot xt: ";
-    std::cout << std::hex << (cell) owner->entry_point() << std::dec;
+    std::cout << std::hex << (cell)owner->entry_point() << std::dec;
     std::cout << std::endl;
     std::cout << "return address: ";
-    std::cout << std::hex << (cell) addr << std::dec;
+    std::cout << std::hex << (cell)addr << std::dec;
     std::cout << std::endl;
   }
 };
@@ -270,7 +270,7 @@ void factor_vm::dump_generations() {
   dump_generation("Tenured", data->tenured);
 
   std::cout << "Cards:";
-  std::cout << "base=" << (cell) data->cards << ", ";
+  std::cout << "base=" << (cell)data->cards << ", ";
   std::cout << "size=" << (cell)(data->cards_end - data->cards) << std::endl;
 
   std::cout << std::dec;
@@ -285,7 +285,7 @@ struct object_dumper {
 
   void operator()(object* obj) {
     if (type == TYPE_COUNT || obj->type() == type) {
-      std::cout << padded_address((cell) obj) << " ";
+      std::cout << padded_address((cell)obj) << " ";
       parent->print_nested_obj(tag_dynamic(obj), 2);
       std::cout << std::endl;
     }
@@ -309,7 +309,7 @@ struct find_data_reference_slot_visitor {
 
   void operator()(cell* scan) {
     if (look_for == *scan) {
-      std::cout << padded_address((cell) obj) << " ";
+      std::cout << padded_address((cell)obj) << " ";
       parent->print_nested_obj(tag_dynamic(obj), 2);
       std::cout << std::endl;
     }
@@ -374,7 +374,7 @@ struct code_block_printer {
       else
         status = "allocated";
 
-      std::cout << std::hex << (cell) scan << std::dec << " ";
+      std::cout << std::hex << (cell)scan << std::dec << " ";
       std::cout << std::hex << size << std::dec << " ";
       std::cout << status << " ";
       std::cout << "stack frame " << scan->stack_frame_size();
@@ -531,7 +531,7 @@ void factor_vm::factorbug() {
       print_callstack();
     else if (strcmp(cmd, "e") == 0) {
       for (cell i = 0; i < special_object_count; i++)
-        dump_cell((cell) & special_objects[i]);
+        dump_cell((cell)&special_objects[i]);
     } else if (strcmp(cmd, "g") == 0)
       dump_generations();
     else if (strcmp(cmd, "c") == 0) {

vm/dispatch.cpp

@@ -40,7 +40,7 @@ cell factor_vm::lookup_tuple_method(cell obj, cell methods) {
   array* echelons = untag<array>(methods);
 
   fixnum echelon = std::min(untag_fixnum(layout->echelon),
-                            (fixnum) array_capacity(echelons) - 1);
+                            (fixnum)array_capacity(echelons) - 1);
 
   while (echelon >= 0) {
     cell echelon_methods = array_nth(echelons, echelon);

vm/factor.cpp

@@ -135,23 +135,23 @@ void factor_vm::init_factor(vm_parameters* p) {
       p->image_path = default_image_path();
   }
 
-  srand((unsigned int) nano_count());
+  srand((unsigned int)nano_count());
   init_ffi();
   init_contexts(p->datastack_size, p->retainstack_size, p->callstack_size);
   init_callbacks(p->callback_size);
   load_image(p);
   init_c_io();
-  init_inline_caching((int) p->max_pic_size);
+  init_inline_caching((int)p->max_pic_size);
   special_objects[OBJ_CPU] =
-      allot_alien(false_object, (cell) FACTOR_CPU_STRING);
+      allot_alien(false_object, (cell)FACTOR_CPU_STRING);
-  special_objects[OBJ_OS] = allot_alien(false_object, (cell) FACTOR_OS_STRING);
+  special_objects[OBJ_OS] = allot_alien(false_object, (cell)FACTOR_OS_STRING);
   special_objects[OBJ_CELL_SIZE] = tag_fixnum(sizeof(cell));
   special_objects[OBJ_EXECUTABLE] =
-      allot_alien(false_object, (cell) p->executable_path);
+      allot_alien(false_object, (cell)p->executable_path);
   special_objects[OBJ_ARGS] = false_object;
   special_objects[OBJ_EMBEDDED] = false_object;
   special_objects[OBJ_VM_COMPILER] =
-      allot_alien(false_object, (cell) FACTOR_COMPILER_VERSION);
+      allot_alien(false_object, (cell)FACTOR_COMPILER_VERSION);
 
   /* We can GC now */
   gc_off = false;
@@ -172,7 +172,7 @@ void factor_vm::pass_args_to_factor(int argc, vm_char** argv) {
   growable_array args(this);
 
   for (fixnum i = 1; i < argc; i++)
-    args.add(allot_alien(false_object, (cell) argv[i]));
+    args.add(allot_alien(false_object, (cell)argv[i]));
 
   args.trim();
   special_objects[OBJ_ARGS] = args.elements.value();

vm/free_list.cpp

@@ -14,7 +14,7 @@ void free_list::initial_free_list(cell start, cell end, cell occupied) {
   clear_free_list();
   if (occupied != end - start) {
     free_heap_block* last_block = (free_heap_block*)(start + occupied);
-    last_block->make_free(end - (cell) last_block);
+    last_block->make_free(end - (cell)last_block);
     add_to_free_list(last_block);
   }
 }
@@ -49,7 +49,7 @@ free_heap_block* free_list::find_free_block(cell size) {
       /* Split it up into pieces and add each piece back to the free list */
       for (cell offset = 0; offset < large_block_size; offset += size) {
         free_heap_block* small_block = large_block;
-        large_block = (free_heap_block*)((cell) large_block + size);
+        large_block = (free_heap_block*)((cell)large_block + size);
         small_block->make_free(size);
         add_to_free_list(small_block);
       }
@@ -87,7 +87,7 @@ free_heap_block* free_list::split_free_block(free_heap_block* block,
                                              cell size) {
   if (block->size() != size) {
     /* split the block in two */
-    free_heap_block* split = (free_heap_block*)((cell) block + size);
+    free_heap_block* split = (free_heap_block*)((cell)block + size);
     split->make_free(block->size() - size);
     block->make_free(size);
     add_to_free_list(split);

vm/free_list_allocator.hpp

@@ -46,7 +46,7 @@ void free_list_allocator<Block>::initial_free_list(cell occupied) {
 
 template <typename Block>
 bool free_list_allocator<Block>::contains_p(Block* block) {
-  return ((cell) block - start) < size;
+  return ((cell)block - start) < size;
 }
 
 template <typename Block> Block* free_list_allocator<Block>::first_block() {
@@ -59,14 +59,14 @@ template <typename Block> Block* free_list_allocator<Block>::last_block() {
 
 template <typename Block>
 Block* free_list_allocator<Block>::next_block_after(Block* block) {
-  return (Block*)((cell) block + block->size());
+  return (Block*)((cell)block + block->size());
 }
 
 template <typename Block>
 Block* free_list_allocator<Block>::next_allocated_block_after(Block* block) {
   while (block != this->last_block() && block->free_p()) {
     free_heap_block* free_block = (free_heap_block*)block;
-    block = (object*)((cell) free_block + free_block->size());
+    block = (object*)((cell)free_block + free_block->size());
   }
 
   if (block == this->last_block())
@@ -182,7 +182,7 @@ void free_list_allocator<Block>::compact(Iterator& iter, Fixup fixup,
 
   /* Now update the free list; there will be a single free block at
      the end */
-  free_blocks.initial_free_list(start, end, (cell) compactor.address - start);
+  free_blocks.initial_free_list(start, end, (cell)compactor.address - start);
 }
 
 /* During compaction we have to be careful and measure object sizes
@@ -195,7 +195,7 @@ void free_list_allocator<Block>::iterate(Iterator& iter, Fixup fixup) {
 
   while (scan != end) {
     cell size = fixup.size(scan);
-    Block* next = (Block*)((cell) scan + size);
+    Block* next = (Block*)((cell)scan + size);
     if (!scan->free_p())
       iter(scan, size);
     scan = next;

vm/full_collector.hpp

@@ -13,7 +13,7 @@ struct full_policy {
 
   void promoted_object(object* obj) {
     tenured->set_marked_p(obj);
-    parent->mark_stack.push_back((cell) obj);
+    parent->mark_stack.push_back((cell)obj);
   }
 
   void visited_object(object* obj) {

vm/gc.cpp

@@ -205,7 +205,7 @@ struct call_frame_scrubber {
 
     FACTOR_ASSERT(return_address < owner->size());
     cell index = info->return_address_index(return_address);
-    if (index != (cell) - 1)
+    if (index != (cell)-1)
       ctx->scrub_stacks(info, index);
   }
 };

vm/gc_info.cpp

@@ -10,7 +10,7 @@ cell gc_info::return_address_index(cell return_address) {
       return i;
   }
 
-  return (cell) - 1;
+  return (cell)-1;
 }
 
 }

vm/image.cpp

@@ -20,7 +20,7 @@ void factor_vm::load_data_heap(FILE* file, image_header* h, vm_parameters* p) {
   fixnum bytes_read =
       safe_fread((void*)data->tenured->start, 1, h->data_size, file);
 
-  if ((cell) bytes_read != h->data_size) {
+  if ((cell)bytes_read != h->data_size) {
     std::cout << "truncated image: " << bytes_read << " bytes read, ";
     std::cout << h->data_size << " bytes expected\n";
     fatal_error("load_data_heap failed", 0);
@@ -59,11 +59,11 @@ struct startup_fixup {
       : data_offset(data_offset), code_offset(code_offset) {}
 
   object* fixup_data(object* obj) {
-    return (object*)((cell) obj + data_offset);
+    return (object*)((cell)obj + data_offset);
   }
 
   code_block* fixup_code(code_block* obj) {
-    return (code_block*)((cell) obj + code_offset);
+    return (code_block*)((cell)obj + code_offset);
   }
 
   object* translate_data(const object* obj) { return fixup_data((object*)obj); }
@@ -140,7 +140,7 @@ struct startup_code_block_relocation_visitor {
   void operator()(instruction_operand op) {
     code_block* compiled = op.compiled;
     cell old_offset =
-        op.rel_offset() + (cell) compiled->entry_point() - fixup.code_offset;
+        op.rel_offset() + (cell)compiled->entry_point() - fixup.code_offset;
 
     switch (op.rel_type()) {
       case RT_LITERAL: {
@@ -159,7 +159,7 @@ struct startup_code_block_relocation_visitor {
         cell value = op.load_value(old_offset);
         cell offset = TAG(value);
         code_block* compiled = (code_block*)UNTAG(value);
-        op.store_value((cell) fixup.fixup_code(compiled) + offset);
+        op.store_value((cell)fixup.fixup_code(compiled) + offset);
         break;
       }
       case RT_UNTAGGED:
@@ -195,8 +195,8 @@ void factor_vm::fixup_code(cell data_offset, cell code_offset) {
 
 bool factor_vm::read_embedded_image_footer(FILE* file,
                                            embedded_image_footer* footer) {
-  safe_fseek(file, -(off_t) sizeof(embedded_image_footer), SEEK_END);
+  safe_fseek(file, -(off_t)sizeof(embedded_image_footer), SEEK_END);
-  safe_fread(footer, (off_t) sizeof(embedded_image_footer), 1, file);
+  safe_fread(footer, (off_t)sizeof(embedded_image_footer), 1, file);
   return footer->magic == image_magic;
 }
 
@@ -213,7 +213,7 @@ FILE* factor_vm::open_image(vm_parameters* p) {
       std::cout << "No embedded image" << std::endl;
       exit(1);
     }
-    safe_fseek(file, (off_t) footer.image_offset, SEEK_SET);
+    safe_fseek(file, (off_t)footer.image_offset, SEEK_SET);
     return file;
   } else
     return OPEN_READ(p->image_path);
@@ -253,7 +253,7 @@ void factor_vm::load_image(vm_parameters* p) {
   fixup_code(data_offset, code_offset);
 
   /* Store image path name */
-  special_objects[OBJ_IMAGE] = allot_alien(false_object, (cell) p->image_path);
+  special_objects[OBJ_IMAGE] = allot_alien(false_object, (cell)p->image_path);
 }
 
 /* Save the current image to disk */

vm/inline_cache.cpp

@@ -7,7 +7,7 @@ void factor_vm::init_inline_caching(int max_size) { max_pic_size = max_size; }
 void factor_vm::deallocate_inline_cache(cell return_address) {
   /* Find the call target. */
   void* old_entry_point = get_call_target(return_address);
-  check_code_pointer((cell) old_entry_point);
+  check_code_pointer((cell)old_entry_point);
 
   code_block* old_block = (code_block*)old_entry_point - 1;
 
@@ -216,7 +216,7 @@ void* factor_vm::inline_cache_miss(cell return_address_) {
 #ifdef PIC_DEBUG
     std::cout << "Updated " << (tail_call_site ? "tail" : "non-tail")
               << " call site 0x" << std::hex << return_address.value << std::dec
-              << " with 0x" << std::hex << (cell) xt << std::dec << std::endl;
+              << " with 0x" << std::hex << (cell)xt << std::dec << std::endl;
     print_callstack();
 #endif
   }

vm/instruction_operands.cpp

@@ -7,7 +7,7 @@ instruction_operand::instruction_operand(relocation_entry rel,
     : rel(rel),
       compiled(compiled),
       index(index),
-      pointer((cell) compiled->entry_point() + rel.rel_offset()) {}
+      pointer((cell)compiled->entry_point() + rel.rel_offset()) {}
 
 /* Load a 32-bit value from a PowerPC LIS/ORI sequence */
 fixnum instruction_operand::load_value_2_2() {
@@ -25,7 +25,7 @@ fixnum instruction_operand::load_value_2_2_2_2() {
   uint64_t lhi = (ptr[-2] & 0xffff);
   uint64_t llo = (ptr[-1] & 0xffff);
   uint64_t val = hhi << 48 | hlo << 32 | lhi << 16 | llo;
-  return (cell) val;
+  return (cell)val;
 }
 
 /* Load a value from a bitfield of a PowerPC instruction */
@@ -33,7 +33,7 @@ fixnum instruction_operand::load_value_masked(cell mask, cell bits,
                                               cell shift) {
   int32_t* ptr = (int32_t*)(pointer - sizeof(uint32_t));
 
-  return (((*ptr & (int32_t) mask) << bits) >> bits) << shift;
+  return (((*ptr & (int32_t)mask) << bits) >> bits) << shift;
 }
 
 fixnum instruction_operand::load_value(cell relative_to) {
@@ -115,10 +115,10 @@ void instruction_operand::store_value(fixnum absolute_value) {
       *(cell*)(pointer - sizeof(cell)) = absolute_value;
       break;
     case RC_ABSOLUTE:
-      *(uint32_t*)(pointer - sizeof(uint32_t)) = (uint32_t) absolute_value;
+      *(uint32_t*)(pointer - sizeof(uint32_t)) = (uint32_t)absolute_value;
       break;
     case RC_RELATIVE:
-      *(int32_t*)(pointer - sizeof(int32_t)) = (int32_t) relative_value;
+      *(int32_t*)(pointer - sizeof(int32_t)) = (int32_t)relative_value;
       break;
     case RC_ABSOLUTE_PPC_2_2:
       store_value_2_2(absolute_value);
@@ -144,10 +144,10 @@ void instruction_operand::store_value(fixnum absolute_value) {
                          0);
       break;
     case RC_ABSOLUTE_2:
-      *(uint16_t*)(pointer - sizeof(uint16_t)) = (uint16_t) absolute_value;
+      *(uint16_t*)(pointer - sizeof(uint16_t)) = (uint16_t)absolute_value;
       break;
     case RC_ABSOLUTE_1:
-      *(uint8_t*)(pointer - sizeof(uint8_t)) = (uint8_t) absolute_value;
+      *(uint8_t*)(pointer - sizeof(uint8_t)) = (uint8_t)absolute_value;
       break;
     case RC_ABSOLUTE_PPC_2_2_2_2:
       store_value_2_2_2_2(absolute_value);
@@ -159,7 +159,7 @@ void instruction_operand::store_value(fixnum absolute_value) {
 }
 
 void instruction_operand::store_code_block(code_block* compiled) {
-  store_value((cell) compiled->entry_point());
+  store_value((cell)compiled->entry_point());
 }
 
 }

vm/io.cpp

@@ -14,9 +14,9 @@ with many more capabilities so these words are not usually used in
 normal operation. */
 
 void factor_vm::init_c_io() {
-  special_objects[OBJ_STDIN] = allot_alien(false_object, (cell) stdin);
+  special_objects[OBJ_STDIN] = allot_alien(false_object, (cell)stdin);
-  special_objects[OBJ_STDOUT] = allot_alien(false_object, (cell) stdout);
+  special_objects[OBJ_STDOUT] = allot_alien(false_object, (cell)stdout);
-  special_objects[OBJ_STDERR] = allot_alien(false_object, (cell) stderr);
+  special_objects[OBJ_STDERR] = allot_alien(false_object, (cell)stderr);
 }
 
 void factor_vm::io_error() {
@@ -196,7 +196,7 @@ void factor_vm::primitive_fread() {
 void factor_vm::primitive_fputc() {
   FILE* file = pop_file_handle();
   fixnum ch = to_fixnum(ctx->pop());
-  safe_fputc((int) ch, file);
+  safe_fputc((int)ch, file);
 }
 
 void factor_vm::primitive_fwrite() {
@@ -219,8 +219,8 @@ void factor_vm::primitive_ftell() {
 
 void factor_vm::primitive_fseek() {
   FILE* file = pop_file_handle();
-  int whence = (int) to_fixnum(ctx->pop());
+  int whence = (int)to_fixnum(ctx->pop());
-  off_t offset = (off_t) to_signed_8(ctx->pop());
+  off_t offset = (off_t)to_signed_8(ctx->pop());
   safe_fseek(file, offset, whence);
 }
 

vm/jit.cpp

@@ -21,13 +21,13 @@ jit::jit(code_block_type type, cell owner, factor_vm* vm)
       parent(vm) {
   fixnum old_count = atomic::fetch_add(&parent->current_jit_count, 1);
   FACTOR_ASSERT(old_count >= 0);
-  (void) old_count;
+  (void)old_count;
 }
 
 jit::~jit() {
   fixnum old_count = atomic::fetch_subtract(&parent->current_jit_count, 1);
   FACTOR_ASSERT(old_count >= 1);
-  (void) old_count;
+  (void)old_count;
 }
 
 void jit::emit_relocation(cell relocation_template_) {

vm/layouts.hpp

@@ -96,7 +96,7 @@ inline static bool immediate_p(cell obj) {
 
 inline static fixnum untag_fixnum(cell tagged) {
   FACTOR_ASSERT(TAG(tagged) == FIXNUM_TYPE);
-  return ((fixnum) tagged) >> TAG_BITS;
+  return ((fixnum)tagged) >> TAG_BITS;
 }
 
 inline static cell tag_fixnum(fixnum untagged) {
@@ -137,7 +137,7 @@ struct object {
 
   object* forwarding_pointer() const { return (object*)UNTAG(header); }
 
-  void forward_to(object* pointer) { header = ((cell) pointer | 2); }
+  void forward_to(object* pointer) { header = ((cell)pointer | 2); }
 };
 
 /* Assembly code makes assumptions about the layout of this struct */

vm/mach_signal.cpp

@@ -37,13 +37,13 @@ void factor_vm::call_fault_handler(exception_type_t exception,
 
   if (exception == EXC_BAD_ACCESS) {
     signal_fault_addr = MACH_EXC_STATE_FAULT(exc_state);
-    signal_fault_pc = (cell) MACH_PROGRAM_COUNTER(thread_state);
+    signal_fault_pc = (cell)MACH_PROGRAM_COUNTER(thread_state);
     verify_memory_protection_error(signal_fault_addr);
-    handler = (cell) factor::memory_signal_handler_impl;
+    handler = (cell)factor::memory_signal_handler_impl;
   } else if (exception == EXC_ARITHMETIC && code != MACH_EXC_INTEGER_DIV) {
     signal_fpu_status = fpu_status(mach_fpu_status(float_state));
     mach_clear_fpu_status(float_state);
-    handler = (cell) factor::fp_signal_handler_impl;
+    handler = (cell)factor::fp_signal_handler_impl;
   } else {
     switch (exception) {
       case EXC_ARITHMETIC:
@@ -57,14 +57,14 @@ void factor_vm::call_fault_handler(exception_type_t exception,
         break;
     }
 
-    handler = (cell) factor::synchronous_signal_handler_impl;
+    handler = (cell)factor::synchronous_signal_handler_impl;
   }
 
   FACTOR_ASSERT(handler != 0);
 
   dispatch_signal_handler((cell*)&MACH_STACK_POINTER(thread_state),
                           (cell*)&MACH_PROGRAM_COUNTER(thread_state),
-                          (cell) handler);
+                          (cell)handler);
 }
 
 static void call_fault_handler(mach_port_t thread, exception_type_t exception,

vm/mark_bits.hpp

@@ -32,7 +32,7 @@ template <typename Block> struct mark_bits {
   }
 
   cell block_line(const Block* address) {
-    return (((cell) address - start) / data_alignment);
+    return (((cell)address - start) / data_alignment);
   }
 
   Block* line_block(cell line) {
@@ -48,19 +48,19 @@ template <typename Block> struct mark_bits {
 
   bool bitmap_elt(cell* bits, const Block* address) {
     std::pair<cell, cell> position = bitmap_deref(address);
-    return (bits[position.first] & ((cell) 1 << position.second)) != 0;
+    return (bits[position.first] & ((cell)1 << position.second)) != 0;
   }
 
   Block* next_block_after(const Block* block) {
-    return (Block*)((cell) block + block->size());
+    return (Block*)((cell)block + block->size());
   }
 
   void set_bitmap_range(cell* bits, const Block* address) {
     std::pair<cell, cell> start = bitmap_deref(address);
     std::pair<cell, cell> end = bitmap_deref(next_block_after(address));
 
-    cell start_mask = ((cell) 1 << start.second) - 1;
+    cell start_mask = ((cell)1 << start.second) - 1;
-    cell end_mask = ((cell) 1 << end.second) - 1;
+    cell end_mask = ((cell)1 << end.second) - 1;
 
     if (start.first == end.first)
       bits[start.first] |= start_mask ^ end_mask;
@@ -69,7 +69,7 @@ template <typename Block> struct mark_bits {
       bits[start.first] |= ~start_mask;
 
       for (cell index = start.first + 1; index < end.first; index++)
-        bits[index] = (cell) - 1;
+        bits[index] = (cell)-1;
 
       if (end_mask != 0) {
         FACTOR_ASSERT(end.first < bits_size);
@@ -97,10 +97,10 @@ template <typename Block> struct mark_bits {
   Block* forward_block(const Block* original) {
     FACTOR_ASSERT(marked_p(original));
     std::pair<cell, cell> position = bitmap_deref(original);
-    cell offset = (cell) original & (data_alignment - 1);
+    cell offset = (cell)original & (data_alignment - 1);
 
     cell approx_popcount = forwarding[position.first];
-    cell mask = ((cell) 1 << position.second) - 1;
+    cell mask = ((cell)1 << position.second) - 1;
 
     cell new_line_number =
         approx_popcount + popcount(marked[position.first] & mask);
@@ -114,7 +114,7 @@ template <typename Block> struct mark_bits {
     cell bit_index = position.second;
 
     for (cell index = position.first; index < bits_size; index++) {
-      cell mask = ((fixnum) marked[index] >> bit_index);
+      cell mask = ((fixnum)marked[index] >> bit_index);
       if (~mask) {
         /* Found an unmarked block on this page. Stop, it's hammer time */
         cell clear_bit = rightmost_clear_bit(mask);

vm/math.cpp

@@ -65,7 +65,7 @@ void factor_vm::primitive_fixnum_shift() {
     ctx->replace(tag_fixnum(x >> -y));
     return;
   } else if (y < WORD_SIZE - TAG_BITS) {
-    fixnum mask = -((fixnum) 1 << (WORD_SIZE - 1 - TAG_BITS - y));
+    fixnum mask = -((fixnum)1 << (WORD_SIZE - 1 - TAG_BITS - y));
     if (!(branchless_abs(x) & mask)) {
       ctx->replace(tag_fixnum(x << y));
       return;
@@ -179,7 +179,7 @@ void factor_vm::primitive_bignum_not() {
 }
 
 void factor_vm::primitive_bignum_bitp() {
-  int bit = (int) to_fixnum(ctx->pop());
+  int bit = (int)to_fixnum(ctx->pop());
   bignum* x = untag<bignum>(ctx->peek());
   ctx->replace(tag_boolean(bignum_logbitp(bit, x)));
 }
@@ -276,12 +276,12 @@ void factor_vm::primitive_float_greatereq() {
 /* Allocates memory */
 void factor_vm::primitive_float_bits() {
   ctx->push(
-      from_unsigned_cell(float_bits((float) untag_float_check(ctx->pop()))));
+      from_unsigned_cell(float_bits((float)untag_float_check(ctx->pop()))));
 }
 
 /* Allocates memory */
 void factor_vm::primitive_bits_float() {
-  ctx->push(allot_float(bits_float((uint32_t) to_cell(ctx->pop()))));
+  ctx->push(allot_float(bits_float((uint32_t)to_cell(ctx->pop()))));
 }
 
 void factor_vm::primitive_double_bits() {
@@ -310,7 +310,7 @@ VM_C_API fixnum to_fixnum(cell tagged, factor_vm* parent) {
   return parent->to_fixnum(tagged);
 }
 
-cell factor_vm::to_cell(cell tagged) { return (cell) to_fixnum(tagged); }
+cell factor_vm::to_cell(cell tagged) { return (cell)to_fixnum(tagged); }
 
 VM_C_API cell to_cell(cell tagged, factor_vm* parent) {
   return parent->to_cell(tagged);
@@ -331,7 +331,7 @@ cell factor_vm::from_signed_8(int64_t n) {
   if (n < fixnum_min || n > fixnum_max)
     return tag<bignum>(long_long_to_bignum(n));
   else
-    return tag_fixnum((fixnum) n);
+    return tag_fixnum((fixnum)n);
 }
 
 VM_C_API cell from_signed_8(int64_t n, factor_vm* parent) {
@@ -357,10 +357,10 @@ VM_C_API int64_t to_signed_8(cell obj, factor_vm* parent) {
 
 /* Allocates memory */
 cell factor_vm::from_unsigned_8(uint64_t n) {
-  if (n > (uint64_t) fixnum_max)
+  if (n > (uint64_t)fixnum_max)
     return tag<bignum>(ulong_long_to_bignum(n));
   else
-    return tag_fixnum((fixnum) n);
+    return tag_fixnum((fixnum)n);
 }
 
 VM_C_API cell from_unsigned_8(uint64_t n, factor_vm* parent) {
@@ -386,7 +386,7 @@ VM_C_API uint64_t to_unsigned_8(cell obj, factor_vm* parent) {
 
 /* Cannot allocate */
 float factor_vm::to_float(cell value) {
-  return (float) untag_float_check(value);
+  return (float)untag_float_check(value);
 }
 
 /* Cannot allocate */

vm/math.hpp

@@ -1,9 +1,9 @@
 namespace factor {
 
 static const fixnum fixnum_max =
-    (((fixnum) 1 << (WORD_SIZE - TAG_BITS - 1)) - 1);
+    (((fixnum)1 << (WORD_SIZE - TAG_BITS - 1)) - 1);
-static const fixnum fixnum_min = (-((fixnum) 1 << (WORD_SIZE - TAG_BITS - 1)));
+static const fixnum fixnum_min = (-((fixnum)1 << (WORD_SIZE - TAG_BITS - 1)));
-static const fixnum array_size_max = ((cell) 1 << (WORD_SIZE - TAG_BITS - 2));
+static const fixnum array_size_max = ((cell)1 << (WORD_SIZE - TAG_BITS - 2));
 
 /* Allocates memory */
 inline cell factor_vm::from_signed_cell(fixnum x) {
@@ -15,7 +15,7 @@ inline cell factor_vm::from_signed_cell(fixnum x) {
 
 /* Allocates memory */
 inline cell factor_vm::from_unsigned_cell(cell x) {
-  if (x > (cell) fixnum_max)
+  if (x > (cell)fixnum_max)
     return tag<bignum>(cell_to_bignum(x));
   else
     return tag_fixnum(x);
@@ -42,18 +42,18 @@ inline double factor_vm::untag_float_check(cell tagged) {
 }
 
 inline fixnum factor_vm::float_to_fixnum(cell tagged) {
-  return (fixnum) untag_float(tagged);
+  return (fixnum)untag_float(tagged);
 }
 
 inline double factor_vm::fixnum_to_float(cell tagged) {
-  return (double) untag_fixnum(tagged);
+  return (double)untag_fixnum(tagged);
 }
 
 inline cell factor_vm::unbox_array_size() {
   cell obj = ctx->peek();
   if (TAG(obj) == FIXNUM_TYPE) {
     fixnum n = untag_fixnum(obj);
-    if (n >= 0 && n < (fixnum) array_size_max) {
+    if (n >= 0 && n < (fixnum)array_size_max) {
       ctx->pop();
       return n;
     }

vm/object_start_map.cpp

@@ -33,8 +33,8 @@ cell object_start_map::find_object_containing_card(cell card_index) {
 
 /* we need to remember the first object allocated in the card */
 void object_start_map::record_object_start_offset(object* obj) {
-  cell idx = addr_to_card((cell) obj - start);
+  cell idx = addr_to_card((cell)obj - start);
-  card obj_start = ((cell) obj & addr_card_mask);
+  card obj_start = ((cell)obj & addr_card_mask);
   object_start_offsets[idx] = std::min(object_start_offsets[idx], obj_start);
 }
 

vm/objects.cpp

@@ -23,7 +23,7 @@ void factor_vm::compute_identity_hashcode(object* obj) {
   object_counter++;
   if (object_counter == 0)
     object_counter++;
-  obj->set_hashcode((cell) obj ^ object_counter);
+  obj->set_hashcode((cell)obj ^ object_counter);
 }
 
 void factor_vm::primitive_compute_identity_hashcode() {

vm/objects.hpp

@@ -118,7 +118,7 @@ inline static bool save_special_p(cell i) {
 }
 
 template <typename Iterator> void object::each_slot(Iterator& iter) {
-  cell scan = (cell) this;
+  cell scan = (cell)this;
   cell payload_start = binary_payload_start();
   cell end = scan + payload_start;
 

vm/os-genunix.cpp

@@ -32,7 +32,7 @@ uint64_t nano_count() {
   int ret = clock_gettime(CLOCK_MONOTONIC, &t);
   if (ret != 0)
     fatal_error("clock_gettime failed", 0);
-  return (uint64_t) t.tv_sec * 1000000000 + t.tv_nsec;
+  return (uint64_t)t.tv_sec * 1000000000 + t.tv_nsec;
 }
 
 }

vm/os-linux-arm.hpp

@@ -11,10 +11,10 @@ void flush_icache(cell start, cell len);
 #define UAP_PROGRAM_COUNTER(ucontext) \
   (((ucontext_t*)ucontext)->uc_mcontext.arm_pc)
 #define UAP_STACK_POINTER_TYPE greg_t
-#define UAP_SET_TOC_POINTER(uap, ptr) (void) 0
+#define UAP_SET_TOC_POINTER(uap, ptr) (void)0
 
-#define CODE_TO_FUNCTION_POINTER(code) (void) 0
+#define CODE_TO_FUNCTION_POINTER(code) (void)0
-#define CODE_TO_FUNCTION_POINTER_CALLBACK(vm, code) (void) 0
+#define CODE_TO_FUNCTION_POINTER_CALLBACK(vm, code) (void)0
 #define FUNCTION_CODE_POINTER(ptr) ptr
 #define FUNCTION_TOC_POINTER(ptr) ptr
 }

vm/os-linux-ppc.32.hpp

@@ -8,10 +8,10 @@ namespace factor {
   ((ucontext_t*)ucontext)->uc_mcontext.uc_regs->gregs[1]
 #define UAP_PROGRAM_COUNTER(ucontext) \
   (((ucontext_t*)ucontext)->uc_mcontext.uc_regs->gregs[32])
-#define UAP_SET_TOC_POINTER(uap, ptr) (void) 0
+#define UAP_SET_TOC_POINTER(uap, ptr) (void)0
 
-#define CODE_TO_FUNCTION_POINTER(code) (void) 0
+#define CODE_TO_FUNCTION_POINTER(code) (void)0
-#define CODE_TO_FUNCTION_POINTER_CALLBACK(vm, code) (void) 0
+#define CODE_TO_FUNCTION_POINTER_CALLBACK(vm, code) (void)0
 #define FUNCTION_CODE_POINTER(ptr) ptr
 #define FUNCTION_TOC_POINTER(ptr) ptr
 

vm/os-linux-ppc.64.hpp

@@ -8,7 +8,7 @@ namespace factor {
   ((ucontext_t*)ucontext)->uc_mcontext.gp_regs[1]
 #define UAP_PROGRAM_COUNTER(ucontext) \
   (((ucontext_t*)ucontext)->uc_mcontext.gp_regs[32])
-#define UAP_SET_TOC_POINTER(uap, ptr) (void) 0
+#define UAP_SET_TOC_POINTER(uap, ptr) (void)0
 
 #define FACTOR_PPC_TOC 1
 

vm/os-linux-x86.32.hpp

@@ -50,10 +50,10 @@ inline static void uap_clear_fpu_status(void* uap) {
   (((ucontext_t*)ucontext)->uc_mcontext.gregs[7])
 #define UAP_PROGRAM_COUNTER(ucontext) \
   (((ucontext_t*)ucontext)->uc_mcontext.gregs[14])
-#define UAP_SET_TOC_POINTER(uap, ptr) (void) 0
+#define UAP_SET_TOC_POINTER(uap, ptr) (void)0
 
-#define CODE_TO_FUNCTION_POINTER(code) (void) 0
+#define CODE_TO_FUNCTION_POINTER(code) (void)0
-#define CODE_TO_FUNCTION_POINTER_CALLBACK(vm, code) (void) 0
+#define CODE_TO_FUNCTION_POINTER_CALLBACK(vm, code) (void)0
 #define FUNCTION_CODE_POINTER(ptr) ptr
 #define FUNCTION_TOC_POINTER(ptr) ptr
 

vm/os-linux-x86.64.hpp

@@ -18,10 +18,10 @@ inline static void uap_clear_fpu_status(void* uap) {
   (((ucontext_t*)ucontext)->uc_mcontext.gregs[15])
 #define UAP_PROGRAM_COUNTER(ucontext) \
   (((ucontext_t*)ucontext)->uc_mcontext.gregs[16])
-#define UAP_SET_TOC_POINTER(uap, ptr) (void) 0
+#define UAP_SET_TOC_POINTER(uap, ptr) (void)0
 
-#define CODE_TO_FUNCTION_POINTER(code) (void) 0
+#define CODE_TO_FUNCTION_POINTER(code) (void)0
-#define CODE_TO_FUNCTION_POINTER_CALLBACK(vm, code) (void) 0
+#define CODE_TO_FUNCTION_POINTER_CALLBACK(vm, code) (void)0
 #define FUNCTION_CODE_POINTER(ptr) ptr
 #define FUNCTION_TOC_POINTER(ptr) ptr
 

vm/os-macosx.hpp

@@ -9,12 +9,12 @@ const char* vm_executable_path();
 const char* default_image_path();
 
 #define UAP_STACK_POINTER(ucontext) (((ucontext_t*)ucontext)->uc_stack.ss_sp)
-#define UAP_SET_TOC_POINTER(uap, ptr) (void) 0
+#define UAP_SET_TOC_POINTER(uap, ptr) (void)0
 
-#define UAP_STACK_POINTER_TYPE void *
+#define UAP_STACK_POINTER_TYPE void*
 
-#define CODE_TO_FUNCTION_POINTER(code) (void) 0
+#define CODE_TO_FUNCTION_POINTER(code) (void)0
-#define CODE_TO_FUNCTION_POINTER_CALLBACK(vm, code) (void) 0
+#define CODE_TO_FUNCTION_POINTER_CALLBACK(vm, code) (void)0
 #define FUNCTION_CODE_POINTER(ptr) ptr
 #define FUNCTION_TOC_POINTER(ptr) ptr
 

vm/os-unix.cpp

@@ -92,10 +92,10 @@ segment::segment(cell size_, bool executable_p) {
     out_of_memory();
 
   if (mprotect(array, pagesize, PROT_NONE) == -1)
-    fatal_error("Cannot protect low guard page", (cell) array);
+    fatal_error("Cannot protect low guard page", (cell)array);
 
   if (mprotect(array + pagesize + size, pagesize, PROT_NONE) == -1)
-    fatal_error("Cannot protect high guard page", (cell) array);
+    fatal_error("Cannot protect high guard page", (cell)array);
 
   start = (cell)(array + pagesize);
   end = start + size;
@@ -110,19 +110,19 @@ segment::~segment() {
 
 void code_heap::guard_safepoint() {
   if (mprotect(safepoint_page, getpagesize(), PROT_NONE) == -1)
-    fatal_error("Cannot protect safepoint guard page", (cell) safepoint_page);
+    fatal_error("Cannot protect safepoint guard page", (cell)safepoint_page);
 }
 
 void code_heap::unguard_safepoint() {
   if (mprotect(safepoint_page, getpagesize(), PROT_WRITE) == -1)
-    fatal_error("Cannot unprotect safepoint guard page", (cell) safepoint_page);
+    fatal_error("Cannot unprotect safepoint guard page", (cell)safepoint_page);
 }
 
 void factor_vm::dispatch_signal(void* uap, void(handler)()) {
   dispatch_signal_handler((cell*)&UAP_STACK_POINTER(uap),
                           (cell*)&UAP_PROGRAM_COUNTER(uap),
-                          (cell) FUNCTION_CODE_POINTER(handler));
+                          (cell)FUNCTION_CODE_POINTER(handler));
-  UAP_SET_TOC_POINTER(uap, (cell) FUNCTION_TOC_POINTER(handler));
+  UAP_SET_TOC_POINTER(uap, (cell)FUNCTION_TOC_POINTER(handler));
 }
 
 void factor_vm::start_sampling_profiler_timer() {
@@ -141,9 +141,9 @@ void factor_vm::end_sampling_profiler_timer() {
 
 void memory_signal_handler(int signal, siginfo_t* siginfo, void* uap) {
   factor_vm* vm = current_vm();
-  vm->verify_memory_protection_error((cell) siginfo->si_addr);
+  vm->verify_memory_protection_error((cell)siginfo->si_addr);
-  vm->signal_fault_addr = (cell) siginfo->si_addr;
+  vm->signal_fault_addr = (cell)siginfo->si_addr;
-  vm->signal_fault_pc = (cell) UAP_PROGRAM_COUNTER(uap);
+  vm->signal_fault_pc = (cell)UAP_PROGRAM_COUNTER(uap);
   vm->dispatch_signal(uap, factor::memory_signal_handler_impl);
 }
 
@@ -195,7 +195,7 @@ void sample_signal_handler(int signal, siginfo_t* siginfo, void* uap) {
     vm = thread_vms.begin()->second;
   }
   if (atomic::load(&vm->sampling_profiler_p))
-    vm->safepoint.enqueue_samples(vm, 1, (cell) UAP_PROGRAM_COUNTER(uap),
+    vm->safepoint.enqueue_samples(vm, 1, (cell)UAP_PROGRAM_COUNTER(uap),
                                   foreign_thread);
   else if (!foreign_thread)
     enqueue_signal(vm, signal);

vm/os-windows-x86.64.cpp

@@ -54,7 +54,7 @@ void factor_vm::c_to_factor_toplevel(cell quot) {
   seh_area->handler[12] = 0xe0;
 
   /* Store address of exception handler in the operand of the 'mov' */
-  cell handler = (cell) & factor::exception_handler;
+  cell handler = (cell)&factor::exception_handler;
   memcpy(&seh_area->handler[2], &handler, sizeof(cell));
 
   UNWIND_INFO* unwind_info = &seh_area->unwind_info;
@@ -64,13 +64,13 @@ void factor_vm::c_to_factor_toplevel(cell quot) {
   unwind_info->CountOfCodes = 0;
   unwind_info->FrameRegister = 0;
   unwind_info->FrameOffset = 0;
-  unwind_info->ExceptionHandler = (DWORD)((cell) & seh_area->handler[0] - base);
+  unwind_info->ExceptionHandler = (DWORD)((cell)&seh_area->handler[0] - base);
   unwind_info->ExceptionData[0] = 0;
 
   RUNTIME_FUNCTION* func = &seh_area->func;
   func->BeginAddress = 0;
   func->EndAddress = (DWORD)(code->seg->end - base);
-  func->UnwindData = (DWORD)((cell) & seh_area->unwind_info - base);
+  func->UnwindData = (DWORD)((cell)&seh_area->unwind_info - base);
 
   if (!RtlAddFunctionTable(func, 1, base))
     fatal_error("RtlAddFunctionTable() failed", 0);

vm/os-windows.cpp

@@ -104,13 +104,13 @@ segment::segment(cell size_, bool executable_p) {
     out_of_memory();
 
   if (!VirtualProtect(mem, getpagesize(), PAGE_NOACCESS, &ignore))
-    fatal_error("Cannot allocate low guard page", (cell) mem);
+    fatal_error("Cannot allocate low guard page", (cell)mem);
 
   if (!VirtualProtect(mem + size + getpagesize(), getpagesize(), PAGE_NOACCESS,
                       &ignore))
-    fatal_error("Cannot allocate high guard page", (cell) mem);
+    fatal_error("Cannot allocate high guard page", (cell)mem);
 
-  start = (cell) mem + getpagesize();
+  start = (cell)mem + getpagesize();
   end = start + size;
 }
 
@@ -134,13 +134,13 @@ long getpagesize() {
 void code_heap::guard_safepoint() {
   DWORD ignore;
   if (!VirtualProtect(safepoint_page, getpagesize(), PAGE_NOACCESS, &ignore))
-    fatal_error("Cannot protect safepoint guard page", (cell) safepoint_page);
+    fatal_error("Cannot protect safepoint guard page", (cell)safepoint_page);
 }
 
 void code_heap::unguard_safepoint() {
   DWORD ignore;
   if (!VirtualProtect(safepoint_page, getpagesize(), PAGE_READWRITE, &ignore))
-    fatal_error("Cannot unprotect safepoint guard page", (cell) safepoint_page);
+    fatal_error("Cannot unprotect safepoint guard page", (cell)safepoint_page);
 }
 
 void factor_vm::move_file(const vm_char* path1, const vm_char* path2) {
@@ -184,7 +184,7 @@ uint64_t nano_count() {
 #endif
   lo = count.LowPart;
 
-  return (uint64_t)((((uint64_t) hi << 32) | (uint64_t) lo) * scale_factor);
+  return (uint64_t)((((uint64_t)hi << 32) | (uint64_t)lo) * scale_factor);
 }
 
 void sleep_nanos(uint64_t nsec) { Sleep((DWORD)(nsec / 1000000)); }
@@ -203,7 +203,7 @@ LONG factor_vm::exception_handler(PEXCEPTION_RECORD e, void* frame, PCONTEXT c,
       signal_fault_addr = e->ExceptionInformation[1];
       verify_memory_protection_error(signal_fault_addr);
       dispatch_signal_handler((cell*)&c->ESP, (cell*)&c->EIP,
-                              (cell) factor::memory_signal_handler_impl);
+                              (cell)factor::memory_signal_handler_impl);
       break;
 
     case STATUS_FLOAT_DENORMAL_OPERAND:
@@ -225,12 +225,12 @@ LONG factor_vm::exception_handler(PEXCEPTION_RECORD e, void* frame, PCONTEXT c,
 #endif
       MXCSR(c) &= 0xffffffc0;
       dispatch_signal_handler((cell*)&c->ESP, (cell*)&c->EIP,
-                              (cell) factor::fp_signal_handler_impl);
+                              (cell)factor::fp_signal_handler_impl);
       break;
     default:
       signal_number = e->ExceptionCode;
       dispatch_signal_handler((cell*)&c->ESP, (cell*)&c->EIP,
-                              (cell) factor::synchronous_signal_handler_impl);
+                              (cell)factor::synchronous_signal_handler_impl);
       break;
   }
 

vm/os-windows.hpp

@@ -86,8 +86,8 @@ inline static THREADHANDLE thread_id() {
 
 inline static void breakpoint() { DebugBreak(); }
 
-#define CODE_TO_FUNCTION_POINTER(code) (void) 0
+#define CODE_TO_FUNCTION_POINTER(code) (void)0
-#define CODE_TO_FUNCTION_POINTER_CALLBACK(vm, code) (void) 0
+#define CODE_TO_FUNCTION_POINTER_CALLBACK(vm, code) (void)0
 #define FUNCTION_CODE_POINTER(ptr) ptr
 #define FUNCTION_TOC_POINTER(ptr) ptr
 }

vm/quotations.cpp

@@ -350,8 +350,8 @@ void factor_vm::primitive_array_to_quotation() {
 void factor_vm::primitive_quotation_code() {
   data_root<quotation> quot(ctx->pop(), this);
 
-  ctx->push(from_unsigned_cell((cell) quot->entry_point));
+  ctx->push(from_unsigned_cell((cell)quot->entry_point));
-  ctx->push(from_unsigned_cell((cell) quot->code() + quot->code()->size()));
+  ctx->push(from_unsigned_cell((cell)quot->code() + quot->code()->size()));
 }
 
 /* Allocates memory */

vm/run.cpp

@@ -2,7 +2,7 @@
 
 namespace factor {
 
-void factor_vm::primitive_exit() { exit((int) to_fixnum(ctx->pop())); }
+void factor_vm::primitive_exit() { exit((int)to_fixnum(ctx->pop())); }
 
 void exit(int status) {
   factor_vm::close_console();

vm/safepoints.cpp

@@ -44,7 +44,7 @@ void safepoint_state::handle_safepoint(factor_vm* parent, cell pc) volatile {
   } else if (atomic::load(&parent->sampling_profiler_p)) {
     FACTOR_ASSERT(parent->code->seg->in_segment_p(pc));
     code_block* block = parent->code->code_block_for_address(pc);
-    bool prolog_p = (cell) block->entry_point() == pc;
+    bool prolog_p = (cell)block->entry_point() == pc;
 
     parent->record_sample(prolog_p);
   }

vm/slot_visitor.hpp

@@ -36,7 +36,7 @@ template <typename Fixup> cell object::size(Fixup fixup) const {
           callstack_object_size(untag_fixnum(((callstack*)this)->length)),
           data_alignment);
     default:
-      critical_error("Invalid header in size", (cell) this);
+      critical_error("Invalid header in size", (cell)this);
       return 0; /* can't happen */
   }
 }
@@ -79,7 +79,7 @@ template <typename Fixup> cell object::binary_payload_start(Fixup fixup) const {
     case WRAPPER_TYPE:
       return sizeof(wrapper);
     default:
-      critical_error("Invalid header in binary_payload_start", (cell) this);
+      critical_error("Invalid header in binary_payload_start", (cell)this);
       return 0; /* can't happen */
   }
 }
@@ -154,7 +154,7 @@ void slot_visitor<Fixup>::visit_object_array(cell* start, cell* end) {
 template <typename Fixup>
 void slot_visitor<Fixup>::visit_slots(object* ptr, cell payload_start) {
   cell* slot = (cell*)ptr;
-  cell* end = (cell*)((cell) ptr + payload_start);
+  cell* end = (cell*)((cell)ptr + payload_start);
 
   if (slot != end) {
     slot++;
@@ -191,7 +191,7 @@ template <typename Fixup> void slot_visitor<Fixup>::visit_bignum_roots() {
     cell* handle = (cell*)(*iter);
 
     if (*handle)
-      *handle = (cell) fixup.fixup_data(*(object**)handle);
+      *handle = (cell)fixup.fixup_data(*(object**)handle);
   }
 }
 
@@ -285,7 +285,7 @@ template <typename Fixup> struct call_frame_slot_visitor {
 
     FACTOR_ASSERT(return_address < compiled->size());
     cell callsite = info->return_address_index(return_address);
-    if (callsite == (cell) - 1)
+    if (callsite == (cell)-1)
       return;
 
 #ifdef DEBUG_GC_MAPS

vm/tenured_space.hpp

@@ -16,13 +16,13 @@ struct tenured_space : free_list_allocator<object> {
   }
 
   cell first_object() {
-    return (cell) next_allocated_block_after(this->first_block());
+    return (cell)next_allocated_block_after(this->first_block());
   }
 
   cell next_object_after(cell scan) {
     cell size = ((object*)scan)->size();
     object* next = (object*)(scan + size);
-    return (cell) next_allocated_block_after(next);
+    return (cell)next_allocated_block_after(next);
   }
 
   void clear_mark_bits() { state.clear_mark_bits(); }

vm/to_tenured_collector.hpp

@@ -12,7 +12,7 @@ struct to_tenured_policy {
   }
 
   void promoted_object(object* obj) {
-    parent->mark_stack.push_back((cell) obj);
+    parent->mark_stack.push_back((cell)obj);
   }
 
   void visited_object(object* obj) {}

vm/utilities.hpp

@@ -9,7 +9,7 @@ inline static void memset_2(void* dst, uint16_t pattern, size_t size) {
     memset(dst, 0, size);
   else {
     uint16_t* start = (uint16_t*)dst;
-    uint16_t* end = (uint16_t*)((cell) dst + size);
+    uint16_t* end = (uint16_t*)((cell)dst + size);
     while (start < end) {
       *start = pattern;
       start++;
@@ -30,7 +30,7 @@ inline static void memset_cell(void* dst, cell pattern, size_t size) {
     memset(dst, 0, size);
   else {
     cell* start = (cell*)dst;
-    cell* end = (cell*)((cell) dst + size);
+    cell* end = (cell*)((cell)dst + size);
     while (start < end) {
       *start = pattern;
       start++;

vm/vm.hpp

@@ -337,13 +337,13 @@ struct factor_vm {
   /* the write barrier must be called any time we are potentially storing a
      pointer from an older generation to a younger one */
   inline void write_barrier(cell* slot_ptr) {
-    *(char*)(cards_offset + ((cell) slot_ptr >> card_bits)) = card_mark_mask;
+    *(char*)(cards_offset + ((cell)slot_ptr >> card_bits)) = card_mark_mask;
-    *(char*)(decks_offset + ((cell) slot_ptr >> deck_bits)) = card_mark_mask;
+    *(char*)(decks_offset + ((cell)slot_ptr >> deck_bits)) = card_mark_mask;
   }
 
   inline void write_barrier(object* obj, cell size) {
-    cell start = (cell) obj & (~card_size + 1);
+    cell start = (cell)obj & (~card_size + 1);
-    cell end = ((cell) obj + size + card_size - 1) & (~card_size + 1);
+    cell end = ((cell)obj + size + card_size - 1) & (~card_size + 1);
 
     for (cell offset = start; offset < end; offset += card_size)
       write_barrier((cell*)offset);
@@ -387,7 +387,7 @@ struct factor_vm {
 
   inline void check_data_pointer(object* pointer) {
     FACTOR_ASSERT((current_gc && current_gc->op == collect_growing_heap_op) ||
-                  data->seg->in_segment_p((cell) pointer));
+                  data->seg->in_segment_p((cell)pointer));
   }
 
   // generic arrays

vm/words.cpp

@@ -77,8 +77,8 @@ void factor_vm::primitive_word_code() {
   data_root<word> w(ctx->pop(), this);
   w.untag_check(this);
 
-  ctx->push(from_unsigned_cell((cell) w->entry_point));
+  ctx->push(from_unsigned_cell((cell)w->entry_point));
-  ctx->push(from_unsigned_cell((cell) w->code() + w->code()->size()));
+  ctx->push(from_unsigned_cell((cell)w->code() + w->code()->size()));
 }
 
 void factor_vm::primitive_optimized_p() {