syslib.cpp

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

	CHECK_PRIMITIVE_ARGUMENT(args[2], CTK_INTEGER);
	till = args[2].u.ivalue;
	if (till < from) { 
	    till = from;
	} else if (till > len) { 
	    till = len;
	}
    }
    char* dst = (char*)ctkAllocateObject(till-from+1, NULL);
    memcpy(dst, src + from, till-from);
    dst[till-from] = '\0';
    CtkObject result;
    MAKE_STRING(result, dst);
    return result;
}    
static CtkPrimitive p26("substring", substring);

static CtkObject toLower(int nArgs, CtkObject* args) {
    CHECK_PRIMITIVE_N_ARGS(1, nArgs);
    CHECK_PRIMITIVE_ARGUMENT(args[0], CTK_STRING);
    char* src = args[0].u.svalue;
    char* dst = (char*)ctkAllocateObject(strlen(src)+1, NULL);
    CtkObject result;
    MAKE_STRING(result, dst);
    while ((*dst++ = tolower((unsigned char)*src++)) != 0);
    return result;
}
static CtkPrimitive p27("toLower", toLower);

static CtkObject toUpper(int nArgs, CtkObject* args) {
    CHECK_PRIMITIVE_N_ARGS(1, nArgs);
    CHECK_PRIMITIVE_ARGUMENT(args[0], CTK_STRING);
    char* src = args[0].u.svalue;
    char* dst = (char*)ctkAllocateObject(strlen(src)+1, NULL);
    CtkObject result;
    MAKE_STRING(result, dst);
    while ((*dst++ = toupper((unsigned char)*src++)) != 0);
    return result;
}
static CtkPrimitive p28("toUpper", toUpper);

static CtkObject trim(int nArgs, CtkObject* args) {
    CHECK_PRIMITIVE_N_ARGS(1, nArgs);
    CHECK_PRIMITIVE_ARGUMENT(args[0], CTK_STRING);
    char* src = args[0].u.svalue;
    int start = 0, end = strlen(src);
    while ((unsigned char)(src[start]-1) <= ' ') { 
        start += 1;
    }
    while (end > start && (unsigned char)src[end-1] <= ' ') { 
	end -= 1;
    }
    char* dst = (char*)ctkAllocateObject(end-start+1, NULL);
    CtkObject result;
    MAKE_STRING(result, dst);
    memcpy(dst, src+start, end-start);
    dst[end-start] = '\0';
    return result;
}
static CtkPrimitive p29("trim", trim);

static CtkObject startsWith(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* p = args[0].u.svalue;
    char* q = args[1].u.svalue;
    while (*q != '\0') { 
	if (*p != *q) { 
	    return ctkFalse;
	}
    }
    return ctkTrue;
}
static CtkPrimitive p30("startsWith", startsWith);

static CtkObject endsWith(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);
    return (n1 >= n2 && strcmp(s1 + n1 - n2, s2) == 0) ? ctkTrue : ctkFalse;
}
static CtkPrimitive p31("endsWith", endsWith);

static CtkObject string(int nArgs, CtkObject* args) {
    char buf[256];
    CHECK_PRIMITIVE_N_ARGS(1, nArgs);
    if (args[0].type == CTK_STRING) { 
	return args[0];
    }
    ctkToString(args[0], buf);
    char* str = (char*)ctkAllocateObject(strlen(buf) + 1, NULL);
    strcpy(str, buf);
    CtkObject result;
    MAKE_STRING(result, str);
    return result;
}
static CtkPrimitive p32("string", string);

static CtkObject length(int nArgs, CtkObject* args) {
    CHECK_PRIMITIVE_N_ARGS(1, nArgs);
    int len = 0;
    switch (args[0].type) { 
      case CTK_STRING:
	len = strlen(args[0].u.svalue);
	break;
      case CTK_ARRAY:
	len = ((CtkArray*)args[0].u.ptr)->nUsed;
	break;
      default:
	ctkThrowException("Incompatible type of primitive parameter");
    } 
    CtkObject result;
    MAKE_INTEGER(result, len);
    return result;
}
static CtkPrimitive p33("length", length);

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

static CtkObject pwd(int nArgs, CtkObject*) {
    CHECK_PRIMITIVE_N_ARGS(0, nArgs);
    char buf[1024];    
    if (getcwd(buf, sizeof buf) == NULL) {
	return ctkNull;
    }
    CtkObject result;
    ALLOCATE_STRING(result, buf);
    return result;
}
static CtkPrimitive p35("pwd", pwd);

static CtkObject sleepSec(int nArgs, CtkObject* args) {
    CHECK_PRIMITIVE_N_ARGS(1, nArgs);
    CHECK_PRIMITIVE_ARGUMENT(args[0], CTK_INTEGER);
    CtkThread* thr = ctkGetCurrentThread();
    CtkMemoryManager::instance.endAccess(thr);
    ctkSleep(args[0].u.ivalue);
    CtkMemoryManager::instance.beginAccess(thr);
    return ctkNull;
}
static CtkPrimitive p36("sleep", sleepSec);

static CtkObject input(int nArgs, CtkObject* args) {
    char buf[1024];
    FILE* f = stdin;
    if (nArgs == 1) { 
	switch (args[0].type) { 
	  case CTK_STRING:
	    fputs(args[0].u.svalue, stdout);
	    break;
	  case CTK_FILE:
	    f = ((CtkFile*)args[0].u.ptr)->f;
	    break;
	  default: 
	    ctkThrowException("Incompatible type of primitive parameter");
	}
    } else { 
	CHECK_PRIMITIVE_N_ARGS(0, nArgs);
    }
    CtkObject result = ctkNull;
    CtkThread* thr = ctkGetCurrentThread();
    CtkMemoryManager::instance.endAccess(thr);
    if (fgets(buf, sizeof buf, f)) { 
	ALLOCATE_STRING(result, buf);
    }
    CtkMemoryManager::instance.beginAccess(thr);
    return result;
}
static CtkPrimitive p37("input", input);

static CtkObject integer(int nArgs, CtkObject* args) {
    CtkObject result;
    char ch;

    CHECK_PRIMITIVE_N_ARGS(1, nArgs);
    switch (args[0].type) { 
      case CTK_INTEGER:
	return args[0];
      case CTK_REAL:
	MAKE_INTEGER(result, (ctk_integer)args[0].u.rvalue);
	break;
      case CTK_STRING:
	if (sscanf(args[0].u.svalue, "%ld%c", &result.u.ivalue, &ch) != 1) { 
	    ctkThrowException("Invalid number format");
	}
	result.type = CTK_INTEGER;
	break;
      case CTK_RAW_POINTER:
	MAKE_INTEGER(result, (ctk_integer)args[0].u.ptr);
	break;        
      default: 
	ctkThrowException("Incompatible type of primitive parameter");
    }
    return result;
}
static CtkPrimitive p38("integer", integer);

static CtkObject real(int nArgs, CtkObject* args) {
    CtkObject result;
    char ch;

    CHECK_PRIMITIVE_N_ARGS(1, nArgs);
    switch (args[0].type) { 
      case CTK_INTEGER:
	MAKE_REAL(result, args[0].u.ivalue);
	break;	
      case CTK_REAL:
	return args[0];
      case CTK_STRING:
	if (sscanf(args[0].u.svalue, "%lf%c", &result.u.rvalue, &ch) != 1) { 
	    ctkThrowException("Invalid number format");
	}
	result.type = CTK_REAL;
	break;
      default: 
	ctkThrowException("Incompatible type of primitive parameter");
    }
    return result;
}
static CtkPrimitive p38r("real", real);

static CtkObject options(int nArgs, CtkObject* args) {
    if (nArgs == 1) { 
	return ctkGetArray(ctkGetCommandLineOptions(), args[0]);
    } else { 
	CtkObject result;
	CHECK_PRIMITIVE_N_ARGS(0, nArgs);
	MAKE_ARRAY(result, ctkGetCommandLineOptions());
	return result;
    }
}
static CtkPrimitive p39("options", options);


static CtkObject isInteger(int nArgs, CtkObject* args) {
    CHECK_PRIMITIVE_N_ARGS(1, nArgs);
    return args->type == CTK_INTEGER ? ctkTrue : ctkFalse;
}
static CtkPrimitive p40("isInteger", isInteger);

static CtkObject isReal(int nArgs, CtkObject* args) {
    CHECK_PRIMITIVE_N_ARGS(1, nArgs);
    return args->type == CTK_REAL ? ctkTrue : ctkFalse;
}
static CtkPrimitive p40r("isReal", isReal);


static CtkObject isString(int nArgs, CtkObject* args) {
    CHECK_PRIMITIVE_N_ARGS(1, nArgs);
    return args->type == CTK_STRING ? ctkTrue : ctkFalse;
}
static CtkPrimitive p41("isString", isString);



static CtkObject isArray(int nArgs, CtkObject* args) {
    CHECK_PRIMITIVE_N_ARGS(1, nArgs);
    return args->type == CTK_ARRAY ? ctkTrue : ctkFalse;
}
static CtkPrimitive p42("isArray", isArray);

static CtkObject isFile(int nArgs, CtkObject* args) {
    CHECK_PRIMITIVE_N_ARGS(1, nArgs);
    return args->type == CTK_FILE ? ctkTrue : ctkFalse;
}
static CtkPrimitive p43("isFile", isFile);

static CtkObject isThread(int nArgs, CtkObject* args) {
    CHECK_PRIMITIVE_N_ARGS(1, nArgs);
    return args->type == CTK_THREAD ? ctkTrue : ctkFalse;
}
static CtkPrimitive p44("isThread", isThread);



static CtkObject isNull(int nArgs, CtkObject* args) {
    CHECK_PRIMITIVE_N_ARGS(1, nArgs);
    return args->type == CTK_NULL ? ctkTrue : ctkFalse;
}
static CtkPrimitive p45("isNull", isNull);


static CtkObject isMutex(int nArgs, CtkObject* args) {
    CHECK_PRIMITIVE_N_ARGS(1, nArgs);
    return args->type == CTK_MUTEX ? ctkTrue : ctkFalse;
}
static CtkPrimitive p46("isMutex", isMutex);


static CtkObject isFunction(int nArgs, CtkObject* args) {
    CHECK_PRIMITIVE_N_ARGS(1, nArgs);
    return args->type == CTK_FUNCTION ? ctkTrue : ctkFalse;
}
static CtkPrimitive p47("isFunction", isFunction);

static CtkObject isPrimitive(int nArgs, CtkObject* args) {
    CHECK_PRIMITIVE_N_ARGS(1, nArgs);
    return args->type == CTK_PRIMITIVE ? ctkTrue : ctkFalse;
}
static CtkPrimitive p48("isPrimitive", isPrimitive);


static CtkObject getTypeName(int nArgs, CtkObject* args) {
    CHECK_PRIMITIVE_N_ARGS(1, nArgs);
    static char const* typeMnem[] = { 
	"null", "integer", "real", "primitive", "raw_pointer", 
	"string", "array", "file", "mutex", "thread", "function", "frame", "user_type"
    };
    CtkObject result;
    ALLOCATE_STRING(result, typeMnem[args->type]);
    return result;
}
static CtkPrimitive p49("getTypeName", getTypeName);


static CtkObject getType(int nArgs, CtkObject* args) {
    CHECK_PRIMITIVE_N_ARGS(1, nArgs);
    CtkObject result;
    MAKE_INTEGER(result, args->type);
    return result;
}
static CtkPrimitive p50("getType", getType);