vm/kite_vm.h

Go to the documentation of this file.

#ifndef KITE_VM__KITEVM_H
#define KITE_VM__KITEVM_H
/*****************************************************************************
 * Copyright (c) 2007, Mooneer Salem
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the Kite Language organization nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY MOONEER SALEM ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL MOONEER SALEM BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ****************************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <setjmp.h>

#ifdef WIN32
#undef __MINGW32__
#else
#include <pthread.h>
#endif /* WIN32 */

#include <signal.h>
#include <assert.h>
#include "kite_opcodes.h"

struct kite_object_t;
struct kite_symtab_t;

/*
 * Stack representation
 */
struct kite_stack_entry_t;
typedef struct kite_stack_t 
{
    size_t allocated ;
    int length ;
    struct kite_stack_entry_t *stack ;
} kite_stack_t;

typedef struct kite_stack_entry_t 
{
    int reference ;
    void *obj ;
} kite_stack_entry_t;
    
/*
 * Entry on function call stack.
 */
typedef struct kite_funccall_info_t 
{
    char *file ;
    int line ;
    int sys_or_user ;
    struct kite_symtab_t *locals ;
    struct kite_object_t *this ;
    char *last_deref ;
    struct kite_symtab_t *last_deref_obj ;
} kite_funccall_info_t;
    
/*
 * Kite thread object. This object represents a single thread in the Kite
 * threading system (and its current state)
 */
typedef struct kite_thread_t
{
    struct kite_thread_t **entry ;
    struct kite_vm_t *vm ;
    kite_stack_t *running_stack ;
    kite_stack_t *func_stack ;
    struct kite_object_t *exception ;
    void *start ;
#ifdef WIN32
    HANDLE thread ;
#else
    pthread_t thread ;
#endif /* WIN32 */
} kite_thread_t ;

/*
 * Kite list object. 
 */
typedef struct kite_list_t 
{
    void *obj ;
    struct kite_list_t *prev ;
    struct kite_list_t *next ;
} kite_list_t;

/*
 * Kite VM object. This object is how other developers will access
 * Kite internals.
 */
typedef struct kite_vm_t
{
    struct kite_object_t *root_package ;
    struct kite_object_t *true_cached ;
    struct kite_object_t *false_cached ;
    struct kite_object_t *null_cached ;
    struct kite_object_t *int_cached ;
    struct kite_symtab_t *loader_refs ;
    struct kite_object_t *instruction_tracer;
    int numthreads ;
    kite_thread_t **thread_list ;
#ifndef HAVE_GC_H
    kite_list_t *gc_begin , *gc_end ; /* garbage collector queue */
#endif /* HAVE_GC_H */
#ifdef WIN32
    HANDLE gc_mtx ;
#else
    pthread_mutex_t gc_mtx ;
#endif /* WIN32 */
#ifdef HAVE_GC_H
    GC_warn_proc old_proc ;
#endif /* HAVE_GC_H */
    char **args ;
} kite_vm_t ;

/*
 * Kite compiler state object
 */
typedef struct kite_compiler_t 
{
    kite_thread_t *thd ;
    char *file ;
    int verMajor ;
    int verMinor ;
    int verPatch ;
    int currentLine ;
    int currentCol ;
    kite_stack_t *obj_created ;
    kite_stack_t *decide_exits ; /* to fix ticket #17 and short-circuiting */
    char *curStr ;
} kite_compiler_t;

/*
 * VM handling functions
 */

KITE_EXPORT void kite_app_init();
 
KITE_EXPORT kite_vm_t *kite_new_vm(char **args);

KITE_EXPORT void kite_free_vm(kite_vm_t **vm);

/*
 * Thread handling functions
 */
 
KITE_EXPORT kite_thread_t *kite_new_thread_without_start(kite_vm_t *vm);

KITE_EXPORT kite_thread_t *kite_new_thread_bytecode(kite_vm_t *vm, void *ptr);

KITE_EXPORT kite_thread_t *kite_new_thread_compiled(kite_vm_t *vm, void *ptr);

#define kite_vm_creator_thread(vm) ((vm)->thread_list[0])

KITE_EXPORT void kite_start_bytecode(kite_thread_t *thd, void *ptr);

KITE_EXPORT void kite_start_compiled(kite_thread_t *thd, void *ptr);

KITE_EXPORT void kite_join_thread(kite_vm_t *vm, kite_thread_t *thd);

KITE_EXPORT void kite_exit_thread(kite_vm_t *vm, kite_thread_t *thd);

/*
 * Stack handling functions
 */

KITE_EXPORT void kite_push_stack(kite_stack_t **stack, int ref, void *obj);

KITE_EXPORT void kite_destroy_stack(kite_stack_t **stack);

KITE_EXPORT void *kite_pop_stack(kite_stack_t **stack);

#ifndef WIN32
/*#define INLINE_STACK*/
#endif
#ifndef INLINE_STACK

KITE_EXPORT void *kite_top_stack(kite_stack_t *stack);

#else
#define kite_top_stack(st) \
    ((!st || st->length == 0) ? \
        NULL : \
        (((&st->stack[st->length - 1])->reference) ? \
            ((kite_symtab_t*)(&st->stack[st->length - 1])->obj)->value : \
            (&st->stack[st->length - 1])->obj))
#endif /* INLINE_STACK */

/*
 * List handling functions
 */

KITE_EXPORT void kite_list_remove(kite_list_t **begin, kite_list_t **end, kite_list_t *item);

KITE_EXPORT void kite_list_add_end(kite_list_t **begin, kite_list_t **end, kite_list_t *item);

KITE_EXPORT void kite_list_add_begin(kite_list_t **begin, kite_list_t **end, kite_list_t *item);

/* 
 * Script operation functions
 */
#ifndef WIN32

void *kite_vm_execute(void *);

#else

KITE_EXPORT DWORD WINAPI kite_vm_execute(LPVOID);

#endif /* WIN32 */

KITE_EXPORT void kite_vm_execute_user_method(kite_thread_t *, void *);

KITE_EXPORT void kite_vm_execute_exception(kite_thread_t *, int);

KITE_EXPORT void kite_vm_call_method(kite_thread_t *thd, struct kite_object_t *this, 
                         char *name, struct kite_object_t *args, int err);

KITE_EXPORT void kite_vm_call_object(kite_thread_t *thd, struct kite_object_t *this, 
                         struct kite_object_t *method, struct kite_object_t *args);

KITE_EXPORT void kite_vm_call_constructor(kite_thread_t *thd, struct kite_object_t *this, 
                              struct kite_object_t *args);

KITE_EXPORT int kite_vm_call_operator(kite_thread_t *thd, struct kite_object_t *this, 
                          int op, struct kite_object_t *args, int err);

#define kite_vm_push(thd, obj) \
    kite_push_stack(&(thd)->running_stack, FALSE, kite_reference_object(obj))
    
#define kite_vm_pop(thd) (struct kite_object_t*)kite_pop_stack(&(thd)->running_stack)

#define kite_vm_return(thd, obj) \
    { \
        kite_object_t *tmp = (obj); \
        kite_vm_push((thd), tmp); \
        kite_dereference_object(tmp); \
        return; \
    }

#define STACK_MAX 1024

#ifndef HAVE_GC_H 

#define PUSH_FUNC_STACK(t) \
     fc_entry = malloc(sizeof(kite_funccall_info_t)); \
     oldentry = ((kite_funccall_info_t*)kite_top_stack(thd->func_stack)); \
     old_sys = oldentry ? oldentry->sys_or_user : 0; \
     fc_entry->this = t; \
     fc_entry->locals = NULL; \
     fc_entry->file = ins->common.file; \
     fc_entry->line = ins->common.line; \
     fc_entry->last_deref = NULL; \
     fc_entry->last_deref_obj = NULL; \
     fc_entry->sys_or_user = 0; \
     kite_push_stack(&thd->func_stack, FALSE, fc_entry); \
     if (thd->func_stack->length >= STACK_MAX && !old_sys) { \
         kite_object_t *exc; \
         fc_entry->sys_or_user = 1; \
         exc = kite_new_exception(thd, "System.exceptions.StackOverflow", \
                                  "The function call stack has overflowed."); \
         kite_vm_call_method(thd, exc, "throw", kite_new_list(thd), TRUE); \
         fc_entry->sys_or_user = 0; \
         return; \
     }

#define PUSH_FUNC_STACK_WITH_RET_VALUE(t, nxt) \
     fc_entry = malloc(sizeof(kite_funccall_info_t)); \
     oldentry = ((kite_funccall_info_t*)kite_top_stack(thd->func_stack)); \
     old_sys = oldentry ? oldentry->sys_or_user : 0; \
     fc_entry->this = t; \
     fc_entry->locals = NULL; \
     fc_entry->file = ins->common.file; \
     fc_entry->line = ins->common.line; \
     fc_entry->last_deref = NULL; \
     fc_entry->last_deref_obj = NULL; \
     fc_entry->sys_or_user = 0; \
     kite_push_stack(&thd->func_stack, FALSE, fc_entry); \
     if (thd->func_stack->length >= STACK_MAX && !old_sys) { \
         kite_object_t *exc; \
         fc_entry->sys_or_user = 1; \
         exc = kite_new_exception(thd, "System.exceptions.StackOverflow", \
                                  "The function call stack has overflowed."); \
         kite_vm_call_method(thd, exc, "throw", kite_new_list(thd), TRUE); \
         fc_entry->sys_or_user = 0; \
         return nxt; \
     }

#define POP_FUNC_STACK \
    kite_pop_stack(&thd->func_stack); \
    if (fc_entry->locals) kite_destruct_symtab(thd, &fc_entry->locals, TRUE); \
    free(fc_entry);

#else

#define PUSH_FUNC_STACK(t) \
     fc_entry = (kite_funccall_info_t*)GC_malloc(sizeof(kite_funccall_info_t)); \
     oldentry = ((kite_funccall_info_t*)kite_top_stack(thd->func_stack)); \
     old_sys = oldentry ? oldentry->sys_or_user : 0; \
     fc_entry->this = t; \
     fc_entry->locals = NULL; \
     fc_entry->file = ins->common.file; \
     fc_entry->line = ins->common.line; \
     fc_entry->last_deref = NULL; \
     fc_entry->last_deref_obj = NULL; \
     fc_entry->sys_or_user = 0; \
     kite_push_stack(&thd->func_stack, FALSE, fc_entry); \
     if (thd->func_stack->length >= STACK_MAX && !old_sys) { \
         kite_object_t *exc; \
         fc_entry->sys_or_user = 1; \
         exc = kite_new_exception(thd, "System.exceptions.StackOverflow", \
                                  "The function call stack has overflowed."); \
         kite_vm_call_method(thd, exc, "throw", kite_new_list(thd), TRUE); \
         fc_entry->sys_or_user = 0; \
         return; \
     }

#define PUSH_FUNC_STACK_WITH_RET_VALUE(t, nxt) \
     fc_entry = (kite_funccall_info_t*)GC_malloc(sizeof(kite_funccall_info_t)); \
     oldentry = ((kite_funccall_info_t*)kite_top_stack(thd->func_stack)); \
     old_sys = oldentry ? oldentry->sys_or_user : 0; \
     fc_entry->this = t; \
     fc_entry->locals = NULL; \
     fc_entry->file = ins->common.file; \
     fc_entry->line = ins->common.line; \
     fc_entry->last_deref = NULL; \
     fc_entry->last_deref_obj = NULL; \
     fc_entry->sys_or_user = 0; \
     kite_push_stack(&thd->func_stack, FALSE, fc_entry); \
     if (thd->func_stack->length >= STACK_MAX && !old_sys) { \
         kite_object_t *exc; \
         fc_entry->sys_or_user = 1; \
         exc = kite_new_exception(thd, "System.exceptions.StackOverflow", \
                                  "The function call stack has overflowed."); \
         kite_vm_call_method(thd, exc, "throw", kite_new_list(thd), TRUE); \
         fc_entry->sys_or_user = 0; \
         return nxt; \
     }

#define POP_FUNC_STACK \
    kite_pop_stack(&thd->func_stack); \
    if (fc_entry->locals) kite_destruct_symtab(thd, &fc_entry->locals, TRUE);

#endif /* HAVE_GC_H */

/*
 * Compiler functions
 */
 
KITE_EXPORT struct kite_object_t *kite_vm_compile_from_file(kite_thread_t *thd, char *file);

KITE_EXPORT struct kite_object_t *kite_vm_compile_from_fp
    (kite_thread_t *thd, FILE *fp, char *file, struct kite_object_t *created_obj);

KITE_EXPORT struct kite_object_t *kite_vm_compile_from_string(kite_thread_t *thd, char *code, int ln);

KITE_EXPORT struct kite_object_t *kite_vm_compile_from_file_without_create(
    kite_thread_t *thd, char *file, struct kite_object_t *created_obj);

/*
 * Signal handling.
 */
#ifndef WIN32
#undef NSIG

#define NSIG 65

#endif /* WIN32 */

KITE_EXPORT extern struct kite_object_t *kite_signal_handlers[NSIG + 1];

void kite_handle_signal(int);

/*
 * To facilitate module loading
 */
#ifndef KITE_MODULE_INITIALIZER_C

extern void kite_module_initialize_now(kite_thread_t*);
#endif /* KITE_MODULE_INITIALIZER_C */

#ifdef INLINE_STACK
inline void *kite_pop_stack(kite_stack_t **st)
{
    kite_stack_t *entry;
    void *ret;

    assert(st != NULL && (*st)->length > 0);
    entry = *st;

    ret = kite_top_stack(entry);
    entry->length--;

    return ret;
}

inline void kite_push_stack(kite_stack_t **st, int ref, void *obj)
{
    assert(st != NULL && obj != NULL);

    kite_stack_t *cur = *st;
    if (cur == NULL)
    {
#ifndef HAVE_GC_H
        cur = malloc(sizeof(kite_stack_t));
#else
        cur = GC_malloc(sizeof(kite_stack_t));
#endif /* HAVE_GC_H */
        assert(cur != NULL);
        cur->length = 0;
        cur->allocated = sizeof(kite_stack_entry_t);
#ifndef HAVE_GC_H
        cur->stack = malloc(cur->allocated);
#else
        cur->stack = GC_malloc(cur->allocated);
#endif /* HAVE_GC_H */
        *st = cur;
    }

    if (((cur->length + 1) * sizeof(kite_stack_entry_t)) > cur->allocated)
    {
        int newsize = cur->allocated << 1;
#ifndef HAVE_GC_H
        cur->stack = realloc(cur->stack, newsize);
#else
        cur->stack = GC_realloc(cur->stack, newsize);
#endif /* HAVE_GC_H */
        assert(cur->stack != NULL);
        cur->allocated = newsize;
    }

    kite_stack_entry_t *entry = &cur->stack[++cur->length - 1];
    entry->obj = obj;
    entry->reference = ref;
}
#endif

#endif /* KITE_VM__KITEVM_H */

---