diff --git a/vm/alien.cpp b/vm/alien.cpp index 220e528ef7..b000586531 100644 --- a/vm/alien.cpp +++ b/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; \ } diff --git a/vm/assert.hpp b/vm/assert.hpp index 58294c5c3a..297e15bba8 100644 --- a/vm/assert.hpp +++ b/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 diff --git a/vm/atomic-cl-32.hpp b/vm/atomic-cl-32.hpp index a4b6af8a4f..d3983ef6f4 100644 --- a/vm/atomic-cl-32.hpp +++ b/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) - InterlockedExchangeAdd(reinterpret_cast(ptr), (LONG) val); + return (cell)InterlockedExchangeAdd(reinterpret_cast(ptr), + (LONG) val); } __forceinline static fixnum fetch_add(volatile fixnum* ptr, fixnum val) { - return (fixnum) - InterlockedExchangeAdd(reinterpret_cast(ptr), (LONG) val); + return (fixnum)InterlockedExchangeAdd(reinterpret_cast(ptr), + (LONG) val); } __forceinline static cell fetch_subtract(volatile cell* ptr, cell val) { - return (cell) InterlockedExchangeAdd(reinterpret_cast(ptr), - -(LONG) val); + return (cell)InterlockedExchangeAdd(reinterpret_cast(ptr), + -(LONG)val); } __forceinline static fixnum fetch_subtract(volatile fixnum* ptr, fixnum val) { - return (fixnum) InterlockedExchangeAdd(reinterpret_cast(ptr), - -(LONG) val); + return (fixnum)InterlockedExchangeAdd(reinterpret_cast(ptr), + -(LONG)val); } __forceinline static void fence() { MemoryBarrier(); } diff --git a/vm/atomic-cl-64.hpp b/vm/atomic-cl-64.hpp index 615f7f3b7a..3e99b851a3 100644 --- a/vm/atomic-cl-64.hpp +++ b/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(ptr), - (LONG64) old_val, (LONG64) new_val) == - (LONG64) old_val; + (LONG64)old_val, (LONG64)new_val) == + (LONG64)old_val; } __forceinline static bool cas(volatile fixnum* ptr, fixnum old_val, fixnum new_val) { return InterlockedCompareExchange64(reinterpret_cast(ptr), - (LONG64) old_val, (LONG64) new_val) == - (LONG64) old_val; + (LONG64)old_val, (LONG64)new_val) == + (LONG64)old_val; } __forceinline static cell fetch_add(volatile cell* ptr, cell val) { - return (cell) InterlockedExchangeAdd64( - reinterpret_cast(ptr), (LONG64) val); + return (cell)InterlockedExchangeAdd64( + reinterpret_cast(ptr), (LONG64)val); } __forceinline static fixnum fetch_add(volatile fixnum* ptr, fixnum val) { - return (fixnum) InterlockedExchangeAdd64( - reinterpret_cast(ptr), (LONG64) val); + return (fixnum)InterlockedExchangeAdd64( + reinterpret_cast(ptr), (LONG64)val); } __forceinline static cell fetch_subtract(volatile cell* ptr, cell val) { - return (cell) InterlockedExchangeAdd64( - reinterpret_cast(ptr), -(LONG64) val); + return (cell)InterlockedExchangeAdd64( + reinterpret_cast(ptr), -(LONG64)val); } __forceinline static fixnum fetch_subtract(volatile fixnum* ptr, fixnum val) { - return (fixnum) InterlockedExchangeAdd64( - reinterpret_cast(ptr), -(LONG64) val); + return (fixnum)InterlockedExchangeAdd64( + reinterpret_cast(ptr), -(LONG64)val); } __forceinline static void fence() { MemoryBarrier(); } diff --git a/vm/bignum.cpp b/vm/bignum.cpp index 4e20bf19c0..620dc97dd2 100644 --- a/vm/bignum.cpp +++ b/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::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; } diff --git a/vm/bignumint.hpp b/vm/bignumint.hpp index 8b3469f54f..e81809b4a7 100644 --- a/vm/bignumint.hpp +++ b/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) diff --git a/vm/bump_allocator.hpp b/vm/bump_allocator.hpp index 5eee8a22fc..12c4453b63 100644 --- a/vm/bump_allocator.hpp +++ b/vm/bump_allocator.hpp @@ -10,7 +10,7 @@ template 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; diff --git a/vm/callbacks.cpp b/vm/callbacks.cpp index d7ba882267..01811f297a 100644 --- a/vm/callbacks.cpp +++ b/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(), size); /* Store VM pointer */ - store_callback_operand(stub, 0, (cell) parent); + store_callback_operand(stub, 0, (cell)parent); cell index; diff --git a/vm/callbacks.hpp b/vm/callbacks.hpp index 1368b0d171..385fb680cd 100644 --- a/vm/callbacks.hpp +++ b/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 void each_callback(Iterator& iter) { diff --git a/vm/callstack.cpp b/vm/callstack.cpp index 23338ae3a3..fb146108ab 100644 --- a/vm/callstack.cpp +++ b/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); - cell frame_size = owner->stack_frame_size_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); return (void*)((char*)frame_top + frame_size); } @@ -99,14 +99,14 @@ void factor_vm::primitive_innermost_stack_frame_executing() { callstack* stack = untag_check(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(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); } diff --git a/vm/callstack.hpp b/vm/callstack.hpp index a69054da0f..52f5c59d06 100644 --- a/vm/callstack.hpp +++ b/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); - cell frame_size = owner->stack_frame_size_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); 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; diff --git a/vm/code_blocks.cpp b/vm/code_blocks.cpp index 17175d2f1e..e3117e3fb5 100644 --- a/vm/code_blocks.cpp +++ b/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(obj).type()) { case WORD_TYPE: - return (cell) untag(obj)->entry_point; + return (cell)untag(obj)->entry_point; case QUOTATION_TYPE: - return (cell) untag(obj)->entry_point; + return (cell)untag(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(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(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(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(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(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 - .insert(std::make_pair(compiled, literals.value())); - this->code->all_blocks.insert((cell) compiled); + this->code->uninitialized_blocks.insert( + std::make_pair(compiled, literals.value())); + 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); - find_symbol_at_address_visitor visitor(this, (cell) return_address); + code_block* compiled = code->code_block_for_address((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); } diff --git a/vm/code_blocks.hpp b/vm/code_blocks.hpp index c87415e478..6393c6f7e6 100644 --- a/vm/code_blocks.hpp +++ b/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 void each_instruction_operand(Iterator& iter) { if (to_boolean(relocation)) { diff --git a/vm/code_heap.cpp b/vm/code_heap.cpp index 52019dbf38..8ec6e0a61f 100644 --- a/vm/code_heap.cpp +++ b/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::iterator erase_from = - code->all_blocks.lower_bound((cell) free_block); + code->all_blocks.lower_bound((cell)free_block); std::set::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); diff --git a/vm/code_heap.hpp b/vm/code_heap.hpp index 12d1f732f2..cfd7fd3589 100644 --- a/vm/code_heap.hpp +++ b/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; } }; diff --git a/vm/collector.hpp b/vm/collector.hpp index 36f3bf897a..8894af56db 100644 --- a/vm/collector.hpp +++ b/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; diff --git a/vm/compaction.cpp b/vm/compaction.cpp index 1e301bc196..4fc196bafb 100644 --- a/vm/compaction.cpp +++ b/vm/compaction.cpp @@ -88,7 +88,7 @@ template 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 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; } diff --git a/vm/cpu-ppc.hpp b/vm/cpu-ppc.hpp index c846aa15db..70146ef1b8 100644 --- a/vm/cpu-ppc.hpp +++ b/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; diff --git a/vm/cpu-x86.cpp b/vm/cpu-x86.cpp index a716502489..bce75a4edc 100644 --- a/vm/cpu-x86.cpp +++ b/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; } } diff --git a/vm/cpu-x86.hpp b/vm/cpu-x86.hpp index 83b65f0091..1e3cbf6392 100644 --- a/vm/cpu-x86.hpp +++ b/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) { diff --git a/vm/data_heap.cpp b/vm/data_heap.cpp index aa3c9903b9..5a5af548fa 100644 --- a/vm/data_heap.cpp +++ b/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); - decks_offset = (cell) data->decks - addr_to_deck(data->start); + cards_offset = (cell)data->cards - addr_to_card(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_) { diff --git a/vm/data_heap_checker.cpp b/vm/data_heap_checker.cpp index ff33821096..373fd5940f 100644 --- a/vm/data_heap_checker.cpp +++ b/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); - return (generation) - 1; + critical_error("Bad object", (cell)obj); + 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; diff --git a/vm/data_roots.hpp b/vm/data_roots.hpp index bfbcb803e2..0d6d745c59 100644 --- a/vm/data_roots.hpp +++ b/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(); } }; diff --git a/vm/debug.cpp b/vm/debug.cpp index 5107be242b..a180c2ad3b 100644 --- a/vm/debug.cpp +++ b/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) { diff --git a/vm/dispatch.cpp b/vm/dispatch.cpp index 3aab4f9ffe..be3ae38774 100644 --- a/vm/dispatch.cpp +++ b/vm/dispatch.cpp @@ -40,7 +40,7 @@ cell factor_vm::lookup_tuple_method(cell obj, cell methods) { array* echelons = untag(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); diff --git a/vm/factor.cpp b/vm/factor.cpp index c1d3adc2e3..0cad4d1e60 100644 --- a/vm/factor.cpp +++ b/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); - special_objects[OBJ_OS] = allot_alien(false_object, (cell) FACTOR_OS_STRING); + allot_alien(false_object, (cell)FACTOR_CPU_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(); diff --git a/vm/free_list.cpp b/vm/free_list.cpp index 46de38ddae..8bdff892d1 100644 --- a/vm/free_list.cpp +++ b/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); diff --git a/vm/free_list_allocator.hpp b/vm/free_list_allocator.hpp index 16e3d28ded..f536fcd39e 100644 --- a/vm/free_list_allocator.hpp +++ b/vm/free_list_allocator.hpp @@ -46,7 +46,7 @@ void free_list_allocator::initial_free_list(cell occupied) { template bool free_list_allocator::contains_p(Block* block) { - return ((cell) block - start) < size; + return ((cell)block - start) < size; } template Block* free_list_allocator::first_block() { @@ -59,14 +59,14 @@ template Block* free_list_allocator::last_block() { template Block* free_list_allocator::next_block_after(Block* block) { - return (Block*)((cell) block + block->size()); + return (Block*)((cell)block + block->size()); } template Block* free_list_allocator::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::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::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; diff --git a/vm/full_collector.hpp b/vm/full_collector.hpp index 26c3624e52..a17dec51ee 100644 --- a/vm/full_collector.hpp +++ b/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) { diff --git a/vm/gc.cpp b/vm/gc.cpp index 074446be1e..200842e781 100644 --- a/vm/gc.cpp +++ b/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); } }; diff --git a/vm/gc_info.cpp b/vm/gc_info.cpp index fe2f216c73..3e3e81938d 100644 --- a/vm/gc_info.cpp +++ b/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; } } diff --git a/vm/image.cpp b/vm/image.cpp index fc1c399f8d..a34879bc30 100644 --- a/vm/image.cpp +++ b/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_fread(footer, (off_t) sizeof(embedded_image_footer), 1, file); + safe_fseek(file, -(off_t)sizeof(embedded_image_footer), SEEK_END); + 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 */ diff --git a/vm/inline_cache.cpp b/vm/inline_cache.cpp index ec8ac00636..d5e2159645 100644 --- a/vm/inline_cache.cpp +++ b/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 } diff --git a/vm/instruction_operands.cpp b/vm/instruction_operands.cpp index f48be296cf..93f190eb68 100644 --- a/vm/instruction_operands.cpp +++ b/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()); } } diff --git a/vm/io.cpp b/vm/io.cpp index d5a3c1c346..e56570820a 100644 --- a/vm/io.cpp +++ b/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_STDOUT] = allot_alien(false_object, (cell) stdout); - special_objects[OBJ_STDERR] = allot_alien(false_object, (cell) stderr); + special_objects[OBJ_STDIN] = allot_alien(false_object, (cell)stdin); + special_objects[OBJ_STDOUT] = allot_alien(false_object, (cell)stdout); + 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()); - off_t offset = (off_t) to_signed_8(ctx->pop()); + int whence = (int)to_fixnum(ctx->pop()); + off_t offset = (off_t)to_signed_8(ctx->pop()); safe_fseek(file, offset, whence); } diff --git a/vm/jit.cpp b/vm/jit.cpp index d8b2c40924..a377af536c 100644 --- a/vm/jit.cpp +++ b/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_) { diff --git a/vm/layouts.hpp b/vm/layouts.hpp index c56d1f1a80..95d75c026e 100644 --- a/vm/layouts.hpp +++ b/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 */ diff --git a/vm/mach_signal.cpp b/vm/mach_signal.cpp index abbf7ae8c6..0795da2165 100644 --- a/vm/mach_signal.cpp +++ b/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, diff --git a/vm/mark_bits.hpp b/vm/mark_bits.hpp index fe5cf587b6..29eb1f8417 100644 --- a/vm/mark_bits.hpp +++ b/vm/mark_bits.hpp @@ -32,7 +32,7 @@ template 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 struct mark_bits { bool bitmap_elt(cell* bits, const Block* address) { std::pair 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 start = bitmap_deref(address); std::pair end = bitmap_deref(next_block_after(address)); - cell start_mask = ((cell) 1 << start.second) - 1; - cell end_mask = ((cell) 1 << end.second) - 1; + cell start_mask = ((cell)1 << start.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 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 struct mark_bits { Block* forward_block(const Block* original) { FACTOR_ASSERT(marked_p(original)); std::pair 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 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); diff --git a/vm/math.cpp b/vm/math.cpp index 9670a98e33..c85a279081 100644 --- a/vm/math.cpp +++ b/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(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(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(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 */ diff --git a/vm/math.hpp b/vm/math.hpp index adfc1209a2..b39ee80b6f 100644 --- a/vm/math.hpp +++ b/vm/math.hpp @@ -1,9 +1,9 @@ namespace factor { static const fixnum fixnum_max = - (((fixnum) 1 << (WORD_SIZE - TAG_BITS - 1)) - 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)); + (((fixnum)1 << (WORD_SIZE - TAG_BITS - 1)) - 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)); /* 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(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; } diff --git a/vm/object_start_map.cpp b/vm/object_start_map.cpp index 980d271e33..5d371e7ab7 100644 --- a/vm/object_start_map.cpp +++ b/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); - card obj_start = ((cell) obj & addr_card_mask); + cell idx = addr_to_card((cell)obj - start); + card obj_start = ((cell)obj & addr_card_mask); object_start_offsets[idx] = std::min(object_start_offsets[idx], obj_start); } diff --git a/vm/objects.cpp b/vm/objects.cpp index d1e65b46c7..819c33cd83 100644 --- a/vm/objects.cpp +++ b/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() { diff --git a/vm/objects.hpp b/vm/objects.hpp index b792763f1f..d082c18ba2 100644 --- a/vm/objects.hpp +++ b/vm/objects.hpp @@ -118,7 +118,7 @@ inline static bool save_special_p(cell i) { } template 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; diff --git a/vm/os-genunix.cpp b/vm/os-genunix.cpp index 905fbac2f6..08893f3889 100644 --- a/vm/os-genunix.cpp +++ b/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; } } diff --git a/vm/os-linux-arm.hpp b/vm/os-linux-arm.hpp index 7388698961..de0fea20d7 100644 --- a/vm/os-linux-arm.hpp +++ b/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_CALLBACK(vm, code) (void) 0 +#define CODE_TO_FUNCTION_POINTER(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 } diff --git a/vm/os-linux-ppc.32.hpp b/vm/os-linux-ppc.32.hpp index 67c1852bda..8b3df761cb 100644 --- a/vm/os-linux-ppc.32.hpp +++ b/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_CALLBACK(vm, code) (void) 0 +#define CODE_TO_FUNCTION_POINTER(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 diff --git a/vm/os-linux-ppc.64.hpp b/vm/os-linux-ppc.64.hpp index ce016b4524..cd76a01048 100644 --- a/vm/os-linux-ppc.64.hpp +++ b/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 diff --git a/vm/os-linux-x86.32.hpp b/vm/os-linux-x86.32.hpp index fc80c5fd56..16319086ab 100644 --- a/vm/os-linux-x86.32.hpp +++ b/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_CALLBACK(vm, code) (void) 0 +#define CODE_TO_FUNCTION_POINTER(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 diff --git a/vm/os-linux-x86.64.hpp b/vm/os-linux-x86.64.hpp index 1eae40a011..662ffca9bb 100644 --- a/vm/os-linux-x86.64.hpp +++ b/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_CALLBACK(vm, code) (void) 0 +#define CODE_TO_FUNCTION_POINTER(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 diff --git a/vm/os-macosx.hpp b/vm/os-macosx.hpp index 0657d60eba..30e50ba0a0 100644 --- a/vm/os-macosx.hpp +++ b/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_CALLBACK(vm, code) (void) 0 +#define CODE_TO_FUNCTION_POINTER(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 diff --git a/vm/os-unix.cpp b/vm/os-unix.cpp index e33c43b210..671f96f6b5 100644 --- a/vm/os-unix.cpp +++ b/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)); - UAP_SET_TOC_POINTER(uap, (cell) FUNCTION_TOC_POINTER(handler)); + (cell)FUNCTION_CODE_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->signal_fault_addr = (cell) siginfo->si_addr; - vm->signal_fault_pc = (cell) UAP_PROGRAM_COUNTER(uap); + vm->verify_memory_protection_error((cell)siginfo->si_addr); + vm->signal_fault_addr = (cell)siginfo->si_addr; + 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); diff --git a/vm/os-windows-x86.64.cpp b/vm/os-windows-x86.64.cpp index 6533287ce8..c0220851e2 100644 --- a/vm/os-windows-x86.64.cpp +++ b/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); diff --git a/vm/os-windows.cpp b/vm/os-windows.cpp index 8b4105b71d..43e70a3368 100644 --- a/vm/os-windows.cpp +++ b/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; } diff --git a/vm/os-windows.hpp b/vm/os-windows.hpp index ee0518d1c6..1f9a1da715 100644 --- a/vm/os-windows.hpp +++ b/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_CALLBACK(vm, code) (void) 0 +#define CODE_TO_FUNCTION_POINTER(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 } diff --git a/vm/quotations.cpp b/vm/quotations.cpp index fb75468fff..445f88e424 100644 --- a/vm/quotations.cpp +++ b/vm/quotations.cpp @@ -350,8 +350,8 @@ void factor_vm::primitive_array_to_quotation() { void factor_vm::primitive_quotation_code() { data_root quot(ctx->pop(), this); - 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->entry_point)); + ctx->push(from_unsigned_cell((cell)quot->code() + quot->code()->size())); } /* Allocates memory */ diff --git a/vm/run.cpp b/vm/run.cpp index 098175cc64..22dd77f5a8 100644 --- a/vm/run.cpp +++ b/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(); diff --git a/vm/safepoints.cpp b/vm/safepoints.cpp index 65eb89508e..53e198db81 100644 --- a/vm/safepoints.cpp +++ b/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); } diff --git a/vm/slot_visitor.hpp b/vm/slot_visitor.hpp index 42c0f7976f..7ac2c0c173 100644 --- a/vm/slot_visitor.hpp +++ b/vm/slot_visitor.hpp @@ -36,7 +36,7 @@ template 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 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::visit_object_array(cell* start, cell* end) { template void slot_visitor::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 void slot_visitor::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 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 diff --git a/vm/tenured_space.hpp b/vm/tenured_space.hpp index 62745df9ec..58dcc9ca0a 100644 --- a/vm/tenured_space.hpp +++ b/vm/tenured_space.hpp @@ -16,13 +16,13 @@ struct tenured_space : free_list_allocator { } 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(); } diff --git a/vm/to_tenured_collector.hpp b/vm/to_tenured_collector.hpp index 3aeca4203d..4198480659 100644 --- a/vm/to_tenured_collector.hpp +++ b/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) {} diff --git a/vm/utilities.hpp b/vm/utilities.hpp index f5f0264341..dcd717657b 100644 --- a/vm/utilities.hpp +++ b/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++; diff --git a/vm/vm.hpp b/vm/vm.hpp index 3b2ddacf36..7039fd047d 100644 --- a/vm/vm.hpp +++ b/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*)(decks_offset + ((cell) slot_ptr >> deck_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; } inline void write_barrier(object* obj, cell size) { - cell start = (cell) obj & (~card_size + 1); - cell end = ((cell) obj + size + card_size - 1) & (~card_size + 1); + cell start = (cell)obj & (~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 diff --git a/vm/words.cpp b/vm/words.cpp index c67e7449b1..7b7e4e8e05 100644 --- a/vm/words.cpp +++ b/vm/words.cpp @@ -77,8 +77,8 @@ void factor_vm::primitive_word_code() { data_root w(ctx->pop(), this); w.untag_check(this); - 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->entry_point)); + ctx->push(from_unsigned_cell((cell)w->code() + w->code()->size())); } void factor_vm::primitive_optimized_p() {