diff --git a/.gitignore b/.gitignore index 2573aa58..38ef80e8 100644 --- a/.gitignore +++ b/.gitignore @@ -8,6 +8,7 @@ /.make/* /base/bin/* +/base/lib/kuroko /base/src /_base /cdrom/extra diff --git a/.gitmodules b/.gitmodules index 47e008c2..c8bf8f65 100644 --- a/.gitmodules +++ b/.gitmodules @@ -1,3 +1,3 @@ [submodule "kuroko"] path = kuroko - url = git@github.com:klange/kuroko + url = git@github.com:kuroko-lang/kuroko diff --git a/Makefile b/Makefile index cb050000..f045b34b 100644 --- a/Makefile +++ b/Makefile @@ -164,7 +164,7 @@ base/cdrom: mkdir -p $@ base/var: mkdir -p $@ -base/usr/local/lib/kuroko: +base/lib/kuroko: mkdir -p $@ fatbase/efi/boot: mkdir -p $@ @@ -172,7 +172,7 @@ cdrom: mkdir -p $@ .make: mkdir -p .make -dirs: base/dev base/tmp base/proc base/bin base/lib base/cdrom base/usr/local/lib/kuroko cdrom base/var fatbase/efi/boot .make +dirs: base/dev base/tmp base/proc base/bin base/lib base/cdrom base/lib/kuroko cdrom base/var fatbase/efi/boot .make # C Library @@ -201,13 +201,13 @@ kuroko/%.o: kuroko/%.c $(CC) $(CFLAGS) -DDEBUG -fPIC -c -o $@ $^ KUROKO_CMODS=$(patsubst kuroko/src/module_%.c,%,$(wildcard kuroko/src/module_*.c)) $(patsubst lib/kuroko/%.c,%,$(wildcard lib/kuroko/*.c)) -KUROKO_CMODS_X=$(foreach lib,$(KUROKO_CMODS),base/usr/local/lib/kuroko/$(lib).so) +KUROKO_CMODS_X=$(foreach lib,$(KUROKO_CMODS),base/lib/kuroko/$(lib).so) KUROKO_CMODS_Y=$(foreach lib,$(KUROKO_CMODS),.make/$(lib).kmak) -KUROKO_KRK_MODS=$(patsubst kuroko/modules/%.krk,base/usr/local/lib/kuroko/%.krk,$(wildcard kuroko/modules/*.krk kuroko/modules/*/*.krk)) +KUROKO_KRK_MODS=$(patsubst kuroko/modules/%.krk,base/lib/kuroko/%.krk,$(wildcard kuroko/modules/*.krk kuroko/modules/*/*.krk)) KUROKO_FILES=$(KUROKO_CMODS_X) $(KUROKO_KRK_MODS) base/lib/libkuroko.so -base/usr/local/lib/kuroko/%.krk: kuroko/modules/%.krk +base/lib/kuroko/%.krk: kuroko/modules/%.krk @mkdir -p `dirname $@` cp $< $@ diff --git a/apps/bim.c b/apps/bim.c index 86d11916..df00fd07 100644 --- a/apps/bim.c +++ b/apps/bim.c @@ -954,12 +954,12 @@ void recalculate_syntax(line_t * line, int line_no) { s->state.i = 0; while (1) { - ptrdiff_t before = vm.stackTop - vm.stack; + ptrdiff_t before = krk_currentThread.stackTop - krk_currentThread.stack; krk_push(OBJECT_VAL(s)); KrkValue result = krk_callSimple(OBJECT_VAL(env->syntax->krkFunc), 1, 0); - vm.stackTop = vm.stack + before; - if (IS_NONE(result) && (vm.flags & KRK_HAS_EXCEPTION)) { - render_error("Exception occurred in plugin: %s", AS_INSTANCE(vm.currentException)->_class->name->chars); + krk_currentThread.stackTop = krk_currentThread.stack + before; + if (IS_NONE(result) && (krk_currentThread.flags & KRK_HAS_EXCEPTION)) { + render_error("Exception occurred in plugin: %s", AS_INSTANCE(krk_currentThread.currentException)->_class->name->chars); krk_dumpTraceback(); fprintf(stderr,"\n\nThis syntax highlighter will be disabled in this environment.\n\n"); int key = 0; @@ -5477,11 +5477,11 @@ BIM_COMMAND(theme,"theme","Set color theme") { } else { for (struct theme_def * d = themes; themes && d->name; ++d) { if (!strcmp(argv[1], d->name)) { - ptrdiff_t before = vm.stackTop - vm.stack; + ptrdiff_t before = krk_currentThread.stackTop - krk_currentThread.stack; KrkValue result = krk_callSimple(OBJECT_VAL(d->callable), 0, 0); - vm.stackTop = vm.stack + before; - if (IS_NONE(result) && (vm.flags & KRK_HAS_EXCEPTION)) { - render_error("Exception occurred in theme: %s", AS_INSTANCE(vm.currentException)->_class->name->chars); + krk_currentThread.stackTop = krk_currentThread.stack + before; + if (IS_NONE(result) && (krk_currentThread.flags & KRK_HAS_EXCEPTION)) { + render_error("Exception occurred in theme: %s", AS_INSTANCE(krk_currentThread.currentException)->_class->name->chars); krk_dumpTraceback(); int key = 0; while ((key = bim_getkey(DEFAULT_KEY_WAIT)) == KEY_TIMEOUT); @@ -9930,7 +9930,7 @@ int process_krk_command(const char * cmd, KrkValue * outVal) { krk_push(NONE_VAL()); /* If we don't set outSlots for the top frame a syntax error will * get printed by the interpreter and we can't catch it here. */ - vm.frames[0].outSlots = 1; + krk_currentThread.frames[0].outSlots = 1; /* Call the interpreter */ KrkValue out = krk_interpret(cmd,0,"",""); /* If the user typed just a command name, try to execute it. */ @@ -9942,8 +9942,8 @@ int process_krk_command(const char * cmd, KrkValue * outVal) { int retval = (IS_INTEGER(out)) ? AS_INTEGER(out) : 0; int hadOutput = 0; /* If we got an exception during execution, print it now */ - if (vm.flags & KRK_HAS_EXCEPTION) { - if (krk_isInstanceOf(vm.currentException, vm.exceptions.syntaxError)) { + if (krk_currentThread.flags & KRK_HAS_EXCEPTION) { + if (krk_isInstanceOf(krk_currentThread.currentException, vm.exceptions->syntaxError)) { } set_fg_color(COLOR_RED); fflush(stdout); @@ -10026,10 +10026,10 @@ BIM_COMMAND(runkrk,"runkrk", "Run a kuroko script") { if (argc < 2) return 1; /* In case we're running in a weird context? */ - int previousExitFrame = vm.exitOnFrame; - vm.exitOnFrame = vm.frameCount; + int previousExitFrame = krk_currentThread.exitOnFrame; + krk_currentThread.exitOnFrame = krk_currentThread.frameCount; krk_runfile(argv[1],1,"",argv[1]); - vm.exitOnFrame = previousExitFrame; + krk_currentThread.exitOnFrame = previousExitFrame; redraw_all(); @@ -10163,9 +10163,9 @@ static int checkClass(KrkClass * _class, KrkClass * base) { } static KrkValue krk_bim_syntax_dict; -static KrkValue krk_bim_register_syntax(int argc, KrkValue argv[]) { +static KrkValue krk_bim_register_syntax(int argc, KrkValue argv[], int hasKw) { if (argc < 1 || !IS_CLASS(argv[0]) || !checkClass(AS_CLASS(argv[0]), syntaxStateClass)) - return krk_runtimeError(vm.exceptions.typeError, "Can not register '%s' as a syntax highlighter, expected subclass of SyntaxState.", krk_typeName(argv[0])); + return krk_runtimeError(vm.exceptions->typeError, "Can not register '%s' as a syntax highlighter, expected subclass of SyntaxState.", krk_typeName(argv[0])); KrkValue name = NONE_VAL(), extensions = NONE_VAL(), spaces = BOOLEAN_VAL(0), calculate = NONE_VAL(); krk_tableGet(&AS_CLASS(argv[0])->fields, OBJECT_VAL(S("name")), &name); @@ -10173,13 +10173,13 @@ static KrkValue krk_bim_register_syntax(int argc, KrkValue argv[]) { krk_tableGet(&AS_CLASS(argv[0])->fields, OBJECT_VAL(S("spaces")), &spaces); krk_tableGet(&AS_CLASS(argv[0])->methods, OBJECT_VAL(S("calculate")), &calculate); if (!IS_STRING(name)) - return krk_runtimeError(vm.exceptions.typeError, "%s.name must be str", AS_CLASS(argv[0])->name->chars); + return krk_runtimeError(vm.exceptions->typeError, "%s.name must be str", AS_CLASS(argv[0])->name->chars); if (!IS_TUPLE(extensions)) - return krk_runtimeError(vm.exceptions.typeError, "%s.extensions must by tuple", AS_CLASS(argv[0])->name->chars); + return krk_runtimeError(vm.exceptions->typeError, "%s.extensions must by tuple", AS_CLASS(argv[0])->name->chars); if (!IS_BOOLEAN(spaces)) - return krk_runtimeError(vm.exceptions.typeError, "%s.spaces must be bool", AS_CLASS(argv[0])->name->chars); + return krk_runtimeError(vm.exceptions->typeError, "%s.spaces must be bool", AS_CLASS(argv[0])->name->chars); if (!IS_CLOSURE(calculate)) - return krk_runtimeError(vm.exceptions.typeError, "%s.calculate must be method, not '%s'", AS_CLASS(argv[0])->name->chars, krk_typeName(calculate)); + return krk_runtimeError(vm.exceptions->typeError, "%s.calculate must be method, not '%s'", AS_CLASS(argv[0])->name->chars, krk_typeName(calculate)); /* Convert tuple of strings */ char ** ext = malloc(sizeof(char *) * (AS_TUPLE(extensions)->values.count + 1)); /* +1 for NULL */ @@ -10187,7 +10187,7 @@ static KrkValue krk_bim_register_syntax(int argc, KrkValue argv[]) { for (size_t i = 0; i < AS_TUPLE(extensions)->values.count; ++i) { if (!IS_STRING(AS_TUPLE(extensions)->values.values[i])) { free(ext); - return krk_runtimeError(vm.exceptions.typeError, "%s.extensions must by tuple", AS_CLASS(argv[0])->name->chars); + return krk_runtimeError(vm.exceptions->typeError, "%s.extensions must by tuple", AS_CLASS(argv[0])->name->chars); } ext[i] = AS_CSTRING(AS_TUPLE(extensions)->values.values[i]); } @@ -10210,9 +10210,9 @@ static KrkValue krk_bim_register_syntax(int argc, KrkValue argv[]) { } static KrkValue krk_bim_theme_dict; -static KrkValue krk_bim_define_theme(int argc, KrkValue argv[]) { +static KrkValue krk_bim_define_theme(int argc, KrkValue argv[], int hasKw) { if (argc < 1 || !IS_CLOSURE(argv[0])) - return krk_runtimeError(vm.exceptions.typeError, "themes must be functions, not '%s'", krk_typeName(argv[0])); + return krk_runtimeError(vm.exceptions->typeError, "themes must be functions, not '%s'", krk_typeName(argv[0])); KrkValue name = OBJECT_VAL(AS_CLOSURE(argv[0])->function->name); @@ -10230,35 +10230,35 @@ int c_keyword_qualifier(int c) { } #define BIM_STATE() \ - if (argc < 1 || !krk_isInstanceOf(argv[0],syntaxStateClass)) return krk_runtimeError(vm.exceptions.typeError, "expected state"); \ + if (argc < 1 || !krk_isInstanceOf(argv[0],syntaxStateClass)) return krk_runtimeError(vm.exceptions->typeError, "expected state"); \ KrkInstance * _self = AS_INSTANCE(argv[0]); \ struct SyntaxState * self = (struct SyntaxState*)_self; \ struct syntax_state * state = &self->state; -static KrkValue bim_krk_state_getstate(int argc, KrkValue argv[]) { +static KrkValue bim_krk_state_getstate(int argc, KrkValue argv[], int hasKw) { BIM_STATE(); return INTEGER_VAL(state->state); } -static KrkValue bim_krk_state_setstate(int argc, KrkValue argv[]) { +static KrkValue bim_krk_state_setstate(int argc, KrkValue argv[], int hasKw) { BIM_STATE(); if (argc > 1 && IS_INTEGER(argv[1])) { state->state = AS_INTEGER(argv[1]); } else if (argc > 1 && IS_NONE(argv[1])) { state->state = -1; } else { - return krk_runtimeError(vm.exceptions.typeError, "expected int"); + return krk_runtimeError(vm.exceptions->typeError, "expected int"); } return NONE_VAL(); } -static KrkValue bim_krk_state_index(int argc, KrkValue argv[]) { +static KrkValue bim_krk_state_index(int argc, KrkValue argv[], int hasKw) { BIM_STATE(); return INTEGER_VAL(state->i); } -static KrkValue bim_krk_state_lineno(int argc, KrkValue argv[]) { +static KrkValue bim_krk_state_lineno(int argc, KrkValue argv[], int hasKw) { BIM_STATE(); return INTEGER_VAL(state->line_no); } -static KrkValue bim_krk_state_get(int argc, KrkValue argv[]) { +static KrkValue bim_krk_state_get(int argc, KrkValue argv[], int hasKw) { BIM_STATE(); long arg = AS_INTEGER(argv[1]); int charRel = charrel(arg); @@ -10267,26 +10267,26 @@ static KrkValue bim_krk_state_get(int argc, KrkValue argv[]) { size_t len = to_eight(charRel, tmp); return OBJECT_VAL(krk_copyString(tmp,len)); } -static KrkValue bim_krk_state_isdigit(int argc, KrkValue argv[]) { +static KrkValue bim_krk_state_isdigit(int argc, KrkValue argv[], int hasKw) { if (IS_NONE(argv[1])) return BOOLEAN_VAL(0); if (!IS_STRING(argv[1])) { - krk_runtimeError(vm.exceptions.typeError, "not a string: %s", krk_typeName(argv[1])); + krk_runtimeError(vm.exceptions->typeError, "not a string: %s", krk_typeName(argv[1])); return BOOLEAN_VAL(0); } if (AS_STRING(argv[1])->codesLength > 1) { - krk_runtimeError(vm.exceptions.typeError, "arg must be str of len 1"); + krk_runtimeError(vm.exceptions->typeError, "arg must be str of len 1"); return BOOLEAN_VAL(0); } unsigned int c = krk_unicodeCodepoint(AS_STRING(argv[1]), 0); return BOOLEAN_VAL(!!isdigit(c)); } -static KrkValue bim_krk_state_isxdigit(int argc, KrkValue argv[]) { +static KrkValue bim_krk_state_isxdigit(int argc, KrkValue argv[], int hasKw) { if (!IS_STRING(argv[1])) return BOOLEAN_VAL(0); if (AS_STRING(argv[1])->length > 1) return BOOLEAN_VAL(0); int c = AS_CSTRING(argv[1])[0]; return BOOLEAN_VAL(!!isxdigit(c)); } -static KrkValue bim_krk_state_paint(int argc, KrkValue argv[]) { +static KrkValue bim_krk_state_paint(int argc, KrkValue argv[], int hasKw) { BIM_STATE(); long howMuch = AS_INTEGER(argv[1]); if (howMuch == -1) howMuch = state->line->actual; @@ -10294,17 +10294,17 @@ static KrkValue bim_krk_state_paint(int argc, KrkValue argv[]) { paint(howMuch, whatFlag); return NONE_VAL(); } -static KrkValue bim_krk_state_paintComment(int argc, KrkValue argv[]) { +static KrkValue bim_krk_state_paintComment(int argc, KrkValue argv[], int hasKw) { BIM_STATE(); paint_comment(state); return NONE_VAL(); } -static KrkValue bim_krk_state_skip(int argc, KrkValue argv[]) { +static KrkValue bim_krk_state_skip(int argc, KrkValue argv[], int hasKw) { BIM_STATE(); skip(); return NONE_VAL(); } -static KrkValue bim_krk_state_cKeywordQualifier(int argc, KrkValue argv[]) { +static KrkValue bim_krk_state_cKeywordQualifier(int argc, KrkValue argv[], int hasKw) { if (IS_INTEGER(argv[1])) return BOOLEAN_VAL(!!c_keyword_qualifier(AS_INTEGER(argv[1]))); if (!IS_STRING(argv[1])) return BOOLEAN_VAL(0); if (AS_STRING(argv[1])->length > 1) return BOOLEAN_VAL(0); @@ -10319,10 +10319,10 @@ static int callQualifier(KrkValue qualifier, int codepoint) { return 0; } -static KrkValue bim_krk_state_findKeywords(int argc, KrkValue argv[]) { +static KrkValue bim_krk_state_findKeywords(int argc, KrkValue argv[], int hasKw) { BIM_STATE(); - if (argc < 4 || !krk_isInstanceOf(argv[1], vm.baseClasses.listClass) || !IS_INTEGER(argv[2])) - return krk_runtimeError(vm.exceptions.typeError, "invalid arguments to SyntaxState.findKeywords"); + if (argc < 4 || !krk_isInstanceOf(argv[1], vm.baseClasses->listClass) || !IS_INTEGER(argv[2])) + return krk_runtimeError(vm.exceptions->typeError, "invalid arguments to SyntaxState.findKeywords"); KrkValue qualifier = argv[3]; int flag = AS_INTEGER(argv[2]); @@ -10332,7 +10332,7 @@ static KrkValue bim_krk_state_findKeywords(int argc, KrkValue argv[]) { for (size_t keyword = 0; keyword < AS_LIST(argv[1])->count; ++keyword) { if (!IS_STRING(AS_LIST(argv[1])->values[keyword])) - return krk_runtimeError(vm.exceptions.typeError, "expected list of strings, found '%s'", krk_typeName(AS_LIST(argv[1])->values[keyword])); + return krk_runtimeError(vm.exceptions->typeError, "expected list of strings, found '%s'", krk_typeName(AS_LIST(argv[1])->values[keyword])); KrkString * me = AS_STRING(AS_LIST(argv[1])->values[keyword]); size_t d = 0; @@ -10354,10 +10354,10 @@ static KrkValue bim_krk_state_findKeywords(int argc, KrkValue argv[]) { } return BOOLEAN_VAL(0); } -static KrkValue bim_krk_state_matchAndPaint(int argc, KrkValue argv[]) { +static KrkValue bim_krk_state_matchAndPaint(int argc, KrkValue argv[], int hasKw) { BIM_STATE(); if (argc < 4 || !IS_STRING(argv[1]) || !IS_INTEGER(argv[2])) - return krk_runtimeError(vm.exceptions.typeError, "invalid arguments to SyntaxState.matchAndPaint"); + return krk_runtimeError(vm.exceptions->typeError, "invalid arguments to SyntaxState.matchAndPaint"); KrkValue qualifier = argv[3]; int flag = AS_INTEGER(argv[2]); KrkString * me = AS_STRING(argv[1]); @@ -10379,19 +10379,19 @@ static KrkValue bim_krk_state_matchAndPaint(int argc, KrkValue argv[]) { } return BOOLEAN_VAL(0); } -static KrkValue bim_krk_state_rewind(int argc, KrkValue argv[]) { +static KrkValue bim_krk_state_rewind(int argc, KrkValue argv[], int hasKw) { BIM_STATE(); state->i -= AS_INTEGER(argv[1]); return NONE_VAL(); } -static KrkValue bim_krk_state_commentBuzzwords(int argc, KrkValue argv[]) { +static KrkValue bim_krk_state_commentBuzzwords(int argc, KrkValue argv[], int hasKw) { BIM_STATE(); return BOOLEAN_VAL(common_comment_buzzwords(state)); } -static KrkValue bim_krk_state_init(int argc, KrkValue argv[]) { +static KrkValue bim_krk_state_init(int argc, KrkValue argv[], int hasKw) { BIM_STATE(); if (argc < 2 || !krk_isInstanceOf(argv[1], syntaxStateClass)) { - return krk_runtimeError(vm.exceptions.typeError, "Can only initialize subhighlighter from an existing highlighter."); + return krk_runtimeError(vm.exceptions->typeError, "Can only initialize subhighlighter from an existing highlighter."); } *state = ((struct SyntaxState*)AS_INSTANCE(argv[1]))->state; @@ -10399,8 +10399,8 @@ static KrkValue bim_krk_state_init(int argc, KrkValue argv[]) { return argv[0]; } -static KrkValue krk_bim_get_commands(int argc, KrkValue argv[]) { - KrkValue myList = krk_list_of(0, NULL); +static KrkValue krk_bim_get_commands(int argc, KrkValue argv[], int hasKw) { + KrkValue myList = krk_list_of(0, NULL,0); krk_push(myList); for (struct command_def * c = regular_commands; regular_commands && c->name; ++c) { krk_writeValueArray(AS_LIST(myList), OBJECT_VAL(krk_copyString(c->name,strlen(c->name)))); @@ -10417,7 +10417,7 @@ struct ActionDef { struct action_def * action; }; -static KrkValue bim_krk_action_call(int argc, KrkValue argv[]) { +static KrkValue bim_krk_action_call(int argc, KrkValue argv[], int hasKw) { struct ActionDef * self = (void*)AS_OBJECT(argv[0]); /* Figure out arguments */ @@ -10429,7 +10429,7 @@ static KrkValue bim_krk_action_call(int argc, KrkValue argv[]) { int argsAsInts[3] = { 0, 0, 0 }; for (int i = 0; i < args; i++) { if (argc < i + 2) - return krk_runtimeError(vm.exceptions.argumentError, "%s() takes %d argument%s", + return krk_runtimeError(vm.exceptions->argumentError, "%s() takes %d argument%s", self->action->name, args, args == 1 ? "" : "s"); if (IS_INTEGER(argv[i+1])) { argsAsInts[i] = AS_INTEGER(argv[i+1]); @@ -10438,7 +10438,7 @@ static KrkValue bim_krk_action_call(int argc, KrkValue argv[]) { } else if (IS_BOOLEAN(argv[i+1])) { argsAsInts[i] = AS_BOOLEAN(argv[i+1]); } else { - return krk_runtimeError(vm.exceptions.typeError, + return krk_runtimeError(vm.exceptions->typeError, "argument to %s() must be int, bool, or str of len 1", self->action->name); } @@ -10449,7 +10449,7 @@ static KrkValue bim_krk_action_call(int argc, KrkValue argv[]) { return NONE_VAL(); } -static KrkValue bim_krk_command_call(int argc, KrkValue argv[]) { +static KrkValue bim_krk_command_call(int argc, KrkValue argv[], int hasKw) { struct CommandDef * self = (void*)AS_OBJECT(argv[0]); char ** args = malloc(sizeof(char*)*argc); @@ -10614,20 +10614,22 @@ void initialize(void) { global_config.tab_indicator = strdup(">"); global_config.space_indicator = strdup("-"); + fprintf(stderr, "init vm\n"); krk_initVM(0); /* no debug flags */ + fprintf(stderr, "done\n"); - KrkInstance * bimModule = krk_newInstance(vm.moduleClass); + KrkInstance * bimModule = krk_newInstance(vm.baseClasses->moduleClass); krk_attachNamedObject(&vm.modules, "bim", (KrkObj*)bimModule); krk_attachNamedObject(&bimModule->fields, "__name__", (KrkObj*)S("bim")); krk_defineNative(&bimModule->fields, "bindHighlighter", krk_bim_register_syntax); krk_defineNative(&bimModule->fields, "getCommands", krk_bim_get_commands); - krk_bim_theme_dict = krk_dict_of(0,NULL); + krk_bim_theme_dict = krk_dict_of(0,NULL,0); krk_attachNamedValue(&bimModule->fields, "themes", krk_bim_theme_dict); krk_defineNative(&bimModule->fields, "defineTheme", krk_bim_define_theme); - krk_bim_syntax_dict = krk_dict_of(0,NULL); + krk_bim_syntax_dict = krk_dict_of(0,NULL,0); krk_attachNamedValue(&bimModule->fields, "highlighters", krk_bim_syntax_dict); - makeClass(bimModule, &ActionDef, "Action", vm.objectClass); + makeClass(bimModule, &ActionDef, "Action", vm.baseClasses->objectClass); ActionDef->allocSize = sizeof(struct ActionDef); krk_defineNative(&ActionDef->methods, ".__call__", bim_krk_action_call); krk_finalizeClass(ActionDef); @@ -10638,12 +10640,12 @@ void initialize(void) { krk_attachNamedObject(&vm.builtins->fields, a->name, (KrkObj*)actionObj); } - makeClass(bimModule, &CommandDef, "Command", vm.objectClass); + makeClass(bimModule, &CommandDef, "Command", vm.baseClasses->objectClass); CommandDef->allocSize = sizeof(struct CommandDef); krk_defineNative(&CommandDef->methods, ".__call__", bim_krk_command_call); krk_finalizeClass(CommandDef); - KrkInstance * global = krk_newInstance(vm.objectClass); + KrkInstance * global = krk_newInstance(vm.baseClasses->objectClass); krk_attachNamedObject(&vm.builtins->fields, "global", (KrkObj*)global); for (struct command_def * c = regular_commands; regular_commands && c->name; ++c) { @@ -10656,7 +10658,7 @@ void initialize(void) { } } - makeClass(bimModule, &syntaxStateClass, "SyntaxState", vm.objectClass); + makeClass(bimModule, &syntaxStateClass, "SyntaxState", vm.baseClasses->objectClass); syntaxStateClass->allocSize = sizeof(struct SyntaxState); krk_defineNative(&syntaxStateClass->methods, ":state", bim_krk_state_getstate); krk_defineNative(&syntaxStateClass->methods, ".set_state", bim_krk_state_setstate); /* TODO property? */ @@ -10694,16 +10696,18 @@ void initialize(void) { krk_resetStack(); + krk_startModule(""); import_directory("syntax"); + krk_startModule(""); import_directory("themes"); + /* Start context for command line */ + krk_startModule(""); + /* Load bimrc */ load_bimrc(); krk_resetStack(); - /* Start context for command line */ - krk_startModule(""); - /* Initialize space for buffers */ buffers_avail = 4; buffers = malloc(sizeof(buffer_t *) * buffers_avail); diff --git a/apps/krk_test_noise.krk b/apps/krk_test_noise.krk new file mode 100755 index 00000000..c4994531 --- /dev/null +++ b/apps/krk_test_noise.krk @@ -0,0 +1,47 @@ +#!/bin/kuroko +import os +if 'KUROKO_TEST_ENV' in os.environ: + return 0 + +from time import sleep +from fileio import open, stdin +from threading import Thread + +let d = {} +let stop = False + +for y in range(0x40): + for x in range(0x40): + d[(y,x)] = 0 + +class NoisePainter(Thread): + def run(self): + let myRando = open('/dev/urandom','rb') + while not stop: + let bytes = myRando.read(3) + let x = bytes[0] & 0x3F + let y = bytes[1] & 0x3F + d[(y,x)] = bytes[2] + +let painters = [NoisePainter() for i in range(5)] + +for painter in painters: + painter.start() + +def drawScreen(): + print("\[[H",end="") + for y in range(0x20): + for x in range(0x40): + let top = d[(y*2,x)] + let bottom = d[(y*2+1,x)] + print("\[[38","2",top,top,top,"48","2",bottom,bottom,bottom,sep=";",end="m▀") + print("\[[0m") + +for i in range(5): + drawScreen() + +stop = True +for painter in painters: + painter.join() + +drawScreen() diff --git a/apps/kuroko.c b/apps/kuroko.c index 9b19a4bb..696b4c7a 100644 --- a/apps/kuroko.c +++ b/apps/kuroko.c @@ -11,6 +11,7 @@ #include #include #include +#include #ifdef __toaru__ #include @@ -33,13 +34,13 @@ static int enableRline = 1; static int exitRepl = 0; -static KrkValue exitFunc(int argc, KrkValue argv[]) { +static KrkValue exitFunc(int argc, KrkValue argv[], int hasKw) { exitRepl = 1; return NONE_VAL(); } static int pasteEnabled = 0; -static KrkValue paste(int argc, KrkValue argv[]) { +static KrkValue paste(int argc, KrkValue argv[], int hasKw) { pasteEnabled = !pasteEnabled; fprintf(stderr, "Pasting is %s.\n", pasteEnabled ? "enabled" : "disabled"); return NONE_VAL(); @@ -123,7 +124,7 @@ static void tab_complete_func(rline_context_t * c) { if (n <= count) { /* Now work forwards, starting from the current globals. */ - KrkValue root = OBJECT_VAL(vm.module); + KrkValue root = OBJECT_VAL(krk_currentThread.module); int isGlobal = 1; while (n > base) { /* And look at the potential fields for instances/classes */ @@ -148,10 +149,10 @@ static void tab_complete_func(rline_context_t * c) { int matchCount = 0; /* Take the last symbol name from the chain and get its member list from dir() */ - KRK_PAUSE_GC(); for (;;) { - KrkValue dirList = krk_dirObject(1,(KrkValue[]){root}); + KrkValue dirList = krk_dirObject(1,(KrkValue[]){root},0); + krk_push(dirList); if (!IS_INSTANCE(dirList)) { fprintf(stderr,"\nInternal error while tab completting.\n"); goto _cleanup; @@ -159,13 +160,17 @@ static void tab_complete_func(rline_context_t * c) { for (size_t i = 0; i < AS_LIST(dirList)->count; ++i) { KrkString * s = AS_STRING(AS_LIST(dirList)->values[i]); + krk_push(OBJECT_VAL(s)); KrkToken asToken = {.start = s->chars, .literalWidth = s->length}; KrkValue thisValue = findFromProperty(root, asToken); + krk_push(thisValue); if (IS_CLOSURE(thisValue) || IS_BOUND_METHOD(thisValue) || (IS_NATIVE(thisValue) && ((KrkNative*)AS_OBJECT(thisValue))->isMethod != 2)) { char * tmp = malloc(s->length + 2); sprintf(tmp, "%s(", s->chars); s = krk_takeString(tmp, strlen(tmp)); + krk_pop(); + krk_push(OBJECT_VAL(s)); } /* If this symbol is shorter than the current submatch, skip it. */ @@ -192,16 +197,17 @@ static void tab_complete_func(rline_context_t * c) { * If the object we were scanning was the current module, * then we should also throw the builtins into the ring. */ - if (isGlobal && AS_OBJECT(root) == (KrkObj*)vm.module) { + if (isGlobal && AS_OBJECT(root) == (KrkObj*)krk_currentThread.module) { root = OBJECT_VAL(vm.builtins); continue; } else if (isGlobal && AS_OBJECT(root) == (KrkObj*)vm.builtins) { extern char * syn_krk_keywords[]; - KrkInstance * fakeKeywordsObject = krk_newInstance(vm.objectClass); + KrkInstance * fakeKeywordsObject = krk_newInstance(vm.baseClasses->objectClass); + root = OBJECT_VAL(fakeKeywordsObject); + krk_push(root); for (char ** keyword = syn_krk_keywords; *keyword; keyword++) { krk_attachNamedValue(&fakeKeywordsObject->fields, *keyword, NONE_VAL()); } - root = OBJECT_VAL(fakeKeywordsObject); continue; } else { break; @@ -262,15 +268,15 @@ _toomany: _cleanup: free(tmp); free(space); - KRK_RESUME_GC(); + krk_resetStack(); return; } } #endif static void handleSigint(int sigNum) { - if (vm.frameCount) { - krk_runtimeError(vm.exceptions.keyboardInterrupt, "Keyboard interrupt."); + if (krk_currentThread.frameCount) { + krk_runtimeError(vm.exceptions->keyboardInterrupt, "Keyboard interrupt."); } signal(sigNum, handleSigint); @@ -282,7 +288,7 @@ static void findInterpreter(char * argv[]) { #else /* Try asking /proc */ char * binpath = realpath("/proc/self/exe", NULL); - if (!binpath) { + if (!binpath || (access(binpath, X_OK) != 0)) { if (strchr(argv[0], '/')) { binpath = realpath(argv[0], NULL); } else { @@ -295,7 +301,7 @@ static void findInterpreter(char * argv[]) { char tmp[4096]; sprintf(tmp, "%s/%s", path, argv[0]); - if (access(tmp, X_OK)) { + if (access(tmp, X_OK) == 0) { binpath = strdup(tmp); break; } @@ -310,14 +316,57 @@ static void findInterpreter(char * argv[]) { #endif } -static int runString(char * argv[], char * string) { +static int runString(char * argv[], int flags, char * string) { findInterpreter(argv); - krk_initVM(0); + krk_initVM(flags); + krk_startModule("__main__"); krk_interpret(string, 1, "",""); krk_freeVM(); return 0; } +/* This isn't normally exposed. */ +extern KrkFunction * krk_compile(const char * src, int newScope, char * fileName); +static int compileFile(char * argv[], int flags, char * fileName) { + findInterpreter(argv); + krk_initVM(flags); + + /* Open the file. */ + FILE * f = fopen(fileName,"r"); + if (!f) { + fprintf(stderr, "%s: could not read file '%s': %s\n", argv[0], fileName, strerror(errno)); + return 1; + } + + /* Read it like we normally do... */ + fseek(f, 0, SEEK_END); + size_t size = ftell(f); + fseek(f, 0, SEEK_SET); + char * buf = malloc(size+1); + if (fread(buf, 1, size, f) != size) return 2; + fclose(f); + buf[size] = '\0'; + + /* Set up a module scope */ + krk_startModule("__main__"); + + /* Call the compiler directly. */ + KrkFunction * func = krk_compile(buf, 0, fileName); + + /* See if there was an exception. */ + if (krk_currentThread.flags & KRK_HAS_EXCEPTION) { + krk_dumpTraceback(); + } + + /* Free the source string */ + free(buf); + + /* Close out the compiler */ + krk_freeVM(); + + return func == NULL; +} + #ifdef BUNDLE_LIBS #define BUNDLED(name) do { \ extern KrkValue krk_module_onload_ ## name (); \ @@ -332,10 +381,10 @@ int main(int argc, char * argv[]) { int flags = 0; int moduleAsMain = 0; int opt; - while ((opt = getopt(argc, argv, "c:dgm:rstMV-:")) != -1) { + while ((opt = getopt(argc, argv, "+c:C:dgm:rstMV-:")) != -1) { switch (opt) { case 'c': - return runString(argv, optarg); + return runString(argv, flags, optarg); case 'd': /* Disassemble code blocks after compilation. */ flags |= KRK_ENABLE_DISASSEMBLY; @@ -360,12 +409,14 @@ int main(int argc, char * argv[]) { enableRline = 0; break; case 'M': - return runString(argv,"import kuroko; print(kuroko.module_paths)\n"); + return runString(argv,0,"import kuroko; print(kuroko.module_paths)\n"); case 'V': - return runString(argv,"import kuroko; print('Kuroko',kuroko.version)\n"); + return runString(argv,0,"import kuroko; print('Kuroko',kuroko.version)\n"); + case 'C': + return compileFile(argv,flags,optarg); case '-': if (!strcmp(optarg,"version")) { - return runString(argv,"import kuroko; print('Kuroko',kuroko.version)\n"); + return runString(argv,0,"import kuroko; print('Kuroko',kuroko.version)\n"); } else if (!strcmp(optarg,"help")) { fprintf(stderr,"usage: %s [flags] [FILE...]\n" "\n" @@ -376,6 +427,8 @@ int main(int argc, char * argv[]) { " -r Disable complex line editing in the REPL.\n" " -s Debug output from the scanner/tokenizer.\n" " -t Disassemble instructions as they are exceuted.\n" + " -C file Compile 'file', but do not execute it.\n" + " -M Print the default module import paths.\n" " -V Print version information.\n" "\n" " --version Print version information.\n" @@ -401,7 +454,7 @@ _finishArgs: for (int arg = optind; arg < argc; ++arg) { krk_push(OBJECT_VAL(krk_copyString(argv[arg],strlen(argv[arg])))); } - KrkValue argList = krk_list_of(argc - optind + (optind == argc), &vm.stackTop[-(argc - optind + (optind == argc))]); + KrkValue argList = krk_list_of(argc - optind + (optind == argc), &krk_currentThread.stackTop[-(argc - optind + (optind == argc))],0); krk_push(argList); krk_attachNamedValue(&vm.system->fields, "argv", argList); krk_pop(); @@ -432,7 +485,7 @@ _finishArgs: AS_STRING(AS_LIST(argList)->values[0]), &module, AS_STRING(krk_peek(0))); - if (vm.flags & KRK_HAS_EXCEPTION) { + if (krk_currentThread.flags & KRK_HAS_EXCEPTION) { krk_dumpTraceback(); krk_resetStack(); } @@ -445,7 +498,7 @@ _finishArgs: /* The repl runs in the context of a top-level module so each input * line can share a globals state with the others. */ krk_startModule(""); - krk_attachNamedValue(&vm.module->fields,"__doc__", NONE_VAL()); + krk_attachNamedValue(&krk_currentThread.module->fields,"__doc__", NONE_VAL()); #ifndef NO_RLINE /* Set ^D to send EOF */ @@ -646,6 +699,7 @@ _finishArgs: (void)blockWidth; } } else { + krk_startModule("__main__"); result = krk_runfile(argv[optind],1,"__main__",argv[optind]); } diff --git a/kuroko b/kuroko index 4eceb98f..6a95c4a9 160000 --- a/kuroko +++ b/kuroko @@ -1 +1 @@ -Subproject commit 4eceb98ffed5c49f57d362887134613a2c6733ba +Subproject commit 6a95c4a97921e9aa76fda65e1f289428dd95e4b2 diff --git a/lib/kuroko/_yutani.c b/lib/kuroko/_yutani.c index 8b97b070..cf5782dc 100644 --- a/lib/kuroko/_yutani.c +++ b/lib/kuroko/_yutani.c @@ -94,7 +94,7 @@ static KrkClass * MenuEntrySeparatorClass; * handling stack push/pop to keep things from being prematurely GC'd. */ KrkClass * krk_createClass(KrkInstance * inModule, const char * name, KrkClass * base) { - if (!base) base = vm.objectClass; + if (!base) base = vm.baseClasses->objectClass; KrkString * str_Name = krk_copyString(name, strlen(name)); krk_push(OBJECT_VAL(str_Name)); KrkClass * obj_Class = krk_newClass(str_Name, base); @@ -122,7 +122,7 @@ static void _message_sweep(KrkInstance * self) { free(((struct MessageClass*)self)->msg); } -static KrkValue _message_getattr(int argc, KrkValue argv[]) { +static KrkValue _message_getattr(int argc, KrkValue argv[], int hasKw) { assert(argc == 2); KrkInstance * self = AS_INSTANCE(argv[0]); @@ -203,7 +203,7 @@ static KrkValue _message_getattr(int argc, KrkValue argv[]) { } break; } - krk_runtimeError(vm.exceptions.attributeError, "no attribute '%s'", AS_CSTRING(argv[1])); + krk_runtimeError(vm.exceptions->attributeError, "no attribute '%s'", AS_CSTRING(argv[1])); return NONE_VAL(); } #undef DO_FIELD @@ -212,7 +212,7 @@ static KrkValue _message_getattr(int argc, KrkValue argv[]) { #undef TO_INT #undef WID -static KrkValue _yutani_repr(int argc, KrkValue argv[]) { +static KrkValue _yutani_repr(int argc, KrkValue argv[], int hasKw) { struct YutaniClass * self = (struct YutaniClass*)AS_INSTANCE(argv[0]); char out[500]; size_t len = sprintf(out, "Yutani(fd=%d,server=%s,display_width=%d,display_height=%d)", @@ -225,7 +225,7 @@ static KrkValue _yutani_repr(int argc, KrkValue argv[]) { static KrkValue _yutani_init(int argc, KrkValue argv[], int hasKw) { if (yctxInstance) { - krk_runtimeError(vm.exceptions.valueError, "class 'Yutani' is a singleton and has already been initialized."); + krk_runtimeError(vm.exceptions->valueError, "class 'Yutani' is a singleton and has already been initialized."); return NONE_VAL(); } @@ -234,7 +234,7 @@ static KrkValue _yutani_init(int argc, KrkValue argv[], int hasKw) { /* Connect and let's go. */ yutani_t * yctx = yutani_init(); if (!yctx) { - krk_runtimeError(vm.exceptions.ioError, "Failed to connect to compositor."); + krk_runtimeError(vm.exceptions->ioError, "Failed to connect to compositor."); return NONE_VAL(); } @@ -249,15 +249,15 @@ static KrkValue _yutani_init(int argc, KrkValue argv[], int hasKw) { #define CHECK_YUTANI() \ if (argc < 1 || !krk_isInstanceOf(argv[0], Yutani)) \ - return krk_runtimeError(vm.exceptions.typeError, "expected Yutani"); \ + return krk_runtimeError(vm.exceptions->typeError, "expected Yutani"); \ struct YutaniClass * self = (struct YutaniClass*)AS_INSTANCE(argv[0]) -static KrkValue _yutani_display_width(int argc, KrkValue argv[]) { +static KrkValue _yutani_display_width(int argc, KrkValue argv[], int hasKw) { CHECK_YUTANI(); return INTEGER_VAL(self->yctx->display_width); } -static KrkValue _yutani_display_height(int argc, KrkValue argv[]) { +static KrkValue _yutani_display_height(int argc, KrkValue argv[], int hasKw) { CHECK_YUTANI(); return INTEGER_VAL(self->yctx->display_height); } @@ -283,9 +283,9 @@ static KrkValue _yutani_poll(int argc, KrkValue argv[], int hasKw) { return krk_pop(); } -static KrkValue _yutani_wait_for(int argc, KrkValue argv[]) { +static KrkValue _yutani_wait_for(int argc, KrkValue argv[], int hasKw) { CHECK_YUTANI(); - if (argc != 2 || !IS_INTEGER(argv[1])) { krk_runtimeError(vm.exceptions.argumentError, "expected int for msgtype"); return NONE_VAL(); } + if (argc != 2 || !IS_INTEGER(argv[1])) { krk_runtimeError(vm.exceptions->argumentError, "expected int for msgtype"); return NONE_VAL(); } yutani_msg_t * result = yutani_wait_for(self->yctx, AS_INTEGER(argv[1])); KrkInstance * out = krk_newInstance(Message); krk_push(OBJECT_VAL(out)); @@ -295,38 +295,38 @@ static KrkValue _yutani_wait_for(int argc, KrkValue argv[]) { return krk_pop(); } -static KrkValue _yutani_subscribe(int argc, KrkValue argv[]) { +static KrkValue _yutani_subscribe(int argc, KrkValue argv[], int hasKw) { CHECK_YUTANI(); yutani_subscribe_windows(self->yctx); return NONE_VAL(); } -static KrkValue _yutani_unsubscribe(int argc, KrkValue argv[]) { +static KrkValue _yutani_unsubscribe(int argc, KrkValue argv[], int hasKw) { CHECK_YUTANI(); yutani_unsubscribe_windows(self->yctx); return NONE_VAL(); } -static KrkValue _yutani_query_windows(int argc, KrkValue argv[]) { +static KrkValue _yutani_query_windows(int argc, KrkValue argv[], int hasKw) { CHECK_YUTANI(); yutani_query_windows(self->yctx); return NONE_VAL(); } -static KrkValue _yutani_fileno(int argc, KrkValue argv[]) { +static KrkValue _yutani_fileno(int argc, KrkValue argv[], int hasKw) { CHECK_YUTANI(); return INTEGER_VAL(fileno(self->yctx->sock)); } -static KrkValue _yutani_query(int argc, KrkValue argv[]) { +static KrkValue _yutani_query(int argc, KrkValue argv[], int hasKw) { CHECK_YUTANI(); return INTEGER_VAL(yutani_query(self->yctx)); } -static KrkValue _yutani_menu_process_event(int argc, KrkValue argv[]) { +static KrkValue _yutani_menu_process_event(int argc, KrkValue argv[], int hasKw) { CHECK_YUTANI(); if (argc < 2 || !krk_isInstanceOf(argv[1],Message)) - return krk_runtimeError(vm.exceptions.typeError, "expected Message"); + return krk_runtimeError(vm.exceptions->typeError, "expected Message"); struct MessageClass* msg = (struct MessageClass*)AS_INSTANCE(argv[1]); return INTEGER_VAL(menu_process_event(self->yctx, msg->msg)); @@ -335,18 +335,18 @@ static KrkValue _yutani_menu_process_event(int argc, KrkValue argv[]) { #define GET_ARG(p,name,type) do { \ if (hasKw && krk_tableGet(AS_DICT(argv[argc]), OBJECT_VAL(S(#name)), &name)) { \ if (!krk_isInstanceOf(name,type)) \ - return krk_runtimeError(vm.exceptions.typeError, #name " argument should be " #type ", not '%s'", krk_typeName(name)); \ + return krk_runtimeError(vm.exceptions->typeError, #name " argument should be " #type ", not '%s'", krk_typeName(name)); \ } else if (argc > p) { \ name = argv[p]; \ if (!krk_isInstanceOf(name,type)) \ - return krk_runtimeError(vm.exceptions.typeError, #name " argument should be " #type ", not '%s'", krk_typeName(name)); \ + return krk_runtimeError(vm.exceptions->typeError, #name " argument should be " #type ", not '%s'", krk_typeName(name)); \ } \ } while (0) #define GFX_PROPERTY(name) \ -static KrkValue _gfx_ ## name (int argc, KrkValue argv[]) { \ +static KrkValue _gfx_ ## name (int argc, KrkValue argv[], int hasKw) { \ if (argc != 1 || !krk_isInstanceOf(argv[0], GraphicsContext)) \ - return krk_runtimeError(vm.exceptions.typeError, "Expected GraphicsContext"); \ + return krk_runtimeError(vm.exceptions->typeError, "Expected GraphicsContext"); \ struct GraphicsContext * self = (struct GraphicsContext *)AS_INSTANCE(argv[0]); \ return INTEGER_VAL(self->ctx-> name); \ } @@ -356,19 +356,19 @@ GFX_PROPERTY(height); #define CHECK_GFX() \ if (argc < 1 || !krk_isInstanceOf(argv[0], GraphicsContext)) \ - return krk_runtimeError(vm.exceptions.typeError, "expected GraphicsContext"); \ + return krk_runtimeError(vm.exceptions->typeError, "expected GraphicsContext"); \ struct GraphicsContext * self = (struct GraphicsContext*)AS_INSTANCE(argv[0]) -static KrkValue _gfx_fill(int argc, KrkValue argv[]) { +static KrkValue _gfx_fill(int argc, KrkValue argv[], int hasKw) { CHECK_GFX(); if (argc < 2 || !krk_isInstanceOf(argv[1], YutaniColor)) - return krk_runtimeError(vm.exceptions.typeError, "fill() takes one color() argument"); + return krk_runtimeError(vm.exceptions->typeError, "fill() takes one color() argument"); struct YutaniColor * color = (struct YutaniColor*)AS_INSTANCE(argv[1]); draw_fill(self->ctx, color->color); return NONE_VAL(); } -static KrkValue _gfx_flip(int argc, KrkValue argv[]) { +static KrkValue _gfx_flip(int argc, KrkValue argv[], int hasKw) { CHECK_GFX(); if (self->doubleBuffered) { flip(self->ctx); @@ -376,16 +376,16 @@ static KrkValue _gfx_flip(int argc, KrkValue argv[]) { return NONE_VAL(); } -static KrkValue _gfx_blur(int argc, KrkValue argv[]) { +static KrkValue _gfx_blur(int argc, KrkValue argv[], int hasKw) { CHECK_GFX(); int radius = 2; if (argc > 1 && IS_INTEGER(argv[1])) radius = AS_INTEGER(argv[1]); - else if (argc > 1) return krk_runtimeError(vm.exceptions.typeError, "expected int"); + else if (argc > 1) return krk_runtimeError(vm.exceptions->typeError, "expected int"); blur_context_box(self->ctx, radius); return NONE_VAL(); } -static KrkValue _gfx_line(int argc, KrkValue argv[]) { +static KrkValue _gfx_line(int argc, KrkValue argv[], int hasKw) { CHECK_GFX(); if (argc < 6 || !IS_INTEGER(argv[1]) || @@ -393,7 +393,7 @@ static KrkValue _gfx_line(int argc, KrkValue argv[]) { !IS_INTEGER(argv[3]) || !IS_INTEGER(argv[4]) || !krk_isInstanceOf(argv[5], YutaniColor)) { - return krk_runtimeError(vm.exceptions.typeError, "line() expects 4 ints and a color"); + return krk_runtimeError(vm.exceptions->typeError, "line() expects 4 ints and a color"); } int32_t x0 = AS_INTEGER(argv[1]); @@ -408,7 +408,7 @@ static KrkValue _gfx_line(int argc, KrkValue argv[]) { } else if (IS_FLOATING(argv[6])) { draw_line_aa(self->ctx,x0,x1,y0,y1,color->color,AS_FLOATING(argv[6])); } else { - return krk_runtimeError(vm.exceptions.typeError, "thickness must be int or float, not '%s'", krk_typeName(argv[6])); + return krk_runtimeError(vm.exceptions->typeError, "thickness must be int or float, not '%s'", krk_typeName(argv[6])); } } else { draw_line(self->ctx,x0,x1,y0,y1,color->color); @@ -426,7 +426,7 @@ static KrkValue _gfx_rect(int argc, KrkValue argv[], int hasKw) { !IS_INTEGER(argv[3]) || !IS_INTEGER(argv[4]) || !krk_isInstanceOf(argv[5], YutaniColor)) { - return krk_runtimeError(vm.exceptions.typeError, "rect() expects 4 ints and a color"); + return krk_runtimeError(vm.exceptions->typeError, "rect() expects 4 ints and a color"); } int32_t x = AS_INTEGER(argv[1]); @@ -442,11 +442,11 @@ static KrkValue _gfx_rect(int argc, KrkValue argv[], int hasKw) { } if (!IS_BOOLEAN(solid)) - return krk_runtimeError(vm.exceptions.typeError, "solid must be bool"); + return krk_runtimeError(vm.exceptions->typeError, "solid must be bool"); if (!IS_NONE(radius) && !IS_INTEGER(radius)) - return krk_runtimeError(vm.exceptions.typeError, "radius must be int"); + return krk_runtimeError(vm.exceptions->typeError, "radius must be int"); if (!IS_NONE(radius) && AS_BOOLEAN(solid)) - return krk_runtimeError(vm.exceptions.typeError, "radius and solid can not be used together"); + return krk_runtimeError(vm.exceptions->typeError, "radius and solid can not be used together"); if (AS_BOOLEAN(solid)) { draw_rectangle_solid(self->ctx, x, y, width, height, color->color); @@ -463,10 +463,10 @@ static KrkValue _gfx_draw_sprite(int argc, KrkValue argv[], int hasKw) { CHECK_GFX(); if (argc < 2 || !krk_isInstanceOf(argv[1], YutaniSprite)) - return krk_runtimeError(vm.exceptions.typeError, "expected Sprite"); + return krk_runtimeError(vm.exceptions->typeError, "expected Sprite"); if (argc < 4 || !IS_INTEGER(argv[2]) || !IS_INTEGER(argv[3])) - return krk_runtimeError(vm.exceptions.typeError, "expected integer coordinate pair"); + return krk_runtimeError(vm.exceptions->typeError, "expected integer coordinate pair"); /* Potential kwargs: rotation:float, alpha:float, scale:(int,int)... */ KrkValue rotation = NONE_VAL(), alpha = NONE_VAL(), scale=NONE_VAL(), color=NONE_VAL(); @@ -478,17 +478,17 @@ static KrkValue _gfx_draw_sprite(int argc, KrkValue argv[], int hasKw) { } if (!IS_NONE(alpha) && !IS_FLOATING(alpha)) - return krk_runtimeError(vm.exceptions.typeError, "alpha must be float"); + return krk_runtimeError(vm.exceptions->typeError, "alpha must be float"); if (!IS_NONE(rotation) && !IS_FLOATING(rotation)) - return krk_runtimeError(vm.exceptions.typeError, "rotation must be float"); + return krk_runtimeError(vm.exceptions->typeError, "rotation must be float"); if (!IS_NONE(color) && !krk_isInstanceOf(color,YutaniColor)) - return krk_runtimeError(vm.exceptions.typeError, "color must be color"); + return krk_runtimeError(vm.exceptions->typeError, "color must be color"); if (!IS_NONE(scale) && (!IS_TUPLE(scale) || AS_TUPLE(scale)->values.count != 2 || !IS_INTEGER(AS_TUPLE(scale)->values.values[0]) || !IS_INTEGER(AS_TUPLE(scale)->values.values[1]))) - return krk_runtimeError(vm.exceptions.typeError, "scale must be 2-tuple of ints"); + return krk_runtimeError(vm.exceptions->typeError, "scale must be 2-tuple of ints"); if (!IS_NONE(rotation) + !IS_NONE(scale) + !IS_NONE(color) > 1) - return krk_runtimeError(vm.exceptions.typeError, "can not combine rotation / scale / color"); + return krk_runtimeError(vm.exceptions->typeError, "can not combine rotation / scale / color"); if ((!IS_NONE(rotation) || !IS_NONE(color)) && IS_NONE(alpha)) alpha = FLOATING_VAL(1.0); @@ -526,7 +526,7 @@ static void _sprite_sweep(KrkInstance * self) { if (sprite->ctx) free(sprite->ctx); } -static KrkValue _sprite_repr(int argc, KrkValue argv[]) { +static KrkValue _sprite_repr(int argc, KrkValue argv[], int hasKw) { struct YutaniSprite * self = (struct YutaniSprite *)AS_INSTANCE(argv[0]); KrkValue file; @@ -540,18 +540,18 @@ static KrkValue _sprite_repr(int argc, KrkValue argv[]) { return OBJECT_VAL(krk_copyString(out,len)); } -static KrkValue _sprite_init(int argc, KrkValue argv[]) { +static KrkValue _sprite_init(int argc, KrkValue argv[], int hasKw) { if (argc < 1 || !krk_isInstanceOf(argv[0], YutaniSprite)) - return krk_runtimeError(vm.exceptions.typeError, "expected sprite"); + return krk_runtimeError(vm.exceptions->typeError, "expected sprite"); if (argc < 2 || !IS_STRING(argv[1])) - return krk_runtimeError(vm.exceptions.typeError, "Sprite() takes one str argument"); + return krk_runtimeError(vm.exceptions->typeError, "Sprite() takes one str argument"); struct YutaniSprite * self = (struct YutaniSprite*)AS_INSTANCE(argv[0]); int result = load_sprite(&self->sprite, AS_CSTRING(argv[1])); if (result) { - return krk_runtimeError(vm.exceptions.ioError, "Sprite() could not be initialized"); + return krk_runtimeError(vm.exceptions->ioError, "Sprite() could not be initialized"); } self->ctx = init_graphics_sprite(&self->sprite); @@ -562,11 +562,11 @@ static KrkValue _sprite_init(int argc, KrkValue argv[]) { #define CHECK_WINDOW() \ if (argc < 1 || !krk_isInstanceOf(argv[0], YutaniWindow)) \ - return krk_runtimeError(vm.exceptions.typeError, "expected Window"); \ + return krk_runtimeError(vm.exceptions->typeError, "expected Window"); \ struct WindowClass * self = (struct WindowClass*)AS_INSTANCE(argv[0]); \ - if (!self->window) return krk_runtimeError(vm.exceptions.valueError, "Window is closed") + if (!self->window) return krk_runtimeError(vm.exceptions->valueError, "Window is closed") -static KrkValue _window_repr(int argc, KrkValue argv[]) { +static KrkValue _window_repr(int argc, KrkValue argv[], int hasKw) { CHECK_WINDOW(); KrkValue title; krk_tableGet(&self->inst.fields, OBJECT_VAL(S("title")), &title); @@ -580,12 +580,12 @@ static KrkValue _window_repr(int argc, KrkValue argv[]) { } static KrkValue _window_init(int argc, KrkValue argv[], int hasKw) { - if (!yctxInstance) return krk_runtimeError(vm.exceptions.valueError, "Compositor is not initialized"); + if (!yctxInstance) return krk_runtimeError(vm.exceptions->valueError, "Compositor is not initialized"); if (argc < 1 || !krk_isInstanceOf(argv[0], YutaniWindow)) - return krk_runtimeError(vm.exceptions.typeError, "Failed to initialize window"); + return krk_runtimeError(vm.exceptions->typeError, "Failed to initialize window"); if (argc < 3 || !IS_INTEGER(argv[1]) || !IS_INTEGER(argv[2])) - return krk_runtimeError(vm.exceptions.argumentError, "Expected at least two (integer) arguments (width, height)"); + return krk_runtimeError(vm.exceptions->argumentError, "Expected at least two (integer) arguments (width, height)"); KrkInstance * _self = AS_INSTANCE(argv[0]); struct WindowClass * self = (struct WindowClass*)_self; @@ -593,10 +593,10 @@ static KrkValue _window_init(int argc, KrkValue argv[], int hasKw) { krk_integer_type height = AS_INTEGER(argv[2]); KrkValue flags = INTEGER_VAL(0), title = NONE_VAL(), icon = NONE_VAL(), doublebuffer = BOOLEAN_VAL(0); - GET_ARG(3, flags, vm.baseClasses.intClass); - GET_ARG(4, title, vm.baseClasses.strClass); - GET_ARG(5, icon, vm.baseClasses.strClass); - GET_ARG(6, doublebuffer, vm.baseClasses.boolClass); + GET_ARG(3, flags, vm.baseClasses->intClass); + GET_ARG(4, title, vm.baseClasses->strClass); + GET_ARG(5, icon, vm.baseClasses->strClass); + GET_ARG(6, doublebuffer, vm.baseClasses->boolClass); self->window = yutani_window_create_flags(((struct YutaniClass*)yctxInstance)->yctx, width, height, AS_INTEGER(flags)); @@ -624,7 +624,7 @@ static KrkValue _window_init(int argc, KrkValue argv[], int hasKw) { return argv[0]; } -static KrkValue _window_flip(int argc, KrkValue argv[]) { +static KrkValue _window_flip(int argc, KrkValue argv[], int hasKw) { CHECK_WINDOW(); if (self->doubleBuffered) { flip(self->ctx); @@ -633,23 +633,23 @@ static KrkValue _window_flip(int argc, KrkValue argv[]) { return NONE_VAL(); } -static KrkValue _window_move(int argc, KrkValue argv[]) { +static KrkValue _window_move(int argc, KrkValue argv[], int hasKw) { CHECK_WINDOW(); if (argc < 3 || !IS_INTEGER(argv[1]) || !IS_INTEGER(argv[2])) - return krk_runtimeError(vm.exceptions.typeError, "expected two integer arguments"); + return krk_runtimeError(vm.exceptions->typeError, "expected two integer arguments"); yutani_window_move(((struct YutaniClass*)yctxInstance)->yctx, self->window, AS_INTEGER(argv[1]), AS_INTEGER(argv[2])); return NONE_VAL(); } -static KrkValue _window_set_focused(int argc, KrkValue argv[]) { +static KrkValue _window_set_focused(int argc, KrkValue argv[], int hasKw) { CHECK_WINDOW(); if (argc < 2 || !IS_INTEGER(argv[1])) - return krk_runtimeError(vm.exceptions.typeError, "expected integer argument"); + return krk_runtimeError(vm.exceptions->typeError, "expected integer argument"); self->window->focused = AS_INTEGER(argv[1]); return NONE_VAL(); } -static KrkValue _window_close(int argc, KrkValue argv[]) { +static KrkValue _window_close(int argc, KrkValue argv[], int hasKw) { CHECK_WINDOW(); yutani_close(((struct YutaniClass*)yctxInstance)->yctx, self->window); self->window = NULL; @@ -658,90 +658,90 @@ static KrkValue _window_close(int argc, KrkValue argv[]) { return NONE_VAL(); } -static KrkValue _window_set_stack(int argc, KrkValue argv[]) { +static KrkValue _window_set_stack(int argc, KrkValue argv[], int hasKw) { CHECK_WINDOW(); - if (argc < 2 || !IS_INTEGER(argv[1])) return krk_runtimeError(vm.exceptions.typeError, "expected int for z-order"); + if (argc < 2 || !IS_INTEGER(argv[1])) return krk_runtimeError(vm.exceptions->typeError, "expected int for z-order"); int z = AS_INTEGER(argv[1]); yutani_set_stack(((struct YutaniClass*)yctxInstance)->yctx, self->window, z); return NONE_VAL(); } -static KrkValue _window_update_shape(int argc, KrkValue argv[]) { +static KrkValue _window_update_shape(int argc, KrkValue argv[], int hasKw) { CHECK_WINDOW(); - if (argc < 2 || !IS_INTEGER(argv[1])) return krk_runtimeError(vm.exceptions.typeError, "expected int for shape specifier"); + if (argc < 2 || !IS_INTEGER(argv[1])) return krk_runtimeError(vm.exceptions->typeError, "expected int for shape specifier"); int set_shape = AS_INTEGER(argv[1]); yutani_window_update_shape(((struct YutaniClass*)yctxInstance)->yctx, self->window, set_shape); return NONE_VAL(); } -static KrkValue _window_warp_mouse(int argc, KrkValue argv[]) { +static KrkValue _window_warp_mouse(int argc, KrkValue argv[], int hasKw) { CHECK_WINDOW(); if (argc < 3 || !IS_INTEGER(argv[1]) || !IS_INTEGER(argv[2])) - return krk_runtimeError(vm.exceptions.typeError, "expected two int values for x, y"); + return krk_runtimeError(vm.exceptions->typeError, "expected two int values for x, y"); int32_t x = AS_INTEGER(argv[1]); int32_t y = AS_INTEGER(argv[2]); yutani_window_warp_mouse(((struct YutaniClass*)yctxInstance)->yctx, self->window, x, y); return NONE_VAL(); } -static KrkValue _window_show_mouse(int argc, KrkValue argv[]) { +static KrkValue _window_show_mouse(int argc, KrkValue argv[], int hasKw) { CHECK_WINDOW(); - if (argc < 2 || !IS_INTEGER(argv[1])) return krk_runtimeError(vm.exceptions.typeError, "expected int for show_mouse"); + if (argc < 2 || !IS_INTEGER(argv[1])) return krk_runtimeError(vm.exceptions->typeError, "expected int for show_mouse"); int show_mouse = AS_INTEGER(argv[1]); yutani_window_show_mouse(((struct YutaniClass*)yctxInstance)->yctx, self->window, show_mouse); return NONE_VAL(); } -static KrkValue _window_resize_start(int argc, KrkValue argv[]) { +static KrkValue _window_resize_start(int argc, KrkValue argv[], int hasKw) { CHECK_WINDOW(); - if (argc < 2 || !IS_INTEGER(argv[1])) return krk_runtimeError(vm.exceptions.typeError, "expected int for direction"); + if (argc < 2 || !IS_INTEGER(argv[1])) return krk_runtimeError(vm.exceptions->typeError, "expected int for direction"); yutani_scale_direction_t direction = AS_INTEGER(argv[1]); yutani_window_resize_start(((struct YutaniClass*)yctxInstance)->yctx, self->window, direction); return NONE_VAL(); } -static KrkValue _window_resize(int argc, KrkValue argv[]) { +static KrkValue _window_resize(int argc, KrkValue argv[], int hasKw) { CHECK_WINDOW(); if (argc < 3 || !IS_INTEGER(argv[1]) || !IS_INTEGER(argv[2])) - return krk_runtimeError(vm.exceptions.typeError, "expected two int values for width, height"); + return krk_runtimeError(vm.exceptions->typeError, "expected two int values for width, height"); uint32_t width = AS_INTEGER(argv[1]); uint32_t height = AS_INTEGER(argv[2]); yutani_window_resize(((struct YutaniClass*)yctxInstance)->yctx, self->window, width, height); return NONE_VAL(); } -static KrkValue _window_resize_offer(int argc, KrkValue argv[]) { +static KrkValue _window_resize_offer(int argc, KrkValue argv[], int hasKw) { CHECK_WINDOW(); if (argc < 3 || !IS_INTEGER(argv[1]) || !IS_INTEGER(argv[2])) - return krk_runtimeError(vm.exceptions.typeError, "expected two int values for width, height"); + return krk_runtimeError(vm.exceptions->typeError, "expected two int values for width, height"); uint32_t width = AS_INTEGER(argv[1]); uint32_t height = AS_INTEGER(argv[2]); yutani_window_resize_offer(((struct YutaniClass*)yctxInstance)->yctx, self->window, width, height); return NONE_VAL(); } -static KrkValue _window_resize_accept(int argc, KrkValue argv[]) { +static KrkValue _window_resize_accept(int argc, KrkValue argv[], int hasKw) { CHECK_WINDOW(); if (argc < 3 || !IS_INTEGER(argv[1]) || !IS_INTEGER(argv[2])) - return krk_runtimeError(vm.exceptions.typeError, "expected two int values for width, height"); + return krk_runtimeError(vm.exceptions->typeError, "expected two int values for width, height"); uint32_t width = AS_INTEGER(argv[1]); uint32_t height = AS_INTEGER(argv[2]); yutani_window_resize_accept(((struct YutaniClass*)yctxInstance)->yctx, self->window, width, height); return NONE_VAL(); } -static KrkValue _window_resize_done(int argc, KrkValue argv[]) { +static KrkValue _window_resize_done(int argc, KrkValue argv[], int hasKw) { CHECK_WINDOW(); yutani_window_resize_done(((struct YutaniClass*)yctxInstance)->yctx, self->window); return NONE_VAL(); } -static KrkValue _window_advertise(int argc, KrkValue argv[]) { +static KrkValue _window_advertise(int argc, KrkValue argv[], int hasKw) { CHECK_WINDOW(); if (argc < 2 || !IS_STRING(argv[1])) - return krk_runtimeError(vm.exceptions.typeError, "expected string for title"); + return krk_runtimeError(vm.exceptions->typeError, "expected string for title"); if (argc > 2 && !IS_STRING(argv[2])) - return krk_runtimeError(vm.exceptions.typeError, "expected string for icon"); + return krk_runtimeError(vm.exceptions->typeError, "expected string for icon"); if (argc > 2) { yutani_window_advertise_icon(((struct YutaniClass*)yctxInstance)->yctx, self->window, AS_CSTRING(argv[1]), AS_CSTRING(argv[2])); @@ -751,24 +751,24 @@ static KrkValue _window_advertise(int argc, KrkValue argv[]) { return NONE_VAL(); } -static KrkValue _window_special_request(int argc, KrkValue argv[]) { +static KrkValue _window_special_request(int argc, KrkValue argv[], int hasKw) { CHECK_WINDOW(); - if (argc < 2 || !IS_INTEGER(argv[1])) return krk_runtimeError(vm.exceptions.typeError, "expected int for request"); + if (argc < 2 || !IS_INTEGER(argv[1])) return krk_runtimeError(vm.exceptions->typeError, "expected int for request"); uint32_t request = AS_INTEGER(argv[1]); yutani_special_request(((struct YutaniClass*)yctxInstance)->yctx, self->window, request); return NONE_VAL(); } -static KrkValue _window_reinit(int argc, KrkValue argv[]) { +static KrkValue _window_reinit(int argc, KrkValue argv[], int hasKw) { CHECK_WINDOW(); reinit_graphics_yutani(self->ctx, self->window); return NONE_VAL(); } #define WINDOW_PROPERTY(name) \ -static KrkValue _window_ ## name (int argc, KrkValue argv[]) { \ +static KrkValue _window_ ## name (int argc, KrkValue argv[], int hasKw) { \ if (argc != 1 || !krk_isInstanceOf(argv[0], YutaniWindow)) \ - return krk_runtimeError(vm.exceptions.typeError, "Expected Window"); \ + return krk_runtimeError(vm.exceptions->typeError, "Expected Window"); \ struct WindowClass * self = (struct WindowClass*)AS_INSTANCE(argv[0]); \ return INTEGER_VAL(self->window-> name); \ } @@ -778,39 +778,38 @@ WINDOW_PROPERTY(x); WINDOW_PROPERTY(y); WINDOW_PROPERTY(focused); -static KrkValue _decor_get_bounds(int argc, KrkValue argv[]) { +static KrkValue _decor_get_bounds(int argc, KrkValue argv[], int hasKw) { if (argc > 0 && !krk_isInstanceOf(argv[0], YutaniWindow)) - return krk_runtimeError(vm.exceptions.typeError, "expected window"); + return krk_runtimeError(vm.exceptions->typeError, "expected window"); struct decor_bounds bounds; decor_get_bounds((argc > 0) ? ((struct WindowClass*)AS_INSTANCE(argv[0]))->window : NULL, &bounds); - KRK_PAUSE_GC(); + KrkValue result = krk_dict_of(0, NULL, 0); + krk_push(result); - KrkValue result = krk_dict_of(6 * 2, (KrkValue[]) { - OBJECT_VAL(S("top_height")), INTEGER_VAL(bounds.top_height), - OBJECT_VAL(S("bottom_height")), INTEGER_VAL(bounds.bottom_height), - OBJECT_VAL(S("left_width")), INTEGER_VAL(bounds.left_width), - OBJECT_VAL(S("right_width")), INTEGER_VAL(bounds.right_width), - OBJECT_VAL(S("width")), INTEGER_VAL(bounds.width), - OBJECT_VAL(S("height")), INTEGER_VAL(bounds.height) - }); +#define SET(val) krk_attachNamedValue(AS_DICT(result), #val, INTEGER_VAL(bounds. val)); - KRK_RESUME_GC(); + SET(top_height); + SET(bottom_height); + SET(left_width); + SET(right_width); + SET(width); + SET(height); - return result; + return krk_pop(); } -static KrkValue _decor_handle_event(int argc, KrkValue argv[]) { +static KrkValue _decor_handle_event(int argc, KrkValue argv[], int hasKw) { if (argc < 1 || !krk_isInstanceOf(argv[0], Message)) - return krk_runtimeError(vm.exceptions.typeError, "expected message"); + return krk_runtimeError(vm.exceptions->typeError, "expected message"); return INTEGER_VAL(decor_handle_event(((struct YutaniClass*)yctxInstance)->yctx, ((struct MessageClass*)AS_INSTANCE(argv[0]))->msg)); } -static KrkValue _decor_render(int argc, KrkValue argv[]) { +static KrkValue _decor_render(int argc, KrkValue argv[], int hasKw) { if (argc < 1 || !krk_isInstanceOf(argv[0], YutaniWindow)) - return krk_runtimeError(vm.exceptions.typeError, "expected window"); + return krk_runtimeError(vm.exceptions->typeError, "expected window"); char * title = (argc > 1 && IS_STRING(argv[1])) ? AS_CSTRING(argv[1]) : NULL; if (title == NULL) { KrkValue winTitle; @@ -825,11 +824,11 @@ static KrkValue _decor_render(int argc, KrkValue argv[]) { return NONE_VAL(); } -static KrkValue _decor_show_default_menu(int argc, KrkValue argv[]) { +static KrkValue _decor_show_default_menu(int argc, KrkValue argv[], int hasKw) { if (argc < 1 || !krk_isInstanceOf(argv[0], YutaniWindow)) - return krk_runtimeError(vm.exceptions.typeError, "show_default_menu() expects Window"); + return krk_runtimeError(vm.exceptions->typeError, "show_default_menu() expects Window"); if (argc < 3 || !IS_INTEGER(argv[1]) || !IS_INTEGER(argv[2])) - return krk_runtimeError(vm.exceptions.typeError, "show_default_menu() expects int coordinate pair"); + return krk_runtimeError(vm.exceptions->typeError, "show_default_menu() expects int coordinate pair"); struct WindowClass * window = (void*)AS_INSTANCE(argv[0]); int32_t x = AS_INTEGER(argv[1]); @@ -839,10 +838,10 @@ static KrkValue _decor_show_default_menu(int argc, KrkValue argv[]) { return NONE_VAL(); } -static KrkValue _yutani_color_init(int argc, KrkValue argv[]) { +static KrkValue _yutani_color_init(int argc, KrkValue argv[], int hasKw) { if (argc < 4 || !IS_INTEGER(argv[1]) || !IS_INTEGER(argv[2]) || !IS_INTEGER(argv[3]) || - (argc > 5) || (argc == 5 && !IS_INTEGER(argv[4]))) return krk_runtimeError(vm.exceptions.typeError, "color() expects three or four integer arguments"); - if (!krk_isInstanceOf(argv[0], YutaniColor)) return krk_runtimeError(vm.exceptions.typeError, "expected color [__init__], not '%s'", krk_typeName(argv[0])); + (argc > 5) || (argc == 5 && !IS_INTEGER(argv[4]))) return krk_runtimeError(vm.exceptions->typeError, "color() expects three or four integer arguments"); + if (!krk_isInstanceOf(argv[0], YutaniColor)) return krk_runtimeError(vm.exceptions->typeError, "expected color [__init__], not '%s'", krk_typeName(argv[0])); struct YutaniColor * self = (struct YutaniColor*)AS_INSTANCE(argv[0]); if (argc == 5) { self->color = rgba(AS_INTEGER(argv[1]),AS_INTEGER(argv[2]),AS_INTEGER(argv[3]),AS_INTEGER(argv[4])); @@ -852,8 +851,8 @@ static KrkValue _yutani_color_init(int argc, KrkValue argv[]) { return argv[0]; } -static KrkValue _yutani_color_repr(int argc, KrkValue argv[]) { - if (argc != 1 || !krk_isInstanceOf(argv[0], YutaniColor)) return krk_runtimeError(vm.exceptions.typeError, "expected color [__repr__], not '%s'", krk_typeName(argv[0])); +static KrkValue _yutani_color_repr(int argc, KrkValue argv[], int hasKw) { + if (argc != 1 || !krk_isInstanceOf(argv[0], YutaniColor)) return krk_runtimeError(vm.exceptions->typeError, "expected color [__repr__], not '%s'", krk_typeName(argv[0])); struct YutaniColor * self = (struct YutaniColor*)AS_INSTANCE(argv[0]); char tmp[30]; if (_ALP(self->color) != 255) { @@ -864,8 +863,8 @@ static KrkValue _yutani_color_repr(int argc, KrkValue argv[]) { return OBJECT_VAL(krk_copyString(tmp,strlen(tmp))); } -static KrkValue _yutani_color_str(int argc, KrkValue argv[]) { - if (argc != 1 || !krk_isInstanceOf(argv[0], YutaniColor)) return krk_runtimeError(vm.exceptions.typeError, "expected color [__str__], not '%s'", krk_typeName(argv[0])); +static KrkValue _yutani_color_str(int argc, KrkValue argv[], int hasKw) { + if (argc != 1 || !krk_isInstanceOf(argv[0], YutaniColor)) return krk_runtimeError(vm.exceptions->typeError, "expected color [__str__], not '%s'", krk_typeName(argv[0])); struct YutaniColor * self = (struct YutaniColor*)AS_INSTANCE(argv[0]); char tmp[30]; if (_ALP(self->color) != 255) { @@ -878,16 +877,16 @@ static KrkValue _yutani_color_str(int argc, KrkValue argv[]) { #define CHECK_FONT() \ if (argc < 1 || !krk_isInstanceOf(argv[0], YutaniFont)) \ - return krk_runtimeError(vm.exceptions.typeError, "expected Font"); \ + return krk_runtimeError(vm.exceptions->typeError, "expected Font"); \ struct YutaniFont * self = (struct YutaniFont*)AS_INSTANCE(argv[0]) static KrkValue _font_init(int argc, KrkValue argv[], int hasKw) { CHECK_FONT(); if (argc < 2 || !IS_INTEGER(argv[1])) - return krk_runtimeError(vm.exceptions.typeError, "expected int for font type"); + return krk_runtimeError(vm.exceptions->typeError, "expected int for font type"); if (argc < 3 || !IS_INTEGER(argv[2])) - return krk_runtimeError(vm.exceptions.typeError, "expected int for font size"); + return krk_runtimeError(vm.exceptions->typeError, "expected int for font size"); KrkValue fontGamma = FLOATING_VAL(1.7); KrkValue fontStroke = FLOATING_VAL(0.75); @@ -896,9 +895,9 @@ static KrkValue _font_init(int argc, KrkValue argv[], int hasKw) { krk_tableGet(AS_DICT(argv[argc]), OBJECT_VAL(S("gamma")), &fontGamma); krk_tableGet(AS_DICT(argv[argc]), OBJECT_VAL(S("stroke")), &fontStroke); krk_tableGet(AS_DICT(argv[argc]), OBJECT_VAL(S("color")), &fontColor); - if (!IS_FLOATING(fontGamma)) return krk_runtimeError(vm.exceptions.typeError, "expected float for gamma"); - if (!IS_FLOATING(fontStroke)) return krk_runtimeError(vm.exceptions.typeError, "expected float for stroke"); - if (!krk_isInstanceOf(fontColor, YutaniColor)) return krk_runtimeError(vm.exceptions.typeError, "expected color"); + if (!IS_FLOATING(fontGamma)) return krk_runtimeError(vm.exceptions->typeError, "expected float for gamma"); + if (!IS_FLOATING(fontStroke)) return krk_runtimeError(vm.exceptions->typeError, "expected float for stroke"); + if (!krk_isInstanceOf(fontColor, YutaniColor)) return krk_runtimeError(vm.exceptions->typeError, "expected color"); } self->fontType = AS_INTEGER(argv[1]); @@ -910,19 +909,19 @@ static KrkValue _font_init(int argc, KrkValue argv[], int hasKw) { return argv[0]; } -static KrkValue _font_size(int argc, KrkValue argv[]) { +static KrkValue _font_size(int argc, KrkValue argv[], int hasKw) { CHECK_FONT(); return INTEGER_VAL(self->fontSize); } -static KrkValue _font_draw_string(int argc, KrkValue argv[]) { +static KrkValue _font_draw_string(int argc, KrkValue argv[], int hasKw) { CHECK_FONT(); if (argc < 2 || !krk_isInstanceOf(argv[1], GraphicsContext)) - return krk_runtimeError(vm.exceptions.typeError, "expected GraphicsContext"); + return krk_runtimeError(vm.exceptions->typeError, "expected GraphicsContext"); if (argc < 3 || !IS_STRING(argv[2])) - return krk_runtimeError(vm.exceptions.typeError, "expected str"); + return krk_runtimeError(vm.exceptions->typeError, "expected str"); if (argc < 5 || !IS_INTEGER(argv[3]) || !IS_INTEGER(argv[4])) - return krk_runtimeError(vm.exceptions.typeError, "expected int coordinate pair"); + return krk_runtimeError(vm.exceptions->typeError, "expected int coordinate pair"); gfx_context_t * ctx = ((struct GraphicsContext*)AS_INSTANCE(argv[1]))->ctx; const char * str = AS_CSTRING(argv[2]); @@ -932,10 +931,10 @@ static KrkValue _font_draw_string(int argc, KrkValue argv[]) { return INTEGER_VAL(draw_sdf_string_stroke(ctx,x,y,str,self->fontSize,self->fontColor,self->fontType,self->fontGamma,self->fontStroke)); } -static KrkValue _font_width(int argc, KrkValue argv[]) { +static KrkValue _font_width(int argc, KrkValue argv[], int hasKw) { CHECK_FONT(); if (argc < 2 || !IS_STRING(argv[1])) - return krk_runtimeError(vm.exceptions.typeError, "expected str"); + return krk_runtimeError(vm.exceptions->typeError, "expected str"); const char * str = AS_CSTRING(argv[1]); return INTEGER_VAL(draw_sdf_string_width(str, self->fontSize, self->fontType)); @@ -961,11 +960,11 @@ static void _menubar_callback(struct menu_bar * _self) { } } -static KrkValue _MenuBar_init(int argc, KrkValue argv[]) { +static KrkValue _MenuBar_init(int argc, KrkValue argv[], int hasKw) { if (argc < 1 || !krk_isInstanceOf(argv[0], MenuBarClass)) - return krk_runtimeError(vm.exceptions.typeError, "expected MenuBar"); + return krk_runtimeError(vm.exceptions->typeError, "expected MenuBar"); if (argc < 2 || !IS_TUPLE(argv[1])) - return krk_runtimeError(vm.exceptions.typeError, "expected tuple of tuples"); + return krk_runtimeError(vm.exceptions->typeError, "expected tuple of tuples"); struct MenuBarClass * self = (struct MenuBarClass*)AS_INSTANCE(argv[0]); self->menuBar.entries = malloc(sizeof(struct menu_bar_entries) * (AS_TUPLE(argv[1])->values.count + 1)); @@ -974,7 +973,7 @@ static KrkValue _MenuBar_init(int argc, KrkValue argv[]) { AS_TUPLE(AS_TUPLE(argv[1])->values.values[i])->values.count != 2 || !IS_STRING(AS_TUPLE(AS_TUPLE(argv[1])->values.values[i])->values.values[0]) || !IS_STRING(AS_TUPLE(AS_TUPLE(argv[1])->values.values[i])->values.values[1])) { - return krk_runtimeError(vm.exceptions.typeError, "invalid menu bar entry: expected (str,str) but %d is '%s'", + return krk_runtimeError(vm.exceptions->typeError, "invalid menu bar entry: expected (str,str) but %d is '%s'", (int)i, krk_typeName(AS_TUPLE(argv[1])->values.values[i])); } @@ -994,20 +993,20 @@ static KrkValue _MenuBar_init(int argc, KrkValue argv[]) { krk_attachNamedValue(&self->inst.fields, "entries", argv[1]); /* Give ourselves a dict to track the same information */ - KrkValue dict = krk_dict_of(0,NULL); + KrkValue dict = krk_dict_of(0,NULL, 0); krk_attachNamedValue(&self->inst.fields, "set", dict); return argv[0]; } -static KrkValue _MenuBar_place(int argc, KrkValue argv[]) { +static KrkValue _MenuBar_place(int argc, KrkValue argv[], int hasKw) { if (argc < 1 || !krk_isInstanceOf(argv[0], MenuBarClass)) - return krk_runtimeError(vm.exceptions.typeError, "expected MenuBar"); + return krk_runtimeError(vm.exceptions->typeError, "expected MenuBar"); struct MenuBarClass * self = (struct MenuBarClass*)AS_INSTANCE(argv[0]); if (argc < 4 || !IS_INTEGER(argv[1]) || !IS_INTEGER(argv[2]) || !IS_INTEGER(argv[3])) - return krk_runtimeError(vm.exceptions.typeError, "expected int for x, y, width"); + return krk_runtimeError(vm.exceptions->typeError, "expected int for x, y, width"); if (argc < 5 || !krk_isInstanceOf(argv[4],YutaniWindow)) - return krk_runtimeError(vm.exceptions.typeError, "expected Window"); + return krk_runtimeError(vm.exceptions->typeError, "expected Window"); self->menuBar.x = AS_INTEGER(argv[1]); self->menuBar.y = AS_INTEGER(argv[2]); @@ -1016,23 +1015,23 @@ static KrkValue _MenuBar_place(int argc, KrkValue argv[]) { return NONE_VAL(); } -static KrkValue _MenuBar_render(int argc, KrkValue argv[]) { +static KrkValue _MenuBar_render(int argc, KrkValue argv[], int hasKw) { if (argc < 1 || !krk_isInstanceOf(argv[0], MenuBarClass)) - return krk_runtimeError(vm.exceptions.typeError, "expected MenuBar"); + return krk_runtimeError(vm.exceptions->typeError, "expected MenuBar"); struct MenuBarClass * self = (struct MenuBarClass*)AS_INSTANCE(argv[0]); if (argc < 2 || !krk_isInstanceOf(argv[1], GraphicsContext)) - return krk_runtimeError(vm.exceptions.typeError, "expected GraphicsContext"); + return krk_runtimeError(vm.exceptions->typeError, "expected GraphicsContext"); menu_bar_render(&self->menuBar, ((struct GraphicsContext*)AS_INSTANCE(argv[1]))->ctx); return NONE_VAL(); } -static KrkValue _MenuBar_mouse_event(int argc, KrkValue argv[]) { +static KrkValue _MenuBar_mouse_event(int argc, KrkValue argv[], int hasKw) { if (argc < 1 || !krk_isInstanceOf(argv[0], MenuBarClass)) - return krk_runtimeError(vm.exceptions.typeError, "expected MenuBar"); + return krk_runtimeError(vm.exceptions->typeError, "expected MenuBar"); struct MenuBarClass * self = (struct MenuBarClass*)AS_INSTANCE(argv[0]); if (argc < 3 || !krk_isInstanceOf(argv[1], YutaniWindow) || !krk_isInstanceOf(argv[2], Message)) - return krk_runtimeError(vm.exceptions.typeError, "expected Window and Message"); + return krk_runtimeError(vm.exceptions->typeError, "expected Window and Message"); struct MessageClass * msg = ((struct MessageClass*)AS_INSTANCE(argv[2])); struct yutani_msg_window_mouse_event * me = (struct yutani_msg_window_mouse_event*)msg->msg->data; @@ -1042,44 +1041,44 @@ static KrkValue _MenuBar_mouse_event(int argc, KrkValue argv[]) { &self->menuBar, me, me->new_x, me->new_y)); } -static KrkValue _MenuBar_insert(int argc, KrkValue argv[]) { +static KrkValue _MenuBar_insert(int argc, KrkValue argv[], int hasKw) { if (argc < 1 || !krk_isInstanceOf(argv[0], MenuBarClass)) - return krk_runtimeError(vm.exceptions.typeError, "expected MenuBar"); + return krk_runtimeError(vm.exceptions->typeError, "expected MenuBar"); struct MenuBarClass * self = (struct MenuBarClass*)AS_INSTANCE(argv[0]); if (argc < 3 || !IS_STRING(argv[1]) || !krk_isInstanceOf(argv[2], MenuListClass)) - return krk_runtimeError(vm.exceptions.typeError, "expected str and MenuList"); + return krk_runtimeError(vm.exceptions->typeError, "expected str and MenuList"); menu_set_insert(self->menuBar.set, AS_CSTRING(argv[1]), ((struct MenuListClass*)AS_INSTANCE(argv[2]))->menuList); /* Also assign it to our dict */ KrkValue dict = NONE_VAL(); krk_tableGet(&self->inst.fields, OBJECT_VAL(S("set")), &dict); - if (IS_NONE(dict) || !krk_isInstanceOf(dict,vm.baseClasses.dictClass)) - return krk_runtimeError(vm.exceptions.baseException, "Failed to get set entries?"); + if (IS_NONE(dict) || !krk_isInstanceOf(dict,vm.baseClasses->dictClass)) + return krk_runtimeError(vm.exceptions->baseException, "Failed to get set entries?"); krk_tableSet(AS_DICT(dict), argv[1], argv[2]); return NONE_VAL(); } -static KrkValue _MenuList_init(int argc, KrkValue argv[]) { +static KrkValue _MenuList_init(int argc, KrkValue argv[], int hasKw) { if (argc < 1 || !krk_isInstanceOf(argv[0], MenuListClass)) - return krk_runtimeError(vm.exceptions.typeError, "expected MenuList"); + return krk_runtimeError(vm.exceptions->typeError, "expected MenuList"); struct MenuListClass * self = (struct MenuListClass*)AS_INSTANCE(argv[0]); self->menuList = menu_create(); /* Give us a list to put entries in for GC tracking and retrieval by kuroko code */ - KrkValue list = krk_list_of(0,NULL); + KrkValue list = krk_list_of(0,NULL,0); krk_attachNamedValue(&self->inst.fields, "entries", list); return argv[0]; } -static KrkValue _MenuList_insert(int argc, KrkValue argv[]) { +static KrkValue _MenuList_insert(int argc, KrkValue argv[], int hasKw) { if (argc < 1 || !krk_isInstanceOf(argv[0], MenuListClass)) - return krk_runtimeError(vm.exceptions.typeError, "expected MenuList"); + return krk_runtimeError(vm.exceptions->typeError, "expected MenuList"); struct MenuListClass * self = (struct MenuListClass*)AS_INSTANCE(argv[0]); if (argc < 2 || !krk_isInstanceOf(argv[1], MenuEntryClass)) - return krk_runtimeError(vm.exceptions.typeError, "Expected MenuEntry"); + return krk_runtimeError(vm.exceptions->typeError, "Expected MenuEntry"); /* Append to menu */ menu_insert(self->menuList, ((struct MenuEntryClass*)AS_INSTANCE(argv[1]))->menuEntry); @@ -1087,8 +1086,8 @@ static KrkValue _MenuList_insert(int argc, KrkValue argv[]) { /* Append to internal list */ KrkValue list = NONE_VAL(); krk_tableGet(&self->inst.fields, OBJECT_VAL(S("entries")), &list); - if (IS_NONE(list) || !krk_isInstanceOf(list,vm.baseClasses.listClass)) - return krk_runtimeError(vm.exceptions.baseException, "Failed to get entries?"); + if (IS_NONE(list) || !krk_isInstanceOf(list,vm.baseClasses->listClass)) + return krk_runtimeError(vm.exceptions->baseException, "Failed to get entries?"); krk_writeValueArray(AS_LIST(list), argv[1]); return NONE_VAL(); @@ -1104,20 +1103,20 @@ static void _MenuEntry_callback_internal(struct MenuEntry * _self) { static KrkValue _MenuEntry_init(int argc, KrkValue argv[], int hasKw) { if (argc < 1 || !krk_isInstanceOf(argv[0], MenuEntryClass)) - return krk_runtimeError(vm.exceptions.typeError, "expected MenuEntry"); + return krk_runtimeError(vm.exceptions->typeError, "expected MenuEntry"); struct MenuEntryClass * self = (struct MenuEntryClass*)AS_INSTANCE(argv[0]); if (argc < 3 || !IS_STRING(argv[1])) - return krk_runtimeError(vm.exceptions.typeError, "expected title and callback"); + return krk_runtimeError(vm.exceptions->typeError, "expected title and callback"); KrkValue icon = NONE_VAL(), action = NONE_VAL(); if (hasKw) { krk_tableGet(AS_DICT(argv[argc]), OBJECT_VAL(S("icon")), &icon); krk_tableGet(AS_DICT(argv[argc]), OBJECT_VAL(S("action")), &action); if (!IS_NONE(icon) && !IS_STRING(icon)) - return krk_runtimeError(vm.exceptions.typeError, "icon must be str, not '%s'", krk_typeName(icon)); + return krk_runtimeError(vm.exceptions->typeError, "icon must be str, not '%s'", krk_typeName(icon)); if (!IS_NONE(action) && !IS_STRING(action)) - return krk_runtimeError(vm.exceptions.typeError, "action must be str, not '%s'", krk_typeName(action)); + return krk_runtimeError(vm.exceptions->typeError, "action must be str, not '%s'", krk_typeName(action)); } self->menuEntry = menu_create_normal( @@ -1137,21 +1136,21 @@ static KrkValue _MenuEntry_init(int argc, KrkValue argv[], int hasKw) { static KrkValue _MenuEntrySubmenu_init(int argc, KrkValue argv[], int hasKw) { if (argc < 1 || !krk_isInstanceOf(argv[0], MenuEntrySubmenuClass)) - return krk_runtimeError(vm.exceptions.typeError, "expected MenuEntrySubmenu"); + return krk_runtimeError(vm.exceptions->typeError, "expected MenuEntrySubmenu"); struct MenuEntryClass * self = (struct MenuEntryClass*)AS_INSTANCE(argv[0]); if (argc < 2 || !IS_STRING(argv[1])) - return krk_runtimeError(vm.exceptions.typeError, "expected title to be a str"); + return krk_runtimeError(vm.exceptions->typeError, "expected title to be a str"); KrkValue icon = NONE_VAL(), action = NONE_VAL(); if (hasKw) { krk_tableGet(AS_DICT(argv[argc]), OBJECT_VAL(S("icon")), &icon); krk_tableGet(AS_DICT(argv[argc]), OBJECT_VAL(S("action")), &action); if (!IS_NONE(icon) && !IS_STRING(icon)) - return krk_runtimeError(vm.exceptions.typeError, "icon must be str, not '%s'", krk_typeName(icon)); + return krk_runtimeError(vm.exceptions->typeError, "icon must be str, not '%s'", krk_typeName(icon)); if (!IS_NONE(action) && !IS_STRING(action)) - return krk_runtimeError(vm.exceptions.typeError, "action must be str, not '%s'", krk_typeName(action)); + return krk_runtimeError(vm.exceptions->typeError, "action must be str, not '%s'", krk_typeName(action)); } self->menuEntry = menu_create_submenu( @@ -1164,9 +1163,9 @@ static KrkValue _MenuEntrySubmenu_init(int argc, KrkValue argv[], int hasKw) { return argv[0]; } -static KrkValue _MenuEntrySeparator_init(int argc, KrkValue argv[]) { +static KrkValue _MenuEntrySeparator_init(int argc, KrkValue argv[], int hasKw) { if (argc < 1 || !krk_isInstanceOf(argv[0], MenuEntrySeparatorClass)) - return krk_runtimeError(vm.exceptions.typeError, "expected MenuEntrySeparator"); + return krk_runtimeError(vm.exceptions->typeError, "expected MenuEntrySeparator"); struct MenuEntryClass * self = (struct MenuEntryClass*)AS_INSTANCE(argv[0]); self->menuEntry = menu_create_separator(); self->menuEntry->_private = self; @@ -1174,7 +1173,7 @@ static KrkValue _MenuEntrySeparator_init(int argc, KrkValue argv[]) { } KrkValue krk_module_onload__yutani(void) { - module = krk_newInstance(vm.moduleClass); + module = krk_newInstance(vm.baseClasses->moduleClass); /* Store it on the stack for now so we can do stuff that may trip GC * and not lose it to garbage colletion... */ krk_push(OBJECT_VAL(module)); diff --git a/util/auto-dep.py b/util/auto-dep.py index 71588e0e..d0477679 100755 --- a/util/auto-dep.py +++ b/util/auto-dep.py @@ -179,7 +179,7 @@ if __name__ == "__main__": elif command == "--makekurokomod": libname = os.path.basename(filename).replace(".c","").replace("module_","") _libs = [x for x in c.libs if not x.startswith('-ltoaru_') or x.replace("-ltoaru_","") != libname] - print("base/usr/local/lib/kuroko/{lib}.so: {source} {headers} util/auto-dep.py | {libraryfiles} $(LC)\n\t$(CC) $(CFLAGS) -DDEBUG {includes} -shared -fPIC -o $@ $< {libraries}".format( + print("base/lib/kuroko/{lib}.so: {source} {headers} util/auto-dep.py | {libraryfiles} $(LC)\n\t$(CC) $(CFLAGS) -DDEBUG {includes} -shared -fPIC -o $@ $< {libraries}".format( lib=libname, source=filename, headers=" ".join([toheader(x) for x in c.libs]),