From 83b0769eef2df2d5c9a3b396f6119922aa892189 Mon Sep 17 00:00:00 2001 From: Phil Dawes Date: Wed, 23 Sep 2009 19:05:46 +0100 Subject: [PATCH] renamed factorvm to factor_vm --- vm/alien.cpp | 48 +++++------ vm/alien.hpp | 14 ++-- vm/arrays.cpp | 16 ++-- vm/bignum.cpp | 107 ++++++++++++------------- vm/bignum.hpp | 4 +- vm/booleans.cpp | 8 +- vm/booleans.hpp | 4 +- vm/byte_arrays.cpp | 14 ++-- vm/callstack.cpp | 42 +++++----- vm/callstack.hpp | 2 +- vm/code_block.cpp | 82 +++++++++---------- vm/code_block.hpp | 12 +-- vm/code_gc.cpp | 32 ++++---- vm/code_gc.hpp | 2 +- vm/code_heap.cpp | 28 +++---- vm/code_heap.hpp | 4 +- vm/contexts.cpp | 36 ++++----- vm/contexts.hpp | 6 +- vm/data_gc.cpp | 62 +++++++-------- vm/data_gc.hpp | 4 +- vm/data_heap.cpp | 54 ++++++------- vm/debug.cpp | 48 +++++------ vm/dispatch.cpp | 30 +++---- vm/errors.cpp | 32 ++++---- vm/factor.cpp | 30 +++---- vm/image.cpp | 42 +++++----- vm/inline_cache.cpp | 28 +++---- vm/inline_cache.hpp | 2 +- vm/inlineimpls.hpp | 84 ++++++++++---------- vm/io.cpp | 20 ++--- vm/jit.cpp | 2 +- vm/jit.hpp | 4 +- vm/mach_signal.cpp | 2 +- vm/math.cpp | 184 +++++++++++++++++++++---------------------- vm/math.hpp | 42 +++++----- vm/os-genunix.cpp | 2 +- vm/os-macosx.mm | 2 +- vm/os-unix.cpp | 26 +++--- vm/os-unix.hpp | 6 +- vm/os-windows-nt.cpp | 12 +-- vm/os-windows-nt.hpp | 6 +- vm/os-windows.cpp | 26 +++--- vm/profiler.cpp | 8 +- vm/quotations.cpp | 20 ++--- vm/quotations.hpp | 4 +- vm/run.cpp | 18 ++--- vm/strings.cpp | 28 +++---- vm/tagged.hpp | 6 +- vm/tuples.cpp | 6 +- vm/vm-data.hpp | 4 +- vm/vm.hpp | 16 ++-- vm/words.cpp | 12 +-- 52 files changed, 667 insertions(+), 666 deletions(-) diff --git a/vm/alien.cpp b/vm/alien.cpp index 32900e328c..0242c12c9e 100755 --- a/vm/alien.cpp +++ b/vm/alien.cpp @@ -5,7 +5,7 @@ namespace factor /* gets the address of an object representing a C pointer, with the intention of storing the pointer across code which may potentially GC. */ -char *factorvm::pinned_alien_offset(cell obj) +char *factor_vm::pinned_alien_offset(cell obj) { switch(tagged(obj).type()) { @@ -25,7 +25,7 @@ char *factorvm::pinned_alien_offset(cell obj) } /* make an alien */ -cell factorvm::allot_alien(cell delegate_, cell displacement) +cell factor_vm::allot_alien(cell delegate_, cell displacement) { gc_root delegate(delegate_,this); gc_root new_alien(allot(sizeof(alien)),this); @@ -46,7 +46,7 @@ cell factorvm::allot_alien(cell delegate_, cell displacement) } /* make an alien pointing at an offset of another alien */ -inline void factorvm::primitive_displaced_alien() +inline void factor_vm::primitive_displaced_alien() { cell alien = dpop(); cell displacement = to_cell(dpop()); @@ -76,7 +76,7 @@ PRIMITIVE(displaced_alien) /* address of an object representing a C pointer. Explicitly throw an error if the object is a byte array, as a sanity check. */ -inline void factorvm::primitive_alien_address() +inline void factor_vm::primitive_alien_address() { box_unsigned_cell((cell)pinned_alien_offset(dpop())); } @@ -87,7 +87,7 @@ PRIMITIVE(alien_address) } /* pop ( alien n ) from datastack, return alien's address plus n */ -void *factorvm::alien_pointer() +void *factor_vm::alien_pointer() { fixnum offset = to_fixnum(dpop()); return unbox_alien() + offset; @@ -121,7 +121,7 @@ DEFINE_ALIEN_ACCESSOR(double,double,box_double,to_double) DEFINE_ALIEN_ACCESSOR(cell,void *,box_alien,pinned_alien_offset) /* open a native library and push a handle */ -inline void factorvm::primitive_dlopen() +inline void factor_vm::primitive_dlopen() { gc_root path(dpop(),this); path.untag_check(this); @@ -137,7 +137,7 @@ PRIMITIVE(dlopen) } /* look up a symbol in a native library */ -inline void factorvm::primitive_dlsym() +inline void factor_vm::primitive_dlsym() { gc_root library(dpop(),this); gc_root name(dpop(),this); @@ -164,7 +164,7 @@ PRIMITIVE(dlsym) } /* close a native library handle */ -inline void factorvm::primitive_dlclose() +inline void factor_vm::primitive_dlclose() { dll *d = untag_check(dpop()); if(d->dll != NULL) @@ -176,7 +176,7 @@ PRIMITIVE(dlclose) PRIMITIVE_GETVM()->primitive_dlclose(); } -inline void factorvm::primitive_dll_validp() +inline void factor_vm::primitive_dll_validp() { cell library = dpop(); if(library == F) @@ -191,7 +191,7 @@ PRIMITIVE(dll_validp) } /* gets the address of an object representing a C pointer */ -char *factorvm::alien_offset(cell obj) +char *factor_vm::alien_offset(cell obj) { switch(tagged(obj).type()) { @@ -212,26 +212,26 @@ char *factorvm::alien_offset(cell obj) } } -VM_C_API char *alien_offset(cell obj, factorvm *myvm) +VM_C_API char *alien_offset(cell obj, factor_vm *myvm) { ASSERTVM(); return VM_PTR->alien_offset(obj); } /* pop an object representing a C pointer */ -char *factorvm::unbox_alien() +char *factor_vm::unbox_alien() { return alien_offset(dpop()); } -VM_C_API char *unbox_alien(factorvm *myvm) +VM_C_API char *unbox_alien(factor_vm *myvm) { ASSERTVM(); return VM_PTR->unbox_alien(); } /* make an alien and push */ -void factorvm::box_alien(void *ptr) +void factor_vm::box_alien(void *ptr) { if(ptr == NULL) dpush(F); @@ -239,40 +239,40 @@ void factorvm::box_alien(void *ptr) dpush(allot_alien(F,(cell)ptr)); } -VM_C_API void box_alien(void *ptr, factorvm *myvm) +VM_C_API void box_alien(void *ptr, factor_vm *myvm) { ASSERTVM(); return VM_PTR->box_alien(ptr); } /* for FFI calls passing structs by value */ -void factorvm::to_value_struct(cell src, void *dest, cell size) +void factor_vm::to_value_struct(cell src, void *dest, cell size) { memcpy(dest,alien_offset(src),size); } -VM_C_API void to_value_struct(cell src, void *dest, cell size, factorvm *myvm) +VM_C_API void to_value_struct(cell src, void *dest, cell size, factor_vm *myvm) { ASSERTVM(); return VM_PTR->to_value_struct(src,dest,size); } /* for FFI callbacks receiving structs by value */ -void factorvm::box_value_struct(void *src, cell size) +void factor_vm::box_value_struct(void *src, cell size) { byte_array *bytes = allot_byte_array(size); memcpy(bytes->data(),src,size); dpush(tag(bytes)); } -VM_C_API void box_value_struct(void *src, cell size,factorvm *myvm) +VM_C_API void box_value_struct(void *src, cell size,factor_vm *myvm) { ASSERTVM(); return VM_PTR->box_value_struct(src,size); } /* On some x86 OSes, structs <= 8 bytes are returned in registers. */ -void factorvm::box_small_struct(cell x, cell y, cell size) +void factor_vm::box_small_struct(cell x, cell y, cell size) { cell data[2]; data[0] = x; @@ -280,14 +280,14 @@ void factorvm::box_small_struct(cell x, cell y, cell size) box_value_struct(data,size); } -VM_C_API void box_small_struct(cell x, cell y, cell size, factorvm *myvm) +VM_C_API void box_small_struct(cell x, cell y, cell size, factor_vm *myvm) { ASSERTVM(); return VM_PTR->box_small_struct(x,y,size); } /* On OS X/PPC, complex numbers are returned in registers. */ -void factorvm::box_medium_struct(cell x1, cell x2, cell x3, cell x4, cell size) +void factor_vm::box_medium_struct(cell x1, cell x2, cell x3, cell x4, cell size) { cell data[4]; data[0] = x1; @@ -297,13 +297,13 @@ void factorvm::box_medium_struct(cell x1, cell x2, cell x3, cell x4, cell size) box_value_struct(data,size); } -VM_C_API void box_medium_struct(cell x1, cell x2, cell x3, cell x4, cell size, factorvm *myvm) +VM_C_API void box_medium_struct(cell x1, cell x2, cell x3, cell x4, cell size, factor_vm *myvm) { ASSERTVM(); return VM_PTR->box_medium_struct(x1, x2, x3, x4, size); } -inline void factorvm::primitive_vm_ptr() +inline void factor_vm::primitive_vm_ptr() { box_alien(this); } diff --git a/vm/alien.hpp b/vm/alien.hpp index ca3601f51e..839143b9e0 100755 --- a/vm/alien.hpp +++ b/vm/alien.hpp @@ -38,12 +38,12 @@ PRIMITIVE(dll_validp); PRIMITIVE(vm_ptr); -VM_C_API char *alien_offset(cell object, factorvm *vm); -VM_C_API char *unbox_alien(factorvm *vm); -VM_C_API void box_alien(void *ptr, factorvm *vm); -VM_C_API void to_value_struct(cell src, void *dest, cell size, factorvm *vm); -VM_C_API void box_value_struct(void *src, cell size,factorvm *vm); -VM_C_API void box_small_struct(cell x, cell y, cell size,factorvm *vm); -VM_C_API void box_medium_struct(cell x1, cell x2, cell x3, cell x4, cell size,factorvm *vm); +VM_C_API char *alien_offset(cell object, factor_vm *vm); +VM_C_API char *unbox_alien(factor_vm *vm); +VM_C_API void box_alien(void *ptr, factor_vm *vm); +VM_C_API void to_value_struct(cell src, void *dest, cell size, factor_vm *vm); +VM_C_API void box_value_struct(void *src, cell size,factor_vm *vm); +VM_C_API void box_small_struct(cell x, cell y, cell size,factor_vm *vm); +VM_C_API void box_medium_struct(cell x1, cell x2, cell x3, cell x4, cell size,factor_vm *vm); } diff --git a/vm/arrays.cpp b/vm/arrays.cpp index 3305c37e7c..aeae1d664f 100644 --- a/vm/arrays.cpp +++ b/vm/arrays.cpp @@ -4,7 +4,7 @@ namespace factor { /* make a new array with an initial element */ -array *factorvm::allot_array(cell capacity, cell fill_) +array *factor_vm::allot_array(cell capacity, cell fill_) { gc_root fill(fill_,this); gc_root new_array(allot_array_internal(capacity),this); @@ -24,7 +24,7 @@ array *factorvm::allot_array(cell capacity, cell fill_) } /* push a new array on the stack */ -inline void factorvm::primitive_array() +inline void factor_vm::primitive_array() { cell initial = dpop(); cell size = unbox_array_size(); @@ -36,7 +36,7 @@ PRIMITIVE(array) PRIMITIVE_GETVM()->primitive_array(); } -cell factorvm::allot_array_1(cell obj_) +cell factor_vm::allot_array_1(cell obj_) { gc_root obj(obj_,this); gc_root a(allot_array_internal(1),this); @@ -44,7 +44,7 @@ cell factorvm::allot_array_1(cell obj_) return a.value(); } -cell factorvm::allot_array_2(cell v1_, cell v2_) +cell factor_vm::allot_array_2(cell v1_, cell v2_) { gc_root v1(v1_,this); gc_root v2(v2_,this); @@ -54,7 +54,7 @@ cell factorvm::allot_array_2(cell v1_, cell v2_) return a.value(); } -cell factorvm::allot_array_4(cell v1_, cell v2_, cell v3_, cell v4_) +cell factor_vm::allot_array_4(cell v1_, cell v2_, cell v3_, cell v4_) { gc_root v1(v1_,this); gc_root v2(v2_,this); @@ -68,7 +68,7 @@ cell factorvm::allot_array_4(cell v1_, cell v2_, cell v3_, cell v4_) return a.value(); } -inline void factorvm::primitive_resize_array() +inline void factor_vm::primitive_resize_array() { array* a = untag_check(dpop()); cell capacity = unbox_array_size(); @@ -82,7 +82,7 @@ PRIMITIVE(resize_array) void growable_array::add(cell elt_) { - factorvm* myvm = elements.myvm; + factor_vm* myvm = elements.myvm; gc_root elt(elt_,myvm); if(count == array_capacity(elements.untagged())) elements = myvm->reallot_array(elements.untagged(),count * 2); @@ -92,7 +92,7 @@ void growable_array::add(cell elt_) void growable_array::trim() { - factorvm *myvm = elements.myvm; + factor_vm *myvm = elements.myvm; elements = myvm->reallot_array(elements.untagged(),count); } diff --git a/vm/bignum.cpp b/vm/bignum.cpp index 0099aecc8a..80bc58ce21 100755 --- a/vm/bignum.cpp +++ b/vm/bignum.cpp @@ -60,7 +60,7 @@ namespace factor /* Exports */ -int factorvm::bignum_equal_p(bignum * x, bignum * y) +int factor_vm::bignum_equal_p(bignum * x, bignum * y) { return ((BIGNUM_ZERO_P (x)) @@ -72,7 +72,7 @@ int factorvm::bignum_equal_p(bignum * x, bignum * y) && (bignum_equal_p_unsigned (x, y)))); } -enum bignum_comparison factorvm::bignum_compare(bignum * x, bignum * y) +enum bignum_comparison factor_vm::bignum_compare(bignum * x, bignum * y) { return ((BIGNUM_ZERO_P (x)) @@ -95,7 +95,7 @@ enum bignum_comparison factorvm::bignum_compare(bignum * x, bignum * y) } /* allocates memory */ -bignum *factorvm::bignum_add(bignum * x, bignum * y) +bignum *factor_vm::bignum_add(bignum * x, bignum * y) { return ((BIGNUM_ZERO_P (x)) @@ -112,7 +112,7 @@ bignum *factorvm::bignum_add(bignum * x, bignum * y) } /* allocates memory */ -bignum *factorvm::bignum_subtract(bignum * x, bignum * y) +bignum *factor_vm::bignum_subtract(bignum * x, bignum * y) { return ((BIGNUM_ZERO_P (x)) @@ -131,7 +131,7 @@ bignum *factorvm::bignum_subtract(bignum * x, bignum * y) } /* allocates memory */ -bignum *factorvm::bignum_multiply(bignum * x, bignum * y) +bignum *factor_vm::bignum_multiply(bignum * x, bignum * y) { bignum_length_type x_length = (BIGNUM_LENGTH (x)); bignum_length_type y_length = (BIGNUM_LENGTH (y)); @@ -163,7 +163,7 @@ bignum *factorvm::bignum_multiply(bignum * x, bignum * y) } /* allocates memory */ -void factorvm::bignum_divide(bignum * numerator, bignum * denominator, bignum * * quotient, bignum * * remainder) +void factor_vm::bignum_divide(bignum * numerator, bignum * denominator, bignum * * quotient, bignum * * remainder) { if (BIGNUM_ZERO_P (denominator)) { @@ -234,7 +234,7 @@ void factorvm::bignum_divide(bignum * numerator, bignum * denominator, bignum * } /* allocates memory */ -bignum *factorvm::bignum_quotient(bignum * numerator, bignum * denominator) +bignum *factor_vm::bignum_quotient(bignum * numerator, bignum * denominator) { if (BIGNUM_ZERO_P (denominator)) { @@ -286,7 +286,7 @@ bignum *factorvm::bignum_quotient(bignum * numerator, bignum * denominator) } /* allocates memory */ -bignum *factorvm::bignum_remainder(bignum * numerator, bignum * denominator) +bignum *factor_vm::bignum_remainder(bignum * numerator, bignum * denominator) { if (BIGNUM_ZERO_P (denominator)) { @@ -330,7 +330,7 @@ bignum *factorvm::bignum_remainder(bignum * numerator, bignum * denominator) } #define FOO_TO_BIGNUM(name,type,utype) \ -bignum * factorvm::name##_to_bignum(type n) \ +bignum * factor_vm::name##_to_bignum(type n) \ { \ int negative_p; \ bignum_digit_type result_digits [BIGNUM_DIGITS_FOR(type)]; \ @@ -365,8 +365,9 @@ FOO_TO_BIGNUM(fixnum,fixnum,cell) FOO_TO_BIGNUM(long_long,s64,u64) FOO_TO_BIGNUM(ulong_long,u64,u64) + #define BIGNUM_TO_FOO(name,type,utype) \ - type factorvm::bignum_to_##name(bignum * bignum) \ + type factor_vm::bignum_to_##name(bignum * bignum) \ { \ if (BIGNUM_ZERO_P (bignum)) \ return (0); \ @@ -386,7 +387,7 @@ BIGNUM_TO_FOO(fixnum,fixnum,cell); BIGNUM_TO_FOO(long_long,s64,u64) BIGNUM_TO_FOO(ulong_long,u64,u64) -double factorvm::bignum_to_double(bignum * bignum) +double factor_vm::bignum_to_double(bignum * bignum) { if (BIGNUM_ZERO_P (bignum)) return (0); @@ -411,7 +412,7 @@ double factorvm::bignum_to_double(bignum * bignum) /* allocates memory */ #define inf std::numeric_limits::infinity() -bignum *factorvm::double_to_bignum(double x) +bignum *factor_vm::double_to_bignum(double x) { if (x == inf || x == -inf || x != x) return (BIGNUM_ZERO ()); int exponent; @@ -446,7 +447,7 @@ bignum *factorvm::double_to_bignum(double x) /* Comparisons */ -int factorvm::bignum_equal_p_unsigned(bignum * x, bignum * y) +int factor_vm::bignum_equal_p_unsigned(bignum * x, bignum * y) { bignum_length_type length = (BIGNUM_LENGTH (x)); if (length != (BIGNUM_LENGTH (y))) @@ -463,7 +464,7 @@ int factorvm::bignum_equal_p_unsigned(bignum * x, bignum * y) } } -enum bignum_comparison factorvm::bignum_compare_unsigned(bignum * x, bignum * y) +enum bignum_comparison factor_vm::bignum_compare_unsigned(bignum * x, bignum * y) { bignum_length_type x_length = (BIGNUM_LENGTH (x)); bignum_length_type y_length = (BIGNUM_LENGTH (y)); @@ -491,7 +492,7 @@ enum bignum_comparison factorvm::bignum_compare_unsigned(bignum * x, bignum * y) /* Addition */ /* allocates memory */ -bignum *factorvm::bignum_add_unsigned(bignum * x, bignum * y, int negative_p) +bignum *factor_vm::bignum_add_unsigned(bignum * x, bignum * y, int negative_p) { GC_BIGNUM(x); GC_BIGNUM(y); @@ -558,7 +559,7 @@ bignum *factorvm::bignum_add_unsigned(bignum * x, bignum * y, int negative_p) /* Subtraction */ /* allocates memory */ -bignum *factorvm::bignum_subtract_unsigned(bignum * x, bignum * y) +bignum *factor_vm::bignum_subtract_unsigned(bignum * x, bignum * y) { GC_BIGNUM(x); GC_BIGNUM(y); @@ -636,7 +637,7 @@ bignum *factorvm::bignum_subtract_unsigned(bignum * x, bignum * y) where R == BIGNUM_RADIX_ROOT */ /* allocates memory */ -bignum *factorvm::bignum_multiply_unsigned(bignum * x, bignum * y, int negative_p) +bignum *factor_vm::bignum_multiply_unsigned(bignum * x, bignum * y, int negative_p) { GC_BIGNUM(x); GC_BIGNUM(y); @@ -707,7 +708,7 @@ bignum *factorvm::bignum_multiply_unsigned(bignum * x, bignum * y, int negative_ } /* allocates memory */ -bignum *factorvm::bignum_multiply_unsigned_small_factor(bignum * x, bignum_digit_type y, int negative_p) +bignum *factor_vm::bignum_multiply_unsigned_small_factor(bignum * x, bignum_digit_type y, int negative_p) { GC_BIGNUM(x); @@ -721,7 +722,7 @@ bignum *factorvm::bignum_multiply_unsigned_small_factor(bignum * x, bignum_digit return (bignum_trim (p)); } -void factorvm::bignum_destructive_add(bignum * bignum, bignum_digit_type n) +void factor_vm::bignum_destructive_add(bignum * bignum, bignum_digit_type n) { bignum_digit_type * scan = (BIGNUM_START_PTR (bignum)); bignum_digit_type digit; @@ -744,7 +745,7 @@ void factorvm::bignum_destructive_add(bignum * bignum, bignum_digit_type n) } } -void factorvm::bignum_destructive_scale_up(bignum * bignum, bignum_digit_type factor) +void factor_vm::bignum_destructive_scale_up(bignum * bignum, bignum_digit_type factor) { bignum_digit_type carry = 0; bignum_digit_type * scan = (BIGNUM_START_PTR (bignum)); @@ -781,7 +782,7 @@ void factorvm::bignum_destructive_scale_up(bignum * bignum, bignum_digit_type fa section 4.3.1, "Multiple-Precision Arithmetic". */ /* allocates memory */ -void factorvm::bignum_divide_unsigned_large_denominator(bignum * numerator, bignum * denominator, bignum * * quotient, bignum * * remainder, int q_negative_p, int r_negative_p) +void factor_vm::bignum_divide_unsigned_large_denominator(bignum * numerator, bignum * denominator, bignum * * quotient, bignum * * remainder, int q_negative_p, int r_negative_p) { GC_BIGNUM(numerator); GC_BIGNUM(denominator); @@ -838,7 +839,7 @@ void factorvm::bignum_divide_unsigned_large_denominator(bignum * numerator, bign return; } -void factorvm::bignum_divide_unsigned_normalized(bignum * u, bignum * v, bignum * q) +void factor_vm::bignum_divide_unsigned_normalized(bignum * u, bignum * v, bignum * q) { bignum_length_type u_length = (BIGNUM_LENGTH (u)); bignum_length_type v_length = (BIGNUM_LENGTH (v)); @@ -912,7 +913,7 @@ void factorvm::bignum_divide_unsigned_normalized(bignum * u, bignum * v, bignum #undef qj } -bignum_digit_type factorvm::bignum_divide_subtract(bignum_digit_type * v_start, bignum_digit_type * v_end, bignum_digit_type guess, bignum_digit_type * u_start) +bignum_digit_type factor_vm::bignum_divide_subtract(bignum_digit_type * v_start, bignum_digit_type * v_end, bignum_digit_type guess, bignum_digit_type * u_start) { bignum_digit_type * v_scan = v_start; bignum_digit_type * u_scan = u_start; @@ -988,7 +989,7 @@ bignum_digit_type factorvm::bignum_divide_subtract(bignum_digit_type * v_start, } /* allocates memory */ -void factorvm::bignum_divide_unsigned_medium_denominator(bignum * numerator,bignum_digit_type denominator, bignum * * quotient, bignum * * remainder,int q_negative_p, int r_negative_p) +void factor_vm::bignum_divide_unsigned_medium_denominator(bignum * numerator,bignum_digit_type denominator, bignum * * quotient, bignum * * remainder,int q_negative_p, int r_negative_p) { GC_BIGNUM(numerator); @@ -1046,7 +1047,7 @@ void factorvm::bignum_divide_unsigned_medium_denominator(bignum * numerator,bign return; } -void factorvm::bignum_destructive_normalization(bignum * source, bignum * target, int shift_left) +void factor_vm::bignum_destructive_normalization(bignum * source, bignum * target, int shift_left) { bignum_digit_type digit; bignum_digit_type * scan_source = (BIGNUM_START_PTR (source)); @@ -1069,7 +1070,7 @@ void factorvm::bignum_destructive_normalization(bignum * source, bignum * target return; } -void factorvm::bignum_destructive_unnormalization(bignum * bignum, int shift_right) +void factor_vm::bignum_destructive_unnormalization(bignum * bignum, int shift_right) { bignum_digit_type * start = (BIGNUM_START_PTR (bignum)); bignum_digit_type * scan = (start + (BIGNUM_LENGTH (bignum))); @@ -1115,7 +1116,7 @@ void factorvm::bignum_destructive_unnormalization(bignum * bignum, int shift_rig qn = (bignum_digit_divide_subtract (v1, v2, guess, (&u[j]))); \ } -bignum_digit_type factorvm::bignum_digit_divide(bignum_digit_type uh, bignum_digit_type ul, bignum_digit_type v, bignum_digit_type * q) /* return value */ +bignum_digit_type factor_vm::bignum_digit_divide(bignum_digit_type uh, bignum_digit_type ul, bignum_digit_type v, bignum_digit_type * q) /* return value */ { bignum_digit_type guess; bignum_digit_type comparand; @@ -1184,7 +1185,7 @@ bignum_digit_type factorvm::bignum_digit_divide(bignum_digit_type uh, bignum_dig } \ } -bignum_digit_type factorvm::bignum_digit_divide_subtract(bignum_digit_type v1, bignum_digit_type v2, bignum_digit_type guess, bignum_digit_type * u) +bignum_digit_type factor_vm::bignum_digit_divide_subtract(bignum_digit_type v1, bignum_digit_type v2, bignum_digit_type guess, bignum_digit_type * u) { { bignum_digit_type product; @@ -1218,7 +1219,7 @@ bignum_digit_type factorvm::bignum_digit_divide_subtract(bignum_digit_type v1, b #undef BDDS_ADD /* allocates memory */ -void factorvm::bignum_divide_unsigned_small_denominator(bignum * numerator, bignum_digit_type denominator, bignum * * quotient, bignum * * remainder,int q_negative_p, int r_negative_p) +void factor_vm::bignum_divide_unsigned_small_denominator(bignum * numerator, bignum_digit_type denominator, bignum * * quotient, bignum * * remainder,int q_negative_p, int r_negative_p) { GC_BIGNUM(numerator); @@ -1241,7 +1242,7 @@ void factorvm::bignum_divide_unsigned_small_denominator(bignum * numerator, bign (quotient_high < BIGNUM_RADIX_ROOT), after which it is easy to see that all digits are < BIGNUM_RADIX. */ -bignum_digit_type factorvm::bignum_destructive_scale_down(bignum * bignum, bignum_digit_type denominator) +bignum_digit_type factor_vm::bignum_destructive_scale_down(bignum * bignum, bignum_digit_type denominator) { bignum_digit_type numerator; bignum_digit_type remainder = 0; @@ -1264,7 +1265,7 @@ bignum_digit_type factorvm::bignum_destructive_scale_down(bignum * bignum, bignu } /* allocates memory */ -bignum * factorvm::bignum_remainder_unsigned_small_denominator(bignum * n, bignum_digit_type d, int negative_p) +bignum * factor_vm::bignum_remainder_unsigned_small_denominator(bignum * n, bignum_digit_type d, int negative_p) { bignum_digit_type two_digits; bignum_digit_type * start = (BIGNUM_START_PTR (n)); @@ -1283,7 +1284,7 @@ bignum * factorvm::bignum_remainder_unsigned_small_denominator(bignum * n, bignu } /* allocates memory */ -bignum *factorvm::bignum_digit_to_bignum(bignum_digit_type digit, int negative_p) +bignum *factor_vm::bignum_digit_to_bignum(bignum_digit_type digit, int negative_p) { if (digit == 0) return (BIGNUM_ZERO ()); @@ -1296,7 +1297,7 @@ bignum *factorvm::bignum_digit_to_bignum(bignum_digit_type digit, int negative_p } /* allocates memory */ -bignum *factorvm::allot_bignum(bignum_length_type length, int negative_p) +bignum *factor_vm::allot_bignum(bignum_length_type length, int negative_p) { BIGNUM_ASSERT ((length >= 0) || (length < BIGNUM_RADIX)); bignum * result = allot_array_internal(length + 1); @@ -1305,7 +1306,7 @@ bignum *factorvm::allot_bignum(bignum_length_type length, int negative_p) } /* allocates memory */ -bignum * factorvm::allot_bignum_zeroed(bignum_length_type length, int negative_p) +bignum * factor_vm::allot_bignum_zeroed(bignum_length_type length, int negative_p) { bignum * result = allot_bignum(length,negative_p); bignum_digit_type * scan = (BIGNUM_START_PTR (result)); @@ -1319,7 +1320,7 @@ bignum * factorvm::allot_bignum_zeroed(bignum_length_type length, int negative_p source = reallot_array(source,length + 1) /* allocates memory */ -bignum *factorvm::bignum_shorten_length(bignum * bignum, bignum_length_type length) +bignum *factor_vm::bignum_shorten_length(bignum * bignum, bignum_length_type length) { bignum_length_type current_length = (BIGNUM_LENGTH (bignum)); BIGNUM_ASSERT ((length >= 0) || (length <= current_length)); @@ -1332,7 +1333,7 @@ bignum *factorvm::bignum_shorten_length(bignum * bignum, bignum_length_type leng } /* allocates memory */ -bignum *factorvm::bignum_trim(bignum * bignum) +bignum *factor_vm::bignum_trim(bignum * bignum) { bignum_digit_type * start = (BIGNUM_START_PTR (bignum)); bignum_digit_type * end = (start + (BIGNUM_LENGTH (bignum))); @@ -1352,7 +1353,7 @@ bignum *factorvm::bignum_trim(bignum * bignum) /* Copying */ /* allocates memory */ -bignum *factorvm::bignum_new_sign(bignum * x, int negative_p) +bignum *factor_vm::bignum_new_sign(bignum * x, int negative_p) { GC_BIGNUM(x); bignum * result = (allot_bignum ((BIGNUM_LENGTH (x)), negative_p)); @@ -1362,7 +1363,7 @@ bignum *factorvm::bignum_new_sign(bignum * x, int negative_p) } /* allocates memory */ -bignum *factorvm::bignum_maybe_new_sign(bignum * x, int negative_p) +bignum *factor_vm::bignum_maybe_new_sign(bignum * x, int negative_p) { if ((BIGNUM_NEGATIVE_P (x)) ? negative_p : (! negative_p)) return (x); @@ -1375,7 +1376,7 @@ bignum *factorvm::bignum_maybe_new_sign(bignum * x, int negative_p) } } -void factorvm::bignum_destructive_copy(bignum * source, bignum * target) +void factor_vm::bignum_destructive_copy(bignum * source, bignum * target) { bignum_digit_type * scan_source = (BIGNUM_START_PTR (source)); bignum_digit_type * end_source = @@ -1391,13 +1392,13 @@ void factorvm::bignum_destructive_copy(bignum * source, bignum * target) */ /* allocates memory */ -bignum *factorvm::bignum_bitwise_not(bignum * x) +bignum *factor_vm::bignum_bitwise_not(bignum * x) { return bignum_subtract(BIGNUM_ONE(1), x); } /* allocates memory */ -bignum *factorvm::bignum_arithmetic_shift(bignum * arg1, fixnum n) +bignum *factor_vm::bignum_arithmetic_shift(bignum * arg1, fixnum n) { if (BIGNUM_NEGATIVE_P(arg1) && n < 0) return bignum_bitwise_not(bignum_magnitude_ash(bignum_bitwise_not(arg1), n)); @@ -1410,7 +1411,7 @@ bignum *factorvm::bignum_arithmetic_shift(bignum * arg1, fixnum n) #define XOR_OP 2 /* allocates memory */ -bignum *factorvm::bignum_bitwise_and(bignum * arg1, bignum * arg2) +bignum *factor_vm::bignum_bitwise_and(bignum * arg1, bignum * arg2) { return( (BIGNUM_NEGATIVE_P (arg1)) @@ -1424,7 +1425,7 @@ bignum *factorvm::bignum_bitwise_and(bignum * arg1, bignum * arg2) } /* allocates memory */ -bignum *factorvm::bignum_bitwise_ior(bignum * arg1, bignum * arg2) +bignum *factor_vm::bignum_bitwise_ior(bignum * arg1, bignum * arg2) { return( (BIGNUM_NEGATIVE_P (arg1)) @@ -1438,7 +1439,7 @@ bignum *factorvm::bignum_bitwise_ior(bignum * arg1, bignum * arg2) } /* allocates memory */ -bignum *factorvm::bignum_bitwise_xor(bignum * arg1, bignum * arg2) +bignum *factor_vm::bignum_bitwise_xor(bignum * arg1, bignum * arg2) { return( (BIGNUM_NEGATIVE_P (arg1)) @@ -1454,7 +1455,7 @@ bignum *factorvm::bignum_bitwise_xor(bignum * arg1, bignum * arg2) /* allocates memory */ /* ash for the magnitude */ /* assume arg1 is a big number, n is a long */ -bignum *factorvm::bignum_magnitude_ash(bignum * arg1, fixnum n) +bignum *factor_vm::bignum_magnitude_ash(bignum * arg1, fixnum n) { GC_BIGNUM(arg1); @@ -1515,7 +1516,7 @@ bignum *factorvm::bignum_magnitude_ash(bignum * arg1, fixnum n) } /* allocates memory */ -bignum *factorvm::bignum_pospos_bitwise_op(int op, bignum * arg1, bignum * arg2) +bignum *factor_vm::bignum_pospos_bitwise_op(int op, bignum * arg1, bignum * arg2) { GC_BIGNUM(arg1); GC_BIGNUM(arg2); @@ -1549,7 +1550,7 @@ bignum *factorvm::bignum_pospos_bitwise_op(int op, bignum * arg1, bignum * arg2) } /* allocates memory */ -bignum *factorvm::bignum_posneg_bitwise_op(int op, bignum * arg1, bignum * arg2) +bignum *factor_vm::bignum_posneg_bitwise_op(int op, bignum * arg1, bignum * arg2) { GC_BIGNUM(arg1); GC_BIGNUM(arg2); @@ -1601,7 +1602,7 @@ bignum *factorvm::bignum_posneg_bitwise_op(int op, bignum * arg1, bignum * arg2) } /* allocates memory */ -bignum *factorvm::bignum_negneg_bitwise_op(int op, bignum * arg1, bignum * arg2) +bignum *factor_vm::bignum_negneg_bitwise_op(int op, bignum * arg1, bignum * arg2) { GC_BIGNUM(arg1); GC_BIGNUM(arg2); @@ -1660,7 +1661,7 @@ bignum *factorvm::bignum_negneg_bitwise_op(int op, bignum * arg1, bignum * arg2) return bignum_trim(result); } -void factorvm::bignum_negate_magnitude(bignum * arg) +void factor_vm::bignum_negate_magnitude(bignum * arg) { bignum_digit_type *scan; bignum_digit_type *end; @@ -1688,7 +1689,7 @@ void factorvm::bignum_negate_magnitude(bignum * arg) } /* Allocates memory */ -bignum *factorvm::bignum_integer_length(bignum * x) +bignum *factor_vm::bignum_integer_length(bignum * x) { GC_BIGNUM(x); @@ -1709,14 +1710,14 @@ bignum *factorvm::bignum_integer_length(bignum * x) } /* Allocates memory */ -int factorvm::bignum_logbitp(int shift, bignum * arg) +int factor_vm::bignum_logbitp(int shift, bignum * arg) { return((BIGNUM_NEGATIVE_P (arg)) ? !bignum_unsigned_logbitp (shift, bignum_bitwise_not (arg)) : bignum_unsigned_logbitp (shift,arg)); } -int factorvm::bignum_unsigned_logbitp(int shift, bignum * bignum) +int factor_vm::bignum_unsigned_logbitp(int shift, bignum * bignum) { bignum_length_type len = (BIGNUM_LENGTH (bignum)); int index = shift / BIGNUM_DIGIT_LENGTH; @@ -1729,7 +1730,7 @@ int factorvm::bignum_unsigned_logbitp(int shift, bignum * bignum) } /* Allocates memory */ -bignum *factorvm::digit_stream_to_bignum(unsigned int n_digits, unsigned int (*producer)(unsigned int, factorvm*), unsigned int radix, int negative_p) +bignum *factor_vm::digit_stream_to_bignum(unsigned int n_digits, unsigned int (*producer)(unsigned int, factor_vm*), unsigned int radix, int negative_p) { BIGNUM_ASSERT ((radix > 1) && (radix <= BIGNUM_RADIX_ROOT)); if (n_digits == 0) diff --git a/vm/bignum.hpp b/vm/bignum.hpp index ca04be3765..7d230c3897 100644 --- a/vm/bignum.hpp +++ b/vm/bignum.hpp @@ -44,7 +44,7 @@ enum bignum_comparison bignum_comparison_greater = 1 }; -struct factorvm; -bignum * digit_stream_to_bignum(unsigned int n_digits, unsigned int (*producer)(unsigned int,factorvm*), unsigned int radix, int negative_p); +struct factor_vm; +bignum * digit_stream_to_bignum(unsigned int n_digits, unsigned int (*producer)(unsigned int,factor_vm*), unsigned int radix, int negative_p); } diff --git a/vm/booleans.cpp b/vm/booleans.cpp index aa3f392b3e..5e3cb03822 100644 --- a/vm/booleans.cpp +++ b/vm/booleans.cpp @@ -3,23 +3,23 @@ namespace factor { -void factorvm::box_boolean(bool value) +void factor_vm::box_boolean(bool value) { dpush(value ? T : F); } -VM_C_API void box_boolean(bool value, factorvm *myvm) +VM_C_API void box_boolean(bool value, factor_vm *myvm) { ASSERTVM(); return VM_PTR->box_boolean(value); } -bool factorvm::to_boolean(cell value) +bool factor_vm::to_boolean(cell value) { return value != F; } -VM_C_API bool to_boolean(cell value, factorvm *myvm) +VM_C_API bool to_boolean(cell value, factor_vm *myvm) { ASSERTVM(); return VM_PTR->to_boolean(value); diff --git a/vm/booleans.hpp b/vm/booleans.hpp index fb3991fc21..88235122a3 100644 --- a/vm/booleans.hpp +++ b/vm/booleans.hpp @@ -1,7 +1,7 @@ namespace factor { -VM_C_API void box_boolean(bool value, factorvm *vm); -VM_C_API bool to_boolean(cell value, factorvm *vm); +VM_C_API void box_boolean(bool value, factor_vm *vm); +VM_C_API bool to_boolean(cell value, factor_vm *vm); } diff --git a/vm/byte_arrays.cpp b/vm/byte_arrays.cpp index 5a1744b374..82474e18c2 100644 --- a/vm/byte_arrays.cpp +++ b/vm/byte_arrays.cpp @@ -3,14 +3,14 @@ namespace factor { -byte_array *factorvm::allot_byte_array(cell size) +byte_array *factor_vm::allot_byte_array(cell size) { byte_array *array = allot_array_internal(size); memset(array + 1,0,size); return array; } -inline void factorvm::primitive_byte_array() +inline void factor_vm::primitive_byte_array() { cell size = unbox_array_size(); dpush(tag(allot_byte_array(size))); @@ -21,7 +21,7 @@ PRIMITIVE(byte_array) PRIMITIVE_GETVM()->primitive_byte_array(); } -inline void factorvm::primitive_uninitialized_byte_array() +inline void factor_vm::primitive_uninitialized_byte_array() { cell size = unbox_array_size(); dpush(tag(allot_array_internal(size))); @@ -32,7 +32,7 @@ PRIMITIVE(uninitialized_byte_array) PRIMITIVE_GETVM()->primitive_uninitialized_byte_array(); } -inline void factorvm::primitive_resize_byte_array() +inline void factor_vm::primitive_resize_byte_array() { byte_array *array = untag_check(dpop()); cell capacity = unbox_array_size(); @@ -47,7 +47,7 @@ PRIMITIVE(resize_byte_array) void growable_byte_array::append_bytes(void *elts, cell len) { cell new_size = count + len; - factorvm *myvm = elements.myvm; + factor_vm *myvm = elements.myvm; if(new_size >= array_capacity(elements.untagged())) elements = myvm->reallot_array(elements.untagged(),new_size * 2); @@ -62,7 +62,7 @@ void growable_byte_array::append_byte_array(cell byte_array_) cell len = array_capacity(byte_array.untagged()); cell new_size = count + len; - factorvm *myvm = elements.myvm; + factor_vm *myvm = elements.myvm; if(new_size >= array_capacity(elements.untagged())) elements = myvm->reallot_array(elements.untagged(),new_size * 2); @@ -73,7 +73,7 @@ void growable_byte_array::append_byte_array(cell byte_array_) void growable_byte_array::trim() { - factorvm *myvm = elements.myvm; + factor_vm *myvm = elements.myvm; elements = myvm->reallot_array(elements.untagged(),count); } diff --git a/vm/callstack.cpp b/vm/callstack.cpp index 1358ac59ea..445ebf88ee 100755 --- a/vm/callstack.cpp +++ b/vm/callstack.cpp @@ -3,7 +3,7 @@ namespace factor { -void factorvm::check_frame(stack_frame *frame) +void factor_vm::check_frame(stack_frame *frame) { #ifdef FACTOR_DEBUG check_code_pointer((cell)frame->xt); @@ -11,14 +11,14 @@ void factorvm::check_frame(stack_frame *frame) #endif } -callstack *factorvm::allot_callstack(cell size) +callstack *factor_vm::allot_callstack(cell size) { callstack *stack = allot(callstack_size(size)); stack->length = tag_fixnum(size); return stack; } -stack_frame *factorvm::fix_callstack_top(stack_frame *top, stack_frame *bottom) +stack_frame *factor_vm::fix_callstack_top(stack_frame *top, stack_frame *bottom) { stack_frame *frame = bottom - 1; @@ -35,7 +35,7 @@ This means that if 'callstack' is called in tail position, we will have popped a necessary frame... however this word is only called by continuation implementation, and user code shouldn't be calling it at all, so we leave it as it is for now. */ -stack_frame *factorvm::capture_start() +stack_frame *factor_vm::capture_start() { stack_frame *frame = stack_chain->callstack_bottom - 1; while(frame >= stack_chain->callstack_top @@ -46,7 +46,7 @@ stack_frame *factorvm::capture_start() return frame + 1; } -inline void factorvm::primitive_callstack() +inline void factor_vm::primitive_callstack() { stack_frame *top = capture_start(); stack_frame *bottom = stack_chain->callstack_bottom; @@ -65,7 +65,7 @@ PRIMITIVE(callstack) PRIMITIVE_GETVM()->primitive_callstack(); } -inline void factorvm::primitive_set_callstack() +inline void factor_vm::primitive_set_callstack() { callstack *stack = untag_check(dpop()); @@ -83,18 +83,18 @@ PRIMITIVE(set_callstack) PRIMITIVE_GETVM()->primitive_set_callstack(); } -code_block *factorvm::frame_code(stack_frame *frame) +code_block *factor_vm::frame_code(stack_frame *frame) { check_frame(frame); return (code_block *)frame->xt - 1; } -cell factorvm::frame_type(stack_frame *frame) +cell factor_vm::frame_type(stack_frame *frame) { return frame_code(frame)->type; } -cell factorvm::frame_executing(stack_frame *frame) +cell factor_vm::frame_executing(stack_frame *frame) { code_block *compiled = frame_code(frame); if(compiled->literals == F || !stack_traces_p()) @@ -108,14 +108,14 @@ cell factorvm::frame_executing(stack_frame *frame) } } -stack_frame *factorvm::frame_successor(stack_frame *frame) +stack_frame *factor_vm::frame_successor(stack_frame *frame) { check_frame(frame); return (stack_frame *)((cell)frame - frame->size); } /* Allocates memory */ -cell factorvm::frame_scan(stack_frame *frame) +cell factor_vm::frame_scan(stack_frame *frame) { switch(frame_type(frame)) { @@ -147,9 +147,9 @@ namespace struct stack_frame_accumulator { growable_array frames; - stack_frame_accumulator(factorvm *vm) : frames(vm) {} + stack_frame_accumulator(factor_vm *vm) : frames(vm) {} - void operator()(stack_frame *frame, factorvm *myvm) + void operator()(stack_frame *frame, factor_vm *myvm) { gc_root executing(myvm->frame_executing(frame),myvm); gc_root scan(myvm->frame_scan(frame),myvm); @@ -161,7 +161,7 @@ struct stack_frame_accumulator { } -inline void factorvm::primitive_callstack_to_array() +inline void factor_vm::primitive_callstack_to_array() { gc_root callstack(dpop(),this); @@ -177,7 +177,7 @@ PRIMITIVE(callstack_to_array) PRIMITIVE_GETVM()->primitive_callstack_to_array(); } -stack_frame *factorvm::innermost_stack_frame(callstack *stack) +stack_frame *factor_vm::innermost_stack_frame(callstack *stack) { stack_frame *top = stack->top(); stack_frame *bottom = stack->bottom(); @@ -189,7 +189,7 @@ stack_frame *factorvm::innermost_stack_frame(callstack *stack) return frame; } -stack_frame *factorvm::innermost_stack_frame_quot(callstack *callstack) +stack_frame *factor_vm::innermost_stack_frame_quot(callstack *callstack) { stack_frame *inner = innermost_stack_frame(callstack); tagged(frame_executing(inner)).untag_check(this); @@ -198,7 +198,7 @@ stack_frame *factorvm::innermost_stack_frame_quot(callstack *callstack) /* Some primitives implementing a limited form of callstack mutation. Used by the single stepper. */ -inline void factorvm::primitive_innermost_stack_frame_executing() +inline void factor_vm::primitive_innermost_stack_frame_executing() { dpush(frame_executing(innermost_stack_frame(untag_check(dpop())))); } @@ -208,7 +208,7 @@ PRIMITIVE(innermost_stack_frame_executing) PRIMITIVE_GETVM()->primitive_innermost_stack_frame_executing(); } -inline void factorvm::primitive_innermost_stack_frame_scan() +inline void factor_vm::primitive_innermost_stack_frame_scan() { dpush(frame_scan(innermost_stack_frame_quot(untag_check(dpop())))); } @@ -218,7 +218,7 @@ PRIMITIVE(innermost_stack_frame_scan) PRIMITIVE_GETVM()->primitive_innermost_stack_frame_scan(); } -inline void factorvm::primitive_set_innermost_stack_frame_quot() +inline void factor_vm::primitive_set_innermost_stack_frame_quot() { gc_root callstack(dpop(),this); gc_root quot(dpop(),this); @@ -240,12 +240,12 @@ PRIMITIVE(set_innermost_stack_frame_quot) } /* called before entry into Factor code. */ -void factorvm::save_callstack_bottom(stack_frame *callstack_bottom) +void factor_vm::save_callstack_bottom(stack_frame *callstack_bottom) { stack_chain->callstack_bottom = callstack_bottom; } -VM_ASM_API void save_callstack_bottom(stack_frame *callstack_bottom, factorvm *myvm) +VM_ASM_API void save_callstack_bottom(stack_frame *callstack_bottom, factor_vm *myvm) { ASSERTVM(); return VM_PTR->save_callstack_bottom(callstack_bottom); diff --git a/vm/callstack.hpp b/vm/callstack.hpp index 0a6e8ff936..ae1e80ca9a 100755 --- a/vm/callstack.hpp +++ b/vm/callstack.hpp @@ -13,7 +13,7 @@ PRIMITIVE(innermost_stack_frame_executing); PRIMITIVE(innermost_stack_frame_scan); PRIMITIVE(set_innermost_stack_frame_quot); -VM_ASM_API void save_callstack_bottom(stack_frame *callstack_bottom,factorvm *vm); +VM_ASM_API void save_callstack_bottom(stack_frame *callstack_bottom,factor_vm *vm); } diff --git a/vm/code_block.cpp b/vm/code_block.cpp index c007ace39b..2251345af7 100755 --- a/vm/code_block.cpp +++ b/vm/code_block.cpp @@ -3,27 +3,27 @@ namespace factor { -relocation_type factorvm::relocation_type_of(relocation_entry r) +relocation_type factor_vm::relocation_type_of(relocation_entry r) { return (relocation_type)((r & 0xf0000000) >> 28); } -relocation_class factorvm::relocation_class_of(relocation_entry r) +relocation_class factor_vm::relocation_class_of(relocation_entry r) { return (relocation_class)((r & 0x0f000000) >> 24); } -cell factorvm::relocation_offset_of(relocation_entry r) +cell factor_vm::relocation_offset_of(relocation_entry r) { return (r & 0x00ffffff); } -void factorvm::flush_icache_for(code_block *block) +void factor_vm::flush_icache_for(code_block *block) { flush_icache((cell)block,block->size); } -int factorvm::number_of_parameters(relocation_type type) +int factor_vm::number_of_parameters(relocation_type type) { switch(type) { @@ -48,7 +48,7 @@ int factorvm::number_of_parameters(relocation_type type) } } -void *factorvm::object_xt(cell obj) +void *factor_vm::object_xt(cell obj) { switch(tagged(obj).type()) { @@ -62,7 +62,7 @@ void *factorvm::object_xt(cell obj) } } -void *factorvm::xt_pic(word *w, cell tagged_quot) +void *factor_vm::xt_pic(word *w, cell tagged_quot) { if(tagged_quot == F || max_pic_size == 0) return w->xt; @@ -76,30 +76,30 @@ void *factorvm::xt_pic(word *w, cell tagged_quot) } } -void *factorvm::word_xt_pic(word *w) +void *factor_vm::word_xt_pic(word *w) { return xt_pic(w,w->pic_def); } -void *factorvm::word_xt_pic_tail(word *w) +void *factor_vm::word_xt_pic_tail(word *w) { return xt_pic(w,w->pic_tail_def); } /* References to undefined symbols are patched up to call this function on image load */ -void factorvm::undefined_symbol() +void factor_vm::undefined_symbol() { general_error(ERROR_UNDEFINED_SYMBOL,F,F,NULL); } -void undefined_symbol(factorvm *myvm) +void undefined_symbol(factor_vm *myvm) { return myvm->undefined_symbol(); } /* Look up an external library symbol referenced by a compiled code block */ -void *factorvm::get_rel_symbol(array *literals, cell index) +void *factor_vm::get_rel_symbol(array *literals, cell index) { cell symbol = array_nth(literals,index); cell library = array_nth(literals,index + 1); @@ -143,7 +143,7 @@ void *factorvm::get_rel_symbol(array *literals, cell index) } } -cell factorvm::compute_relocation(relocation_entry rel, cell index, code_block *compiled) +cell factor_vm::compute_relocation(relocation_entry rel, cell index, code_block *compiled) { array *literals = untag(compiled->literals); cell offset = relocation_offset_of(rel) + (cell)compiled->xt(); @@ -187,7 +187,7 @@ cell factorvm::compute_relocation(relocation_entry rel, cell index, code_block * #undef ARG } -void factorvm::iterate_relocations(code_block *compiled, relocation_iterator iter) +void factor_vm::iterate_relocations(code_block *compiled, relocation_iterator iter) { if(compiled->relocation != F) { @@ -206,14 +206,14 @@ void factorvm::iterate_relocations(code_block *compiled, relocation_iterator ite } /* Store a 32-bit value into a PowerPC LIS/ORI sequence */ -void factorvm::store_address_2_2(cell *ptr, cell value) +void factor_vm::store_address_2_2(cell *ptr, cell value) { ptr[-1] = ((ptr[-1] & ~0xffff) | ((value >> 16) & 0xffff)); ptr[ 0] = ((ptr[ 0] & ~0xffff) | (value & 0xffff)); } /* Store a value into a bitfield of a PowerPC instruction */ -void factorvm::store_address_masked(cell *ptr, fixnum value, cell mask, fixnum shift) +void factor_vm::store_address_masked(cell *ptr, fixnum value, cell mask, fixnum shift) { /* This is unaccurate but good enough */ fixnum test = (fixnum)mask >> 1; @@ -224,7 +224,7 @@ void factorvm::store_address_masked(cell *ptr, fixnum value, cell mask, fixnum s } /* Perform a fixup on a code block */ -void factorvm::store_address_in_code_block(cell klass, cell offset, fixnum absolute_value) +void factor_vm::store_address_in_code_block(cell klass, cell offset, fixnum absolute_value) { fixnum relative_value = absolute_value - offset; @@ -269,7 +269,7 @@ void factorvm::store_address_in_code_block(cell klass, cell offset, fixnum absol } } -void factorvm::update_literal_references_step(relocation_entry rel, cell index, code_block *compiled) +void factor_vm::update_literal_references_step(relocation_entry rel, cell index, code_block *compiled) { if(relocation_type_of(rel) == RT_IMMEDIATE) { @@ -280,13 +280,13 @@ void factorvm::update_literal_references_step(relocation_entry rel, cell index, } } -void update_literal_references_step(relocation_entry rel, cell index, code_block *compiled, factorvm *myvm) +void update_literal_references_step(relocation_entry rel, cell index, code_block *compiled, factor_vm *myvm) { return myvm->update_literal_references_step(rel,index,compiled); } /* Update pointers to literals from compiled code. */ -void factorvm::update_literal_references(code_block *compiled) +void factor_vm::update_literal_references(code_block *compiled) { if(!compiled->needs_fixup) { @@ -297,7 +297,7 @@ void factorvm::update_literal_references(code_block *compiled) /* Copy all literals referenced from a code block to newspace. Only for aging and nursery collections */ -void factorvm::copy_literal_references(code_block *compiled) +void factor_vm::copy_literal_references(code_block *compiled) { if(collecting_gen >= compiled->last_scan) { @@ -320,13 +320,13 @@ void factorvm::copy_literal_references(code_block *compiled) } } -void copy_literal_references(code_block *compiled, factorvm *myvm) +void copy_literal_references(code_block *compiled, factor_vm *myvm) { return myvm->copy_literal_references(compiled); } /* Compute an address to store at a relocation */ -void factorvm::relocate_code_block_step(relocation_entry rel, cell index, code_block *compiled) +void factor_vm::relocate_code_block_step(relocation_entry rel, cell index, code_block *compiled) { #ifdef FACTOR_DEBUG tagged(compiled->literals).untag_check(this); @@ -338,19 +338,19 @@ void factorvm::relocate_code_block_step(relocation_entry rel, cell index, code_b compute_relocation(rel,index,compiled)); } -void relocate_code_block_step(relocation_entry rel, cell index, code_block *compiled, factorvm *myvm) +void relocate_code_block_step(relocation_entry rel, cell index, code_block *compiled, factor_vm *myvm) { return myvm->relocate_code_block_step(rel,index,compiled); } -void factorvm::update_word_references_step(relocation_entry rel, cell index, code_block *compiled) +void factor_vm::update_word_references_step(relocation_entry rel, cell index, code_block *compiled) { relocation_type type = relocation_type_of(rel); if(type == RT_XT || type == RT_XT_PIC || type == RT_XT_PIC_TAIL) relocate_code_block_step(rel,index,compiled); } -void update_word_references_step(relocation_entry rel, cell index, code_block *compiled, factorvm *myvm) +void update_word_references_step(relocation_entry rel, cell index, code_block *compiled, factor_vm *myvm) { return myvm->update_word_references_step(rel,index,compiled); } @@ -359,7 +359,7 @@ void update_word_references_step(relocation_entry rel, cell index, code_block *c dlsyms, and words. For all other words in the code heap, we only need to update references to other words, without worrying about literals or dlsyms. */ -void factorvm::update_word_references(code_block *compiled) +void factor_vm::update_word_references(code_block *compiled) { if(compiled->needs_fixup) relocate_code_block(compiled); @@ -379,23 +379,23 @@ void factorvm::update_word_references(code_block *compiled) } } -void update_word_references(code_block *compiled, factorvm *myvm) +void update_word_references(code_block *compiled, factor_vm *myvm) { return myvm->update_word_references(compiled); } -void factorvm::update_literal_and_word_references(code_block *compiled) +void factor_vm::update_literal_and_word_references(code_block *compiled) { update_literal_references(compiled); update_word_references(compiled); } -void update_literal_and_word_references(code_block *compiled, factorvm *myvm) +void update_literal_and_word_references(code_block *compiled, factor_vm *myvm) { return myvm->update_literal_and_word_references(compiled); } -void factorvm::check_code_address(cell address) +void factor_vm::check_code_address(cell address) { #ifdef FACTOR_DEBUG assert(address >= code.seg->start && address < code.seg->end); @@ -407,7 +407,7 @@ is added to the heap. */ /* Mark all literals referenced from a word XT. Only for tenured collections */ -void factorvm::mark_code_block(code_block *compiled) +void factor_vm::mark_code_block(code_block *compiled) { check_code_address((cell)compiled); @@ -417,18 +417,18 @@ void factorvm::mark_code_block(code_block *compiled) copy_handle(&compiled->relocation); } -void factorvm::mark_stack_frame_step(stack_frame *frame) +void factor_vm::mark_stack_frame_step(stack_frame *frame) { mark_code_block(frame_code(frame)); } -void mark_stack_frame_step(stack_frame *frame, factorvm *myvm) +void mark_stack_frame_step(stack_frame *frame, factor_vm *myvm) { return myvm->mark_stack_frame_step(frame); } /* Mark code blocks executing in currently active stack frames. */ -void factorvm::mark_active_blocks(context *stacks) +void factor_vm::mark_active_blocks(context *stacks) { if(collecting_gen == data->tenured()) { @@ -439,7 +439,7 @@ void factorvm::mark_active_blocks(context *stacks) } } -void factorvm::mark_object_code_block(object *object) +void factor_vm::mark_object_code_block(object *object) { switch(object->h.hi_tag()) { @@ -469,7 +469,7 @@ void factorvm::mark_object_code_block(object *object) } /* Perform all fixups on a code block */ -void factorvm::relocate_code_block(code_block *compiled) +void factor_vm::relocate_code_block(code_block *compiled) { compiled->last_scan = data->nursery(); compiled->needs_fixup = false; @@ -477,13 +477,13 @@ void factorvm::relocate_code_block(code_block *compiled) flush_icache_for(compiled); } -void relocate_code_block(code_block *compiled, factorvm *myvm) +void relocate_code_block(code_block *compiled, factor_vm *myvm) { return myvm->relocate_code_block(compiled); } /* Fixup labels. This is done at compile time, not image load time */ -void factorvm::fixup_labels(array *labels, code_block *compiled) +void factor_vm::fixup_labels(array *labels, code_block *compiled) { cell i; cell size = array_capacity(labels); @@ -501,7 +501,7 @@ void factorvm::fixup_labels(array *labels, code_block *compiled) } /* Might GC */ -code_block *factorvm::allot_code_block(cell size) +code_block *factor_vm::allot_code_block(cell size) { heap_block *block = heap_allot(&code,size + sizeof(code_block)); @@ -529,7 +529,7 @@ code_block *factorvm::allot_code_block(cell size) } /* Might GC */ -code_block *factorvm::add_code_block(cell type, cell code_, cell labels_, cell relocation_, cell literals_) +code_block *factor_vm::add_code_block(cell type, cell code_, cell labels_, cell relocation_, cell literals_) { gc_root code(code_,this); gc_root labels(labels_,this); diff --git a/vm/code_block.hpp b/vm/code_block.hpp index 60d1a127cd..0a7e0e9cc8 100644 --- a/vm/code_block.hpp +++ b/vm/code_block.hpp @@ -62,14 +62,14 @@ static const cell rel_relative_arm_3_mask = 0xffffff; /* code relocation table consists of a table of entries for each fixup */ typedef u32 relocation_entry; -struct factorvm; +struct factor_vm; -typedef void (*relocation_iterator)(relocation_entry rel, cell index, code_block *compiled, factorvm *vm); +typedef void (*relocation_iterator)(relocation_entry rel, cell index, code_block *compiled, factor_vm *vm); // callback functions -void relocate_code_block(code_block *compiled, factorvm *myvm); -void copy_literal_references(code_block *compiled, factorvm *myvm); -void update_word_references(code_block *compiled, factorvm *myvm); -void update_literal_and_word_references(code_block *compiled, factorvm *myvm); +void relocate_code_block(code_block *compiled, factor_vm *myvm); +void copy_literal_references(code_block *compiled, factor_vm *myvm); +void update_word_references(code_block *compiled, factor_vm *myvm); +void update_literal_and_word_references(code_block *compiled, factor_vm *myvm); } diff --git a/vm/code_gc.cpp b/vm/code_gc.cpp index 45330dfbee..1c372368dd 100755 --- a/vm/code_gc.cpp +++ b/vm/code_gc.cpp @@ -3,7 +3,7 @@ namespace factor { -void factorvm::clear_free_list(heap *heap) +void factor_vm::clear_free_list(heap *heap) { memset(&heap->free,0,sizeof(heap_free_list)); } @@ -11,7 +11,7 @@ void factorvm::clear_free_list(heap *heap) /* This malloc-style heap code is reasonably generic. Maybe in the future, it will be used for the data heap too, if we ever get incremental mark/sweep/compact GC. */ -void factorvm::new_heap(heap *heap, cell size) +void factor_vm::new_heap(heap *heap, cell size) { heap->seg = alloc_segment(align_page(size)); if(!heap->seg) @@ -20,7 +20,7 @@ void factorvm::new_heap(heap *heap, cell size) clear_free_list(heap); } -void factorvm::add_to_free_list(heap *heap, free_heap_block *block) +void factor_vm::add_to_free_list(heap *heap, free_heap_block *block) { if(block->size < free_list_count * block_size_increment) { @@ -39,7 +39,7 @@ void factorvm::add_to_free_list(heap *heap, free_heap_block *block) In the former case, we must add a large free block from compiling.base + size to compiling.limit. */ -void factorvm::build_free_list(heap *heap, cell size) +void factor_vm::build_free_list(heap *heap, cell size) { heap_block *prev = NULL; @@ -91,14 +91,14 @@ void factorvm::build_free_list(heap *heap, cell size) } -void factorvm::assert_free_block(free_heap_block *block) +void factor_vm::assert_free_block(free_heap_block *block) { if(block->status != B_FREE) critical_error("Invalid block in free list",(cell)block); } -free_heap_block *factorvm::find_free_block(heap *heap, cell size) +free_heap_block *factor_vm::find_free_block(heap *heap, cell size) { cell attempt = size; @@ -138,7 +138,7 @@ free_heap_block *factorvm::find_free_block(heap *heap, cell size) return NULL; } -free_heap_block *factorvm::split_free_block(heap *heap, free_heap_block *block, cell size) +free_heap_block *factor_vm::split_free_block(heap *heap, free_heap_block *block, cell size) { if(block->size != size ) { @@ -155,7 +155,7 @@ free_heap_block *factorvm::split_free_block(heap *heap, free_heap_block *block, } /* Allocate a block of memory from the mark and sweep GC heap */ -heap_block *factorvm::heap_allot(heap *heap, cell size) +heap_block *factor_vm::heap_allot(heap *heap, cell size) { size = (size + block_size_increment - 1) & ~(block_size_increment - 1); @@ -172,13 +172,13 @@ heap_block *factorvm::heap_allot(heap *heap, cell size) } /* Deallocates a block manually */ -void factorvm::heap_free(heap *heap, heap_block *block) +void factor_vm::heap_free(heap *heap, heap_block *block) { block->status = B_FREE; add_to_free_list(heap,(free_heap_block *)block); } -void factorvm::mark_block(heap_block *block) +void factor_vm::mark_block(heap_block *block) { /* If already marked, do nothing */ switch(block->status) @@ -196,7 +196,7 @@ void factorvm::mark_block(heap_block *block) /* If in the middle of code GC, we have to grow the heap, data GC restarts from scratch, so we have to unmark any marked blocks. */ -void factorvm::unmark_marked(heap *heap) +void factor_vm::unmark_marked(heap *heap) { heap_block *scan = first_block(heap); @@ -211,7 +211,7 @@ void factorvm::unmark_marked(heap *heap) /* After code GC, all referenced code blocks have status set to B_MARKED, so any which are allocated and not marked can be reclaimed. */ -void factorvm::free_unmarked(heap *heap, heap_iterator iter) +void factor_vm::free_unmarked(heap *heap, heap_iterator iter) { clear_free_list(heap); @@ -259,7 +259,7 @@ void factorvm::free_unmarked(heap *heap, heap_iterator iter) } /* Compute total sum of sizes of free blocks, and size of largest free block */ -void factorvm::heap_usage(heap *heap, cell *used, cell *total_free, cell *max_free) +void factor_vm::heap_usage(heap *heap, cell *used, cell *total_free, cell *max_free) { *used = 0; *total_free = 0; @@ -288,7 +288,7 @@ void factorvm::heap_usage(heap *heap, cell *used, cell *total_free, cell *max_fr } /* The size of the heap, not including the last block if it's free */ -cell factorvm::heap_size(heap *heap) +cell factor_vm::heap_size(heap *heap) { heap_block *scan = first_block(heap); @@ -304,7 +304,7 @@ cell factorvm::heap_size(heap *heap) } /* Compute where each block is going to go, after compaction */ -cell factorvm::compute_heap_forwarding(heap *heap, unordered_map &forwarding) +cell factor_vm::compute_heap_forwarding(heap *heap, unordered_map &forwarding) { heap_block *scan = first_block(heap); char *address = (char *)first_block(heap); @@ -325,7 +325,7 @@ cell factorvm::compute_heap_forwarding(heap *heap, unordered_mapseg->start; } -void factorvm::compact_heap(heap *heap, unordered_map &forwarding) +void factor_vm::compact_heap(heap *heap, unordered_map &forwarding) { heap_block *scan = first_block(heap); diff --git a/vm/code_gc.hpp b/vm/code_gc.hpp index c59980dc30..d2cfba0cf4 100755 --- a/vm/code_gc.hpp +++ b/vm/code_gc.hpp @@ -14,7 +14,7 @@ struct heap { heap_free_list free; }; -typedef void (*heap_iterator)(heap_block *compiled,factorvm *vm); +typedef void (*heap_iterator)(heap_block *compiled,factor_vm *vm); inline static heap_block *next_block(heap *h, heap_block *block) { diff --git a/vm/code_heap.cpp b/vm/code_heap.cpp index 19b28e06da..b2361d94ce 100755 --- a/vm/code_heap.cpp +++ b/vm/code_heap.cpp @@ -4,18 +4,18 @@ namespace factor { /* Allocate a code heap during startup */ -void factorvm::init_code_heap(cell size) +void factor_vm::init_code_heap(cell size) { new_heap(&code,size); } -bool factorvm::in_code_heap_p(cell ptr) +bool factor_vm::in_code_heap_p(cell ptr) { return (ptr >= code.seg->start && ptr <= code.seg->end); } /* Compile a word definition with the non-optimizing compiler. Allocates memory */ -void factorvm::jit_compile_word(cell word_, cell def_, bool relocate) +void factor_vm::jit_compile_word(cell word_, cell def_, bool relocate) { gc_root word(word_,this); gc_root def(def_,this); @@ -29,7 +29,7 @@ void factorvm::jit_compile_word(cell word_, cell def_, bool relocate) } /* Apply a function to every code block */ -void factorvm::iterate_code_heap(code_heap_iterator iter) +void factor_vm::iterate_code_heap(code_heap_iterator iter) { heap_block *scan = first_block(&code); @@ -43,19 +43,19 @@ void factorvm::iterate_code_heap(code_heap_iterator iter) /* Copy literals referenced from all code blocks to newspace. Only for aging and nursery collections */ -void factorvm::copy_code_heap_roots() +void factor_vm::copy_code_heap_roots() { iterate_code_heap(factor::copy_literal_references); } /* Update pointers to words referenced from all code blocks. Only after defining a new word. */ -void factorvm::update_code_heap_words() +void factor_vm::update_code_heap_words() { iterate_code_heap(factor::update_word_references); } -inline void factorvm::primitive_modify_code_heap() +inline void factor_vm::primitive_modify_code_heap() { gc_root alist(dpop(),this); @@ -112,7 +112,7 @@ PRIMITIVE(modify_code_heap) } /* Push the free space and total size of the code heap */ -inline void factorvm::primitive_code_room() +inline void factor_vm::primitive_code_room() { cell used, total_free, max_free; heap_usage(&code,&used,&total_free,&max_free); @@ -127,12 +127,12 @@ PRIMITIVE(code_room) PRIMITIVE_GETVM()->primitive_code_room(); } -code_block *factorvm::forward_xt(code_block *compiled) +code_block *factor_vm::forward_xt(code_block *compiled) { return (code_block *)forwarding[compiled]; } -void factorvm::forward_frame_xt(stack_frame *frame) +void factor_vm::forward_frame_xt(stack_frame *frame) { cell offset = (cell)FRAME_RETURN_ADDRESS(frame) - (cell)frame_code(frame); code_block *forwarded = forward_xt(frame_code(frame)); @@ -140,12 +140,12 @@ void factorvm::forward_frame_xt(stack_frame *frame) FRAME_RETURN_ADDRESS(frame) = (void *)((cell)forwarded + offset); } -void forward_frame_xt(stack_frame *frame,factorvm *myvm) +void forward_frame_xt(stack_frame *frame,factor_vm *myvm) { return myvm->forward_frame_xt(frame); } -void factorvm::forward_object_xts() +void factor_vm::forward_object_xts() { begin_scan(); @@ -188,7 +188,7 @@ void factorvm::forward_object_xts() } /* Set the XT fields now that the heap has been compacted */ -void factorvm::fixup_object_xts() +void factor_vm::fixup_object_xts() { begin_scan(); @@ -220,7 +220,7 @@ void factorvm::fixup_object_xts() since it makes several passes over the code and data heaps, but we only ever do this before saving a deployed image and exiting, so performaance is not critical here */ -void factorvm::compact_code_heap() +void factor_vm::compact_code_heap() { /* Free all unreachable code blocks */ gc(); diff --git a/vm/code_heap.hpp b/vm/code_heap.hpp index a357699591..709ec85f95 100755 --- a/vm/code_heap.hpp +++ b/vm/code_heap.hpp @@ -1,7 +1,7 @@ namespace factor { -struct factorvm; -typedef void (*code_heap_iterator)(code_block *compiled,factorvm *myvm); +struct factor_vm; +typedef void (*code_heap_iterator)(code_block *compiled,factor_vm *myvm); PRIMITIVE(modify_code_heap); PRIMITIVE(code_room); diff --git a/vm/contexts.cpp b/vm/contexts.cpp index 65046e346a..6e821552ed 100644 --- a/vm/contexts.cpp +++ b/vm/contexts.cpp @@ -3,19 +3,19 @@ namespace factor { -void factorvm::reset_datastack() +void factor_vm::reset_datastack() { ds = ds_bot - sizeof(cell); } -void factorvm::reset_retainstack() +void factor_vm::reset_retainstack() { rs = rs_bot - sizeof(cell); } static const cell stack_reserved = (64 * sizeof(cell)); -void factorvm::fix_stacks() +void factor_vm::fix_stacks() { if(ds + sizeof(cell) < ds_bot || ds + stack_reserved >= ds_top) reset_datastack(); if(rs + sizeof(cell) < rs_bot || rs + stack_reserved >= rs_top) reset_retainstack(); @@ -23,7 +23,7 @@ void factorvm::fix_stacks() /* called before entry into foreign C code. Note that ds and rs might be stored in registers, so callbacks must save and restore the correct values */ -void factorvm::save_stacks() +void factor_vm::save_stacks() { if(stack_chain) { @@ -32,7 +32,7 @@ void factorvm::save_stacks() } } -context *factorvm::alloc_context() +context *factor_vm::alloc_context() { context *new_context; @@ -51,14 +51,14 @@ context *factorvm::alloc_context() return new_context; } -void factorvm::dealloc_context(context *old_context) +void factor_vm::dealloc_context(context *old_context) { old_context->next = unused_contexts; unused_contexts = old_context; } /* called on entry into a compiled callback */ -void factorvm::nest_stacks() +void factor_vm::nest_stacks() { context *new_context = alloc_context(); @@ -89,14 +89,14 @@ void factorvm::nest_stacks() reset_retainstack(); } -void nest_stacks(factorvm *myvm) +void nest_stacks(factor_vm *myvm) { ASSERTVM(); return VM_PTR->nest_stacks(); } /* called when leaving a compiled callback */ -void factorvm::unnest_stacks() +void factor_vm::unnest_stacks() { ds = stack_chain->datastack_save; rs = stack_chain->retainstack_save; @@ -110,14 +110,14 @@ void factorvm::unnest_stacks() dealloc_context(old_stacks); } -void unnest_stacks(factorvm *myvm) +void unnest_stacks(factor_vm *myvm) { ASSERTVM(); return VM_PTR->unnest_stacks(); } /* called on startup */ -void factorvm::init_stacks(cell ds_size_, cell rs_size_) +void factor_vm::init_stacks(cell ds_size_, cell rs_size_) { ds_size = ds_size_; rs_size = rs_size_; @@ -125,7 +125,7 @@ void factorvm::init_stacks(cell ds_size_, cell rs_size_) unused_contexts = NULL; } -bool factorvm::stack_to_array(cell bottom, cell top) +bool factor_vm::stack_to_array(cell bottom, cell top) { fixnum depth = (fixnum)(top - bottom + sizeof(cell)); @@ -140,7 +140,7 @@ bool factorvm::stack_to_array(cell bottom, cell top) } } -inline void factorvm::primitive_datastack() +inline void factor_vm::primitive_datastack() { if(!stack_to_array(ds_bot,ds)) general_error(ERROR_DS_UNDERFLOW,F,F,NULL); @@ -151,7 +151,7 @@ PRIMITIVE(datastack) PRIMITIVE_GETVM()->primitive_datastack(); } -inline void factorvm::primitive_retainstack() +inline void factor_vm::primitive_retainstack() { if(!stack_to_array(rs_bot,rs)) general_error(ERROR_RS_UNDERFLOW,F,F,NULL); @@ -163,14 +163,14 @@ PRIMITIVE(retainstack) } /* returns pointer to top of stack */ -cell factorvm::array_to_stack(array *array, cell bottom) +cell factor_vm::array_to_stack(array *array, cell bottom) { cell depth = array_capacity(array) * sizeof(cell); memcpy((void*)bottom,array + 1,depth); return bottom + depth - sizeof(cell); } -inline void factorvm::primitive_set_datastack() +inline void factor_vm::primitive_set_datastack() { ds = array_to_stack(untag_check(dpop()),ds_bot); } @@ -180,7 +180,7 @@ PRIMITIVE(set_datastack) PRIMITIVE_GETVM()->primitive_set_datastack(); } -inline void factorvm::primitive_set_retainstack() +inline void factor_vm::primitive_set_retainstack() { rs = array_to_stack(untag_check(dpop()),rs_bot); } @@ -191,7 +191,7 @@ PRIMITIVE(set_retainstack) } /* Used to implement call( */ -inline void factorvm::primitive_check_datastack() +inline void factor_vm::primitive_check_datastack() { fixnum out = to_fixnum(dpop()); fixnum in = to_fixnum(dpop()); diff --git a/vm/contexts.hpp b/vm/contexts.hpp index 060b15fad7..fae451f02c 100644 --- a/vm/contexts.hpp +++ b/vm/contexts.hpp @@ -50,9 +50,9 @@ PRIMITIVE(set_datastack); PRIMITIVE(set_retainstack); PRIMITIVE(check_datastack); -struct factorvm; -VM_C_API void nest_stacks(factorvm *vm); -VM_C_API void unnest_stacks(factorvm *vm); +struct factor_vm; +VM_C_API void nest_stacks(factor_vm *vm); +VM_C_API void unnest_stacks(factor_vm *vm); } diff --git a/vm/data_gc.cpp b/vm/data_gc.cpp index 333fe5c67d..8766cc8c7c 100755 --- a/vm/data_gc.cpp +++ b/vm/data_gc.cpp @@ -3,7 +3,7 @@ namespace factor { -void factorvm::init_data_gc() +void factor_vm::init_data_gc() { performing_gc = false; last_code_heap_scan = data->nursery(); @@ -11,7 +11,7 @@ void factorvm::init_data_gc() } /* Given a pointer to oldspace, copy it to newspace */ -object *factorvm::copy_untagged_object_impl(object *pointer, cell size) +object *factor_vm::copy_untagged_object_impl(object *pointer, cell size) { if(newspace->here + size >= newspace->end) longjmp(gc_jmp,1); @@ -25,14 +25,14 @@ object *factorvm::copy_untagged_object_impl(object *pointer, cell size) return newpointer; } -object *factorvm::copy_object_impl(object *untagged) +object *factor_vm::copy_object_impl(object *untagged) { object *newpointer = copy_untagged_object_impl(untagged,untagged_object_size(untagged)); untagged->h.forward_to(newpointer); return newpointer; } -bool factorvm::should_copy_p(object *untagged) +bool factor_vm::should_copy_p(object *untagged) { if(in_zone(newspace,untagged)) return false; @@ -50,7 +50,7 @@ bool factorvm::should_copy_p(object *untagged) } /* Follow a chain of forwarding pointers */ -object *factorvm::resolve_forwarding(object *untagged) +object *factor_vm::resolve_forwarding(object *untagged) { check_data_pointer(untagged); @@ -68,7 +68,7 @@ object *factorvm::resolve_forwarding(object *untagged) } } -template TYPE *factorvm::copy_untagged_object(TYPE *untagged) +template TYPE *factor_vm::copy_untagged_object(TYPE *untagged) { check_data_pointer(untagged); @@ -83,12 +83,12 @@ template TYPE *factorvm::copy_untagged_object(TYPE *untagged) return untagged; } -cell factorvm::copy_object(cell pointer) +cell factor_vm::copy_object(cell pointer) { return RETAG(copy_untagged_object(untag(pointer)),TAG(pointer)); } -void factorvm::copy_handle(cell *handle) +void factor_vm::copy_handle(cell *handle) { cell pointer = *handle; @@ -102,7 +102,7 @@ void factorvm::copy_handle(cell *handle) } /* Scan all the objects in the card */ -void factorvm::copy_card(card *ptr, cell gen, cell here) +void factor_vm::copy_card(card *ptr, cell gen, cell here) { cell card_scan = card_to_addr(ptr) + card_offset(ptr); cell card_end = card_to_addr(ptr + 1); @@ -115,7 +115,7 @@ void factorvm::copy_card(card *ptr, cell gen, cell here) cards_scanned++; } -void factorvm::copy_card_deck(card_deck *deck, cell gen, card mask, card unmask) +void factor_vm::copy_card_deck(card_deck *deck, cell gen, card mask, card unmask) { card *first_card = deck_to_card(deck); card *last_card = deck_to_card(deck + 1); @@ -147,7 +147,7 @@ void factorvm::copy_card_deck(card_deck *deck, cell gen, card mask, card unmask) } /* Copy all newspace objects referenced from marked cards to the destination */ -void factorvm::copy_gen_cards(cell gen) +void factor_vm::copy_gen_cards(cell gen) { card_deck *first_deck = addr_to_deck(data->generations[gen].start); card_deck *last_deck = addr_to_deck(data->generations[gen].end); @@ -214,7 +214,7 @@ void factorvm::copy_gen_cards(cell gen) /* Scan cards in all generations older than the one being collected, copying old->new references */ -void factorvm::copy_cards() +void factor_vm::copy_cards() { u64 start = current_micros(); @@ -226,7 +226,7 @@ void factorvm::copy_cards() } /* Copy all tagged pointers in a range of memory */ -void factorvm::copy_stack_elements(segment *region, cell top) +void factor_vm::copy_stack_elements(segment *region, cell top) { cell ptr = region->start; @@ -234,7 +234,7 @@ void factorvm::copy_stack_elements(segment *region, cell top) copy_handle((cell*)ptr); } -void factorvm::copy_registered_locals() +void factor_vm::copy_registered_locals() { std::vector::const_iterator iter = gc_locals.begin(); std::vector::const_iterator end = gc_locals.end(); @@ -243,7 +243,7 @@ void factorvm::copy_registered_locals() copy_handle((cell *)(*iter)); } -void factorvm::copy_registered_bignums() +void factor_vm::copy_registered_bignums() { std::vector::const_iterator iter = gc_bignums.begin(); std::vector::const_iterator end = gc_bignums.end(); @@ -267,7 +267,7 @@ void factorvm::copy_registered_bignums() /* Copy roots over at the start of GC, namely various constants, stacks, the user environment and extra roots registered by local_roots.hpp */ -void factorvm::copy_roots() +void factor_vm::copy_roots() { copy_handle(&T); copy_handle(&bignum_zero); @@ -301,7 +301,7 @@ void factorvm::copy_roots() copy_handle(&userenv[i]); } -cell factorvm::copy_next_from_nursery(cell scan) +cell factor_vm::copy_next_from_nursery(cell scan) { cell *obj = (cell *)scan; cell *end = (cell *)(scan + binary_payload_start((object *)scan)); @@ -329,7 +329,7 @@ cell factorvm::copy_next_from_nursery(cell scan) return scan + untagged_object_size((object *)scan); } -cell factorvm::copy_next_from_aging(cell scan) +cell factor_vm::copy_next_from_aging(cell scan) { cell *obj = (cell *)scan; cell *end = (cell *)(scan + binary_payload_start((object *)scan)); @@ -361,7 +361,7 @@ cell factorvm::copy_next_from_aging(cell scan) return scan + untagged_object_size((object *)scan); } -cell factorvm::copy_next_from_tenured(cell scan) +cell factor_vm::copy_next_from_tenured(cell scan) { cell *obj = (cell *)scan; cell *end = (cell *)(scan + binary_payload_start((object *)scan)); @@ -391,7 +391,7 @@ cell factorvm::copy_next_from_tenured(cell scan) return scan + untagged_object_size((object *)scan); } -void factorvm::copy_reachable_objects(cell scan, cell *end) +void factor_vm::copy_reachable_objects(cell scan, cell *end) { if(collecting_gen == data->nursery()) { @@ -411,7 +411,7 @@ void factorvm::copy_reachable_objects(cell scan, cell *end) } /* Prepare to start copying reachable objects into an unused zone */ -void factorvm::begin_gc(cell requested_bytes) +void factor_vm::begin_gc(cell requested_bytes) { if(growing_data_heap) { @@ -444,7 +444,7 @@ void factorvm::begin_gc(cell requested_bytes) } } -void factorvm::end_gc(cell gc_elapsed) +void factor_vm::end_gc(cell gc_elapsed) { gc_stats *s = &stats[collecting_gen]; @@ -485,7 +485,7 @@ void factorvm::end_gc(cell gc_elapsed) /* Collect gen and all younger generations. If growing_data_heap_ is true, we must grow the data heap to such a size that an allocation of requested_bytes won't fail */ -void factorvm::garbage_collection(cell gen,bool growing_data_heap_,cell requested_bytes) +void factor_vm::garbage_collection(cell gen,bool growing_data_heap_,cell requested_bytes) { if(gc_off) { @@ -563,12 +563,12 @@ void factorvm::garbage_collection(cell gen,bool growing_data_heap_,cell requeste performing_gc = false; } -void factorvm::gc() +void factor_vm::gc() { garbage_collection(data->tenured(),false,0); } -inline void factorvm::primitive_gc() +inline void factor_vm::primitive_gc() { gc(); } @@ -578,7 +578,7 @@ PRIMITIVE(gc) PRIMITIVE_GETVM()->primitive_gc(); } -inline void factorvm::primitive_gc_stats() +inline void factor_vm::primitive_gc_stats() { growable_array result(this); @@ -613,7 +613,7 @@ PRIMITIVE(gc_stats) PRIMITIVE_GETVM()->primitive_gc_stats(); } -void factorvm::clear_gc_stats() +void factor_vm::clear_gc_stats() { for(cell i = 0; i < max_gen_count; i++) memset(&stats[i],0,sizeof(gc_stats)); @@ -624,7 +624,7 @@ void factorvm::clear_gc_stats() code_heap_scans = 0; } -inline void factorvm::primitive_clear_gc_stats() +inline void factor_vm::primitive_clear_gc_stats() { clear_gc_stats(); } @@ -636,7 +636,7 @@ PRIMITIVE(clear_gc_stats) /* classes.tuple uses this to reshape tuples; tools.deploy.shaker uses this to coalesce equal but distinct quotations and wrappers. */ -inline void factorvm::primitive_become() +inline void factor_vm::primitive_become() { array *new_objects = untag_check(dpop()); array *old_objects = untag_check(dpop()); @@ -670,7 +670,7 @@ PRIMITIVE(become) PRIMITIVE_GETVM()->primitive_become(); } -void factorvm::inline_gc(cell *gc_roots_base, cell gc_roots_size) +void factor_vm::inline_gc(cell *gc_roots_base, cell gc_roots_size) { for(cell i = 0; i < gc_roots_size; i++) gc_locals.push_back((cell)&gc_roots_base[i]); @@ -681,7 +681,7 @@ void factorvm::inline_gc(cell *gc_roots_base, cell gc_roots_size) gc_locals.pop_back(); } -VM_ASM_API void inline_gc(cell *gc_roots_base, cell gc_roots_size, factorvm *myvm) +VM_ASM_API void inline_gc(cell *gc_roots_base, cell gc_roots_size, factor_vm *myvm) { ASSERTVM(); VM_PTR->inline_gc(gc_roots_base,gc_roots_size); diff --git a/vm/data_gc.hpp b/vm/data_gc.hpp index 84c824d779..411c4d19fe 100755 --- a/vm/data_gc.hpp +++ b/vm/data_gc.hpp @@ -19,7 +19,7 @@ PRIMITIVE(gc); PRIMITIVE(gc_stats); PRIMITIVE(clear_gc_stats); PRIMITIVE(become); -struct factorvm; -VM_ASM_API void inline_gc(cell *gc_roots_base, cell gc_roots_size, factorvm *myvm); +struct factor_vm; +VM_ASM_API void inline_gc(cell *gc_roots_base, cell gc_roots_size, factor_vm *myvm); } diff --git a/vm/data_heap.cpp b/vm/data_heap.cpp index d880b8544c..72bc9c5d84 100755 --- a/vm/data_heap.cpp +++ b/vm/data_heap.cpp @@ -3,7 +3,7 @@ namespace factor { -cell factorvm::init_zone(zone *z, cell size, cell start) +cell factor_vm::init_zone(zone *z, cell size, cell start) { z->size = size; z->start = z->here = start; @@ -11,7 +11,7 @@ cell factorvm::init_zone(zone *z, cell size, cell start) return z->end; } -void factorvm::init_card_decks() +void factor_vm::init_card_decks() { cell start = align(data->seg->start,deck_size); allot_markers_offset = (cell)data->allot_markers - (start >> card_bits); @@ -19,7 +19,7 @@ void factorvm::init_card_decks() decks_offset = (cell)data->decks - (start >> deck_bits); } -data_heap *factorvm::alloc_data_heap(cell gens, cell young_size,cell aging_size,cell tenured_size) +data_heap *factor_vm::alloc_data_heap(cell gens, cell young_size,cell aging_size,cell tenured_size) { young_size = align(young_size,deck_size); aging_size = align(aging_size,deck_size); @@ -83,7 +83,7 @@ data_heap *factorvm::alloc_data_heap(cell gens, cell young_size,cell aging_size, return data; } -data_heap *factorvm::grow_data_heap(data_heap *data, cell requested_bytes) +data_heap *factor_vm::grow_data_heap(data_heap *data, cell requested_bytes) { cell new_tenured_size = (data->tenured_size * 2) + requested_bytes; @@ -93,7 +93,7 @@ data_heap *factorvm::grow_data_heap(data_heap *data, cell requested_bytes) new_tenured_size); } -void factorvm::dealloc_data_heap(data_heap *data) +void factor_vm::dealloc_data_heap(data_heap *data) { dealloc_segment(data->seg); free(data->generations); @@ -104,7 +104,7 @@ void factorvm::dealloc_data_heap(data_heap *data) free(data); } -void factorvm::clear_cards(cell from, cell to) +void factor_vm::clear_cards(cell from, cell to) { /* NOTE: reverse order due to heap layout. */ card *first_card = addr_to_card(data->generations[to].start); @@ -112,7 +112,7 @@ void factorvm::clear_cards(cell from, cell to) memset(first_card,0,last_card - first_card); } -void factorvm::clear_decks(cell from, cell to) +void factor_vm::clear_decks(cell from, cell to) { /* NOTE: reverse order due to heap layout. */ card_deck *first_deck = addr_to_deck(data->generations[to].start); @@ -120,7 +120,7 @@ void factorvm::clear_decks(cell from, cell to) memset(first_deck,0,last_deck - first_deck); } -void factorvm::clear_allot_markers(cell from, cell to) +void factor_vm::clear_allot_markers(cell from, cell to) { /* NOTE: reverse order due to heap layout. */ card *first_card = addr_to_allot_marker((object *)data->generations[to].start); @@ -128,7 +128,7 @@ void factorvm::clear_allot_markers(cell from, cell to) memset(first_card,invalid_allot_marker,last_card - first_card); } -void factorvm::reset_generation(cell i) +void factor_vm::reset_generation(cell i) { zone *z = (i == data->nursery() ? &nursery : &data->generations[i]); @@ -139,7 +139,7 @@ void factorvm::reset_generation(cell i) /* After garbage collection, any generations which are now empty need to have their allocation pointers and cards reset. */ -void factorvm::reset_generations(cell from, cell to) +void factor_vm::reset_generations(cell from, cell to) { cell i; for(i = from; i <= to; i++) @@ -150,7 +150,7 @@ void factorvm::reset_generations(cell from, cell to) clear_allot_markers(from,to); } -void factorvm::set_data_heap(data_heap *data_) +void factor_vm::set_data_heap(data_heap *data_) { data = data_; nursery = data->generations[data->nursery()]; @@ -160,7 +160,7 @@ void factorvm::set_data_heap(data_heap *data_) clear_allot_markers(data->nursery(),data->tenured()); } -void factorvm::init_data_heap(cell gens,cell young_size,cell aging_size,cell tenured_size,bool secure_gc_) +void factor_vm::init_data_heap(cell gens,cell young_size,cell aging_size,cell tenured_size,bool secure_gc_) { set_data_heap(alloc_data_heap(gens,young_size,aging_size,tenured_size)); secure_gc = secure_gc_; @@ -168,7 +168,7 @@ void factorvm::init_data_heap(cell gens,cell young_size,cell aging_size,cell ten } /* Size of the object pointed to by a tagged pointer */ -cell factorvm::object_size(cell tagged) +cell factor_vm::object_size(cell tagged) { if(immediate_p(tagged)) return 0; @@ -177,13 +177,13 @@ cell factorvm::object_size(cell tagged) } /* Size of the object pointed to by an untagged pointer */ -cell factorvm::untagged_object_size(object *pointer) +cell factor_vm::untagged_object_size(object *pointer) { return align8(unaligned_object_size(pointer)); } /* Size of the data area of an object pointed to by an untagged pointer */ -cell factorvm::unaligned_object_size(object *pointer) +cell factor_vm::unaligned_object_size(object *pointer) { switch(pointer->h.hi_tag()) { @@ -217,7 +217,7 @@ cell factorvm::unaligned_object_size(object *pointer) } } -inline void factorvm::primitive_size() +inline void factor_vm::primitive_size() { box_unsigned_cell(object_size(dpop())); } @@ -230,7 +230,7 @@ PRIMITIVE(size) /* The number of cells from the start of the object which should be scanned by the GC. Some types have a binary payload at the end (string, word, DLL) which we ignore. */ -cell factorvm::binary_payload_start(object *pointer) +cell factor_vm::binary_payload_start(object *pointer) { switch(pointer->h.hi_tag()) { @@ -265,7 +265,7 @@ cell factorvm::binary_payload_start(object *pointer) } /* Push memory usage statistics in data heap */ -inline void factorvm::primitive_data_room() +inline void factor_vm::primitive_data_room() { dpush(tag_fixnum((data->cards_end - data->cards) >> 10)); dpush(tag_fixnum((data->decks_end - data->decks) >> 10)); @@ -290,18 +290,18 @@ PRIMITIVE(data_room) } /* Disables GC and activates next-object ( -- obj ) primitive */ -void factorvm::begin_scan() +void factor_vm::begin_scan() { heap_scan_ptr = data->generations[data->tenured()].start; gc_off = true; } -void factorvm::end_scan() +void factor_vm::end_scan() { gc_off = false; } -inline void factorvm::primitive_begin_scan() +inline void factor_vm::primitive_begin_scan() { begin_scan(); } @@ -311,7 +311,7 @@ PRIMITIVE(begin_scan) PRIMITIVE_GETVM()->primitive_begin_scan(); } -cell factorvm::next_object() +cell factor_vm::next_object() { if(!gc_off) general_error(ERROR_HEAP_SCAN,F,F,NULL); @@ -325,7 +325,7 @@ cell factorvm::next_object() } /* Push object at heap scan cursor and advance; pushes f when done */ -inline void factorvm::primitive_next_object() +inline void factor_vm::primitive_next_object() { dpush(next_object()); } @@ -336,7 +336,7 @@ PRIMITIVE(next_object) } /* Re-enables GC */ -inline void factorvm::primitive_end_scan() +inline void factor_vm::primitive_end_scan() { gc_off = false; } @@ -346,7 +346,7 @@ PRIMITIVE(end_scan) PRIMITIVE_GETVM()->primitive_end_scan(); } -template void factorvm::each_object(TYPE &functor) +template void factor_vm::each_object(TYPE &functor) { begin_scan(); cell obj; @@ -366,13 +366,13 @@ struct word_counter { struct word_accumulator { growable_array words; - word_accumulator(int count,factorvm *vm) : words(vm,count) {} + word_accumulator(int count,factor_vm *vm) : words(vm,count) {} void operator()(tagged obj) { if(obj.type_p(WORD_TYPE)) words.add(obj.value()); } }; } -cell factorvm::find_all_words() +cell factor_vm::find_all_words() { word_counter counter; each_object(counter); diff --git a/vm/debug.cpp b/vm/debug.cpp index 1a862060dc..2b8264ee41 100755 --- a/vm/debug.cpp +++ b/vm/debug.cpp @@ -3,14 +3,14 @@ namespace factor { -void factorvm::print_chars(string* str) +void factor_vm::print_chars(string* str) { cell i; for(i = 0; i < string_capacity(str); i++) putchar(string_nth(str,i)); } -void factorvm::print_word(word* word, cell nesting) +void factor_vm::print_word(word* word, cell nesting) { if(tagged(word->vocabulary).type_p(STRING_TYPE)) { @@ -28,14 +28,14 @@ void factorvm::print_word(word* word, cell nesting) } } -void factorvm::print_factor_string(string* str) +void factor_vm::print_factor_string(string* str) { putchar('"'); print_chars(str); putchar('"'); } -void factorvm::print_array(array* array, cell nesting) +void factor_vm::print_array(array* array, cell nesting) { cell length = array_capacity(array); cell i; @@ -59,7 +59,7 @@ void factorvm::print_array(array* array, cell nesting) print_string("..."); } -void factorvm::print_tuple(tuple *tuple, cell nesting) +void factor_vm::print_tuple(tuple *tuple, cell nesting) { tuple_layout *layout = untag(tuple->layout); cell length = to_fixnum(layout->size); @@ -88,7 +88,7 @@ void factorvm::print_tuple(tuple *tuple, cell nesting) print_string("..."); } -void factorvm::print_nested_obj(cell obj, fixnum nesting) +void factor_vm::print_nested_obj(cell obj, fixnum nesting) { if(nesting <= 0 && !full_output) { @@ -138,12 +138,12 @@ void factorvm::print_nested_obj(cell obj, fixnum nesting) } } -void factorvm::print_obj(cell obj) +void factor_vm::print_obj(cell obj) { print_nested_obj(obj,10); } -void factorvm::print_objects(cell *start, cell *end) +void factor_vm::print_objects(cell *start, cell *end) { for(; start <= end; start++) { @@ -152,19 +152,19 @@ void factorvm::print_objects(cell *start, cell *end) } } -void factorvm::print_datastack() +void factor_vm::print_datastack() { print_string("==== DATA STACK:\n"); print_objects((cell *)ds_bot,(cell *)ds); } -void factorvm::print_retainstack() +void factor_vm::print_retainstack() { print_string("==== RETAIN STACK:\n"); print_objects((cell *)rs_bot,(cell *)rs); } -void factorvm::print_stack_frame(stack_frame *frame) +void factor_vm::print_stack_frame(stack_frame *frame) { print_obj(frame_executing(frame)); print_string("\n"); @@ -181,12 +181,12 @@ void factorvm::print_stack_frame(stack_frame *frame) print_string("\n"); } -void print_stack_frame(stack_frame *frame, factorvm *myvm) +void print_stack_frame(stack_frame *frame, factor_vm *myvm) { return myvm->print_stack_frame(frame); } -void factorvm::print_callstack() +void factor_vm::print_callstack() { print_string("==== CALL STACK:\n"); cell bottom = (cell)stack_chain->callstack_bottom; @@ -194,7 +194,7 @@ void factorvm::print_callstack() iterate_callstack(top,bottom,factor::print_stack_frame); } -void factorvm::dump_cell(cell x) +void factor_vm::dump_cell(cell x) { print_cell_hex_pad(x); print_string(": "); x = *(cell *)x; @@ -202,7 +202,7 @@ void factorvm::dump_cell(cell x) nl(); } -void factorvm::dump_memory(cell from, cell to) +void factor_vm::dump_memory(cell from, cell to) { from = UNTAG(from); @@ -210,14 +210,14 @@ void factorvm::dump_memory(cell from, cell to) dump_cell(from); } -void factorvm::dump_zone(zone *z) +void factor_vm::dump_zone(zone *z) { print_string("Start="); print_cell(z->start); print_string(", size="); print_cell(z->size); print_string(", here="); print_cell(z->here - z->start); nl(); } -void factorvm::dump_generations() +void factor_vm::dump_generations() { cell i; @@ -243,7 +243,7 @@ void factorvm::dump_generations() nl(); } -void factorvm::dump_objects(cell type) +void factor_vm::dump_objects(cell type) { gc(); begin_scan(); @@ -264,7 +264,7 @@ void factorvm::dump_objects(cell type) } -void factorvm::find_data_references_step(cell *scan) +void factor_vm::find_data_references_step(cell *scan) { if(look_for == *scan) { @@ -275,12 +275,12 @@ void factorvm::find_data_references_step(cell *scan) } } -void find_data_references_step(cell *scan,factorvm *myvm) +void find_data_references_step(cell *scan,factor_vm *myvm) { return myvm->find_data_references_step(scan); } -void factorvm::find_data_references(cell look_for_) +void factor_vm::find_data_references(cell look_for_) { look_for = look_for_; @@ -293,7 +293,7 @@ void factorvm::find_data_references(cell look_for_) } /* Dump all code blocks for debugging */ -void factorvm::dump_code_heap() +void factor_vm::dump_code_heap() { cell reloc_size = 0, literal_size = 0; @@ -333,7 +333,7 @@ void factorvm::dump_code_heap() print_cell(literal_size); print_string(" bytes of literal data\n"); } -void factorvm::factorbug() +void factor_vm::factorbug() { if(fep_disabled) { @@ -477,7 +477,7 @@ void factorvm::factorbug() } } -inline void factorvm::primitive_die() +inline void factor_vm::primitive_die() { print_string("The die word was called by the library. Unless you called it yourself,\n"); print_string("you have triggered a bug in Factor. Please report.\n"); diff --git a/vm/dispatch.cpp b/vm/dispatch.cpp index 632561f3a0..96d77c7592 100755 --- a/vm/dispatch.cpp +++ b/vm/dispatch.cpp @@ -3,7 +3,7 @@ namespace factor { -cell factorvm::search_lookup_alist(cell table, cell klass) +cell factor_vm::search_lookup_alist(cell table, cell klass) { array *elements = untag(table); fixnum index = array_capacity(elements) - 2; @@ -18,7 +18,7 @@ cell factorvm::search_lookup_alist(cell table, cell klass) return F; } -cell factorvm::search_lookup_hash(cell table, cell klass, cell hashcode) +cell factor_vm::search_lookup_hash(cell table, cell klass, cell hashcode) { array *buckets = untag(table); cell bucket = array_nth(buckets,hashcode & (array_capacity(buckets) - 1)); @@ -28,19 +28,19 @@ cell factorvm::search_lookup_hash(cell table, cell klass, cell hashcode) return search_lookup_alist(bucket,klass); } -cell factorvm::nth_superclass(tuple_layout *layout, fixnum echelon) +cell factor_vm::nth_superclass(tuple_layout *layout, fixnum echelon) { cell *ptr = (cell *)(layout + 1); return ptr[echelon * 2]; } -cell factorvm::nth_hashcode(tuple_layout *layout, fixnum echelon) +cell factor_vm::nth_hashcode(tuple_layout *layout, fixnum echelon) { cell *ptr = (cell *)(layout + 1); return ptr[echelon * 2 + 1]; } -cell factorvm::lookup_tuple_method(cell obj, cell methods) +cell factor_vm::lookup_tuple_method(cell obj, cell methods) { tuple_layout *layout = untag(untag(obj)->layout); @@ -72,7 +72,7 @@ cell factorvm::lookup_tuple_method(cell obj, cell methods) return F; } -cell factorvm::lookup_hi_tag_method(cell obj, cell methods) +cell factor_vm::lookup_hi_tag_method(cell obj, cell methods) { array *hi_tag_methods = untag(methods); cell tag = untag(obj)->h.hi_tag() - HEADER_TYPE; @@ -82,7 +82,7 @@ cell factorvm::lookup_hi_tag_method(cell obj, cell methods) return array_nth(hi_tag_methods,tag); } -cell factorvm::lookup_hairy_method(cell obj, cell methods) +cell factor_vm::lookup_hairy_method(cell obj, cell methods) { cell method = array_nth(untag(methods),TAG(obj)); if(tagged(method).type_p(WORD_TYPE)) @@ -104,7 +104,7 @@ cell factorvm::lookup_hairy_method(cell obj, cell methods) } } -cell factorvm::lookup_method(cell obj, cell methods) +cell factor_vm::lookup_method(cell obj, cell methods) { cell tag = TAG(obj); if(tag == TUPLE_TYPE || tag == OBJECT_TYPE) @@ -113,7 +113,7 @@ cell factorvm::lookup_method(cell obj, cell methods) return array_nth(untag(methods),TAG(obj)); } -inline void factorvm::primitive_lookup_method() +inline void factor_vm::primitive_lookup_method() { cell methods = dpop(); cell obj = dpop(); @@ -125,7 +125,7 @@ PRIMITIVE(lookup_method) PRIMITIVE_GETVM()->primitive_lookup_method(); } -cell factorvm::object_class(cell obj) +cell factor_vm::object_class(cell obj) { switch(TAG(obj)) { @@ -138,13 +138,13 @@ cell factorvm::object_class(cell obj) } } -cell factorvm::method_cache_hashcode(cell klass, array *array) +cell factor_vm::method_cache_hashcode(cell klass, array *array) { cell capacity = (array_capacity(array) >> 1) - 1; return ((klass >> TAG_BITS) & capacity) << 1; } -void factorvm::update_method_cache(cell cache, cell klass, cell method) +void factor_vm::update_method_cache(cell cache, cell klass, cell method) { array *cache_elements = untag(cache); cell hashcode = method_cache_hashcode(klass,cache_elements); @@ -152,7 +152,7 @@ void factorvm::update_method_cache(cell cache, cell klass, cell method) set_array_nth(cache_elements,hashcode + 1,method); } -inline void factorvm::primitive_mega_cache_miss() +inline void factor_vm::primitive_mega_cache_miss() { megamorphic_cache_misses++; @@ -174,7 +174,7 @@ PRIMITIVE(mega_cache_miss) PRIMITIVE_GETVM()->primitive_mega_cache_miss(); } -inline void factorvm::primitive_reset_dispatch_stats() +inline void factor_vm::primitive_reset_dispatch_stats() { megamorphic_cache_hits = megamorphic_cache_misses = 0; } @@ -184,7 +184,7 @@ PRIMITIVE(reset_dispatch_stats) PRIMITIVE_GETVM()->primitive_reset_dispatch_stats(); } -inline void factorvm::primitive_dispatch_stats() +inline void factor_vm::primitive_dispatch_stats() { growable_array stats(this); stats.add(allot_cell(megamorphic_cache_hits)); diff --git a/vm/errors.cpp b/vm/errors.cpp index c4eb549c9f..4d9d06f7e2 100755 --- a/vm/errors.cpp +++ b/vm/errors.cpp @@ -3,7 +3,7 @@ namespace factor { -void factorvm::out_of_memory() +void factor_vm::out_of_memory() { print_string("Out of memory\n\n"); dump_generations(); @@ -17,7 +17,7 @@ void fatal_error(const char* msg, cell tagged) exit(1); } -void factorvm::critical_error(const char* msg, cell tagged) +void factor_vm::critical_error(const char* msg, cell tagged) { print_string("You have triggered a bug in Factor. Please report.\n"); print_string("critical_error: "); print_string(msg); @@ -25,7 +25,7 @@ void factorvm::critical_error(const char* msg, cell tagged) factorbug(); } -void factorvm::throw_error(cell error, stack_frame *callstack_top) +void factor_vm::throw_error(cell error, stack_frame *callstack_top) { /* If the error handler is set, we rewind any C stack frames and pass the error to user-space. */ @@ -70,25 +70,25 @@ void factorvm::throw_error(cell error, stack_frame *callstack_top) } } -void factorvm::general_error(vm_error_type error, cell arg1, cell arg2, stack_frame *callstack_top) +void factor_vm::general_error(vm_error_type error, cell arg1, cell arg2, stack_frame *callstack_top) { throw_error(allot_array_4(userenv[ERROR_ENV], tag_fixnum(error),arg1,arg2),callstack_top); } -void factorvm::type_error(cell type, cell tagged) +void factor_vm::type_error(cell type, cell tagged) { general_error(ERROR_TYPE,tag_fixnum(type),tagged,NULL); } -void factorvm::not_implemented_error() +void factor_vm::not_implemented_error() { general_error(ERROR_NOT_IMPLEMENTED,F,F,NULL); } /* Test if 'fault' is in the guard page at the top or bottom (depending on offset being 0 or -1) of area+area_size */ -bool factorvm::in_page(cell fault, cell area, cell area_size, int offset) +bool factor_vm::in_page(cell fault, cell area, cell area_size, int offset) { int pagesize = getpagesize(); area += area_size; @@ -97,7 +97,7 @@ bool factorvm::in_page(cell fault, cell area, cell area_size, int offset) return fault >= area && fault <= area + pagesize; } -void factorvm::memory_protection_error(cell addr, stack_frame *native_stack) +void factor_vm::memory_protection_error(cell addr, stack_frame *native_stack) { if(in_page(addr, ds_bot, 0, -1)) general_error(ERROR_DS_UNDERFLOW,F,F,native_stack); @@ -113,22 +113,22 @@ void factorvm::memory_protection_error(cell addr, stack_frame *native_stack) general_error(ERROR_MEMORY,allot_cell(addr),F,native_stack); } -void factorvm::signal_error(int signal, stack_frame *native_stack) +void factor_vm::signal_error(int signal, stack_frame *native_stack) { general_error(ERROR_SIGNAL,tag_fixnum(signal),F,native_stack); } -void factorvm::divide_by_zero_error() +void factor_vm::divide_by_zero_error() { general_error(ERROR_DIVIDE_BY_ZERO,F,F,NULL); } -void factorvm::fp_trap_error(unsigned int fpu_status, stack_frame *signal_callstack_top) +void factor_vm::fp_trap_error(unsigned int fpu_status, stack_frame *signal_callstack_top) { general_error(ERROR_FP_TRAP,tag_fixnum(fpu_status),F,signal_callstack_top); } -inline void factorvm::primitive_call_clear() +inline void factor_vm::primitive_call_clear() { throw_impl(dpop(),stack_chain->callstack_bottom,this); } @@ -139,7 +139,7 @@ PRIMITIVE(call_clear) } /* For testing purposes */ -inline void factorvm::primitive_unimplemented() +inline void factor_vm::primitive_unimplemented() { not_implemented_error(); } @@ -149,7 +149,7 @@ PRIMITIVE(unimplemented) PRIMITIVE_GETVM()->primitive_unimplemented(); } -void factorvm::memory_signal_handler_impl() +void factor_vm::memory_signal_handler_impl() { memory_protection_error(signal_fault_addr,signal_callstack_top); } @@ -159,7 +159,7 @@ void memory_signal_handler_impl() SIGNAL_VM_PTR()->memory_signal_handler_impl(); } -void factorvm::misc_signal_handler_impl() +void factor_vm::misc_signal_handler_impl() { signal_error(signal_number,signal_callstack_top); } @@ -169,7 +169,7 @@ void misc_signal_handler_impl() SIGNAL_VM_PTR()->misc_signal_handler_impl(); } -void factorvm::fp_signal_handler_impl() +void factor_vm::fp_signal_handler_impl() { fp_trap_error(signal_fpu_status,signal_callstack_top); } diff --git a/vm/factor.cpp b/vm/factor.cpp index 8fa9869e23..b7e5c3c672 100755 --- a/vm/factor.cpp +++ b/vm/factor.cpp @@ -3,14 +3,14 @@ namespace factor { -factorvm *vm; +factor_vm *vm; void init_globals() { init_platform_globals(); } -void factorvm::default_parameters(vm_parameters *p) +void factor_vm::default_parameters(vm_parameters *p) { p->image_path = NULL; @@ -54,7 +54,7 @@ void factorvm::default_parameters(vm_parameters *p) p->stack_traces = true; } -bool factorvm::factor_arg(const vm_char* str, const vm_char* arg, cell* value) +bool factor_vm::factor_arg(const vm_char* str, const vm_char* arg, cell* value) { int val; if(SSCANF(str,arg,&val) > 0) @@ -66,7 +66,7 @@ bool factorvm::factor_arg(const vm_char* str, const vm_char* arg, cell* value) return false; } -void factorvm::init_parameters_from_args(vm_parameters *p, int argc, vm_char **argv) +void factor_vm::init_parameters_from_args(vm_parameters *p, int argc, vm_char **argv) { default_parameters(p); p->executable_path = argv[0]; @@ -92,7 +92,7 @@ void factorvm::init_parameters_from_args(vm_parameters *p, int argc, vm_char **a } /* Do some initialization that we do once only */ -void factorvm::do_stage1_init() +void factor_vm::do_stage1_init() { print_string("*** Stage 2 early init... "); fflush(stdout); @@ -104,7 +104,7 @@ void factorvm::do_stage1_init() fflush(stdout); } -void factorvm::init_factor(vm_parameters *p) +void factor_vm::init_factor(vm_parameters *p) { /* Kilobytes */ p->ds_size = align_page(p->ds_size << 10); @@ -161,7 +161,7 @@ void factorvm::init_factor(vm_parameters *p) } /* May allocate memory */ -void factorvm::pass_args_to_factor(int argc, vm_char **argv) +void factor_vm::pass_args_to_factor(int argc, vm_char **argv) { growable_array args(this); int i; @@ -174,7 +174,7 @@ void factorvm::pass_args_to_factor(int argc, vm_char **argv) userenv[ARGS_ENV] = args.elements.value(); } -void factorvm::start_factor(vm_parameters *p) +void factor_vm::start_factor(vm_parameters *p) { if(p->fep) factorbug(); @@ -183,30 +183,30 @@ void factorvm::start_factor(vm_parameters *p) unnest_stacks(); } -char *factorvm::factor_eval_string(char *string) +char *factor_vm::factor_eval_string(char *string) { char *(*callback)(char *) = (char *(*)(char *))alien_offset(userenv[EVAL_CALLBACK_ENV]); return callback(string); } -void factorvm::factor_eval_free(char *result) +void factor_vm::factor_eval_free(char *result) { free(result); } -void factorvm::factor_yield() +void factor_vm::factor_yield() { void (*callback)() = (void (*)())alien_offset(userenv[YIELD_CALLBACK_ENV]); callback(); } -void factorvm::factor_sleep(long us) +void factor_vm::factor_sleep(long us) { void (*callback)(long) = (void (*)(long))alien_offset(userenv[SLEEP_CALLBACK_ENV]); callback(us); } -void factorvm::start_standalone_factor(int argc, vm_char **argv) +void factor_vm::start_standalone_factor(int argc, vm_char **argv) { vm_parameters p; default_parameters(&p); @@ -223,7 +223,7 @@ struct startargs { void* start_standalone_factor_thread(void *arg) { - factorvm *newvm = new factorvm; + factor_vm *newvm = new factor_vm; register_vm_with_thread(newvm); startargs *args = (startargs*) arg; newvm->start_standalone_factor(args->argc, args->argv); @@ -232,7 +232,7 @@ void* start_standalone_factor_thread(void *arg) VM_C_API void start_standalone_factor(int argc, vm_char **argv) { - factorvm *newvm = new factorvm; + factor_vm *newvm = new factor_vm; vm = newvm; register_vm_with_thread(newvm); return newvm->start_standalone_factor(argc,argv); diff --git a/vm/image.cpp b/vm/image.cpp index dba87f908f..61b0de1b2a 100755 --- a/vm/image.cpp +++ b/vm/image.cpp @@ -4,7 +4,7 @@ namespace factor { /* Certain special objects in the image are known to the runtime */ -void factorvm::init_objects(image_header *h) +void factor_vm::init_objects(image_header *h) { memcpy(userenv,h->userenv,sizeof(userenv)); @@ -14,7 +14,7 @@ void factorvm::init_objects(image_header *h) bignum_neg_one = h->bignum_neg_one; } -void factorvm::load_data_heap(FILE *file, image_header *h, vm_parameters *p) +void factor_vm::load_data_heap(FILE *file, image_header *h, vm_parameters *p) { cell good_size = h->data_size + (1 << 20); @@ -47,7 +47,7 @@ void factorvm::load_data_heap(FILE *file, image_header *h, vm_parameters *p) data_relocation_base = h->data_relocation_base; } -void factorvm::load_code_heap(FILE *file, image_header *h, vm_parameters *p) +void factor_vm::load_code_heap(FILE *file, image_header *h, vm_parameters *p) { if(h->code_size > p->code_size) fatal_error("Code heap too small to fit image",h->code_size); @@ -73,7 +73,7 @@ void factorvm::load_code_heap(FILE *file, image_header *h, vm_parameters *p) } /* Save the current image to disk */ -bool factorvm::save_image(const vm_char *filename) +bool factor_vm::save_image(const vm_char *filename) { FILE* file; image_header h; @@ -118,7 +118,7 @@ bool factorvm::save_image(const vm_char *filename) return ok; } -inline void factorvm::primitive_save_image() +inline void factor_vm::primitive_save_image() { /* do a full GC to push everything into tenured space */ gc(); @@ -133,7 +133,7 @@ PRIMITIVE(save_image) PRIMITIVE_GETVM()->primitive_save_image(); } -inline void factorvm::primitive_save_image_and_exit() +inline void factor_vm::primitive_save_image_and_exit() { /* We unbox this before doing anything else. This is the only point where we might throw an error, so we have to throw an error here since @@ -164,7 +164,7 @@ PRIMITIVE(save_image_and_exit) PRIMITIVE_GETVM()->primitive_save_image_and_exit(); } -void factorvm::data_fixup(cell *cell) +void factor_vm::data_fixup(cell *cell) { if(immediate_p(*cell)) return; @@ -173,19 +173,19 @@ void factorvm::data_fixup(cell *cell) *cell += (tenured->start - data_relocation_base); } -void data_fixup(cell *cell, factorvm *myvm) +void data_fixup(cell *cell, factor_vm *myvm) { return myvm->data_fixup(cell); } -template void factorvm::code_fixup(TYPE **handle) +template void factor_vm::code_fixup(TYPE **handle) { TYPE *ptr = *handle; TYPE *new_ptr = (TYPE *)(((cell)ptr) + (code.seg->start - code_relocation_base)); *handle = new_ptr; } -void factorvm::fixup_word(word *word) +void factor_vm::fixup_word(word *word) { if(word->code) code_fixup(&word->code); @@ -194,7 +194,7 @@ void factorvm::fixup_word(word *word) code_fixup(&word->xt); } -void factorvm::fixup_quotation(quotation *quot) +void factor_vm::fixup_quotation(quotation *quot) { if(quot->code) { @@ -205,29 +205,29 @@ void factorvm::fixup_quotation(quotation *quot) quot->xt = (void *)lazy_jit_compile; } -void factorvm::fixup_alien(alien *d) +void factor_vm::fixup_alien(alien *d) { d->expired = T; } -void factorvm::fixup_stack_frame(stack_frame *frame) +void factor_vm::fixup_stack_frame(stack_frame *frame) { code_fixup(&frame->xt); code_fixup(&FRAME_RETURN_ADDRESS(frame)); } -void fixup_stack_frame(stack_frame *frame, factorvm *myvm) +void fixup_stack_frame(stack_frame *frame, factor_vm *myvm) { return myvm->fixup_stack_frame(frame); } -void factorvm::fixup_callstack_object(callstack *stack) +void factor_vm::fixup_callstack_object(callstack *stack) { iterate_callstack_object(stack,factor::fixup_stack_frame); } /* Initialize an object in a newly-loaded image */ -void factorvm::relocate_object(object *object) +void factor_vm::relocate_object(object *object) { cell hi_tag = object->h.hi_tag(); @@ -272,7 +272,7 @@ void factorvm::relocate_object(object *object) /* Since the image might have been saved with a different base address than where it is loaded, we need to fix up pointers in the image. */ -void factorvm::relocate_data() +void factor_vm::relocate_data() { cell relocating; @@ -297,7 +297,7 @@ void factorvm::relocate_data() } } -void factorvm::fixup_code_block(code_block *compiled) +void factor_vm::fixup_code_block(code_block *compiled) { /* relocate literal table data */ data_fixup(&compiled->relocation); @@ -306,19 +306,19 @@ void factorvm::fixup_code_block(code_block *compiled) relocate_code_block(compiled); } -void fixup_code_block(code_block *compiled, factorvm *myvm) +void fixup_code_block(code_block *compiled, factor_vm *myvm) { return myvm->fixup_code_block(compiled); } -void factorvm::relocate_code() +void factor_vm::relocate_code() { iterate_code_heap(factor::fixup_code_block); } /* Read an image file from disk, only done once during startup */ /* This function also initializes the data and code heaps */ -void factorvm::load_image(vm_parameters *p) +void factor_vm::load_image(vm_parameters *p) { FILE *file = OPEN_READ(p->image_path); if(file == NULL) diff --git a/vm/inline_cache.cpp b/vm/inline_cache.cpp index 16ca0fe211..99c563882a 100755 --- a/vm/inline_cache.cpp +++ b/vm/inline_cache.cpp @@ -3,12 +3,12 @@ namespace factor { -void factorvm::init_inline_caching(int max_size) +void factor_vm::init_inline_caching(int max_size) { max_pic_size = max_size; } -void factorvm::deallocate_inline_cache(cell return_address) +void factor_vm::deallocate_inline_cache(cell return_address) { /* Find the call target. */ void *old_xt = get_call_target(return_address); @@ -29,7 +29,7 @@ void factorvm::deallocate_inline_cache(cell return_address) /* Figure out what kind of type check the PIC needs based on the methods it contains */ -cell factorvm::determine_inline_cache_type(array *cache_entries) +cell factor_vm::determine_inline_cache_type(array *cache_entries) { bool seen_hi_tag = false, seen_tuple = false; @@ -66,7 +66,7 @@ cell factorvm::determine_inline_cache_type(array *cache_entries) return 0; } -void factorvm::update_pic_count(cell type) +void factor_vm::update_pic_count(cell type) { pic_counts[type - PIC_TAG]++; } @@ -74,7 +74,7 @@ void factorvm::update_pic_count(cell type) struct inline_cache_jit : public jit { fixnum index; - inline_cache_jit(cell generic_word_,factorvm *vm) : jit(PIC_TYPE,generic_word_,vm) {}; + inline_cache_jit(cell generic_word_,factor_vm *vm) : jit(PIC_TYPE,generic_word_,vm) {}; void emit_check(cell klass); void compile_inline_cache(fixnum index, @@ -138,7 +138,7 @@ void inline_cache_jit::compile_inline_cache(fixnum index, word_special(myvm->userenv[tail_call_p ? PIC_MISS_TAIL_WORD : PIC_MISS_WORD]); } -code_block *factorvm::compile_inline_cache(fixnum index,cell generic_word_,cell methods_,cell cache_entries_,bool tail_call_p) +code_block *factor_vm::compile_inline_cache(fixnum index,cell generic_word_,cell methods_,cell cache_entries_,bool tail_call_p) { gc_root generic_word(generic_word_,this); gc_root methods(methods_,this); @@ -156,18 +156,18 @@ code_block *factorvm::compile_inline_cache(fixnum index,cell generic_word_,cell } /* A generic word's definition performs general method lookup. Allocates memory */ -void *factorvm::megamorphic_call_stub(cell generic_word) +void *factor_vm::megamorphic_call_stub(cell generic_word) { return untag(generic_word)->xt; } -cell factorvm::inline_cache_size(cell cache_entries) +cell factor_vm::inline_cache_size(cell cache_entries) { return array_capacity(untag_check(cache_entries)) / 2; } /* Allocates memory */ -cell factorvm::add_inline_cache_entry(cell cache_entries_, cell klass_, cell method_) +cell factor_vm::add_inline_cache_entry(cell cache_entries_, cell klass_, cell method_) { gc_root cache_entries(cache_entries_,this); gc_root klass(klass_,this); @@ -180,7 +180,7 @@ cell factorvm::add_inline_cache_entry(cell cache_entries_, cell klass_, cell met return new_cache_entries.value(); } -void factorvm::update_pic_transitions(cell pic_size) +void factor_vm::update_pic_transitions(cell pic_size) { if(pic_size == max_pic_size) pic_to_mega_transitions++; @@ -192,7 +192,7 @@ void factorvm::update_pic_transitions(cell pic_size) /* The cache_entries parameter is either f (on cold call site) or an array (on cache miss). Called from assembly with the actual return address */ -void *factorvm::inline_cache_miss(cell return_address) +void *factor_vm::inline_cache_miss(cell return_address) { check_code_pointer(return_address); @@ -244,13 +244,13 @@ void *factorvm::inline_cache_miss(cell return_address) return xt; } -VM_C_API void *inline_cache_miss(cell return_address, factorvm *myvm) +VM_C_API void *inline_cache_miss(cell return_address, factor_vm *myvm) { ASSERTVM(); return VM_PTR->inline_cache_miss(return_address); } -inline void factorvm::primitive_reset_inline_cache_stats() +inline void factor_vm::primitive_reset_inline_cache_stats() { cold_call_to_ic_transitions = ic_to_pic_transitions = pic_to_mega_transitions = 0; cell i; @@ -262,7 +262,7 @@ PRIMITIVE(reset_inline_cache_stats) PRIMITIVE_GETVM()->primitive_reset_inline_cache_stats(); } -inline void factorvm::primitive_inline_cache_stats() +inline void factor_vm::primitive_inline_cache_stats() { growable_array stats(this); stats.add(allot_cell(cold_call_to_ic_transitions)); diff --git a/vm/inline_cache.hpp b/vm/inline_cache.hpp index 02ac43dce8..4292adcd9d 100644 --- a/vm/inline_cache.hpp +++ b/vm/inline_cache.hpp @@ -5,6 +5,6 @@ PRIMITIVE(inline_cache_stats); PRIMITIVE(inline_cache_miss); PRIMITIVE(inline_cache_miss_tail); -VM_C_API void *inline_cache_miss(cell return_address, factorvm *vm); +VM_C_API void *inline_cache_miss(cell return_address, factor_vm *vm); } diff --git a/vm/inlineimpls.hpp b/vm/inlineimpls.hpp index 6d218bf8b3..600629608e 100644 --- a/vm/inlineimpls.hpp +++ b/vm/inlineimpls.hpp @@ -6,58 +6,58 @@ namespace factor // segments.hpp -inline cell factorvm::align_page(cell a) +inline cell factor_vm::align_page(cell a) { return align(a,getpagesize()); } // write_barrier.hpp -inline card *factorvm::addr_to_card(cell a) +inline card *factor_vm::addr_to_card(cell a) { return (card*)(((cell)(a) >> card_bits) + cards_offset); } -inline cell factorvm::card_to_addr(card *c) +inline cell factor_vm::card_to_addr(card *c) { return ((cell)c - cards_offset) << card_bits; } -inline cell factorvm::card_offset(card *c) +inline cell factor_vm::card_offset(card *c) { return *(c - (cell)data->cards + (cell)data->allot_markers); } -inline card_deck *factorvm::addr_to_deck(cell a) +inline card_deck *factor_vm::addr_to_deck(cell a) { return (card_deck *)(((cell)a >> deck_bits) + decks_offset); } -inline cell factorvm::deck_to_addr(card_deck *c) +inline cell factor_vm::deck_to_addr(card_deck *c) { return ((cell)c - decks_offset) << deck_bits; } -inline card *factorvm::deck_to_card(card_deck *d) +inline card *factor_vm::deck_to_card(card_deck *d) { return (card *)((((cell)d - decks_offset) << (deck_bits - card_bits)) + cards_offset); } -inline card *factorvm::addr_to_allot_marker(object *a) +inline card *factor_vm::addr_to_allot_marker(object *a) { return (card *)(((cell)a >> card_bits) + allot_markers_offset); } /* the write barrier must be called any time we are potentially storing a pointer from an older generation to a younger one */ -inline void factorvm::write_barrier(object *obj) +inline void factor_vm::write_barrier(object *obj) { *addr_to_card((cell)obj) = card_mark_mask; *addr_to_deck((cell)obj) = card_mark_mask; } /* we need to remember the first object allocated in the card */ -inline void factorvm::allot_barrier(object *address) +inline void factor_vm::allot_barrier(object *address) { card *ptr = addr_to_allot_marker(address); if(*ptr == invalid_allot_marker) @@ -65,7 +65,7 @@ inline void factorvm::allot_barrier(object *address) } //data_gc.hpp -inline bool factorvm::collecting_accumulation_gen_p() +inline bool factor_vm::collecting_accumulation_gen_p() { return ((data->have_aging_p() && collecting_gen == data->aging() @@ -73,7 +73,7 @@ inline bool factorvm::collecting_accumulation_gen_p() || collecting_gen == data->tenured()); } -inline object *factorvm::allot_zone(zone *z, cell a) +inline object *factor_vm::allot_zone(zone *z, cell a) { cell h = z->here; z->here = h + align8(a); @@ -86,7 +86,7 @@ inline object *factorvm::allot_zone(zone *z, cell a) * It is up to the caller to fill in the object's fields in a meaningful * fashion! */ -inline object *factorvm::allot_object(header header, cell size) +inline object *factor_vm::allot_object(header header, cell size) { #ifdef GC_DEBUG if(!gc_off) @@ -137,12 +137,12 @@ inline object *factorvm::allot_object(header header, cell size) return obj; } -template TYPE *factorvm::allot(cell size) +template TYPE *factor_vm::allot(cell size) { return (TYPE *)allot_object(header(TYPE::type_number),size); } -inline void factorvm::check_data_pointer(object *pointer) +inline void factor_vm::check_data_pointer(object *pointer) { #ifdef FACTOR_DEBUG if(!growing_data_heap) @@ -153,7 +153,7 @@ inline void factorvm::check_data_pointer(object *pointer) #endif } -inline void factorvm::check_tagged_pointer(cell tagged) +inline void factor_vm::check_tagged_pointer(cell tagged) { #ifdef FACTOR_DEBUG if(!immediate_p(tagged)) @@ -169,12 +169,12 @@ inline void factorvm::check_tagged_pointer(cell tagged) template struct gc_root : public tagged { - factorvm *myvm; + factor_vm *myvm; void push() { myvm->check_tagged_pointer(tagged::value()); myvm->gc_locals.push_back((cell)this); } - explicit gc_root(cell value_,factorvm *vm) : tagged(value_),myvm(vm) { push(); } - explicit gc_root(TYPE *value_, factorvm *vm) : tagged(value_),myvm(vm) { push(); } + explicit gc_root(cell value_,factor_vm *vm) : tagged(value_),myvm(vm) { push(); } + explicit gc_root(TYPE *value_, factor_vm *vm) : tagged(value_),myvm(vm) { push(); } const gc_root& operator=(const TYPE *x) { tagged::operator=(x); return *this; } const gc_root& operator=(const cell &x) { tagged::operator=(x); return *this; } @@ -191,8 +191,8 @@ struct gc_root : public tagged struct gc_bignum { bignum **addr; - factorvm *myvm; - gc_bignum(bignum **addr_, factorvm *vm) : addr(addr_), myvm(vm) { + factor_vm *myvm; + gc_bignum(bignum **addr_, factor_vm *vm) : addr(addr_), myvm(vm) { if(*addr_) myvm->check_data_pointer(*addr_); myvm->gc_bignums.push_back((cell)addr); @@ -209,19 +209,19 @@ struct gc_bignum #define GC_BIGNUM(x) gc_bignum x##__gc_root(&x,this) //generic_arrays.hpp -template TYPE *factorvm::allot_array_internal(cell capacity) +template TYPE *factor_vm::allot_array_internal(cell capacity) { TYPE *array = allot(array_size(capacity)); array->capacity = tag_fixnum(capacity); return array; } -template bool factorvm::reallot_array_in_place_p(TYPE *array, cell capacity) +template bool factor_vm::reallot_array_in_place_p(TYPE *array, cell capacity) { return in_zone(&nursery,array) && capacity <= array_capacity(array); } -template TYPE *factorvm::reallot_array(TYPE *array_, cell capacity) +template TYPE *factor_vm::reallot_array(TYPE *array_, cell capacity) { gc_root array(array_,this); @@ -247,7 +247,7 @@ template TYPE *factorvm::reallot_array(TYPE *array_, cell capaci } //arrays.hpp -inline void factorvm::set_array_nth(array *array, cell slot, cell value) +inline void factor_vm::set_array_nth(array *array, cell slot, cell value) { #ifdef FACTOR_DEBUG assert(slot < array_capacity(array)); @@ -262,7 +262,7 @@ struct growable_array { cell count; gc_root elements; - growable_array(factorvm *myvm, cell capacity = 10) : count(0), elements(myvm->allot_array(capacity,F),myvm) {} + growable_array(factor_vm *myvm, cell capacity = 10) : count(0), elements(myvm->allot_array(capacity,F),myvm) {} void add(cell elt); void trim(); @@ -273,7 +273,7 @@ struct growable_byte_array { cell count; gc_root elements; - growable_byte_array(factorvm *myvm,cell capacity = 40) : count(0), elements(myvm->allot_byte_array(capacity),myvm) { } + growable_byte_array(factor_vm *myvm,cell capacity = 40) : count(0), elements(myvm->allot_byte_array(capacity),myvm) { } void append_bytes(void *elts, cell len); void append_byte_array(cell elts); @@ -282,7 +282,7 @@ struct growable_byte_array { }; //math.hpp -inline cell factorvm::allot_integer(fixnum x) +inline cell factor_vm::allot_integer(fixnum x) { if(x < fixnum_min || x > fixnum_max) return tag(fixnum_to_bignum(x)); @@ -290,7 +290,7 @@ inline cell factorvm::allot_integer(fixnum x) return tag_fixnum(x); } -inline cell factorvm::allot_cell(cell x) +inline cell factor_vm::allot_cell(cell x) { if(x > (cell)fixnum_max) return tag(cell_to_bignum(x)); @@ -298,39 +298,39 @@ inline cell factorvm::allot_cell(cell x) return tag_fixnum(x); } -inline cell factorvm::allot_float(double n) +inline cell factor_vm::allot_float(double n) { boxed_float *flo = allot(sizeof(boxed_float)); flo->n = n; return tag(flo); } -inline bignum *factorvm::float_to_bignum(cell tagged) +inline bignum *factor_vm::float_to_bignum(cell tagged) { return double_to_bignum(untag_float(tagged)); } -inline double factorvm::bignum_to_float(cell tagged) +inline double factor_vm::bignum_to_float(cell tagged) { return bignum_to_double(untag(tagged)); } -inline double factorvm::untag_float(cell tagged) +inline double factor_vm::untag_float(cell tagged) { return untag(tagged)->n; } -inline double factorvm::untag_float_check(cell tagged) +inline double factor_vm::untag_float_check(cell tagged) { return untag_check(tagged)->n; } -inline fixnum factorvm::float_to_fixnum(cell tagged) +inline fixnum factor_vm::float_to_fixnum(cell tagged) { return (fixnum)untag_float(tagged); } -inline double factorvm::fixnum_to_float(cell tagged) +inline double factor_vm::fixnum_to_float(cell tagged) { return (double)untag_fixnum(tagged); } @@ -338,7 +338,7 @@ inline double factorvm::fixnum_to_float(cell tagged) //callstack.hpp /* This is a little tricky. The iterator may allocate memory, so we keep the callstack in a GC root and use relative offsets */ -template void factorvm::iterate_callstack_object(callstack *stack_, TYPE &iterator) +template void factor_vm::iterate_callstack_object(callstack *stack_, TYPE &iterator) { gc_root stack(stack_,this); fixnum frame_offset = untag_fixnum(stack->length) - sizeof(stack_frame); @@ -352,13 +352,13 @@ template void factorvm::iterate_callstack_object(callstack *stack } //booleans.hpp -inline cell factorvm::tag_boolean(cell untagged) +inline cell factor_vm::tag_boolean(cell untagged) { return (untagged ? T : F); } // callstack.hpp -template void factorvm::iterate_callstack(cell top, cell bottom, TYPE &iterator) +template void factor_vm::iterate_callstack(cell top, cell bottom, TYPE &iterator) { stack_frame *frame = (stack_frame *)bottom - 1; @@ -373,8 +373,8 @@ template void factorvm::iterate_callstack(cell top, cell bottom, /* Every object has a regular representation in the runtime, which makes GC much simpler. Every slot of the object until binary_payload_start is a pointer to some other object. */ -struct factorvm; -inline void factorvm::do_slots(cell obj, void (* iter)(cell *,factorvm*)) +struct factor_vm; +inline void factor_vm::do_slots(cell obj, void (* iter)(cell *,factor_vm*)) { cell scan = obj; cell payload_start = binary_payload_start((object *)obj); @@ -391,7 +391,7 @@ inline void factorvm::do_slots(cell obj, void (* iter)(cell *,factorvm*)) // code_heap.hpp -inline void factorvm::check_code_pointer(cell ptr) +inline void factor_vm::check_code_pointer(cell ptr) { #ifdef FACTOR_DEBUG assert(in_code_heap_p(ptr)); diff --git a/vm/io.cpp b/vm/io.cpp index fed0fa60d9..1ec9cf2cb6 100755 --- a/vm/io.cpp +++ b/vm/io.cpp @@ -14,14 +14,14 @@ The Factor library provides platform-specific code for Unix and Windows with many more capabilities so these words are not usually used in normal operation. */ -void factorvm::init_c_io() +void factor_vm::init_c_io() { userenv[STDIN_ENV] = allot_alien(F,(cell)stdin); userenv[STDOUT_ENV] = allot_alien(F,(cell)stdout); userenv[STDERR_ENV] = allot_alien(F,(cell)stderr); } -void factorvm::io_error() +void factor_vm::io_error() { #ifndef WINCE if(errno == EINTR) @@ -31,7 +31,7 @@ void factorvm::io_error() general_error(ERROR_IO,tag_fixnum(errno),F,NULL); } -inline void factorvm::primitive_fopen() +inline void factor_vm::primitive_fopen() { gc_root mode(dpop(),this); gc_root path(dpop(),this); @@ -57,7 +57,7 @@ PRIMITIVE(fopen) PRIMITIVE_GETVM()->primitive_fopen(); } -inline void factorvm::primitive_fgetc() +inline void factor_vm::primitive_fgetc() { FILE *file = (FILE *)unbox_alien(); @@ -87,7 +87,7 @@ PRIMITIVE(fgetc) PRIMITIVE_GETVM()->primitive_fgetc(); } -inline void factorvm::primitive_fread() +inline void factor_vm::primitive_fread() { FILE *file = (FILE *)unbox_alien(); fixnum size = unbox_array_size(); @@ -132,7 +132,7 @@ PRIMITIVE(fread) PRIMITIVE_GETVM()->primitive_fread(); } -inline void factorvm::primitive_fputc() +inline void factor_vm::primitive_fputc() { FILE *file = (FILE *)unbox_alien(); fixnum ch = to_fixnum(dpop()); @@ -155,7 +155,7 @@ PRIMITIVE(fputc) PRIMITIVE_GETVM()->primitive_fputc(); } -inline void factorvm::primitive_fwrite() +inline void factor_vm::primitive_fwrite() { FILE *file = (FILE *)unbox_alien(); byte_array *text = untag_check(dpop()); @@ -189,7 +189,7 @@ PRIMITIVE(fwrite) PRIMITIVE_GETVM()->primitive_fwrite(); } -inline void factorvm::primitive_fseek() +inline void factor_vm::primitive_fseek() { int whence = to_fixnum(dpop()); FILE *file = (FILE *)unbox_alien(); @@ -219,7 +219,7 @@ PRIMITIVE(fseek) PRIMITIVE_GETVM()->primitive_fseek(); } -inline void factorvm::primitive_fflush() +inline void factor_vm::primitive_fflush() { FILE *file = (FILE *)unbox_alien(); for(;;) @@ -236,7 +236,7 @@ PRIMITIVE(fflush) PRIMITIVE_GETVM()->primitive_fflush(); } -inline void factorvm::primitive_fclose() +inline void factor_vm::primitive_fclose() { FILE *file = (FILE *)unbox_alien(); for(;;) diff --git a/vm/jit.cpp b/vm/jit.cpp index cdb5acace3..597575fcfd 100644 --- a/vm/jit.cpp +++ b/vm/jit.cpp @@ -10,7 +10,7 @@ namespace factor - polymorphic inline caches (inline_cache.cpp) */ /* Allocates memory */ -jit::jit(cell type_, cell owner_, factorvm *vm) +jit::jit(cell type_, cell owner_, factor_vm *vm) : type(type_), owner(owner_,vm), code(vm), diff --git a/vm/jit.hpp b/vm/jit.hpp index a44f359ffe..1004da9636 100644 --- a/vm/jit.hpp +++ b/vm/jit.hpp @@ -10,9 +10,9 @@ struct jit { bool computing_offset_p; fixnum position; cell offset; - factorvm *myvm; + factor_vm *myvm; - jit(cell jit_type, cell owner, factorvm *vm); + jit(cell jit_type, cell owner, factor_vm *vm); void compute_position(cell offset); void emit_relocation(cell code_template); diff --git a/vm/mach_signal.cpp b/vm/mach_signal.cpp index 9cf792e68b..261f0fb654 100644 --- a/vm/mach_signal.cpp +++ b/vm/mach_signal.cpp @@ -28,7 +28,7 @@ http://www.wodeveloper.com/omniLists/macosx-dev/2000/June/msg00137.html */ /* Modify a suspended thread's thread_state so that when the thread resumes executing, the call frame of the current C primitive (if any) is rewound, and the appropriate Factor error is thrown from the top-most Factor frame. */ -void factorvm::call_fault_handler( +void factor_vm::call_fault_handler( exception_type_t exception, exception_data_type_t code, MACH_EXC_STATE_TYPE *exc_state, diff --git a/vm/math.cpp b/vm/math.cpp index c14d1dd969..61ec096c59 100755 --- a/vm/math.cpp +++ b/vm/math.cpp @@ -3,7 +3,7 @@ namespace factor { -inline void factorvm::primitive_bignum_to_fixnum() +inline void factor_vm::primitive_bignum_to_fixnum() { drepl(tag_fixnum(bignum_to_fixnum(untag(dpeek())))); } @@ -13,7 +13,7 @@ PRIMITIVE(bignum_to_fixnum) PRIMITIVE_GETVM()->primitive_bignum_to_fixnum(); } -inline void factorvm::primitive_float_to_fixnum() +inline void factor_vm::primitive_float_to_fixnum() { drepl(tag_fixnum(float_to_fixnum(dpeek()))); } @@ -25,7 +25,7 @@ PRIMITIVE(float_to_fixnum) /* Division can only overflow when we are dividing the most negative fixnum by -1. */ -inline void factorvm::primitive_fixnum_divint() +inline void factor_vm::primitive_fixnum_divint() { fixnum y = untag_fixnum(dpop()); \ fixnum x = untag_fixnum(dpeek()); @@ -41,7 +41,7 @@ PRIMITIVE(fixnum_divint) PRIMITIVE_GETVM()->primitive_fixnum_divint(); } -inline void factorvm::primitive_fixnum_divmod() +inline void factor_vm::primitive_fixnum_divmod() { cell y = ((cell *)ds)[0]; cell x = ((cell *)ds)[-1]; @@ -66,22 +66,22 @@ PRIMITIVE(fixnum_divmod) * If we're shifting right by n bits, we won't overflow as long as none of the * high WORD_SIZE-TAG_BITS-n bits are set. */ -inline fixnum factorvm::sign_mask(fixnum x) +inline fixnum factor_vm::sign_mask(fixnum x) { return x >> (WORD_SIZE - 1); } -inline fixnum factorvm::branchless_max(fixnum x, fixnum y) +inline fixnum factor_vm::branchless_max(fixnum x, fixnum y) { return (x - ((x - y) & sign_mask(x - y))); } -inline fixnum factorvm::branchless_abs(fixnum x) +inline fixnum factor_vm::branchless_abs(fixnum x) { return (x ^ sign_mask(x)) - sign_mask(x); } -inline void factorvm::primitive_fixnum_shift() +inline void factor_vm::primitive_fixnum_shift() { fixnum y = untag_fixnum(dpop()); fixnum x = untag_fixnum(dpeek()); @@ -113,7 +113,7 @@ PRIMITIVE(fixnum_shift) PRIMITIVE_GETVM()->primitive_fixnum_shift(); } -inline void factorvm::primitive_fixnum_to_bignum() +inline void factor_vm::primitive_fixnum_to_bignum() { drepl(tag(fixnum_to_bignum(untag_fixnum(dpeek())))); } @@ -123,7 +123,7 @@ PRIMITIVE(fixnum_to_bignum) PRIMITIVE_GETVM()->primitive_fixnum_to_bignum(); } -inline void factorvm::primitive_float_to_bignum() +inline void factor_vm::primitive_float_to_bignum() { drepl(tag(float_to_bignum(dpeek()))); } @@ -137,7 +137,7 @@ PRIMITIVE(float_to_bignum) bignum * y = untag(dpop()); \ bignum * x = untag(dpop()); -inline void factorvm::primitive_bignum_eq() +inline void factor_vm::primitive_bignum_eq() { POP_BIGNUMS(x,y); box_boolean(bignum_equal_p(x,y)); @@ -148,7 +148,7 @@ PRIMITIVE(bignum_eq) PRIMITIVE_GETVM()->primitive_bignum_eq(); } -inline void factorvm::primitive_bignum_add() +inline void factor_vm::primitive_bignum_add() { POP_BIGNUMS(x,y); dpush(tag(bignum_add(x,y))); @@ -159,7 +159,7 @@ PRIMITIVE(bignum_add) PRIMITIVE_GETVM()->primitive_bignum_add(); } -inline void factorvm::primitive_bignum_subtract() +inline void factor_vm::primitive_bignum_subtract() { POP_BIGNUMS(x,y); dpush(tag(bignum_subtract(x,y))); @@ -170,7 +170,7 @@ PRIMITIVE(bignum_subtract) PRIMITIVE_GETVM()->primitive_bignum_subtract(); } -inline void factorvm::primitive_bignum_multiply() +inline void factor_vm::primitive_bignum_multiply() { POP_BIGNUMS(x,y); dpush(tag(bignum_multiply(x,y))); @@ -181,7 +181,7 @@ PRIMITIVE(bignum_multiply) PRIMITIVE_GETVM()->primitive_bignum_multiply(); } -inline void factorvm::primitive_bignum_divint() +inline void factor_vm::primitive_bignum_divint() { POP_BIGNUMS(x,y); dpush(tag(bignum_quotient(x,y))); @@ -192,7 +192,7 @@ PRIMITIVE(bignum_divint) PRIMITIVE_GETVM()->primitive_bignum_divint(); } -inline void factorvm::primitive_bignum_divmod() +inline void factor_vm::primitive_bignum_divmod() { bignum *q, *r; POP_BIGNUMS(x,y); @@ -206,7 +206,7 @@ PRIMITIVE(bignum_divmod) PRIMITIVE_GETVM()->primitive_bignum_divmod(); } -inline void factorvm::primitive_bignum_mod() +inline void factor_vm::primitive_bignum_mod() { POP_BIGNUMS(x,y); dpush(tag(bignum_remainder(x,y))); @@ -217,7 +217,7 @@ PRIMITIVE(bignum_mod) PRIMITIVE_GETVM()->primitive_bignum_mod(); } -inline void factorvm::primitive_bignum_and() +inline void factor_vm::primitive_bignum_and() { POP_BIGNUMS(x,y); dpush(tag(bignum_bitwise_and(x,y))); @@ -228,7 +228,7 @@ PRIMITIVE(bignum_and) PRIMITIVE_GETVM()->primitive_bignum_and(); } -inline void factorvm::primitive_bignum_or() +inline void factor_vm::primitive_bignum_or() { POP_BIGNUMS(x,y); dpush(tag(bignum_bitwise_ior(x,y))); @@ -239,7 +239,7 @@ PRIMITIVE(bignum_or) PRIMITIVE_GETVM()->primitive_bignum_or(); } -inline void factorvm::primitive_bignum_xor() +inline void factor_vm::primitive_bignum_xor() { POP_BIGNUMS(x,y); dpush(tag(bignum_bitwise_xor(x,y))); @@ -250,7 +250,7 @@ PRIMITIVE(bignum_xor) PRIMITIVE_GETVM()->primitive_bignum_xor(); } -inline void factorvm::primitive_bignum_shift() +inline void factor_vm::primitive_bignum_shift() { fixnum y = untag_fixnum(dpop()); bignum* x = untag(dpop()); @@ -262,7 +262,7 @@ PRIMITIVE(bignum_shift) PRIMITIVE_GETVM()->primitive_bignum_shift(); } -inline void factorvm::primitive_bignum_less() +inline void factor_vm::primitive_bignum_less() { POP_BIGNUMS(x,y); box_boolean(bignum_compare(x,y) == bignum_comparison_less); @@ -273,7 +273,7 @@ PRIMITIVE(bignum_less) PRIMITIVE_GETVM()->primitive_bignum_less(); } -inline void factorvm::primitive_bignum_lesseq() +inline void factor_vm::primitive_bignum_lesseq() { POP_BIGNUMS(x,y); box_boolean(bignum_compare(x,y) != bignum_comparison_greater); @@ -284,7 +284,7 @@ PRIMITIVE(bignum_lesseq) PRIMITIVE_GETVM()->primitive_bignum_lesseq(); } -inline void factorvm::primitive_bignum_greater() +inline void factor_vm::primitive_bignum_greater() { POP_BIGNUMS(x,y); box_boolean(bignum_compare(x,y) == bignum_comparison_greater); @@ -295,7 +295,7 @@ PRIMITIVE(bignum_greater) PRIMITIVE_GETVM()->primitive_bignum_greater(); } -inline void factorvm::primitive_bignum_greatereq() +inline void factor_vm::primitive_bignum_greatereq() { POP_BIGNUMS(x,y); box_boolean(bignum_compare(x,y) != bignum_comparison_less); @@ -306,7 +306,7 @@ PRIMITIVE(bignum_greatereq) PRIMITIVE_GETVM()->primitive_bignum_greatereq(); } -inline void factorvm::primitive_bignum_not() +inline void factor_vm::primitive_bignum_not() { drepl(tag(bignum_bitwise_not(untag(dpeek())))); } @@ -316,7 +316,7 @@ PRIMITIVE(bignum_not) PRIMITIVE_GETVM()->primitive_bignum_not(); } -inline void factorvm::primitive_bignum_bitp() +inline void factor_vm::primitive_bignum_bitp() { fixnum bit = to_fixnum(dpop()); bignum *x = untag(dpop()); @@ -328,7 +328,7 @@ PRIMITIVE(bignum_bitp) PRIMITIVE_GETVM()->primitive_bignum_bitp(); } -inline void factorvm::primitive_bignum_log2() +inline void factor_vm::primitive_bignum_log2() { drepl(tag(bignum_integer_length(untag(dpeek())))); } @@ -338,18 +338,18 @@ PRIMITIVE(bignum_log2) PRIMITIVE_GETVM()->primitive_bignum_log2(); } -unsigned int factorvm::bignum_producer(unsigned int digit) +unsigned int factor_vm::bignum_producer(unsigned int digit) { unsigned char *ptr = (unsigned char *)alien_offset(dpeek()); return *(ptr + digit); } -unsigned int bignum_producer(unsigned int digit, factorvm *myvm) +unsigned int bignum_producer(unsigned int digit, factor_vm *myvm) { return myvm->bignum_producer(digit); } -inline void factorvm::primitive_byte_array_to_bignum() +inline void factor_vm::primitive_byte_array_to_bignum() { cell n_digits = array_capacity(untag_check(dpeek())); bignum * result = digit_stream_to_bignum(n_digits,factor::bignum_producer,0x100,0); @@ -361,7 +361,7 @@ PRIMITIVE(byte_array_to_bignum) PRIMITIVE_GETVM()->primitive_byte_array_to_bignum(); } -cell factorvm::unbox_array_size() +cell factor_vm::unbox_array_size() { switch(tagged(dpeek()).type()) { @@ -394,7 +394,7 @@ cell factorvm::unbox_array_size() return 0; /* can't happen */ } -inline void factorvm::primitive_fixnum_to_float() +inline void factor_vm::primitive_fixnum_to_float() { drepl(allot_float(fixnum_to_float(dpeek()))); } @@ -404,7 +404,7 @@ PRIMITIVE(fixnum_to_float) PRIMITIVE_GETVM()->primitive_fixnum_to_float(); } -inline void factorvm::primitive_bignum_to_float() +inline void factor_vm::primitive_bignum_to_float() { drepl(allot_float(bignum_to_float(dpeek()))); } @@ -414,7 +414,7 @@ PRIMITIVE(bignum_to_float) PRIMITIVE_GETVM()->primitive_bignum_to_float(); } -inline void factorvm::primitive_str_to_float() +inline void factor_vm::primitive_str_to_float() { byte_array *bytes = untag_check(dpeek()); cell capacity = array_capacity(bytes); @@ -433,7 +433,7 @@ PRIMITIVE(str_to_float) PRIMITIVE_GETVM()->primitive_str_to_float(); } -inline void factorvm::primitive_float_to_str() +inline void factor_vm::primitive_float_to_str() { byte_array *array = allot_byte_array(33); snprintf((char *)(array + 1),32,"%.16g",untag_float_check(dpop())); @@ -449,7 +449,7 @@ PRIMITIVE(float_to_str) double y = untag_float(dpop()); \ double x = untag_float(dpop()); -inline void factorvm::primitive_float_eq() +inline void factor_vm::primitive_float_eq() { POP_FLOATS(x,y); box_boolean(x == y); @@ -460,7 +460,7 @@ PRIMITIVE(float_eq) PRIMITIVE_GETVM()->primitive_float_eq(); } -inline void factorvm::primitive_float_add() +inline void factor_vm::primitive_float_add() { POP_FLOATS(x,y); box_double(x + y); @@ -471,7 +471,7 @@ PRIMITIVE(float_add) PRIMITIVE_GETVM()->primitive_float_add(); } -inline void factorvm::primitive_float_subtract() +inline void factor_vm::primitive_float_subtract() { POP_FLOATS(x,y); box_double(x - y); @@ -482,7 +482,7 @@ PRIMITIVE(float_subtract) PRIMITIVE_GETVM()->primitive_float_subtract(); } -inline void factorvm::primitive_float_multiply() +inline void factor_vm::primitive_float_multiply() { POP_FLOATS(x,y); box_double(x * y); @@ -493,7 +493,7 @@ PRIMITIVE(float_multiply) PRIMITIVE_GETVM()->primitive_float_multiply(); } -inline void factorvm::primitive_float_divfloat() +inline void factor_vm::primitive_float_divfloat() { POP_FLOATS(x,y); box_double(x / y); @@ -504,7 +504,7 @@ PRIMITIVE(float_divfloat) PRIMITIVE_GETVM()->primitive_float_divfloat(); } -inline void factorvm::primitive_float_mod() +inline void factor_vm::primitive_float_mod() { POP_FLOATS(x,y); box_double(fmod(x,y)); @@ -515,7 +515,7 @@ PRIMITIVE(float_mod) PRIMITIVE_GETVM()->primitive_float_mod(); } -inline void factorvm::primitive_float_less() +inline void factor_vm::primitive_float_less() { POP_FLOATS(x,y); box_boolean(x < y); @@ -526,7 +526,7 @@ PRIMITIVE(float_less) PRIMITIVE_GETVM()->primitive_float_less(); } -inline void factorvm::primitive_float_lesseq() +inline void factor_vm::primitive_float_lesseq() { POP_FLOATS(x,y); box_boolean(x <= y); @@ -537,7 +537,7 @@ PRIMITIVE(float_lesseq) PRIMITIVE_GETVM()->primitive_float_lesseq(); } -inline void factorvm::primitive_float_greater() +inline void factor_vm::primitive_float_greater() { POP_FLOATS(x,y); box_boolean(x > y); @@ -548,7 +548,7 @@ PRIMITIVE(float_greater) PRIMITIVE_GETVM()->primitive_float_greater(); } -inline void factorvm::primitive_float_greatereq() +inline void factor_vm::primitive_float_greatereq() { POP_FLOATS(x,y); box_boolean(x >= y); @@ -559,7 +559,7 @@ PRIMITIVE(float_greatereq) PRIMITIVE_GETVM()->primitive_float_greatereq(); } -inline void factorvm::primitive_float_bits() +inline void factor_vm::primitive_float_bits() { box_unsigned_4(float_bits(untag_float_check(dpop()))); } @@ -569,7 +569,7 @@ PRIMITIVE(float_bits) PRIMITIVE_GETVM()->primitive_float_bits(); } -inline void factorvm::primitive_bits_float() +inline void factor_vm::primitive_bits_float() { box_float(bits_float(to_cell(dpop()))); } @@ -579,7 +579,7 @@ PRIMITIVE(bits_float) PRIMITIVE_GETVM()->primitive_bits_float(); } -inline void factorvm::primitive_double_bits() +inline void factor_vm::primitive_double_bits() { box_unsigned_8(double_bits(untag_float_check(dpop()))); } @@ -589,7 +589,7 @@ PRIMITIVE(double_bits) PRIMITIVE_GETVM()->primitive_double_bits(); } -inline void factorvm::primitive_bits_double() +inline void factor_vm::primitive_bits_double() { box_double(bits_double(to_unsigned_8(dpop()))); } @@ -599,7 +599,7 @@ PRIMITIVE(bits_double) PRIMITIVE_GETVM()->primitive_bits_double(); } -fixnum factorvm::to_fixnum(cell tagged) +fixnum factor_vm::to_fixnum(cell tagged) { switch(TAG(tagged)) { @@ -613,112 +613,112 @@ fixnum factorvm::to_fixnum(cell tagged) } } -VM_C_API fixnum to_fixnum(cell tagged,factorvm *myvm) +VM_C_API fixnum to_fixnum(cell tagged,factor_vm *myvm) { ASSERTVM(); return VM_PTR->to_fixnum(tagged); } -cell factorvm::to_cell(cell tagged) +cell factor_vm::to_cell(cell tagged) { return (cell)to_fixnum(tagged); } -VM_C_API cell to_cell(cell tagged, factorvm *myvm) +VM_C_API cell to_cell(cell tagged, factor_vm *myvm) { ASSERTVM(); return VM_PTR->to_cell(tagged); } -void factorvm::box_signed_1(s8 n) +void factor_vm::box_signed_1(s8 n) { dpush(tag_fixnum(n)); } -VM_C_API void box_signed_1(s8 n,factorvm *myvm) +VM_C_API void box_signed_1(s8 n,factor_vm *myvm) { ASSERTVM(); return VM_PTR->box_signed_1(n); } -void factorvm::box_unsigned_1(u8 n) +void factor_vm::box_unsigned_1(u8 n) { dpush(tag_fixnum(n)); } -VM_C_API void box_unsigned_1(u8 n,factorvm *myvm) +VM_C_API void box_unsigned_1(u8 n,factor_vm *myvm) { ASSERTVM(); return VM_PTR->box_unsigned_1(n); } -void factorvm::box_signed_2(s16 n) +void factor_vm::box_signed_2(s16 n) { dpush(tag_fixnum(n)); } -VM_C_API void box_signed_2(s16 n,factorvm *myvm) +VM_C_API void box_signed_2(s16 n,factor_vm *myvm) { ASSERTVM(); return VM_PTR->box_signed_2(n); } -void factorvm::box_unsigned_2(u16 n) +void factor_vm::box_unsigned_2(u16 n) { dpush(tag_fixnum(n)); } -VM_C_API void box_unsigned_2(u16 n,factorvm *myvm) +VM_C_API void box_unsigned_2(u16 n,factor_vm *myvm) { ASSERTVM(); return VM_PTR->box_unsigned_2(n); } -void factorvm::box_signed_4(s32 n) +void factor_vm::box_signed_4(s32 n) { dpush(allot_integer(n)); } -VM_C_API void box_signed_4(s32 n,factorvm *myvm) +VM_C_API void box_signed_4(s32 n,factor_vm *myvm) { ASSERTVM(); return VM_PTR->box_signed_4(n); } -void factorvm::box_unsigned_4(u32 n) +void factor_vm::box_unsigned_4(u32 n) { dpush(allot_cell(n)); } -VM_C_API void box_unsigned_4(u32 n,factorvm *myvm) +VM_C_API void box_unsigned_4(u32 n,factor_vm *myvm) { ASSERTVM(); return VM_PTR->box_unsigned_4(n); } -void factorvm::box_signed_cell(fixnum integer) +void factor_vm::box_signed_cell(fixnum integer) { dpush(allot_integer(integer)); } -VM_C_API void box_signed_cell(fixnum integer,factorvm *myvm) +VM_C_API void box_signed_cell(fixnum integer,factor_vm *myvm) { ASSERTVM(); return VM_PTR->box_signed_cell(integer); } -void factorvm::box_unsigned_cell(cell cell) +void factor_vm::box_unsigned_cell(cell cell) { dpush(allot_cell(cell)); } -VM_C_API void box_unsigned_cell(cell cell,factorvm *myvm) +VM_C_API void box_unsigned_cell(cell cell,factor_vm *myvm) { ASSERTVM(); return VM_PTR->box_unsigned_cell(cell); } -void factorvm::box_signed_8(s64 n) +void factor_vm::box_signed_8(s64 n) { if(n < fixnum_min || n > fixnum_max) dpush(tag(long_long_to_bignum(n))); @@ -726,13 +726,13 @@ void factorvm::box_signed_8(s64 n) dpush(tag_fixnum(n)); } -VM_C_API void box_signed_8(s64 n,factorvm *myvm) +VM_C_API void box_signed_8(s64 n,factor_vm *myvm) { ASSERTVM(); return VM_PTR->box_signed_8(n); } -s64 factorvm::to_signed_8(cell obj) +s64 factor_vm::to_signed_8(cell obj) { switch(tagged(obj).type()) { @@ -746,13 +746,13 @@ s64 factorvm::to_signed_8(cell obj) } } -VM_C_API s64 to_signed_8(cell obj,factorvm *myvm) +VM_C_API s64 to_signed_8(cell obj,factor_vm *myvm) { ASSERTVM(); return VM_PTR->to_signed_8(obj); } -void factorvm::box_unsigned_8(u64 n) +void factor_vm::box_unsigned_8(u64 n) { if(n > (u64)fixnum_max) dpush(tag(ulong_long_to_bignum(n))); @@ -760,13 +760,13 @@ void factorvm::box_unsigned_8(u64 n) dpush(tag_fixnum(n)); } -VM_C_API void box_unsigned_8(u64 n,factorvm *myvm) +VM_C_API void box_unsigned_8(u64 n,factor_vm *myvm) { ASSERTVM(); return VM_PTR->box_unsigned_8(n); } -u64 factorvm::to_unsigned_8(cell obj) +u64 factor_vm::to_unsigned_8(cell obj) { switch(tagged(obj).type()) { @@ -780,51 +780,51 @@ u64 factorvm::to_unsigned_8(cell obj) } } -VM_C_API u64 to_unsigned_8(cell obj,factorvm *myvm) +VM_C_API u64 to_unsigned_8(cell obj,factor_vm *myvm) { ASSERTVM(); return VM_PTR->to_unsigned_8(obj); } -void factorvm::box_float(float flo) +void factor_vm::box_float(float flo) { dpush(allot_float(flo)); } -VM_C_API void box_float(float flo, factorvm *myvm) +VM_C_API void box_float(float flo, factor_vm *myvm) { ASSERTVM(); return VM_PTR->box_float(flo); } -float factorvm::to_float(cell value) +float factor_vm::to_float(cell value) { return untag_float_check(value); } -VM_C_API float to_float(cell value,factorvm *myvm) +VM_C_API float to_float(cell value,factor_vm *myvm) { ASSERTVM(); return VM_PTR->to_float(value); } -void factorvm::box_double(double flo) +void factor_vm::box_double(double flo) { dpush(allot_float(flo)); } -VM_C_API void box_double(double flo,factorvm *myvm) +VM_C_API void box_double(double flo,factor_vm *myvm) { ASSERTVM(); return VM_PTR->box_double(flo); } -double factorvm::to_double(cell value) +double factor_vm::to_double(cell value) { return untag_float_check(value); } -VM_C_API double to_double(cell value,factorvm *myvm) +VM_C_API double to_double(cell value,factor_vm *myvm) { ASSERTVM(); return VM_PTR->to_double(value); @@ -832,29 +832,29 @@ VM_C_API double to_double(cell value,factorvm *myvm) /* The fixnum+, fixnum- and fixnum* primitives are defined in cpu_*.S. On overflow, they call these functions. */ -inline void factorvm::overflow_fixnum_add(fixnum x, fixnum y) +inline void factor_vm::overflow_fixnum_add(fixnum x, fixnum y) { drepl(tag(fixnum_to_bignum( untag_fixnum(x) + untag_fixnum(y)))); } -VM_ASM_API_OVERFLOW void overflow_fixnum_add(fixnum x, fixnum y, factorvm *myvm) +VM_ASM_API_OVERFLOW void overflow_fixnum_add(fixnum x, fixnum y, factor_vm *myvm) { PRIMITIVE_OVERFLOW_GETVM()->overflow_fixnum_add(x,y); } -inline void factorvm::overflow_fixnum_subtract(fixnum x, fixnum y) +inline void factor_vm::overflow_fixnum_subtract(fixnum x, fixnum y) { drepl(tag(fixnum_to_bignum( untag_fixnum(x) - untag_fixnum(y)))); } -VM_ASM_API_OVERFLOW void overflow_fixnum_subtract(fixnum x, fixnum y, factorvm *myvm) +VM_ASM_API_OVERFLOW void overflow_fixnum_subtract(fixnum x, fixnum y, factor_vm *myvm) { PRIMITIVE_OVERFLOW_GETVM()->overflow_fixnum_subtract(x,y); } -inline void factorvm::overflow_fixnum_multiply(fixnum x, fixnum y) +inline void factor_vm::overflow_fixnum_multiply(fixnum x, fixnum y) { bignum *bx = fixnum_to_bignum(x); GC_BIGNUM(bx); @@ -863,7 +863,7 @@ inline void factorvm::overflow_fixnum_multiply(fixnum x, fixnum y) drepl(tag(bignum_multiply(bx,by))); } -VM_ASM_API_OVERFLOW void overflow_fixnum_multiply(fixnum x, fixnum y, factorvm *myvm) +VM_ASM_API_OVERFLOW void overflow_fixnum_multiply(fixnum x, fixnum y, factor_vm *myvm) { PRIMITIVE_OVERFLOW_GETVM()->overflow_fixnum_multiply(x,y); } diff --git a/vm/math.hpp b/vm/math.hpp index 5e6121afb2..a82a9a9580 100644 --- a/vm/math.hpp +++ b/vm/math.hpp @@ -61,30 +61,30 @@ PRIMITIVE(bits_float); PRIMITIVE(double_bits); PRIMITIVE(bits_double); -VM_C_API void box_float(float flo, factorvm *vm); -VM_C_API float to_float(cell value, factorvm *vm); -VM_C_API void box_double(double flo, factorvm *vm); -VM_C_API double to_double(cell value, factorvm *vm); +VM_C_API void box_float(float flo, factor_vm *vm); +VM_C_API float to_float(cell value, factor_vm *vm); +VM_C_API void box_double(double flo, factor_vm *vm); +VM_C_API double to_double(cell value, factor_vm *vm); -VM_C_API void box_signed_1(s8 n, factorvm *vm); -VM_C_API void box_unsigned_1(u8 n, factorvm *vm); -VM_C_API void box_signed_2(s16 n, factorvm *vm); -VM_C_API void box_unsigned_2(u16 n, factorvm *vm); -VM_C_API void box_signed_4(s32 n, factorvm *vm); -VM_C_API void box_unsigned_4(u32 n, factorvm *vm); -VM_C_API void box_signed_cell(fixnum integer, factorvm *vm); -VM_C_API void box_unsigned_cell(cell cell, factorvm *vm); -VM_C_API void box_signed_8(s64 n, factorvm *vm); -VM_C_API void box_unsigned_8(u64 n, factorvm *vm); +VM_C_API void box_signed_1(s8 n, factor_vm *vm); +VM_C_API void box_unsigned_1(u8 n, factor_vm *vm); +VM_C_API void box_signed_2(s16 n, factor_vm *vm); +VM_C_API void box_unsigned_2(u16 n, factor_vm *vm); +VM_C_API void box_signed_4(s32 n, factor_vm *vm); +VM_C_API void box_unsigned_4(u32 n, factor_vm *vm); +VM_C_API void box_signed_cell(fixnum integer, factor_vm *vm); +VM_C_API void box_unsigned_cell(cell cell, factor_vm *vm); +VM_C_API void box_signed_8(s64 n, factor_vm *vm); +VM_C_API void box_unsigned_8(u64 n, factor_vm *vm); -VM_C_API s64 to_signed_8(cell obj, factorvm *vm); -VM_C_API u64 to_unsigned_8(cell obj, factorvm *vm); +VM_C_API s64 to_signed_8(cell obj, factor_vm *vm); +VM_C_API u64 to_unsigned_8(cell obj, factor_vm *vm); -VM_C_API fixnum to_fixnum(cell tagged, factorvm *vm); -VM_C_API cell to_cell(cell tagged, factorvm *vm); +VM_C_API fixnum to_fixnum(cell tagged, factor_vm *vm); +VM_C_API cell to_cell(cell tagged, factor_vm *vm); -VM_ASM_API_OVERFLOW void overflow_fixnum_add(fixnum x, fixnum y, factorvm *vm); -VM_ASM_API_OVERFLOW void overflow_fixnum_subtract(fixnum x, fixnum y, factorvm *vm); -VM_ASM_API_OVERFLOW void overflow_fixnum_multiply(fixnum x, fixnum y, factorvm *vm); +VM_ASM_API_OVERFLOW void overflow_fixnum_add(fixnum x, fixnum y, factor_vm *vm); +VM_ASM_API_OVERFLOW void overflow_fixnum_subtract(fixnum x, fixnum y, factor_vm *vm); +VM_ASM_API_OVERFLOW void overflow_fixnum_multiply(fixnum x, fixnum y, factor_vm *vm); } diff --git a/vm/os-genunix.cpp b/vm/os-genunix.cpp index 6540d8d196..7f2429e46a 100644 --- a/vm/os-genunix.cpp +++ b/vm/os-genunix.cpp @@ -3,7 +3,7 @@ namespace factor { -void factorvm::c_to_factor_toplevel(cell quot) +void factor_vm::c_to_factor_toplevel(cell quot) { c_to_factor(quot,this); } diff --git a/vm/os-macosx.mm b/vm/os-macosx.mm index 872e0b8b48..3aa001774b 100644 --- a/vm/os-macosx.mm +++ b/vm/os-macosx.mm @@ -5,7 +5,7 @@ namespace factor { -void factorvm::c_to_factor_toplevel(cell quot) +void factor_vm::c_to_factor_toplevel(cell quot) { for(;;) { diff --git a/vm/os-unix.cpp b/vm/os-unix.cpp index 3652d34658..e9e26240cd 100644 --- a/vm/os-unix.cpp +++ b/vm/os-unix.cpp @@ -27,14 +27,14 @@ void init_platform_globals() } -void register_vm_with_thread(factorvm *vm) +void register_vm_with_thread(factor_vm *vm) { pthread_setspecific(tlsKey,vm); } -factorvm *tls_vm() +factor_vm *tls_vm() { - return (factorvm*)pthread_getspecific(tlsKey); + return (factor_vm*)pthread_getspecific(tlsKey); } static void *null_dll; @@ -51,24 +51,24 @@ void sleep_micros(cell usec) usleep(usec); } -void factorvm::init_ffi() +void factor_vm::init_ffi() { /* NULL_DLL is "libfactor.dylib" for OS X and NULL for generic unix */ null_dll = dlopen(NULL_DLL,RTLD_LAZY); } -void factorvm::ffi_dlopen(dll *dll) +void factor_vm::ffi_dlopen(dll *dll) { dll->dll = dlopen(alien_offset(dll->path), RTLD_LAZY); } -void *factorvm::ffi_dlsym(dll *dll, symbol_char *symbol) +void *factor_vm::ffi_dlsym(dll *dll, symbol_char *symbol) { void *handle = (dll == NULL ? null_dll : dll->dll); return dlsym(handle,symbol); } -void factorvm::ffi_dlclose(dll *dll) +void factor_vm::ffi_dlclose(dll *dll) { if(dlclose(dll->dll)) general_error(ERROR_FFI,F,F,NULL); @@ -77,7 +77,7 @@ void factorvm::ffi_dlclose(dll *dll) -inline void factorvm::primitive_existsp() +inline void factor_vm::primitive_existsp() { struct stat sb; char *path = (char *)(untag_check(dpop()) + 1); @@ -89,7 +89,7 @@ PRIMITIVE(existsp) PRIMITIVE_GETVM()->primitive_existsp(); } -segment *factorvm::alloc_segment(cell size) +segment *factor_vm::alloc_segment(cell size) { int pagesize = getpagesize(); @@ -128,7 +128,7 @@ void dealloc_segment(segment *block) free(block); } -stack_frame *factorvm::uap_stack_pointer(void *uap) +stack_frame *factor_vm::uap_stack_pointer(void *uap) { /* There is a race condition here, but in practice a signal delivered during stack frame setup/teardown or while transitioning @@ -146,7 +146,7 @@ stack_frame *factorvm::uap_stack_pointer(void *uap) } -void factorvm::memory_signal_handler(int signal, siginfo_t *siginfo, void *uap) +void factor_vm::memory_signal_handler(int signal, siginfo_t *siginfo, void *uap) { signal_fault_addr = (cell)siginfo->si_addr; signal_callstack_top = uap_stack_pointer(uap); @@ -158,7 +158,7 @@ void memory_signal_handler(int signal, siginfo_t *siginfo, void *uap) SIGNAL_VM_PTR()->memory_signal_handler(signal,siginfo,uap); } -void factorvm::misc_signal_handler(int signal, siginfo_t *siginfo, void *uap) +void factor_vm::misc_signal_handler(int signal, siginfo_t *siginfo, void *uap) { signal_number = signal; signal_callstack_top = uap_stack_pointer(uap); @@ -170,7 +170,7 @@ void misc_signal_handler(int signal, siginfo_t *siginfo, void *uap) SIGNAL_VM_PTR()->misc_signal_handler(signal,siginfo,uap); } -void factorvm::fpe_signal_handler(int signal, siginfo_t *siginfo, void *uap) +void factor_vm::fpe_signal_handler(int signal, siginfo_t *siginfo, void *uap) { signal_number = signal; signal_callstack_top = uap_stack_pointer(uap); diff --git a/vm/os-unix.hpp b/vm/os-unix.hpp index 5f84106f97..6ef539ab8b 100644 --- a/vm/os-unix.hpp +++ b/vm/os-unix.hpp @@ -55,8 +55,8 @@ s64 current_micros(); void sleep_micros(cell usec); void init_platform_globals(); -struct factorvm; -void register_vm_with_thread(factorvm *vm); -factorvm *tls_vm(); +struct factor_vm; +void register_vm_with_thread(factor_vm *vm); +factor_vm *tls_vm(); void open_console(); } diff --git a/vm/os-windows-nt.cpp b/vm/os-windows-nt.cpp index 250a3334e6..2ac619dabc 100755 --- a/vm/os-windows-nt.cpp +++ b/vm/os-windows-nt.cpp @@ -15,15 +15,15 @@ void init_platform_globals() fatal_error("TlsAlloc failed - out of indexes",0); } -void register_vm_with_thread(factorvm *vm) +void register_vm_with_thread(factor_vm *vm) { if (! TlsSetValue(dwTlsIndex, vm)) fatal_error("TlsSetValue failed",0); } -factorvm *tls_vm() +factor_vm *tls_vm() { - return (factorvm*)TlsGetValue(dwTlsIndex); + return (factor_vm*)TlsGetValue(dwTlsIndex); } s64 current_micros() @@ -34,7 +34,7 @@ s64 current_micros() - EPOCH_OFFSET) / 10; } -LONG factorvm::exception_handler(PEXCEPTION_POINTERS pe) +LONG factor_vm::exception_handler(PEXCEPTION_POINTERS pe) { PEXCEPTION_RECORD e = (PEXCEPTION_RECORD)pe->ExceptionRecord; CONTEXT *c = (CONTEXT*)pe->ContextRecord; @@ -87,7 +87,7 @@ FACTOR_STDCALL LONG exception_handler(PEXCEPTION_POINTERS pe) bool handler_added = 0; -void factorvm::c_to_factor_toplevel(cell quot) +void factor_vm::c_to_factor_toplevel(cell quot) { if(!handler_added){ if(!AddVectoredExceptionHandler(0, (PVECTORED_EXCEPTION_HANDLER)factor::exception_handler)) @@ -98,7 +98,7 @@ void factorvm::c_to_factor_toplevel(cell quot) RemoveVectoredExceptionHandler((void *)factor::exception_handler); } -void factorvm::open_console() +void factor_vm::open_console() { } diff --git a/vm/os-windows-nt.hpp b/vm/os-windows-nt.hpp index 366348a898..b02006f9d2 100755 --- a/vm/os-windows-nt.hpp +++ b/vm/os-windows-nt.hpp @@ -31,8 +31,8 @@ typedef HANDLE THREADHANDLE; THREADHANDLE start_thread(void *(*start_routine)(void *),void *args); void init_platform_globals(); -struct factorvm; -void register_vm_with_thread(factorvm *vm); -factorvm *tls_vm(); +struct factor_vm; +void register_vm_with_thread(factor_vm *vm); +factor_vm *tls_vm(); } diff --git a/vm/os-windows.cpp b/vm/os-windows.cpp index 419be13f42..4e06c0efb9 100644 --- a/vm/os-windows.cpp +++ b/vm/os-windows.cpp @@ -5,30 +5,30 @@ namespace factor HMODULE hFactorDll; -void factorvm::init_ffi() +void factor_vm::init_ffi() { hFactorDll = GetModuleHandle(FACTOR_DLL); if(!hFactorDll) fatal_error("GetModuleHandle(\"" FACTOR_DLL_NAME "\") failed", 0); } -void factorvm::ffi_dlopen(dll *dll) +void factor_vm::ffi_dlopen(dll *dll) { dll->dll = LoadLibraryEx((WCHAR *)alien_offset(dll->path), NULL, 0); } -void *factorvm::ffi_dlsym(dll *dll, symbol_char *symbol) +void *factor_vm::ffi_dlsym(dll *dll, symbol_char *symbol) { return (void *)GetProcAddress(dll ? (HMODULE)dll->dll : hFactorDll, symbol); } -void factorvm::ffi_dlclose(dll *dll) +void factor_vm::ffi_dlclose(dll *dll) { FreeLibrary((HMODULE)dll->dll); dll->dll = NULL; } -bool factorvm::windows_stat(vm_char *path) +bool factor_vm::windows_stat(vm_char *path) { BY_HANDLE_FILE_INFORMATION bhfi; HANDLE h = CreateFileW(path, @@ -56,14 +56,14 @@ bool factorvm::windows_stat(vm_char *path) return ret; } -void factorvm::windows_image_path(vm_char *full_path, vm_char *temp_path, unsigned int length) +void factor_vm::windows_image_path(vm_char *full_path, vm_char *temp_path, unsigned int length) { snwprintf(temp_path, length-1, L"%s.image", full_path); temp_path[length - 1] = 0; } /* You must free() this yourself. */ -const vm_char *factorvm::default_image_path() +const vm_char *factor_vm::default_image_path() { vm_char full_path[MAX_UNICODE_PATH]; vm_char *ptr; @@ -82,7 +82,7 @@ const vm_char *factorvm::default_image_path() } /* You must free() this yourself. */ -const vm_char *factorvm::vm_executable_path() +const vm_char *factor_vm::vm_executable_path() { vm_char full_path[MAX_UNICODE_PATH]; if(!GetModuleFileName(NULL, full_path, MAX_UNICODE_PATH)) @@ -90,7 +90,7 @@ const vm_char *factorvm::vm_executable_path() return safe_strdup(full_path); } -inline void factorvm::primitive_existsp() +inline void factor_vm::primitive_existsp() { vm_char *path = untag_check(dpop())->data(); box_boolean(windows_stat(path)); @@ -101,7 +101,7 @@ PRIMITIVE(existsp) PRIMITIVE_GETVM()->primitive_existsp(); } -segment *factorvm::alloc_segment(cell size) +segment *factor_vm::alloc_segment(cell size) { char *mem; DWORD ignore; @@ -126,7 +126,7 @@ segment *factorvm::alloc_segment(cell size) return block; } -void factorvm::dealloc_segment(segment *block) +void factor_vm::dealloc_segment(segment *block) { SYSTEM_INFO si; GetSystemInfo(&si); @@ -135,7 +135,7 @@ void factorvm::dealloc_segment(segment *block) free(block); } -long factorvm::getpagesize() +long factor_vm::getpagesize() { static long g_pagesize = 0; if (! g_pagesize) @@ -147,7 +147,7 @@ long factorvm::getpagesize() return g_pagesize; } -void factorvm::sleep_micros(u64 usec) +void factor_vm::sleep_micros(u64 usec) { Sleep((DWORD)(usec / 1000)); } diff --git a/vm/profiler.cpp b/vm/profiler.cpp index 4c4266c76e..cd99c9f27c 100755 --- a/vm/profiler.cpp +++ b/vm/profiler.cpp @@ -3,13 +3,13 @@ namespace factor { -void factorvm::init_profiler() +void factor_vm::init_profiler() { profiling_p = false; } /* Allocates memory */ -code_block *factorvm::compile_profiling_stub(cell word_) +code_block *factor_vm::compile_profiling_stub(cell word_) { gc_root word(word_,this); @@ -20,7 +20,7 @@ code_block *factorvm::compile_profiling_stub(cell word_) } /* Allocates memory */ -void factorvm::set_profiling(bool profiling) +void factor_vm::set_profiling(bool profiling) { if(profiling == profiling_p) return; @@ -47,7 +47,7 @@ void factorvm::set_profiling(bool profiling) iterate_code_heap(factor::relocate_code_block); } -inline void factorvm::primitive_profiling() +inline void factor_vm::primitive_profiling() { set_profiling(to_boolean(dpop())); } diff --git a/vm/quotations.cpp b/vm/quotations.cpp index f1745cd810..d6774692e9 100755 --- a/vm/quotations.cpp +++ b/vm/quotations.cpp @@ -265,7 +265,7 @@ void quotation_jit::iterate_quotation() } } -void factorvm::set_quot_xt(quotation *quot, code_block *code) +void factor_vm::set_quot_xt(quotation *quot, code_block *code) { if(code->type != QUOTATION_TYPE) critical_error("Bad param to set_quot_xt",(cell)code); @@ -275,7 +275,7 @@ void factorvm::set_quot_xt(quotation *quot, code_block *code) } /* Allocates memory */ -void factorvm::jit_compile(cell quot_, bool relocating) +void factor_vm::jit_compile(cell quot_, bool relocating) { gc_root quot(quot_,this); if(quot->code) return; @@ -289,7 +289,7 @@ void factorvm::jit_compile(cell quot_, bool relocating) if(relocating) relocate_code_block(compiled); } -inline void factorvm::primitive_jit_compile() +inline void factor_vm::primitive_jit_compile() { jit_compile(dpop(),true); } @@ -300,7 +300,7 @@ PRIMITIVE(jit_compile) } /* push a new quotation on the stack */ -inline void factorvm::primitive_array_to_quotation() +inline void factor_vm::primitive_array_to_quotation() { quotation *quot = allot(sizeof(quotation)); quot->array = dpeek(); @@ -316,7 +316,7 @@ PRIMITIVE(array_to_quotation) PRIMITIVE_GETVM()->primitive_array_to_quotation(); } -inline void factorvm::primitive_quotation_xt() +inline void factor_vm::primitive_quotation_xt() { quotation *quot = untag_check(dpeek()); drepl(allot_cell((cell)quot->xt)); @@ -327,7 +327,7 @@ PRIMITIVE(quotation_xt) PRIMITIVE_GETVM()->primitive_quotation_xt(); } -void factorvm::compile_all_words() +void factor_vm::compile_all_words() { gc_root words(find_all_words(),this); @@ -348,7 +348,7 @@ void factorvm::compile_all_words() } /* Allocates memory */ -fixnum factorvm::quot_code_offset_to_scan(cell quot_, cell offset) +fixnum factor_vm::quot_code_offset_to_scan(cell quot_, cell offset) { gc_root quot(quot_,this); gc_root array(quot->array,this); @@ -360,7 +360,7 @@ fixnum factorvm::quot_code_offset_to_scan(cell quot_, cell offset) return compiler.get_position(); } -cell factorvm::lazy_jit_compile_impl(cell quot_, stack_frame *stack) +cell factor_vm::lazy_jit_compile_impl(cell quot_, stack_frame *stack) { gc_root quot(quot_,this); stack_chain->callstack_top = stack; @@ -368,13 +368,13 @@ cell factorvm::lazy_jit_compile_impl(cell quot_, stack_frame *stack) return quot.value(); } -VM_ASM_API cell lazy_jit_compile_impl(cell quot_, stack_frame *stack, factorvm *myvm) +VM_ASM_API cell lazy_jit_compile_impl(cell quot_, stack_frame *stack, factor_vm *myvm) { ASSERTVM(); return VM_PTR->lazy_jit_compile_impl(quot_,stack); } -inline void factorvm::primitive_quot_compiled_p() +inline void factor_vm::primitive_quot_compiled_p() { tagged quot(dpop()); quot.untag_check(this); diff --git a/vm/quotations.hpp b/vm/quotations.hpp index ae24a522f9..b21884a35b 100755 --- a/vm/quotations.hpp +++ b/vm/quotations.hpp @@ -5,7 +5,7 @@ struct quotation_jit : public jit { gc_root elements; bool compiling, relocate; - quotation_jit(cell quot, bool compiling_, bool relocate_, factorvm *vm) + quotation_jit(cell quot, bool compiling_, bool relocate_, factor_vm *vm) : jit(QUOTATION_TYPE,quot,vm), elements(owner.as().untagged()->array,vm), compiling(compiling_), @@ -27,7 +27,7 @@ PRIMITIVE(jit_compile); PRIMITIVE(array_to_quotation); PRIMITIVE(quotation_xt); -VM_ASM_API cell lazy_jit_compile_impl(cell quot, stack_frame *stack, factorvm *myvm); +VM_ASM_API cell lazy_jit_compile_impl(cell quot, stack_frame *stack, factor_vm *myvm); PRIMITIVE(quot_compiled_p); diff --git a/vm/run.cpp b/vm/run.cpp index a964fad914..2f162e3ace 100755 --- a/vm/run.cpp +++ b/vm/run.cpp @@ -3,7 +3,7 @@ namespace factor { -inline void factorvm::primitive_getenv() +inline void factor_vm::primitive_getenv() { fixnum e = untag_fixnum(dpeek()); drepl(userenv[e]); @@ -14,7 +14,7 @@ PRIMITIVE(getenv) PRIMITIVE_GETVM()->primitive_getenv(); } -inline void factorvm::primitive_setenv() +inline void factor_vm::primitive_setenv() { fixnum e = untag_fixnum(dpop()); cell value = dpop(); @@ -26,7 +26,7 @@ PRIMITIVE(setenv) PRIMITIVE_GETVM()->primitive_setenv(); } -inline void factorvm::primitive_exit() +inline void factor_vm::primitive_exit() { exit(to_fixnum(dpop())); } @@ -36,7 +36,7 @@ PRIMITIVE(exit) PRIMITIVE_GETVM()->primitive_exit(); } -inline void factorvm::primitive_micros() +inline void factor_vm::primitive_micros() { box_unsigned_8(current_micros()); } @@ -46,7 +46,7 @@ PRIMITIVE(micros) PRIMITIVE_GETVM()->primitive_micros(); } -inline void factorvm::primitive_sleep() +inline void factor_vm::primitive_sleep() { sleep_micros(to_cell(dpop())); } @@ -56,7 +56,7 @@ PRIMITIVE(sleep) PRIMITIVE_GETVM()->primitive_sleep(); } -inline void factorvm::primitive_set_slot() +inline void factor_vm::primitive_set_slot() { fixnum slot = untag_fixnum(dpop()); object *obj = untag(dpop()); @@ -71,7 +71,7 @@ PRIMITIVE(set_slot) PRIMITIVE_GETVM()->primitive_set_slot(); } -inline void factorvm::primitive_load_locals() +inline void factor_vm::primitive_load_locals() { fixnum count = untag_fixnum(dpop()); memcpy((cell *)(rs + sizeof(cell)),(cell *)(ds - sizeof(cell) * (count - 1)),sizeof(cell) * count); @@ -84,7 +84,7 @@ PRIMITIVE(load_locals) PRIMITIVE_GETVM()->primitive_load_locals(); } -cell factorvm::clone_object(cell obj_) +cell factor_vm::clone_object(cell obj_) { gc_root obj(obj_,this); @@ -99,7 +99,7 @@ cell factorvm::clone_object(cell obj_) } } -inline void factorvm::primitive_clone() +inline void factor_vm::primitive_clone() { drepl(clone_object(dpeek())); } diff --git a/vm/strings.cpp b/vm/strings.cpp index 5c0a886513..912706024e 100644 --- a/vm/strings.cpp +++ b/vm/strings.cpp @@ -3,7 +3,7 @@ namespace factor { -cell factorvm::string_nth(string* str, cell index) +cell factor_vm::string_nth(string* str, cell index) { /* If high bit is set, the most significant 16 bits of the char come from the aux vector. The least significant bit of the @@ -22,12 +22,12 @@ cell factorvm::string_nth(string* str, cell index) } } -void factorvm::set_string_nth_fast(string *str, cell index, cell ch) +void factor_vm::set_string_nth_fast(string *str, cell index, cell ch) { str->data()[index] = ch; } -void factorvm::set_string_nth_slow(string *str_, cell index, cell ch) +void factor_vm::set_string_nth_slow(string *str_, cell index, cell ch) { gc_root str(str_,this); @@ -55,7 +55,7 @@ void factorvm::set_string_nth_slow(string *str_, cell index, cell ch) } /* allocates memory */ -void factorvm::set_string_nth(string *str, cell index, cell ch) +void factor_vm::set_string_nth(string *str, cell index, cell ch) { if(ch <= 0x7f) set_string_nth_fast(str,index,ch); @@ -64,7 +64,7 @@ void factorvm::set_string_nth(string *str, cell index, cell ch) } /* Allocates memory */ -string *factorvm::allot_string_internal(cell capacity) +string *factor_vm::allot_string_internal(cell capacity) { string *str = allot(string_size(capacity)); @@ -76,7 +76,7 @@ string *factorvm::allot_string_internal(cell capacity) } /* Allocates memory */ -void factorvm::fill_string(string *str_, cell start, cell capacity, cell fill) +void factor_vm::fill_string(string *str_, cell start, cell capacity, cell fill) { gc_root str(str_,this); @@ -92,14 +92,14 @@ void factorvm::fill_string(string *str_, cell start, cell capacity, cell fill) } /* Allocates memory */ -string *factorvm::allot_string(cell capacity, cell fill) +string *factor_vm::allot_string(cell capacity, cell fill) { gc_root str(allot_string_internal(capacity),this); fill_string(str.untagged(),0,capacity,fill); return str.untagged(); } -inline void factorvm::primitive_string() +inline void factor_vm::primitive_string() { cell initial = to_cell(dpop()); cell length = unbox_array_size(); @@ -111,14 +111,14 @@ PRIMITIVE(string) PRIMITIVE_GETVM()->primitive_string(); } -bool factorvm::reallot_string_in_place_p(string *str, cell capacity) +bool factor_vm::reallot_string_in_place_p(string *str, cell capacity) { return in_zone(&nursery,str) && (str->aux == F || in_zone(&nursery,untag(str->aux))) && capacity <= string_capacity(str); } -string* factorvm::reallot_string(string *str_, cell capacity) +string* factor_vm::reallot_string(string *str_, cell capacity) { gc_root str(str_,this); @@ -160,7 +160,7 @@ string* factorvm::reallot_string(string *str_, cell capacity) } } -inline void factorvm::primitive_resize_string() +inline void factor_vm::primitive_resize_string() { string* str = untag_check(dpop()); cell capacity = unbox_array_size(); @@ -172,7 +172,7 @@ PRIMITIVE(resize_string) PRIMITIVE_GETVM()->primitive_resize_string(); } -inline void factorvm::primitive_string_nth() +inline void factor_vm::primitive_string_nth() { string *str = untag(dpop()); cell index = untag_fixnum(dpop()); @@ -184,7 +184,7 @@ PRIMITIVE(string_nth) PRIMITIVE_GETVM()->primitive_string_nth(); } -inline void factorvm::primitive_set_string_nth_fast() +inline void factor_vm::primitive_set_string_nth_fast() { string *str = untag(dpop()); cell index = untag_fixnum(dpop()); @@ -197,7 +197,7 @@ PRIMITIVE(set_string_nth_fast) PRIMITIVE_GETVM()->primitive_set_string_nth_fast(); } -inline void factorvm::primitive_set_string_nth_slow() +inline void factor_vm::primitive_set_string_nth_slow() { string *str = untag(dpop()); cell index = untag_fixnum(dpop()); diff --git a/vm/tagged.hpp b/vm/tagged.hpp index 8eb492a140..5f3075699a 100755 --- a/vm/tagged.hpp +++ b/vm/tagged.hpp @@ -29,7 +29,7 @@ struct tagged bool type_p(cell type_) const { return type() == type_; } - TYPE *untag_check(factorvm *myvm) const { + TYPE *untag_check(factor_vm *myvm) const { if(TYPE::type_number != TYPE_COUNT && !type_p(TYPE::type_number)) myvm->type_error(TYPE::type_number,value_); return untagged(); @@ -59,12 +59,12 @@ struct tagged template tagged as() { return tagged(value_); } }; -template TYPE *factorvm::untag_check(cell value) +template TYPE *factor_vm::untag_check(cell value) { return tagged(value).untag_check(this); } -template TYPE *factorvm::untag(cell value) +template TYPE *factor_vm::untag(cell value) { return tagged(value).untagged(); } diff --git a/vm/tuples.cpp b/vm/tuples.cpp index 77fd01a5ce..a89265f709 100644 --- a/vm/tuples.cpp +++ b/vm/tuples.cpp @@ -4,7 +4,7 @@ namespace factor { /* push a new tuple on the stack */ -tuple *factorvm::allot_tuple(cell layout_) +tuple *factor_vm::allot_tuple(cell layout_) { gc_root layout(layout_,this); gc_root t(allot(tuple_size(layout.untagged())),this); @@ -12,7 +12,7 @@ tuple *factorvm::allot_tuple(cell layout_) return t.untagged(); } -inline void factorvm::primitive_tuple() +inline void factor_vm::primitive_tuple() { gc_root layout(dpop(),this); tuple *t = allot_tuple(layout.value()); @@ -29,7 +29,7 @@ PRIMITIVE(tuple) } /* push a new tuple on the stack, filling its slots from the stack */ -inline void factorvm::primitive_tuple_boa() +inline void factor_vm::primitive_tuple_boa() { gc_root layout(dpop(),this); gc_root t(allot_tuple(layout.value()),this); diff --git a/vm/vm-data.hpp b/vm/vm-data.hpp index f5ecdc5f62..f4faf5b46b 100644 --- a/vm/vm-data.hpp +++ b/vm/vm-data.hpp @@ -1,7 +1,7 @@ namespace factor { -struct factorvmdata { +struct factor_vm_data { // if you change this struct, also change vm.factor k-------- context *stack_chain; zone nursery; /* new objects are allocated here */ @@ -101,7 +101,7 @@ struct factorvmdata { cell pic_to_mega_transitions; cell pic_counts[4]; /* PIC_TAG, PIC_HI_TAG, PIC_TUPLE, PIC_HI_TAG_TUPLE */ - factorvmdata() + factor_vm_data() : profiling_p(false), secure_gc(false), gc_off(false), diff --git a/vm/vm.hpp b/vm/vm.hpp index d3e2239689..282f48b41e 100644 --- a/vm/vm.hpp +++ b/vm/vm.hpp @@ -3,7 +3,7 @@ namespace factor { -struct factorvm : factorvmdata { +struct factor_vm : factor_vm_data { // segments inline cell align_page(cell a); @@ -124,7 +124,7 @@ struct factorvm : factorvmdata { bignum *bignum_integer_length(bignum * x); int bignum_logbitp(int shift, bignum * arg); int bignum_unsigned_logbitp(int shift, bignum * bignum); - bignum *digit_stream_to_bignum(unsigned int n_digits, unsigned int (*producer)(unsigned int, factorvm *), unsigned int radix, int negative_p); + bignum *digit_stream_to_bignum(unsigned int n_digits, unsigned int (*producer)(unsigned int, factor_vm *), unsigned int radix, int negative_p); //data_heap cell init_zone(zone *z, cell size, cell start); @@ -494,7 +494,7 @@ struct factorvm : factorvmdata { inline void primitive_set_innermost_stack_frame_quot(); void save_callstack_bottom(stack_frame *callstack_bottom); template void iterate_callstack(cell top, cell bottom, T &iterator); - inline void do_slots(cell obj, void (* iter)(cell *,factorvm*)); + inline void do_slots(cell obj, void (* iter)(cell *,factor_vm*)); //alien char *pinned_alien_offset(cell obj); @@ -617,7 +617,7 @@ struct factorvm : factorvmdata { #ifdef FACTOR_SINGLE_THREADED_SINGLETON /* calls are dispatched using the singleton vm ptr */ - extern factorvm *vm; + extern factor_vm *vm; #define PRIMITIVE_GETVM() vm #define PRIMITIVE_OVERFLOW_GETVM() vm #define VM_PTR vm @@ -627,9 +627,9 @@ struct factorvm : factorvmdata { #ifdef FACTOR_SINGLE_THREADED_TESTING /* calls are dispatched as per multithreaded, but checked against singleton */ - extern factorvm *vm; + extern factor_vm *vm; #define ASSERTVM() assert(vm==myvm) - #define PRIMITIVE_GETVM() ((factorvm*)myvm) + #define PRIMITIVE_GETVM() ((factor_vm*)myvm) #define PRIMITIVE_OVERFLOW_GETVM() ASSERTVM(); myvm #define VM_PTR myvm #define SIGNAL_VM_PTR() tls_vm() @@ -645,8 +645,8 @@ struct factorvm : factorvmdata { #endif #ifdef FACTOR_REENTRANT - #define PRIMITIVE_GETVM() ((factorvm*)myvm) - #define PRIMITIVE_OVERFLOW_GETVM() ((factorvm*)myvm) + #define PRIMITIVE_GETVM() ((factor_vm*)myvm) + #define PRIMITIVE_OVERFLOW_GETVM() ((factor_vm*)myvm) #define VM_PTR myvm #define ASSERTVM() #define SIGNAL_VM_PTR() tls_vm() diff --git a/vm/words.cpp b/vm/words.cpp index 5ef229cbd9..f5215b78a8 100644 --- a/vm/words.cpp +++ b/vm/words.cpp @@ -3,7 +3,7 @@ namespace factor { -word *factorvm::allot_word(cell vocab_, cell name_) +word *factor_vm::allot_word(cell vocab_, cell name_) { gc_root vocab(vocab_,this); gc_root name(name_,this); @@ -32,7 +32,7 @@ word *factorvm::allot_word(cell vocab_, cell name_) } /* ( name vocabulary -- word ) */ -inline void factorvm::primitive_word() +inline void factor_vm::primitive_word() { cell vocab = dpop(); cell name = dpop(); @@ -45,7 +45,7 @@ PRIMITIVE(word) } /* word-xt ( word -- start end ) */ -inline void factorvm::primitive_word_xt() +inline void factor_vm::primitive_word_xt() { word *w = untag_check(dpop()); code_block *code = (profiling_p ? w->profiling : w->code); @@ -59,7 +59,7 @@ PRIMITIVE(word_xt) } /* Allocates memory */ -void factorvm::update_word_xt(cell w_) +void factor_vm::update_word_xt(cell w_) { gc_root w(w_,this); @@ -74,7 +74,7 @@ void factorvm::update_word_xt(cell w_) w->xt = w->code->xt(); } -inline void factorvm::primitive_optimized_p() +inline void factor_vm::primitive_optimized_p() { drepl(tag_boolean(word_optimized_p(untag_check(dpeek())))); } @@ -84,7 +84,7 @@ PRIMITIVE(optimized_p) PRIMITIVE_GETVM()->primitive_optimized_p(); } -inline void factorvm::primitive_wrapper() +inline void factor_vm::primitive_wrapper() { wrapper *new_wrapper = allot(sizeof(wrapper)); new_wrapper->object = dpeek(); -- 2.34.1