}
/* pop ( alien n ) from datastack, return alien's address plus n */
-static void *alien_pointer(void)
+static void *alien_pointer()
{
fixnum offset = to_fixnum(dpop());
return unbox_alien() + offset;
}
/* pop an object representing a C pointer */
-VM_C_API char *unbox_alien(void)
+VM_C_API char *unbox_alien()
{
return alien_offset(dpop());
}
PRIMITIVE(dll_validp);
VM_C_API char *alien_offset(cell object);
-VM_C_API char *unbox_alien(void);
+VM_C_API char *unbox_alien();
VM_C_API void box_alien(void *ptr);
VM_C_API void to_value_struct(cell src, void *dest, cell size);
VM_C_API void box_value_struct(void *src, cell size);
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 *capture_start(void)
+stack_frame *capture_start()
{
stack_frame *frame = stack_chain->callstack_bottom - 1;
while(frame >= stack_chain->callstack_top
/* References to undefined symbols are patched up to call this function on
image load */
-void undefined_symbol(void)
+void undefined_symbol()
{
general_error(ERROR_UNDEFINED_SYMBOL,F,F,NULL);
}
void relocate_code_block(code_block *relocating);
-inline static bool stack_traces_p(void)
+inline static bool stack_traces_p()
{
return userenv[STACK_TRACES_ENV] != F;
}
/* Copy literals referenced from all code blocks to newspace. Only for
aging and nursery collections */
-void copy_code_heap_roots(void)
+void copy_code_heap_roots()
{
iterate_code_heap(copy_literal_references);
}
/* Update pointers to words referenced from all code blocks. Only after
defining a new word. */
-void update_code_heap_words(void)
+void update_code_heap_words()
{
iterate_code_heap(update_word_references);
}
}
/* Set the XT fields now that the heap has been compacted */
-void fixup_object_xts(void)
+void fixup_object_xts()
{
begin_scan();
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 compact_code_heap(void)
+void compact_code_heap()
{
/* Free all unreachable code blocks */
gc();
void iterate_code_heap(code_heap_iterator iter);
-void copy_code_heap_roots(void);
+void copy_code_heap_roots();
PRIMITIVE(modify_code_heap);
PRIMITIVE(code_room);
-void compact_code_heap(void);
+void compact_code_heap();
inline static void check_code_pointer(cell ptr)
{
cell ds_size, rs_size;
context *unused_contexts;
-void reset_datastack(void)
+void reset_datastack()
{
ds = ds_bot - sizeof(cell);
}
-void reset_retainstack(void)
+void reset_retainstack()
{
rs = rs_bot - sizeof(cell);
}
#define RESERVED (64 * sizeof(cell))
-void fix_stacks(void)
+void fix_stacks()
{
if(ds + sizeof(cell) < ds_bot || ds + RESERVED >= ds_top) reset_datastack();
if(rs + sizeof(cell) < rs_bot || rs + RESERVED >= rs_top) reset_retainstack();
/* 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 save_stacks(void)
+void save_stacks()
{
if(stack_chain)
{
}
}
-context *alloc_context(void)
+context *alloc_context()
{
context *new_context;
}
/* called on entry into a compiled callback */
-void nest_stacks(void)
+void nest_stacks()
{
context *new_context = alloc_context();
}
/* called when leaving a compiled callback */
-void unnest_stacks(void)
+void unnest_stacks()
{
ds = stack_chain->datastack_save;
rs = stack_chain->retainstack_save;
DEFPUSHPOP(d,ds)
DEFPUSHPOP(r,rs)
-void reset_datastack(void);
-void reset_retainstack(void);
-void fix_stacks(void);
+void reset_datastack();
+void reset_retainstack();
+void fix_stacks();
void init_stacks(cell ds_size, cell rs_size);
PRIMITIVE(datastack);
PRIMITIVE(set_retainstack);
PRIMITIVE(check_datastack);
-VM_C_API void save_stacks(void);
-VM_C_API void nest_stacks(void);
-VM_C_API void unnest_stacks(void);
+VM_C_API void save_stacks();
+VM_C_API void nest_stacks();
+VM_C_API void unnest_stacks();
}
bool growing_data_heap;
data_heap *old_data_heap;
-void init_data_gc(void)
+void init_data_gc()
{
performing_gc = false;
last_code_heap_scan = NURSERY;
/* Scan cards in all generations older than the one being collected, copying
old->new references */
-static void copy_cards(void)
+static void copy_cards()
{
u64 start = current_micros();
copy_handle((cell*)ptr);
}
-static void copy_registered_locals(void)
+static void copy_registered_locals()
{
cell scan = gc_locals_region->start;
copy_handle(*(cell **)scan);
}
-static void copy_registered_bignums(void)
+static void copy_registered_bignums()
{
cell scan = gc_bignums_region->start;
/* Copy roots over at the start of GC, namely various constants, stacks,
the user environment and extra roots registered by local_roots.hpp */
-static void copy_roots(void)
+static void copy_roots()
{
copy_handle(&T);
copy_handle(&bignum_zero);
performing_gc = false;
}
-void gc(void)
+void gc()
{
garbage_collection(TENURED,false,0);
}
dpush(result.elements.value());
}
-void clear_gc_stats(void)
+void clear_gc_stats()
{
int i;
for(i = 0; i < MAX_GEN_COUNT; i++)
compile_all_words();
}
-VM_C_API void minor_gc(void)
+VM_C_API void minor_gc()
{
garbage_collection(NURSERY,false,0);
}
extern cell last_code_heap_scan;
-void init_data_gc(void);
+void init_data_gc();
-void gc(void);
+void gc();
-inline static bool collecting_accumulation_gen_p(void)
+inline static bool collecting_accumulation_gen_p()
{
return ((HAVE_AGING_P
&& collecting_gen == AGING
PRIMITIVE(gc);
PRIMITIVE(gc_stats);
-void clear_gc_stats(void);
+void clear_gc_stats();
PRIMITIVE(clear_gc_stats);
PRIMITIVE(become);
#endif
}
-VM_C_API void minor_gc(void);
+VM_C_API void minor_gc();
}
return z->end;
}
-void init_card_decks(void)
+void init_card_decks()
{
cell start = align(data->seg->start,DECK_SIZE);
allot_markers_offset = (cell)data->allot_markers - (start >> CARD_BITS);
cell heap_scan_ptr;
/* Disables GC and activates next-object ( -- obj ) primitive */
-void begin_scan(void)
+void begin_scan()
{
heap_scan_ptr = data->generations[TENURED].start;
gc_off = true;
begin_scan();
}
-cell next_object(void)
+cell next_object()
{
if(!gc_off)
general_error(ERROR_HEAP_SCAN,F,F,NULL);
gc_off = false;
}
-cell find_all_words(void)
+cell find_all_words()
{
growable_array words;
cell init_zone(zone *z, cell size, cell base);
-void init_card_decks(void);
+void init_card_decks();
data_heap *grow_data_heap(data_heap *data, cell requested_bytes);
cell binary_payload_start(object *pointer);
cell object_size(cell tagged);
-void begin_scan(void);
-cell next_object(void);
+void begin_scan();
+cell next_object();
PRIMITIVE(data_room);
PRIMITIVE(size);
/* GC is off during heap walking */
extern bool gc_off;
-cell find_all_words(void);
+cell find_all_words();
/* 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
}
}
-void print_datastack(void)
+void print_datastack()
{
print_string("==== DATA STACK:\n");
print_objects((cell *)ds_bot,(cell *)ds);
}
-void print_retainstack(void)
+void print_retainstack()
{
print_string("==== RETAIN STACK:\n");
print_objects((cell *)rs_bot,(cell *)rs);
print_string("\n");
}
-void print_callstack(void)
+void print_callstack()
{
print_string("==== CALL STACK:\n");
cell bottom = (cell)stack_chain->callstack_bottom;
print_string(", here="); print_cell(z->here - z->start); nl();
}
-void dump_generations(void)
+void dump_generations()
{
cell i;
}
/* Dump all code blocks for debugging */
-void dump_code_heap(void)
+void dump_code_heap()
{
cell reloc_size = 0, literal_size = 0;
print_cell(literal_size); print_string(" bytes of literal data\n");
}
-void factorbug(void)
+void factorbug()
{
if(fep_disabled)
{
void print_obj(cell obj);
void print_nested_obj(cell obj, fixnum nesting);
-void dump_generations(void);
-void factorbug(void);
+void dump_generations();
+void factorbug();
void dump_zone(zone *z);
PRIMITIVE(die);
cell signal_fault_addr;
stack_frame *signal_callstack_top;
-void out_of_memory(void)
+void out_of_memory()
{
print_string("Out of memory\n\n");
dump_generations();
general_error(ERROR_TYPE,tag_fixnum(type),tagged,NULL);
}
-void not_implemented_error(void)
+void not_implemented_error()
{
general_error(ERROR_NOT_IMPLEMENTED,F,F,NULL);
}
general_error(ERROR_SIGNAL,tag_fixnum(signal),F,native_stack);
}
-void divide_by_zero_error(void)
+void divide_by_zero_error()
{
general_error(ERROR_DIVIDE_BY_ZERO,F,F,NULL);
}
not_implemented_error();
}
-void memory_signal_handler_impl(void)
+void memory_signal_handler_impl()
{
memory_protection_error(signal_fault_addr,signal_callstack_top);
}
-void misc_signal_handler_impl(void)
+void misc_signal_handler_impl()
{
signal_error(signal_number,signal_callstack_top);
}
ERROR_MEMORY,
};
-void out_of_memory(void);
+void out_of_memory();
void fatal_error(const char* msg, cell tagged);
void critical_error(const char* msg, cell tagged);
void throw_error(cell error, stack_frame *native_stack);
void general_error(vm_error_type error, cell arg1, cell arg2, stack_frame *native_stack);
-void divide_by_zero_error(void);
+void divide_by_zero_error();
void memory_protection_error(cell addr, stack_frame *native_stack);
void signal_error(int signal, stack_frame *native_stack);
void type_error(cell type, cell tagged);
-void not_implemented_error(void);
+void not_implemented_error();
PRIMITIVE(call_clear);
PRIMITIVE(unimplemented);
extern cell signal_fault_addr;
extern stack_frame *signal_callstack_top;
-void memory_signal_handler_impl(void);
-void misc_signal_handler_impl(void);
+void memory_signal_handler_impl();
+void misc_signal_handler_impl();
}
}
/* Do some initialization that we do once only */
-static void do_stage1_init(void)
+static void do_stage1_init()
{
print_string("*** Stage 2 early init... ");
fflush(stdout);
free(result);
}
-VM_C_API void factor_yield(void)
+VM_C_API void factor_yield()
{
- void (*callback)(void) = (void (*)(void))alien_offset(userenv[YIELD_CALLBACK_ENV]);
+ void (*callback)() = (void (*)())alien_offset(userenv[YIELD_CALLBACK_ENV]);
callback();
}
VM_C_API char *factor_eval_string(char *string);
VM_C_API void factor_eval_free(char *result);
-VM_C_API void factor_yield(void);
+VM_C_API void factor_yield();
VM_C_API void factor_sleep(long ms);
}
with many more capabilities so these words are not usually used in
normal operation. */
-void init_c_io(void)
+void 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 io_error(void)
+void io_error()
{
#ifndef WINCE
if(errno == EINTR)
/* This function is used by FFI I/O. Accessing the errno global directly is
not portable, since on some libc's errno is not a global but a funky macro that
reads thread-local storage. */
-VM_C_API int err_no(void)
+VM_C_API int err_no()
{
return errno;
}
-VM_C_API void clear_err_no(void)
+VM_C_API void clear_err_no()
{
errno = 0;
}
namespace factor
{
-void init_c_io(void);
-void io_error(void);
+void init_c_io();
+void io_error();
PRIMITIVE(fopen);
PRIMITIVE(fgetc);
PRIMITIVE(existsp);
PRIMITIVE(read_dir);
-VM_C_API int err_no(void);
-VM_C_API void clear_err_no(void);
+VM_C_API int err_no();
+VM_C_API void clear_err_no();
}
}
/* Initialize the Mach exception handler thread. */
-void mach_initialize (void)
+void mach_initialize ()
{
mach_port_t self;
exception_mask_t mask;
namespace factor
{
-void mach_initialize (void);
+void mach_initialize ();
}
drepl(tag<bignum>(result));
}
-cell unbox_array_size(void)
+cell unbox_array_size()
{
switch(tagged<object>(dpeek()).type())
{
return tag_fixnum(x);
}
-cell unbox_array_size(void);
+cell unbox_array_size();
inline static double untag_float(cell tagged)
{
{
/* From SBCL */
-const char *vm_executable_path(void)
+const char *vm_executable_path()
{
char path[PATH_MAX + 1];
#include <osreldate.h>
#include <sys/sysctl.h>
-extern "C" int getosreldate(void);
+extern "C" int getosreldate();
#ifndef KERN_PROC_PATHNAME
#define KERN_PROC_PATHNAME 12
c_to_factor(quot);
}
-void init_signals(void)
+void init_signals()
{
unix_init_signals();
}
-void early_init(void) { }
+void early_init() { }
#define SUFFIX ".image"
#define SUFFIX_LEN 6
-const char *default_image_path(void)
+const char *default_image_path()
{
const char *path = vm_executable_path();
#define NULL_DLL NULL
void c_to_factor_toplevel(cell quot);
-void init_signals(void);
-void early_init(void);
-const char *vm_executable_path(void);
-const char *default_image_path(void);
+void init_signals();
+void early_init();
+const char *vm_executable_path();
+const char *default_image_path();
}
{
/* Snarfed from SBCL linux-so.c. You must free() this yourself. */
-const char *vm_executable_path(void)
+const char *vm_executable_path()
{
char *path = (char *)safe_malloc(PATH_MAX + 1);
#ifdef SYS_inotify_init
-int inotify_init(void)
+int inotify_init()
{
return syscall(SYS_inotify_init);
}
#else
-int inotify_init(void)
+int inotify_init()
{
not_implemented_error();
return -1;
namespace factor
{
-int inotify_init(void);
+int inotify_init();
int inotify_add_watch(int fd, const char *name, u32 mask);
int inotify_rm_watch(int fd, u32 wd);
#define FACTOR_OS_STRING "macosx"
#define NULL_DLL "libfactor.dylib"
-void init_signals(void);
-void early_init(void);
+void init_signals();
+void early_init();
-const char *vm_executable_path(void);
-const char *default_image_path(void);
+const char *vm_executable_path();
+const char *default_image_path();
inline static void *ucontext_stack_pointer(void *uap)
{
extern "C" int main();
-const char *vm_executable_path(void)
+const char *vm_executable_path()
{
static Dl_info info = {0};
if (!info.dli_fname)
namespace factor
{
-const char *vm_executable_path(void)
+const char *vm_executable_path()
{
return NULL;
}
namespace factor
{
-const char *vm_executable_path(void)
+const char *vm_executable_path()
{
return NULL;
}
static void *null_dll;
-s64 current_micros(void)
+s64 current_micros()
{
struct timeval t;
gettimeofday(&t,NULL);
usleep(usec);
}
-void init_ffi(void)
+void init_ffi()
{
/* NULL_DLL is "libfactor.dylib" for OS X and NULL for generic unix */
null_dll = dlopen(NULL_DLL,RTLD_LAZY);
fatal_error("sigaction failed", 0);
}
-void unix_init_signals(void)
+void unix_init_signals()
{
struct sigaction memory_sigaction;
struct sigaction misc_sigaction;
return NULL;
}
-void open_console(void)
+void open_console()
{
int filedes[2];
start_thread(stdin_loop);
}
-VM_C_API void wait_for_stdin(void)
+VM_C_API void wait_for_stdin()
{
if(write(control_write,"X",1) != 1)
{
void start_thread(void *(*start_routine)(void *));
-void init_ffi(void);
+void init_ffi();
void ffi_dlopen(dll *dll);
void *ffi_dlsym(dll *dll, symbol_char *symbol);
void ffi_dlclose(dll *dll);
-void unix_init_signals(void);
+void unix_init_signals();
void signal_handler(int signal, siginfo_t* siginfo, void* uap);
void dump_stack_signal(int signal, siginfo_t* siginfo, void* uap);
-s64 current_micros(void);
+s64 current_micros();
void sleep_micros(cell usec);
-void open_console(void);
+void open_console();
}
namespace factor
{
-s64 current_micros(void)
+s64 current_micros()
{
SYSTEMTIME st;
FILETIME ft;
c_to_factor(quot);
}
-void open_console(void) { }
+void open_console() { }
}
#define snprintf _snprintf
#define snwprintf _snwprintf
-s64 current_micros(void);
+s64 current_micros();
void c_to_factor_toplevel(cell quot);
-void open_console(void);
+void open_console();
}
namespace factor
{
-s64 current_micros(void)
+s64 current_micros()
{
FILETIME t;
GetSystemTimeAsFileTime(&t);
RemoveVectoredExceptionHandler((void*)exception_handler);
}
-void open_console(void)
+void open_console()
{
}
void c_to_factor_toplevel(cell quot);
long exception_handler(PEXCEPTION_POINTERS pe);
-void open_console(void);
+void open_console();
}
HMODULE hFactorDll;
-void init_ffi(void)
+void init_ffi()
{
hFactorDll = GetModuleHandle(FACTOR_DLL);
if(!hFactorDll)
}
/* You must free() this yourself. */
-const vm_char *default_image_path(void)
+const vm_char *default_image_path()
{
vm_char full_path[MAX_UNICODE_PATH];
vm_char *ptr;
}
/* You must free() this yourself. */
-const vm_char *vm_executable_path(void)
+const vm_char *vm_executable_path()
{
vm_char full_path[MAX_UNICODE_PATH];
if(!GetModuleFileName(NULL, full_path, MAX_UNICODE_PATH))
free(block);
}
-long getpagesize(void)
+long getpagesize()
{
static long g_pagesize = 0;
if (! g_pagesize)
/* Difference between Jan 1 00:00:00 1601 and Jan 1 00:00:00 1970 */
#define EPOCH_OFFSET 0x019db1ded53e8000LL
-void init_ffi(void);
+void init_ffi();
void ffi_dlopen(dll *dll);
void *ffi_dlsym(dll *dll, symbol_char *symbol);
void ffi_dlclose(dll *dll);
void sleep_micros(u64 msec);
-inline static void init_signals(void) {}
-inline static void early_init(void) {}
-const vm_char *vm_executable_path(void);
-const vm_char *default_image_path(void);
-long getpagesize (void);
+inline static void init_signals() {}
+inline static void early_init() {}
+const vm_char *vm_executable_path();
+const vm_char *default_image_path();
+long getpagesize ();
-s64 current_micros(void);
+s64 current_micros();
}
bool profiling_p;
-void init_profiler(void)
+void init_profiler()
{
profiling_p = false;
}
{
extern bool profiling_p;
-void init_profiler(void);
+void init_profiler();
code_block *compile_profiling_stub(cell word);
PRIMITIVE(profiling);
drepl(allot_cell((cell)quot->xt));
}
-void compile_all_words(void)
+void compile_all_words()
{
gc_root<array> words(find_all_words());
PRIMITIVE(jit_compile);
-void compile_all_words(void);
+void compile_all_words();
PRIMITIVE(array_to_quotation);
PRIMITIVE(quotation_xt);
#define DEFPUSHPOP(prefix,ptr) \
inline static cell prefix##peek() { return *(cell *)ptr; } \
inline static void prefix##repl(cell tagged) { *(cell *)ptr = tagged; } \
- inline static cell prefix##pop(void) \
+ inline static cell prefix##pop() \
{ \
cell value = prefix##peek(); \
ptr -= sizeof(cell); \
/* We don't use printf directly, because format directives are not portable.
Instead we define the common cases here. */
-void nl(void)
+void nl()
{
fputs("\n",stdout);
}
printf(FIXNUM_FORMAT,x);
}
-cell read_cell_hex(void)
+cell read_cell_hex()
{
cell cell;
if(scanf(cell_HEX_FORMAT,&cell) < 0) exit(1);
void *safe_malloc(size_t size);
vm_char *safe_strdup(const vm_char *str);
-void nl(void);
+void nl();
void print_string(const char *str);
void print_cell(cell x);
void print_cell_hex(cell x);
void print_cell_hex_pad(cell x);
void print_fixnum(fixnum x);
-cell read_cell_hex(void);
+cell read_cell_hex();
}