objs/kite_object.h

Go to the documentation of this file.

#ifndef KITE_OBJS__KITEOBJECT_H
#define KITE_OBJS__KITEOBJECT_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>

#ifdef WIN32
#undef __MINGW32__
#define WIN32_LEAN_AND_MEAN
/*#define _WIN32_WINNT 0x501*/
#include <windows.h>
#ifdef HAVE_GC_GC_H
#define HAVE_GC_H
#endif /* HAVE_GC_GC_H */
#else
#include <pthread.h>
#endif /* WIN32 */

#ifdef CINVOKE_BUILD
#include "config.h"
#endif /* CINVOKE_BUILD */

#ifdef HAVE_GC_H
#define GC_THREADS
#ifdef WIN32
#define WIN32_THREADS
#define GC_NOT_DLL
/*#define GC_WIN32_THREADS*/
#include <gc.h>
#else
#define GC_PTHREADS
#ifndef __APPLE__
void * GC_dlopen(const char *path, int mode);
#else
#define GC_DARWIN_THREADS
#endif /* __APPLE__ */
#include <gc/gc.h>
#endif
#endif /* HAVE_GC_H */

/*
 * FALSE/TRUE definitions (for those platforms that don't already define
 * them).
 */
#ifndef FALSE
#define FALSE 0
#endif
#ifndef TRUE
#define TRUE 1
#endif

/* Dynamic library extensions. */
#ifdef WIN32
#define DYLIB_EXTENSION ".dll"
#define KITE_EXPORT __declspec(dllexport)
#else
#ifdef __APPLE__
#define DYLIB_EXTENSION ".dylib"
#else
#define DYLIB_EXTENSION ".so"
#endif
#define KITE_EXPORT
#endif

/*
 * Representation of Kite method written in C
 */
struct kite_object_t;
struct kite_thread_t;
struct kite_opcode_t;

typedef void (*kite_compiled_func_t)(struct kite_thread_t *thread, 
                                     struct kite_object_t *this, 
                                     struct kite_object_t *args);

typedef struct kite_function_t {
    enum 
    { 
        FUNC_COMPILED , 
        FUNC_BYTECODE 
    } functype ;
    void *funcptr ;
    struct kite_object_t *this ;
    int numargs ;
    struct kite_object_t *arginfo ;
    size_t length ;
} kite_function_t;

struct kite_symtab_t
{
    char *name ;
    char *docstring ;
    int global ;
    struct kite_symtab_t *left ;
    struct kite_symtab_t *right ;
    struct kite_object_t *value ;
};
typedef struct kite_symtab_t kite_symtab_t;

#include "kite_vm.h"

enum kite_object_type_t
{ 
    OBJ_INTEGER , 
    OBJ_FLOAT ,
    OBJ_BOOLEAN ,
    OBJ_NUMBER_OF_BASE_TYPES ,
    OBJ_NULL = OBJ_NUMBER_OF_BASE_TYPES ,
    OBJ_STRING ,
    OBJ_IDENT , 
    OBJ_LIST , 
    OBJ_METHOD , 
    OBJ_CLASS , 
    OBJ_INSTANCE ,
    OBJ_NUMBER_OF_TYPES 
};

typedef struct kite_basic_object_t {
    enum kite_object_type_t type ;
    int shareable ;
    union {
        long intvalue ;
        double floatvalue ;
    } builtin_data;
} kite_basic_object_t;

typedef struct kite_object_t {
#ifndef HAVE_GC_H
    unsigned int refcount ;
    kite_list_t *gc_entry ;
#endif /* HAVE_GC_H */
    enum kite_object_type_t type ;
    int shareable ;
    union {
        long intvalue ;
        double floatvalue ;
        struct {
            int length ;
            char *string ;
        } stringvalue;
        struct {
            struct kite_object_t *car ;
            struct kite_object_t *cdr ;
            struct kite_object_t *iterator ;
        } listvalue;
        kite_function_t funcvalue ;
        kite_thread_t *threadvalue ;
        FILE *filevalue ;
    } builtin_data;
    kite_thread_t *owner_thread ;
    struct kite_object_t *parent ;
    struct {
        char *name ;
        char *docstring ;
        struct kite_object_t *inherit_from ;
        kite_symtab_t *properties ;
#ifdef WIN32
        HANDLE mtx ;
        HMODULE dylib_hndl ;
#else
        pthread_mutex_t *mtx ;
        void *dylib_hndl ;
#endif
    } object_data;
} kite_object_t;

KITE_EXPORT kite_object_t *kite_new_null(kite_thread_t *thd);

KITE_EXPORT kite_object_t *kite_new_integer(kite_thread_t *thd, long val);

KITE_EXPORT kite_object_t *kite_new_float(kite_thread_t *thd, double val);

KITE_EXPORT kite_object_t *kite_new_string(kite_thread_t *thd, char *val);

KITE_EXPORT kite_object_t *kite_new_string_with_length(kite_thread_t *thd, char *val, int length);

KITE_EXPORT kite_object_t *kite_new_ident(kite_thread_t *thd, char *val);

KITE_EXPORT kite_object_t *kite_new_boolean(kite_thread_t *thd, int val);

KITE_EXPORT kite_object_t *kite_new_list(kite_thread_t *thd);

KITE_EXPORT kite_object_t *kite_new_method_compiled(kite_thread_t *thd, kite_compiled_func_t func, int numargs);

KITE_EXPORT kite_object_t *kite_new_method_compiled_with_docs(
    kite_thread_t *thd, kite_compiled_func_t func, char* desc, int numargs, ...);

KITE_EXPORT kite_object_t *kite_new_method_bytecode(kite_thread_t *thd, struct kite_opcode_t *func, int numargs);

KITE_EXPORT kite_object_t *kite_new_method_bytecode_with_docs(
    kite_thread_t *thd, struct kite_opcode_t *func, char *desc, int numargs, ...);

KITE_EXPORT kite_object_t *kite_new_class(kite_thread_t *thd, kite_object_t *parent, char *name);

KITE_EXPORT kite_object_t *kite_new_instance(kite_thread_t *thd, kite_object_t *parent);

KITE_EXPORT kite_object_t *kite_new_instance_with_constructor
    (kite_thread_t *thd, kite_object_t *parent, kite_object_t *args);
    
KITE_EXPORT kite_object_t *kite_new_exception(kite_thread_t *thd, char *name, char *message);

KITE_EXPORT void kite_destruct_object(kite_thread_t *, kite_object_t **, int);

KITE_EXPORT void kite_destruct_object_nofree(kite_thread_t *, kite_object_t **, int);

KITE_EXPORT void kite_finalize_object(void *, void *);

KITE_EXPORT void kite_dereference_object(kite_object_t *obj);

KITE_EXPORT kite_object_t *kite_reference_object(kite_object_t *obj);

/* 
 * Stuff to allow built-in and loadable extensions to add their own
 * properties and methods, among other things.
 */
 
KITE_EXPORT void kite_add_property
    (kite_thread_t *thd, kite_object_t *obj, char *name, int global, char *doc);
    
KITE_EXPORT void kite_add_method
    (kite_thread_t *thd, kite_object_t *obj, char *name, kite_object_t *method);

KITE_EXPORT void kite_add_operator
    (kite_thread_t *thd, kite_object_t *obj, int op, kite_object_t *method);

KITE_EXPORT void kite_set_docstring(kite_object_t *obj, char *str);

KITE_EXPORT char *kite_get_docstring(kite_object_t *obj);

KITE_EXPORT void kite_set_arginfo(kite_object_t *obj, kite_object_t *arginfo);

KITE_EXPORT void kite_remove_property
    (kite_thread_t *thd, kite_object_t *obj, char *name, int global);

KITE_EXPORT void kite_remove_method
    (kite_thread_t *thd, kite_object_t *obj, char *name, int numargs);

KITE_EXPORT void kite_remove_operator(kite_thread_t *thd, kite_object_t *obj, int op);

KITE_EXPORT void kite_set_property
    (kite_thread_t *thd, kite_object_t *obj, char *name, kite_object_t *value);

KITE_EXPORT int kite_exists_property(kite_object_t *obj, char *name);

KITE_EXPORT int kite_exists_method(kite_object_t *obj, char *name);

KITE_EXPORT int kite_exists_operator(kite_object_t *obj, int op);

KITE_EXPORT kite_object_t *kite_get_property(kite_object_t *obj, char *name);

KITE_EXPORT kite_object_t *kite_dereference_and_load(kite_thread_t *thd, char *name);

KITE_EXPORT void kite_set_dylib_path(char *path);

KITE_EXPORT void kite_loader_register
    (kite_thread_t *thd, char *name, void (*ptr)(kite_thread_t*, kite_object_t*));

/*
 * Stuff to find properties/methods
 */
 
#define KITE_FIND_PROPERTY(ret, obj, name, num) \
    KITE_FIND_IN_SYMTAB(ret, obj->object_data.properties, name, num)

#define KITE_FIND_METHOD(ret, obj, name, num) \
    KITE_FIND_IN_SYMTAB(ret, obj->object_data.properties, name, num)

#define KITE_FIND_IN_SYMTAB(ret, symtab, n, num) \
    { \
        ret = symtab; \
        while(ret) { \
            int r = strcmp(n, ret->name); \
            if (!r && ret->global == num) { \
                break; \
            } else if (r < 0 || (!r && ret->global > num)) ret = ret->left; \
            else ret = ret->right; \
        } \
    }

#define KITE_FIND_ANY_IN_SYMTAB(ret, symtab, n) \
    { \
        ret = symtab; \
        while(ret) { \
            int r = strcmp(n, ret->name); \
            if (!r) { \
                break; \
            } else if (r < 0) ret = ret->left; \
            else ret = ret->right; \
        } \
    }
    
/*
 * Symbol table manipulation
 */ 

kite_symtab_t *kite_new_symtab();

KITE_EXPORT void kite_symtab_insert
    (kite_thread_t *thd, kite_symtab_t **symt, kite_symtab_t *entry);

KITE_EXPORT void kite_symtab_remove
    (kite_thread_t *thd, kite_symtab_t **symt, char *name, int num);

KITE_EXPORT void kite_copy_symtab(kite_symtab_t **ret, kite_symtab_t *symt);

KITE_EXPORT void kite_destruct_symtab(kite_thread_t *thd, kite_symtab_t **symt, int ref);

KITE_EXPORT void kite_copy_symtab_elements
    (kite_thread_t *thd, kite_symtab_t **ret, kite_symtab_t *symt, kite_object_t *p);

/*
 * Canonical object representation
 */
 
KITE_EXPORT kite_object_t *kite_object_name(kite_thread_t *thd, kite_object_t *obj);

KITE_EXPORT kite_object_t *kite_boolean_object(kite_thread_t *thd, kite_object_t *obj);

KITE_EXPORT kite_object_t *kite_string_object(kite_thread_t *thd, kite_object_t *obj);

KITE_EXPORT kite_object_t *kite_int_object(kite_thread_t *thd, kite_object_t *obj);

KITE_EXPORT kite_object_t *kite_float_object(kite_thread_t *thd, kite_object_t *obj);

KITE_EXPORT kite_object_t *kite_list_object(kite_thread_t *thd, kite_object_t *obj);

/*
 * List manipulation
 */

KITE_EXPORT int kite_list_count(kite_thread_t *thd, kite_object_t *obj);

KITE_EXPORT void kite_append_list(kite_thread_t *thd, kite_object_t *list, kite_object_t *obj);

/*
 * Defines for module writers
 */
 
#define KITE_MODULE_INITIALIZER_NAME(name) \
     name ## _load_module
     
#define KITE_MODULE_INITIALIZER(name) \
     void KITE_MODULE_INITIALIZER_NAME(name) (kite_thread_t *, kite_object_t *); \
     void* name ## _load_module__wrap(kite_thread_t *thd) { \
         kite_loader_register(thd, #name, KITE_MODULE_INITIALIZER_NAME(name)); \
         return NULL; \
     } \
     void KITE_MODULE_INITIALIZER_NAME(name) (kite_thread_t *thread, kite_object_t *parent)

#define KITE_CLASS_METHOD(name) \
     void name(kite_thread_t *thd, kite_object_t *this, \
               kite_object_t *args)
               
#define KITE_NO_ARGS (void)args;

#define KITE_THIS_NOT_USED (void)this;

#define KITE_GET_METHOD_ARGUMENT(ret, n) KITE_GET_LIST_ELEMENT(ret, args, n)

#define KITE_GET_LIST_ELEMENT(ret, obj, n) \
    { \
        int cur = n - 1; \
        ret = obj; \
        while(ret && cur > 0) { \
            cur--; \
            ret = ret->builtin_data.listvalue.cdr; \
        } \
        if (ret) ret = ret->builtin_data.listvalue.car; \
    }

#define KITE_REPLACE_LIST_ELEMENT(list, n, obj) \
    { \
        int cur = n - 1; \
        kite_object_t *ret = obj; \
        while(ret && cur > 0) { \
            cur--; \
            if (KITE_LIST_CDR(ret) == NULL) { \
                kite_append_list(obj->owner_thread, list, kite_new_null(obj->owner_thread)); \
            } \
            ret = ret->builtin_data.listvalue.cdr; \
        } \
        if (ret) { \
            kite_dereference_object(KITE_LIST_CAR(ret)); \
            KITE_LIST_CAR(ret) = kite_reference_object(obj); \
        } else { \
            kite_append_list(obj->owner_thread, list, obj); \
        } \
    }

#define KITE_REMOVE_LIST_ELEMENT(list, n) \
    { \
        int cur = n - 1; \
        kite_object_t *ret = obj; \
        while(ret && cur > 0) { \
            cur--; \
            ret = ret->builtin_data.listvalue.cdr; \
        } \
        if (ret) { \
            kite_dereference_object(KITE_LIST_CAR(ret)); \
            if (KITE_LIST_CDR(ret)) { \
                kite_object_t *tmp = KITE_LIST_CDR(ret); \
                KITE_LIST_CAR(ret) = KITE_LIST_CAR(KITE_LIST_CDR(ret)); \
                KITE_LIST_CDR(ret) = KITE_LIST_CDR(KITE_LIST_CDR(ret)); \
                kite_dereference_object(tmp); \
            } else { \
                KITE_LIST_CAR(ret) = NULL; \
            } \
        } \
    }

#define KITE_IS_TYPE(val, t) ((val)->type == t)

#define KITE_GET_OBJECT_TYPE(val) ((val)->type)

#define KITE_GET_PARENT_OBJECT(val) ((val)->object_data.inherit_from)

#define KITE_GET_INTEGER(v) (((kite_basic_object_t*)v)->builtin_data.intvalue)

#define KITE_GET_FLOAT(v) (((kite_basic_object_t*)v)->builtin_data.floatvalue)

#define KITE_GET_STRING_VALUE(v) ((v)->builtin_data.stringvalue.string)

#define KITE_GET_STRING_LENGTH(v) ((v)->builtin_data.stringvalue.length)

#define KITE_SET_INTEGER(v, i) KITE_GET_INTEGER(v) = i

#define KITE_SET_FLOAT(v, i) KITE_GET_FLOAT(v) = i

#define KITE_LIST_CAR(v) ((v)->builtin_data.listvalue.car)

#define KITE_LIST_CDR(v) ((v)->builtin_data.listvalue.cdr)

#endif /* KITE_OBJ__KITEOBJECT_H */