syslib.cpp

C-Talk is interpreted scripting language with C-like syntax and dynamic type checking. Variables in

#include "ctalk.h"
#include "compiler.h"
#include <time.h>
#include <ctype.h>
#ifdef _WIN32
#include <direct.h>
#endif

static CtkObject lockMutex(int nArgs, CtkObject* args) {
    CHECK_PRIMITIVE_N_ARGS(1, nArgs);
    CHECK_PRIMITIVE_ARGUMENT(args[0], CTK_MUTEX);
    CtkThread* thr = ctkGetCurrentThread();
    CtkMemoryManager::instance.endAccess(thr);
    ctkLockMutex((CtkMutex*)args[0].u.ptr);
    CtkMemoryManager::instance.beginAccess(thr);
    return ctkNull;
}

static CtkPrimitive p1("lockMutex", lockMutex);

static CtkObject unlockMutex(int nArgs, CtkObject* args) {
    CHECK_PRIMITIVE_N_ARGS(1, nArgs);
    CHECK_PRIMITIVE_ARGUMENT(args[0], CTK_MUTEX);
    ctkUnlockMutex((CtkMutex*)args[0].u.ptr);
    return ctkNull;
}
static CtkPrimitive p2("unlockMutex", unlockMutex);

static CtkObject createMutex(int nArgs, CtkObject*) {
    CHECK_PRIMITIVE_N_ARGS(0, nArgs);
    CtkObject result;
    MAKE_MUTEX(result, ctkCreateMutex());
    return result;
}
static CtkPrimitive p3("createMutex", createMutex);

static CtkObject deleteMutex(int nArgs, CtkObject* args) {
    CHECK_PRIMITIVE_N_ARGS(1, nArgs);
    CHECK_PRIMITIVE_ARGUMENT(args[0], CTK_MUTEX);
    ctkDeleteMutex((CtkMutex*)args[0].u.ptr);
    return ctkNull;
}
static CtkPrimitive p4("deleteMutex", deleteMutex);


CtkObject deleteArray(int nArgs, CtkObject* args) {
    CHECK_PRIMITIVE_N_ARGS(1, nArgs);
    CHECK_PRIMITIVE_ARGUMENT(args[0], CTK_ARRAY);
    ctkDeleteArray((CtkArray*)args[0].u.ptr);
    return ctkNull;
}
static CtkPrimitive p5("deleteArray", deleteArray);


CtkObject clearArray(int nArgs, CtkObject* args) {
    CHECK_PRIMITIVE_N_ARGS(1, nArgs);
    CHECK_PRIMITIVE_ARGUMENT(args[0], CTK_ARRAY);
    ctkClearArray((CtkArray*)args[0].u.ptr);
    return ctkNull;
}
static CtkPrimitive p6("clearArray", clearArray);

CtkObject cloneArray(int nArgs, CtkObject* args) {
    CHECK_PRIMITIVE_N_ARGS(1, nArgs);
    CHECK_PRIMITIVE_ARGUMENT(args[0], CTK_ARRAY);
    CtkObject result;
    MAKE_ARRAY(result, ctkCloneArray((CtkArray*)args[0].u.ptr));
    return result;
}
static CtkPrimitive p7("cloneArray", cloneArray);


CtkObject getKeys(int nArgs, CtkObject* args) {
    CHECK_PRIMITIVE_ARGUMENT(args[0], CTK_ARRAY);
    CtkObject result;
    CtkArray* dst = ctkCreateArray();
    CtkArray* src = (CtkArray*)args[0].u.ptr; 
    CtkObject key;
    key.type = CTK_INTEGER;
    for (int i = src->nAllocated, j = 0; --i >= 0;) { 
	for (CtkHashEntry* entry = src->entries[i]; entry != NULL; entry = entry->next) { 
	    key.u.ivalue = j++;
	    ctkPutArray(dst, key, entry->key);
	}
    }
    MAKE_ARRAY(result, dst);
    return result;
}
static CtkPrimitive p77("getKeys", getKeys);

static CtkObject getMessage(int nArgs, CtkObject* args) {
    CHECK_PRIMITIVE_N_ARGS(1, nArgs);
    CHECK_PRIMITIVE_ARGUMENT(args[0], CTK_THREAD);
    CtkObject object = ctkGetMessage((CtkThread*)args[0].u.ptr);
    return object;
}
static CtkPrimitive p8("getMessage", getMessage);

static CtkObject putMessage(int nArgs, CtkObject* args) {
    CHECK_PRIMITIVE_N_ARGS(2, nArgs);
    CHECK_PRIMITIVE_ARGUMENT(args[0], CTK_THREAD);
    ctkPutMessage((CtkThread*)args[0].u.ptr, args[1]);
    return args[0];
}
static CtkPrimitive p9("putMessage", putMessage);

CtkObject currentThread(int nArgs, CtkObject*) {
    CHECK_PRIMITIVE_N_ARGS(0, nArgs);
    CtkObject result;
    MAKE_THREAD(result, ctkGetCurrentThread());
    return result;
}
static CtkPrimitive p10("currentThread", currentThread);

static CtkObject createFile(int nArgs, CtkObject* args) {
    CHECK_PRIMITIVE_N_ARGS(2, nArgs);
    CHECK_PRIMITIVE_ARGUMENT(args[0], CTK_STRING);
    CHECK_PRIMITIVE_ARGUMENT(args[1], CTK_STRING);
    FILE* f = fopen(args[0].u.svalue, args[1].u.svalue);
    if (f == NULL) { 
	return ctkNull;
    }
    CtkObject result;
    MAKE_FILE(result, ctkCreateFile(args[0].u.svalue, args[1].u.svalue));
    return result;
}
static CtkPrimitive p11("createFile", createFile);

static CtkObject deleteFile(int nArgs, CtkObject* args) {
    CHECK_PRIMITIVE_N_ARGS(1, nArgs);
    CHECK_PRIMITIVE_ARGUMENT(args[0], CTK_FILE);
    ctkDeleteFile((CtkFile*)args[0].u.ptr);
    return ctkNull;
}
static CtkPrimitive p12("deleteFile", deleteFile);

static CtkObject flushFile(int nArgs, CtkObject* args) {
    CHECK_PRIMITIVE_N_ARGS(1, nArgs);
    CHECK_PRIMITIVE_ARGUMENT(args[0], CTK_FILE);
    ctkFlushFile((CtkFile*)args[0].u.ptr);
    return ctkNull;
}
static CtkPrimitive p13("flushFile", flushFile);


static CtkObject printFile(int nArgs, CtkObject* args) {
    if (nArgs < 1 || args[0].type != CTK_FILE) { 
	ctkThrowException("No file specified");
    }
    for (int i = 1; i < nArgs; i++) { 
	ctkPrintFile((CtkFile*)args[0].u.ptr, args[i]);
    }
    return args[0];
}
static CtkPrimitive p14("printFile", printFile);

static CtkObject printlnFile(int nArgs, CtkObject* args) {
    printFile(nArgs, args);
    CtkObject nl;
    MAKE_STRING(nl, "\n");
    ctkPrintFile((CtkFile*)args[0].u.ptr, nl);
    return args[0];
}
static CtkPrimitive p15("printlnFile", printlnFile);

static CtkObject print(int nArgs, CtkObject* args) {
    for (int i = 0; i < nArgs; i++) { 
	ctkPrint(args[i]);
    }
    return ctkNull;
}
static CtkPrimitive p16("print", print);

static CtkObject println(int nArgs, CtkObject* args) {
    print(nArgs, args);
    CtkObject nl;
    MAKE_STRING(nl, "\n");
    ctkPrint(nl);
    return ctkNull;
}
static CtkPrimitive p17("println", println);

#ifdef __sun__
#include <errno.h>
#include <sys/wait.h>

static int my_system (const char *command) {
    int pid, status;
    
    if (command == 0)
	return 1;
    pid = fork();
    if (pid == -1)
	return -1;
    if (pid == 0) {
	char *argv[4];
	argv[0] = "sh";
	argv[1] = "-c";
	argv[2] = (char*)command;
	argv[3] = 0;
	execv("/bin/sh", argv);
	exit(127);
    }
    do {
	if (waitpid(pid, &status, 0) == -1) {
	    if (errno != EINTR)
		return -1;
	} else
	    return status;
    } while(1);
}
#define system my_system
#endif

static CtkObject execute(int nArgs, CtkObject* args) {
    CHECK_PRIMITIVE_N_ARGS(1, nArgs);
    CHECK_PRIMITIVE_ARGUMENT(args[0], CTK_STRING);
    CtkObject result;
    CtkThread* thr = ctkGetCurrentThread();
    CtkMemoryManager::instance.endAccess(thr);
    MAKE_INTEGER(result, system(args[0].u.svalue));
    CtkMemoryManager::instance.beginAccess(thr);
    return result;
}
static CtkPrimitive p18("execute", execute);

static CtkObject currentTime(int nArgs, CtkObject*) {
    CHECK_PRIMITIVE_N_ARGS(0, nArgs);
    CtkObject result;
    MAKE_INTEGER(result, time(NULL));
    return result;
}
static CtkPrimitive p19("time", currentTime);

static CtkObject currentTimeMillis(int nArgs, CtkObject*) {
    CHECK_PRIMITIVE_N_ARGS(0, nArgs);
    CtkObject result;
    MAKE_INTEGER(result, ctkGetTimeMillis());
    return result;
}
static CtkPrimitive p19a("timeMillis", currentTimeMillis);

static CtkObject assertFunc(int nArgs, CtkObject* args) {
    CHECK_PRIMITIVE_N_ARGS(1, nArgs);
    if (!IS_TRUE(args[0])) { 
	ctkThrowException("Assertion failed");
    }
    return ctkNull;
} 
static CtkPrimitive p20("assert", assertFunc);

static CtkObject loadDLL(int nArgs, CtkObject* args) {
    CHECK_PRIMITIVE_N_ARGS(1, nArgs);
    CHECK_PRIMITIVE_ARGUMENT(args[0], CTK_STRING);
    return ctkLoadLibrary(args[0].u.svalue) ? ctkTrue : ctkFalse;
} 
static CtkPrimitive p21("loadDLL", loadDLL);

static CtkObject printExceptionStackTrace(int nArgs, CtkObject*) {
    CHECK_PRIMITIVE_N_ARGS(0, nArgs);
    CtkThread* thread = ctkGetCurrentThread();
    if (thread->exceptionTrace != NULL) { 
	ctkPrintStackTrace(thread->exceptionTrace);
    }
    return ctkNull;
}
static CtkPrimitive p22("printExceptionStackTrace", printExceptionStackTrace);



static CtkObject loadModule(int nArgs, CtkObject* args) {
    CHECK_PRIMITIVE_N_ARGS(1, nArgs);
    CHECK_PRIMITIVE_ARGUMENT(args[0], CTK_STRING);
    return CtkCompiler::instance.compile(args[0].u.svalue) != NULL ? ctkTrue : ctkFalse;
} 
static CtkPrimitive p23("loadModule", loadModule);


static CtkObject indexOf(int nArgs, CtkObject* args) {
    CHECK_PRIMITIVE_N_ARGS(2, nArgs);
    CHECK_PRIMITIVE_ARGUMENT(args[0], CTK_STRING);
    CHECK_PRIMITIVE_ARGUMENT(args[1], CTK_STRING);
    char* s1 = args[0].u.svalue;
    char* s2 = args[1].u.svalue;
    int n1 = strlen(s1);
    int n2 = strlen(s2);
    CtkObject result;
    int i, j;
    for (i = 0; i <= n1-n2; i++) { 
	for (j = 0; j < n2 && s1[i+j] == s2[j]; j++);
	if (j == n2) { 
	    MAKE_INTEGER(result, i);
	    return result;
	}
    }
    MAKE_INTEGER(result, -1);
    return result;
}    
static CtkPrimitive p24("indexOf", indexOf);


static CtkObject lastIndexOf(int nArgs, CtkObject* args) {
    CHECK_PRIMITIVE_N_ARGS(2, nArgs);
    CHECK_PRIMITIVE_ARGUMENT(args[0], CTK_STRING);
    CHECK_PRIMITIVE_ARGUMENT(args[1], CTK_STRING);
    char* s1 = args[0].u.svalue;
    char* s2 = args[1].u.svalue;
    int n1 = strlen(s1);
    int n2 = strlen(s2);
    CtkObject result;
    int i, j;
    for (i = n1-n2; i >= 0; i--) { 
	for (j = 0; j < n2 && s1[i+j] == s2[j]; j++);
	if (j == n2) { 
	    MAKE_INTEGER(result, i);
	    return result;
	}
    }
    MAKE_INTEGER(result, -1);
    return result;
}    
static CtkPrimitive p25("lastIndexOf", lastIndexOf);

static CtkObject substring(int nArgs, CtkObject* args) {
    if (nArgs < 2 || nArgs > 3) { 
	ctkThrowException("Wrong number of primitive arguments");
    }
    CHECK_PRIMITIVE_ARGUMENT(args[0], CTK_STRING);
    char* src = args[0].u.svalue;
    unsigned len = strlen(src);
    CHECK_PRIMITIVE_ARGUMENT(args[1], CTK_INTEGER);
    unsigned from = args[1].u.ivalue;
    if (from > len) { 
	from = len;
    }
    unsigned till = len;
    if (nArgs == 3) {