* common.mk, *.ci: renamed to *.c.

* eval_laod.c: renamed to load.c.



git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@14364 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

1 files changed, 0 insertions, 508 deletions

diff --git a/thread_win32.ci b/thread_win32.ci
deleted file mode 100644
index 9d151cdb6d..0000000000
--- a/thread_win32.ci
+++ /dev/null
@@ -1,508 +0,0 @@
-/* -*-c-*- */
-/**********************************************************************
-
-  thread_win32.ci -
-
-  $Author$
-  $Date$
-
-  Copyright (C) 2004-2007 Koichi Sasada
-
-**********************************************************************/
-
-#ifdef THREAD_SYSTEM_DEPENDENT_IMPLEMENTATION
-
-#include <process.h>
-
-#define WIN32_WAIT_TIMEOUT 10	/* 10 ms */
-#undef Sleep
-
-#define native_thread_yield() Sleep(0)
-#define remove_signal_thread_list(th)
-
-static volatile DWORD ruby_native_thread_key = TLS_OUT_OF_INDEXES;
-
-static rb_thread_t *
-ruby_thread_from_native(void)
-{
-    return TlsGetValue(ruby_native_thread_key);
-}
-
-static int
-ruby_thread_set_native(rb_thread_t *th)
-{
-    return TlsSetValue(ruby_native_thread_key, th);
-}
-
-static void
-Init_native_thread(void)
-{
-    rb_thread_t *th = GET_THREAD();
-
-    ruby_native_thread_key = TlsAlloc();
-    DuplicateHandle(GetCurrentProcess(),
-		    GetCurrentThread(),
-		    GetCurrentProcess(),
-		    &th->thread_id, 0, FALSE, DUPLICATE_SAME_ACCESS);
-
-    th->native_thread_data.interrupt_event = CreateEvent(0, TRUE, FALSE, 0);
-
-    thread_debug("initial thread (th: %p, thid: %p, event: %p)\n",
-		 th, GET_THREAD()->thread_id,
-		 th->native_thread_data.interrupt_event);
-}
-
-static void
-w32_error(void)
-{
-    LPVOID lpMsgBuf;
-    FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
-		  FORMAT_MESSAGE_FROM_SYSTEM |
-		  FORMAT_MESSAGE_IGNORE_INSERTS,
-		  NULL,
-		  GetLastError(),
-		  MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
-		  (LPTSTR) & lpMsgBuf, 0, NULL);
-    rb_bug("%s", lpMsgBuf);
-}
-
-static void
-w32_set_event(HANDLE handle)
-{
-    if (SetEvent(handle) == 0) {
-	w32_error();
-    }
-}
-
-static void
-w32_reset_event(HANDLE handle)
-{
-    if (ResetEvent(handle) == 0) {
-	w32_error();
-    }
-}
-
-static int
-w32_wait_events(HANDLE *events, int count, DWORD timeout, rb_thread_t *th)
-{
-    HANDLE *targets = events;
-    HANDLE intr;
-    DWORD ret;
-
-    thread_debug("  w32_wait_events events:%p, count:%d, timeout:%ld, th:%p\n",
-		 events, count, timeout, th);
-    if (th && (intr = th->native_thread_data.interrupt_event)) {
-	w32_reset_event(intr);
-	if (th->interrupt_flag) {
-	    w32_set_event(intr);
-	}
-
-	targets = ALLOCA_N(HANDLE, count + 1);
-	memcpy(targets, events, sizeof(HANDLE) * count);
-
-	targets[count++] = intr;
-	thread_debug("  * handle: %p (count: %d, intr)\n", intr, count);
-    }
-
-    thread_debug("  WaitForMultipleObjects start (count: %d)\n", count);
-    ret = WaitForMultipleObjects(count, targets, FALSE, timeout);
-    thread_debug("  WaitForMultipleObjects end (ret: %d)\n", ret);
-
-    if (ret == WAIT_OBJECT_0 + count - 1 && th) {
-	errno = EINTR;
-    }
-    if (ret == -1 && THREAD_DEBUG) {
-	int i;
-	DWORD dmy;
-	for (i = 0; i < count; i++) {
-	    thread_debug("  * error handle %d - %s\n", i,
-			 GetHandleInformation(targets[i], &dmy) ? "OK" : "NG");
-	}
-    }
-    return ret;
-}
-
-static void ubf_handle(void *ptr);
-#define ubf_select ubf_handle
-
-int
-rb_w32_wait_events_blocking(HANDLE *events, int num, DWORD timeout)
-{
-    return w32_wait_events(events, num, timeout, GET_THREAD());
-}
-
-int
-rb_w32_wait_events(HANDLE *events, int num, DWORD timeout)
-{
-    int ret;
-
-    BLOCKING_REGION(ret = rb_w32_wait_events_blocking(events, num, timeout),
-		    ubf_handle, GET_THREAD());
-    return ret;
-}
-
-static void
-w32_close_handle(HANDLE handle)
-{
-    if (CloseHandle(handle) == 0) {
-	w32_error();
-    }
-}
-
-static void
-w32_resume_thread(HANDLE handle)
-{
-    if (ResumeThread(handle) == -1) {
-	w32_error();
-    }
-}
-
-#ifdef _MSC_VER
-#define HAVE__BEGINTHREADEX 1
-#else
-#undef HAVE__BEGINTHREADEX
-#endif
-
-#ifdef HAVE__BEGINTHREADEX
-#define start_thread (HANDLE)_beginthreadex
-typedef unsigned long (_stdcall *w32_thread_start_func)(void*);
-#else
-#define start_thread CreateThread
-typedef LPTHREAD_START_ROUTINE w32_thread_start_func;
-#endif
-
-static HANDLE
-w32_create_thread(DWORD stack_size, w32_thread_start_func func, void *val)
-{
-    return start_thread(0, stack_size, func, val, CREATE_SUSPENDED, 0);
-}
-
-int
-rb_w32_sleep(unsigned long msec)
-{
-    return w32_wait_events(0, 0, msec, GET_THREAD());
-}
-
-int WINAPI
-rb_w32_Sleep(unsigned long msec)
-{
-    int ret;
-
-    BLOCKING_REGION(ret = rb_w32_sleep(msec),
-		    ubf_handle, GET_THREAD());
-    return ret;
-}
-
-static void
-native_sleep(rb_thread_t *th, struct timeval *tv)
-{
-    DWORD msec;
-    if (tv) {
-	msec = tv->tv_sec * 1000 + tv->tv_usec / 1000;
-    }
-    else {
-	msec = INFINITE;
-    }
-
-    GVL_UNLOCK_BEGIN();
-    {
-	DWORD ret;
-	int status = th->status;
-	th->status = THREAD_STOPPED;
-	th->unblock_function = ubf_handle;
-	th->unblock_function_arg = th;
-	thread_debug("native_sleep start (%d)\n", (int)msec);
-	ret = w32_wait_events(0, 0, msec, th);
-	thread_debug("native_sleep done (%d)\n", ret);
-	th->unblock_function = 0;
-	th->unblock_function_arg = 0;
-	th->status = status;
-    }
-    GVL_UNLOCK_END();
-}
-
-int
-native_mutex_lock(rb_thread_lock_t *lock)
-{
-#if USE_WIN32_MUTEX
-    DWORD result;
-    while (1) {
-	thread_debug("native_mutex_lock: %p\n", *lock);
-	result = w32_wait_events(&*lock, 1, INFINITE, 0);
-	switch (result) {
-	  case WAIT_OBJECT_0:
-	    /* get mutex object */
-	    thread_debug("acquire mutex: %p\n", *lock);
-	    return 0;
-	  case WAIT_OBJECT_0 + 1:
-	    /* interrupt */
-	    errno = EINTR;
-	    thread_debug("acquire mutex interrupted: %p\n", *lock);
-	    return 0;
-	  case WAIT_TIMEOUT:
-	    thread_debug("timeout mutex: %p\n", *lock);
-	    break;
-	  case WAIT_ABANDONED:
-	    rb_bug("win32_mutex_lock: WAIT_ABANDONED");
-	    break;
-	  default:
-	    rb_bug("win32_mutex_lock: unknown result (%d)", result);
-	    break;
-	}
-    }
-    return 0;
-#else
-    EnterCriticalSection(lock);
-    return 0;
-#endif
-}
-
-int
-native_mutex_unlock(rb_thread_lock_t *lock)
-{
-#if USE_WIN32_MUTEX
-    thread_debug("release mutex: %p\n", *lock);
-    return ReleaseMutex(*lock);
-#else
-    LeaveCriticalSection(lock);
-    return 0;
-#endif
-}
-
-int
-native_mutex_trylock(rb_thread_lock_t *lock)
-{
-#if USE_WIN32_MUTEX
-    int result;
-    thread_debug("native_mutex_trylock: %p\n", *lock);
-    result = w32_wait_events(&*lock, 1, 1, 0);
-    thread_debug("native_mutex_trylock result: %d\n", result);
-    switch (result) {
-      case WAIT_OBJECT_0:
-	return 0;
-      case WAIT_TIMEOUT:
-	return EBUSY;
-    }
-    return EINVAL;
-#else
-    return TryEnterCriticalSection(lock) == 0;
-#endif
-}
-
-void
-native_mutex_initialize(rb_thread_lock_t *lock)
-{
-#if USE_WIN32_MUTEX
-    *lock = CreateMutex(NULL, FALSE, NULL);
-    if (*lock == NULL) {
-	w32_error();
-    }
-    /* thread_debug("initialize mutex: %p\n", *lock); */
-#else
-    InitializeCriticalSection(lock);
-#endif
-}
-
-void
-native_mutex_destroy(rb_thread_lock_t *lock)
-{
-#if USE_WIN32_MUTEX
-    w32_close_handle(lock);
-#else
-    DeleteCriticalSection(lock);
-#endif
-}
-
-struct cond_event_entry {
-    struct cond_event_entry* next;
-    HANDLE event;
-};
-
-struct rb_thread_cond_struct {
-    struct cond_event_entry *next;
-    struct cond_event_entry *last;
-};
-
-void
-native_cond_signal(rb_thread_cond_t *cond)
-{
-    /* cond is guarded by mutex */
-    struct cond_event_entry *e = cond->next;
-
-    if (e) {
-	cond->next = e->next;
-	SetEvent(e->event);
-    }
-    else {
-	rb_bug("native_cond_signal: no pending threads");
-    }
-}
-
-void
-native_cond_broadcast(rb_thread_cond_t *cond)
-{
-    /* cond is guarded by mutex */
-    struct cond_event_entry *e = cond->next;
-    cond->next = 0;
-
-    while (e) {
-	SetEvent(e->event);
-	e = e->next;
-    }
-}
-
-void
-native_cond_wait(rb_thread_cond_t *cond, rb_thread_lock_t *mutex)
-{
-    DWORD r;
-    struct cond_event_entry entry;
-
-    entry.next = 0;
-    entry.event = CreateEvent(0, FALSE, FALSE, 0);
-
-    /* cond is guarded by mutex */
-    if (cond->next) {
-	cond->last->next = &entry;
-	cond->last = &entry;
-    }
-    else {
-	cond->next = &entry;
-	cond->last = &entry;
-    }
-
-    native_mutex_unlock(mutex);
-    {
-	r = WaitForSingleObject(entry.event, INFINITE);
-	if (r != WAIT_OBJECT_0) {
-	    rb_bug("native_cond_wait: WaitForSingleObject returns %d", r);
-	}
-    }
-    native_mutex_lock(mutex);
-
-    w32_close_handle(entry.event);
-}
-
-void
-native_cond_initialize(rb_thread_cond_t *cond)
-{
-    cond->next = 0;
-    cond->last = 0;
-}
-
-void
-native_cond_destroy(rb_thread_cond_t *cond)
-{
-    /* */
-}
-
-static void
-native_thread_destroy(rb_thread_t *th)
-{
-    HANDLE intr = th->native_thread_data.interrupt_event;
-    thread_debug("close handle - intr: %p, thid: %p\n", intr, th->thread_id);
-    th->native_thread_data.interrupt_event = 0;
-    w32_close_handle(intr);
-}
-
-static unsigned long _stdcall
-thread_start_func_1(void *th_ptr)
-{
-    rb_thread_t *th = th_ptr;
-    VALUE stack_start;
-    volatile HANDLE thread_id = th->thread_id;
-
-    th->native_thread_data.interrupt_event = CreateEvent(0, TRUE, FALSE, 0);
-
-    /* run */
-    thread_debug("thread created (th: %p, thid: %p, event: %p)\n", th,
-		 th->thread_id, th->native_thread_data.interrupt_event);
-    thread_start_func_2(th, &stack_start, 0);
-
-    w32_close_handle(thread_id);
-    thread_debug("thread deleted (th: %p)\n", th);
-    return 0;
-}
-
-extern size_t rb_gc_stack_maxsize;
-
-static int
-native_thread_create(rb_thread_t *th)
-{
-    size_t stack_size = 4 * 1024; /* 4KB */
-    th->thread_id = w32_create_thread(stack_size, thread_start_func_1, th);
-
-    th->machine_stack_maxsize = rb_gc_stack_maxsize; /* not tested. */
-
-    if ((th->thread_id) == 0) {
-	st_delete_wrap(th->vm->living_threads, th->self);
-	rb_raise(rb_eThreadError, "can't create Thread (%d)", errno);
-    }
-
-    w32_resume_thread(th->thread_id);
-
-    if (THREAD_DEBUG) {
-	Sleep(0);
-	thread_debug("create: (th: %p, thid: %p, intr: %p), stack size: %d\n",
-		     th, th->thread_id,
-		     th->native_thread_data.interrupt_event, stack_size);
-    }
-    return 0;
-}
-
-static void
-native_thread_join(HANDLE th)
-{
-    w32_wait_events(&th, 1, 0, 0);
-}
-
-static void
-native_thread_apply_priority(rb_thread_t *th)
-{
-    int priority = th->priority;
-    if (th->priority > 0) {
-	priority = THREAD_PRIORITY_ABOVE_NORMAL;
-    }
-    else if (th->priority < 0) {
-	priority = THREAD_PRIORITY_BELOW_NORMAL;
-    }
-    else {
-	priority = THREAD_PRIORITY_NORMAL;
-    }
-
-    SetThreadPriority(th->thread_id, priority);
-}
-
-static void
-ubf_handle(void *ptr)
-{
-    rb_thread_t *th = (rb_thread_t *)ptr;
-    thread_debug("ubf_handle: %p\n", th);
-    w32_set_event(th->native_thread_data.interrupt_event);
-}
-
-static void timer_thread_function(void);
-
-static HANDLE timer_thread_id = 0;
-
-static unsigned long _stdcall
-timer_thread_func(void *dummy)
-{
-    thread_debug("timer_thread\n");
-    while (system_working) {
-	Sleep(WIN32_WAIT_TIMEOUT);
-	timer_thread_function();
-    }
-    thread_debug("timer killed\n");
-    return 0;
-}
-
-void
-rb_thread_create_timer_thread(void)
-{
-    if (timer_thread_id == 0) {
-	timer_thread_id = w32_create_thread(1024, timer_thread_func, 0);
-	w32_resume_thread(timer_thread_id);
-    }
-}
-
-#endif /* THREAD_SYSTEM_DEPENDENT_IMPLEMENTATION */