kuroko-lang/kuroko
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Replace KRK_METHOD, KRK_FUNC with nicer macros

Browse Source
This commit is contained in:
K. Lange 2022-07-05 22:37:54 +09:00
parent 25d5f88454
commit afc522a341
29 changed files with 957 additions and 877 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

210
src/builtins.c
View File

@ -87,15 +87,15 @@ KrkValue krk_dirObject(int argc, const KrkValue argv[], int hasKw) {
#define CURRENT_CTYPE KrkValue
#define CURRENT_NAME self
KRK_METHOD(object,__dir__,{
KRK_Method(object,__dir__) {
return krk_dirObject(argc,argv,hasKw);
})
}
KRK_METHOD(object,__class__,{
KRK_Method(object,__class__) {
return OBJECT_VAL(krk_getType(self));
})
}
KRK_METHOD(object,__hash__,{
KRK_Method(object,__hash__) {
if (!IS_OBJECT(self)) {
uint32_t hashed;
if (krk_hashValue(self, &hashed)) return NONE_VAL();
@ -107,12 +107,12 @@ KRK_METHOD(object,__hash__,{
obj->flags |= KRK_OBJ_FLAGS_VALID_HASH;
}
return INTEGER_VAL(obj->hash);
})
}
KRK_METHOD(object,__eq__,{
KRK_Method(object,__eq__) {
METHOD_TAKES_EXACTLY(1);
return BOOLEAN_VAL(argc == 2 && IS_OBJECT(argv[0]) && IS_OBJECT(argv[1]) && AS_OBJECT(argv[0]) == AS_OBJECT(argv[1]));
})
}
/**
* object.__str__() / object.__repr__()
@ -127,7 +127,7 @@ KRK_METHOD(object,__eq__,{
* all types should have a string representation available through
* those methods.
*/
KRK_METHOD(object,__str__,{
KRK_Method(object,__str__) {
KrkClass * type = krk_getType(self);
KrkValue module = NONE_VAL();
@ -153,12 +153,12 @@ KRK_METHOD(object,__str__,{
KrkValue out = OBJECT_VAL(krk_copyString(tmp, len));
free(tmp);
return out;
})
}
#undef CURRENT_CTYPE
#undef CURRENT_NAME
KRK_FUNC(len,{
KRK_Function(len) {
FUNCTION_TAKES_EXACTLY(1);
/* Shortcuts */
if (IS_STRING(argv[0])) return INTEGER_VAL(AS_STRING(argv[0])->codesLength);
@ -169,9 +169,9 @@ KRK_FUNC(len,{
krk_push(argv[0]);
return krk_callDirect(type->_len, 1);
})
}
KRK_FUNC(dir,{
KRK_Function(dir) {
FUNCTION_TAKES_AT_MOST(1);
if (argc) {
KrkClass * type = krk_getType(argv[0]);
@ -202,15 +202,15 @@ KRK_FUNC(dir,{
FUNC_NAME(list,sort)(1,(KrkValue[]){krk_peek(0)},0);
return krk_pop(); /* Return the list */
}
})
}
KRK_FUNC(repr,{
KRK_Function(repr) {
FUNCTION_TAKES_EXACTLY(1);
/* Everything should have a __repr__ */
KrkClass * type = krk_getType(argv[0]);
krk_push(argv[0]);
return krk_callDirect(type->_reprer, 1);
})
}
#define trySlowMethod(name) do { \
KrkClass * type = krk_getType(argv[0]); \
@ -225,35 +225,35 @@ KRK_FUNC(repr,{
} \
} while (0)
KRK_FUNC(ord,{
KRK_Function(ord) {
FUNCTION_TAKES_EXACTLY(1);
trySlowMethod(vm.specialMethodNames[METHOD_ORD]);
return TYPE_ERROR(string of length 1,argv[0]);
})
}
KRK_FUNC(chr,{
KRK_Function(chr) {
FUNCTION_TAKES_EXACTLY(1);
trySlowMethod(vm.specialMethodNames[METHOD_CHR]);
return TYPE_ERROR(int,argv[0]);
})
}
KRK_FUNC(hex,{
KRK_Function(hex) {
FUNCTION_TAKES_EXACTLY(1);
trySlowMethod(OBJECT_VAL(S("__hex__")));
return TYPE_ERROR(int,argv[0]);
})
}
KRK_FUNC(oct,{
KRK_Function(oct) {
FUNCTION_TAKES_EXACTLY(1);
trySlowMethod(OBJECT_VAL(S("__oct__")));
return TYPE_ERROR(int,argv[0]);
})
}
KRK_FUNC(bin,{
KRK_Function(bin) {
FUNCTION_TAKES_EXACTLY(1);
trySlowMethod(OBJECT_VAL(S("__bin__")));
return TYPE_ERROR(int,argv[0]);
})
}
#define KRK_STRING_FAST(string,offset) (uint32_t)\
((string->obj.flags & KRK_OBJ_FLAGS_STRING_MASK) <= (KRK_OBJ_FLAGS_STRING_UCS1) ? ((uint8_t*)string->codes)[offset] : \
@ -341,12 +341,12 @@ static int _any_callback(void * context, const KrkValue * values, size_t count)
return 0;
}
KRK_FUNC(any,{
KRK_Function(any) {
FUNCTION_TAKES_EXACTLY(1);
struct SimpleContext context = { BOOLEAN_VAL(0) };
krk_unpackIterable(argv[0], &context, _any_callback);
return context.base;
})
}
static int _all_callback(void * context, const KrkValue * values, size_t count) {
struct SimpleContext * _context = context;
@ -359,12 +359,12 @@ static int _all_callback(void * context, const KrkValue * values, size_t count)
return 0;
}
KRK_FUNC(all,{
KRK_Function(all) {
FUNCTION_TAKES_EXACTLY(1);
struct SimpleContext context = { BOOLEAN_VAL(1) };
krk_unpackIterable(argv[0], &context, _all_callback);
return context.base;
})
}
#define CURRENT_CTYPE KrkInstance *
#define CURRENT_NAME self
@ -372,7 +372,7 @@ KRK_FUNC(all,{
#define IS_map(o) (krk_isInstanceOf(o,map))
#define AS_map(o) (AS_INSTANCE(o))
static KrkClass * map;
KRK_METHOD(map,__init__,{
KRK_Method(map,__init__) {
METHOD_TAKES_AT_LEAST(2);
/* Attach the function to it */
@ -399,14 +399,14 @@ KRK_METHOD(map,__init__,{
}
return argv[0];
})
}
KRK_METHOD(map,__iter__,{
KRK_Method(map,__iter__) {
METHOD_TAKES_NONE();
return OBJECT_VAL(self);
})
}
KRK_METHOD(map,__call__,{
KRK_Method(map,__call__) {
METHOD_TAKES_NONE();
size_t stackOffset = krk_currentThread.stackTop - krk_currentThread.stack;
@ -438,12 +438,12 @@ KRK_METHOD(map,__call__,{
KrkValue val = krk_callStack(AS_TUPLE(iterators)->values.count);
krk_currentThread.stackTop = krk_currentThread.stack + stackOffset;
return val;
})
}
#define IS_zip(o) (krk_isInstanceOf(o,zip))
#define AS_zip(o) (AS_INSTANCE(o))
static KrkClass * zip;
KRK_METHOD(zip,__init__,{
KRK_Method(zip,__init__) {
if (hasKw) return krk_runtimeError(vm.exceptions->typeError, "%s() takes no keyword arguments", "zip");
KrkTuple * iters = krk_newTuple(argc - 1);
@ -464,14 +464,14 @@ KRK_METHOD(zip,__init__,{
}
return argv[0];
})
}
KRK_METHOD(zip,__iter__,{
KRK_Method(zip,__iter__) {
METHOD_TAKES_NONE();
return OBJECT_VAL(self);
})
}
KRK_METHOD(zip,__call__,{
KRK_Method(zip,__call__) {
METHOD_TAKES_NONE();
/* Get members */
@ -495,12 +495,12 @@ KRK_METHOD(zip,__call__,{
/* Return tuple */
return krk_pop();
})
}
#define IS_filter(o) (krk_isInstanceOf(o,filter))
#define AS_filter(o) (AS_INSTANCE(o))
static KrkClass * filter;
KRK_METHOD(filter,__init__,{
KRK_Method(filter,__init__) {
METHOD_TAKES_EXACTLY(2);
krk_attachNamedValue(&self->fields, "_function", argv[1]);
KrkClass * type = krk_getType(argv[2]);
@ -512,14 +512,14 @@ KRK_METHOD(filter,__init__,{
if (krk_currentThread.flags & KRK_THREAD_HAS_EXCEPTION) return NONE_VAL();
krk_attachNamedValue(&self->fields, "_iterator", asIter);
return argv[0];
})
}
KRK_METHOD(filter,__iter__,{
KRK_Method(filter,__iter__) {
METHOD_TAKES_NONE();
return OBJECT_VAL(self);
})
}
KRK_METHOD(filter,__call__,{
KRK_Method(filter,__call__) {
METHOD_TAKES_NONE();
size_t stackOffset = krk_currentThread.stackTop - krk_currentThread.stack;
KrkValue function = NONE_VAL();
@ -557,12 +557,12 @@ KRK_METHOD(filter,__call__,{
krk_currentThread.stackTop = krk_currentThread.stack + stackOffset;
return out;
}
})
}
#define IS_enumerate(o) (krk_isInstanceOf(o,enumerate))
#define AS_enumerate(o) (AS_INSTANCE(o))
static KrkClass * enumerate;
KRK_METHOD(enumerate,__init__,{
KRK_Method(enumerate,__init__) {
METHOD_TAKES_EXACTLY(1);
KrkValue start = INTEGER_VAL(0);
if (hasKw) krk_tableGet(AS_DICT(argv[argc]), OBJECT_VAL(S("start")), &start);
@ -580,15 +580,15 @@ KRK_METHOD(enumerate,__init__,{
krk_attachNamedValue(&self->fields, "_iterator", asIter);
return argv[0];
})
}
KRK_METHOD(enumerate,__iter__,{
KRK_Method(enumerate,__iter__) {
METHOD_TAKES_NONE();
return OBJECT_VAL(self);
})
}
extern KrkValue krk_operator_add (KrkValue a, KrkValue b);
KRK_METHOD(enumerate,__call__,{
KRK_Method(enumerate,__call__) {
METHOD_TAKES_NONE();
size_t stackOffset = krk_currentThread.stackTop - krk_currentThread.stack;
KrkValue counter = NONE_VAL();
@ -624,7 +624,7 @@ KRK_METHOD(enumerate,__call__,{
KrkValue out = krk_pop();
krk_currentThread.stackTop = krk_currentThread.stack + stackOffset;
return out;
})
}
static int _sum_callback(void * context, const KrkValue * values, size_t count) {
struct SimpleContext * _context = context;
@ -635,7 +635,7 @@ static int _sum_callback(void * context, const KrkValue * values, size_t count)
return 0;
}
KRK_FUNC(sum,{
KRK_Function(sum) {
FUNCTION_TAKES_AT_LEAST(1);
KrkValue base = INTEGER_VAL(0);
if (hasKw) {
@ -644,7 +644,7 @@ KRK_FUNC(sum,{
struct SimpleContext context = { base };
if (krk_unpackIterable(argv[0], &context, _sum_callback)) return NONE_VAL();
return context.base;
})
}
static int _min_callback(void * context, const KrkValue * values, size_t count) {
struct SimpleContext * _context = context;
@ -659,7 +659,7 @@ static int _min_callback(void * context, const KrkValue * values, size_t count)
return 0;
}
KRK_FUNC(min,{
KRK_Function(min) {
FUNCTION_TAKES_AT_LEAST(1);
struct SimpleContext context = { KWARGS_VAL(0) };
if (argc > 1) {
@ -669,7 +669,7 @@ KRK_FUNC(min,{
}
if (IS_KWARGS(context.base)) return krk_runtimeError(vm.exceptions->valueError, "empty argument to %s()", "min");
return context.base;
})
}
static int _max_callback(void * context, const KrkValue * values, size_t count) {
struct SimpleContext * _context = context;
@ -684,7 +684,7 @@ static int _max_callback(void * context, const KrkValue * values, size_t count)
return 0;
}
KRK_FUNC(max,{
KRK_Function(max) {
FUNCTION_TAKES_AT_LEAST(1);
struct SimpleContext context = { KWARGS_VAL(0) };
if (argc > 1) {
@ -694,9 +694,9 @@ KRK_FUNC(max,{
}
if (IS_KWARGS(context.base)) return krk_runtimeError(vm.exceptions->valueError, "empty argument to %s()", "max");
return context.base;
})
}
KRK_FUNC(print,{
KRK_Function(print) {
KrkValue sepVal;
KrkValue endVal;
char * sep = " "; size_t sepLen = 1;
@ -734,14 +734,16 @@ KRK_FUNC(print,{
fputc(thingToPrint[j], stdout);
}
}
})
return NONE_VAL();
}
/**
* globals()
*
* Returns a dict of names -> values for all the globals.
*/
KRK_FUNC(globals,{
KRK_Function(globals) {
FUNCTION_TAKES_NONE();
/* Make a new empty dict */
KrkValue dict = krk_dict_of(0, NULL, 0);
@ -751,14 +753,14 @@ KRK_FUNC(globals,{
krk_pop();
return dict;
})
}
/**
* locals()
*
* This is a bit trickier. Local names are... complicated. But we can do this!
*/
KRK_FUNC(locals,{
KRK_Function(locals) {
FUNCTION_TAKES_AT_MOST(1);
KrkValue dict = krk_dict_of(0, NULL, 0);
krk_push(dict);
@ -815,9 +817,9 @@ KRK_FUNC(locals,{
}
return krk_pop();
})
}
KRK_FUNC(isinstance,{
KRK_Function(isinstance) {
FUNCTION_TAKES_EXACTLY(2);
if (IS_CLASS(argv[1])) {
return BOOLEAN_VAL(krk_isInstanceOf(argv[0], AS_CLASS(argv[1])));
@ -831,7 +833,7 @@ KRK_FUNC(isinstance,{
} else {
return TYPE_ERROR(class or tuple,argv[1]);
}
})
}
static int _isSubClass(KrkClass * cls, KrkClass * base) {
while (cls) {
@ -841,7 +843,7 @@ static int _isSubClass(KrkClass * cls, KrkClass * base) {
return 0;
}
KRK_FUNC(issubclass,{
KRK_Function(issubclass) {
FUNCTION_TAKES_EXACTLY(2);
CHECK_ARG(0,class,KrkClass*,cls);
if (IS_CLASS(argv[1])) {
@ -856,12 +858,12 @@ KRK_FUNC(issubclass,{
} else {
return TYPE_ERROR(class or tuple,argv[1]);
}
})
}
#define IS_module(o) (IS_INSTANCE(o))
#define AS_module(o) (AS_INSTANCE(o))
KRK_METHOD(module,__repr__,{
KRK_Method(module,__repr__) {
KrkValue name = NONE_VAL();
krk_tableGet(&self->fields, vm.specialMethodNames[METHOD_NAME], &name);
@ -884,9 +886,9 @@ KRK_METHOD(module,__repr__,{
KrkValue out = OBJECT_VAL(krk_copyString(tmp, len));
free(tmp);
return out;
})
}
KRK_FUNC(getattr,{
KRK_Function(getattr) {
FUNCTION_TAKES_AT_LEAST(2);
KrkValue object = argv[0];
CHECK_ARG(1,str,KrkString*,property);
@ -895,31 +897,31 @@ KRK_FUNC(getattr,{
} else {
return krk_valueGetAttribute(object, property->chars);
}
})
}
KRK_FUNC(setattr,{
KRK_Function(setattr) {
FUNCTION_TAKES_EXACTLY(3);
KrkValue object = argv[0];
CHECK_ARG(1,str,KrkString*,property);
KrkValue value = argv[2];
return krk_valueSetAttribute(object, property->chars, value);
})
}
KRK_FUNC(hasattr,{
KRK_Function(hasattr) {
FUNCTION_TAKES_AT_LEAST(2);
KrkValue object = argv[0];
CHECK_ARG(1,str,KrkString*,property);
return BOOLEAN_VAL(!IS_KWARGS(krk_valueGetAttribute_default(object, property->chars, KWARGS_VAL(0))));
})
}
KRK_FUNC(delattr,{
KRK_Function(delattr) {
FUNCTION_TAKES_AT_LEAST(2);
KrkValue object = argv[0];
CHECK_ARG(1,str,KrkString*,property);
return krk_valueDelAttribute(object, property->chars);
})
}
#define IS_Helper(o) (krk_isInstanceOf(o, Helper))
@ -927,11 +929,11 @@ KRK_FUNC(delattr,{
#define IS_LicenseReader(o) (krk_isInstanceOf(o, LicenseReader))
#define AS_LicenseReader(o) (AS_INSTANCE(o))
KRK_METHOD(Helper,__repr__,{
KRK_Method(Helper,__repr__) {
return OBJECT_VAL(S("Type help() for more help, or help(obj) to describe an object."));
})
}
KRK_METHOD(Helper,__call__,{
KRK_Method(Helper,__call__) {
METHOD_TAKES_AT_MOST(1);
if (!krk_doRecursiveModuleLoad(S("help"))) return NONE_VAL();
KrkValue helpModule = krk_pop();
@ -950,13 +952,13 @@ KRK_METHOD(Helper,__call__,{
}
return krk_runtimeError(vm.exceptions->typeError, "unexpected error");
})
}
KRK_METHOD(LicenseReader,__repr__,{
KRK_Method(LicenseReader,__repr__) {
return OBJECT_VAL(S("Copyright 2020-2022 K. Lange <klange@toaruos.org>. Type `license()` for more information."));
})
}
KRK_METHOD(LicenseReader,__call__,{
KRK_Method(LicenseReader,__call__) {
METHOD_TAKES_NONE();
if (!krk_doRecursiveModuleLoad(S("help"))) return NONE_VAL();
KrkValue helpModule = krk_pop();
@ -970,11 +972,11 @@ KRK_METHOD(LicenseReader,__call__,{
}
return krk_runtimeError(vm.exceptions->typeError, "unexpected error");
})
}
#define IS_property(o) (krk_isInstanceOf(o,property))
#define AS_property(o) (AS_INSTANCE(o))
KRK_METHOD(property,__init__,{
KRK_Method(property,__init__) {
METHOD_TAKES_AT_LEAST(1);
METHOD_TAKES_AT_MOST(2); /* TODO fdel */
krk_attachNamedValue(&self->fields, "fget", argv[1]);
@ -1001,15 +1003,15 @@ KRK_METHOD(property,__init__,{
krk_attachNamedValue(&self->fields, "fset", argv[2]);
return argv[0];
})
}
KRK_METHOD(property,setter,{
KRK_Method(property,setter) {
METHOD_TAKES_EXACTLY(1);
krk_attachNamedValue(&self->fields, "fset", argv[1]);
return argv[0]; /* Return the original property */
})
}
KRK_METHOD(property,__get__,{
KRK_Method(property,__get__) {
METHOD_TAKES_EXACTLY(1); /* the owner */
KrkValue fget;
@ -1019,9 +1021,9 @@ KRK_METHOD(property,__get__,{
krk_push(fget);
krk_push(argv[1]);
return krk_callStack(1);
})
}
KRK_METHOD(property,__set__,{
KRK_Method(property,__set__) {
METHOD_TAKES_EXACTLY(2); /* the owner and the value */
KrkValue fset;
@ -1041,28 +1043,28 @@ KRK_METHOD(property,__set__,{
}
return krk_runtimeError(vm.exceptions->attributeError, "attribute can not be set");
})
}
KRK_FUNC(id,{
KRK_Function(id) {
FUNCTION_TAKES_EXACTLY(1);
if (!IS_OBJECT(argv[0])) return krk_runtimeError(vm.exceptions->typeError, "'%s' has no identity", krk_typeName(argv[0]));
return INTEGER_VAL((size_t)AS_OBJECT(argv[0]));
})
}
KRK_FUNC(hash,{
KRK_Function(hash) {
FUNCTION_TAKES_EXACTLY(1);
uint32_t hashed;
if (krk_hashValue(argv[0], &hashed)) return NONE_VAL();
return INTEGER_VAL(hashed);
})
}
KRK_FUNC(next,{
KRK_Function(next) {
FUNCTION_TAKES_EXACTLY(1);
krk_push(argv[0]);
return krk_callStack(0);
})
}
KRK_FUNC(abs,{
KRK_Function(abs) {
FUNCTION_TAKES_EXACTLY(1);
if (IS_INTEGER(argv[0])) {
krk_integer_type i = AS_INTEGER(argv[0]);
@ -1075,7 +1077,7 @@ KRK_FUNC(abs,{
return krk_runtimeError(vm.exceptions->typeError, "bad operand type for 'abs()': '%s'",
krk_typeName(argv[0]));
}
})
}
static void module_sweep(KrkInstance * inst) {
#ifndef STATIC_ONLY

31
src/debug.c
View File

@ -341,11 +341,12 @@ int krk_debug_enableBreakpoint(int breakIndex) {
breakpoints[breakIndex].inFunction->chunk.code[breakpoints[breakIndex].offset] = OP_BREAKPOINT;
return 0;
}
KRK_FUNC(enablebreakpoint,{
KRK_Function(enablebreakpoint) {
CHECK_ARG(0,int,krk_integer_type,breakIndex);
if (krk_debug_enableBreakpoint(breakIndex))
return krk_runtimeError(vm.exceptions->indexError, "invalid breakpoint id");
})
return NONE_VAL();
}
int krk_debug_disableBreakpoint(int breakIndex) {
if (breakIndex < 0 || breakIndex >= breakpointsCount || breakpoints[breakIndex].inFunction == NULL)
@ -357,11 +358,12 @@ int krk_debug_disableBreakpoint(int breakIndex) {
}
return 0;
}
KRK_FUNC(disablebreakpoint,{
KRK_Function(disablebreakpoint) {
CHECK_ARG(0,int,krk_integer_type,breakIndex);
if (krk_debug_disableBreakpoint(breakIndex))
return krk_runtimeError(vm.exceptions->indexError, "invalid breakpoint id");
})
return NONE_VAL();
}
int krk_debug_removeBreakpoint(int breakIndex) {
if (breakIndex < 0 || breakIndex >= breakpointsCount || breakpoints[breakIndex].inFunction == NULL)
@ -373,13 +375,14 @@ int krk_debug_removeBreakpoint(int breakIndex) {
}
return 0;
}
KRK_FUNC(delbreakpoint,{
KRK_Function(delbreakpoint) {
CHECK_ARG(0,int,krk_integer_type,breakIndex);
if (krk_debug_removeBreakpoint(breakIndex))
return krk_runtimeError(vm.exceptions->indexError, "invalid breakpoint id");
})
return NONE_VAL();
}
KRK_FUNC(addbreakpoint,{
KRK_Function(addbreakpoint) {
FUNCTION_TAKES_EXACTLY(2);
CHECK_ARG(1,int,krk_integer_type,lineNo);
@ -425,7 +428,7 @@ KRK_FUNC(addbreakpoint,{
return krk_runtimeError(vm.exceptions->baseException, "Could not add breakpoint.");
return INTEGER_VAL(result);
})
}
/*
* Begin debugger utility functions.
@ -566,7 +569,7 @@ int krk_debugBreakpointHandler(void) {
/**
* dis.dis(object)
*/
KRK_FUNC(dis,{
KRK_Function(dis) {
FUNCTION_TAKES_EXACTLY(1);
if (IS_CLOSURE(argv[0])) {
@ -599,9 +602,9 @@ KRK_FUNC(dis,{
}
return NONE_VAL();
})
}
KRK_FUNC(build,{
KRK_Function(build) {
FUNCTION_TAKES_AT_LEAST(1);
FUNCTION_TAKES_AT_MOST(2);
CHECK_ARG(0,str,KrkString*,code);
@ -620,7 +623,7 @@ KRK_FUNC(build,{
krk_pop();
if (c) return OBJECT_VAL(c);
else return NONE_VAL();
})
}
#define SIMPLE(opc) case opc: size = 1; break;
#define CONSTANT(opc,more) case opc: { constant = chunk->code[offset + 1]; size = 2; more; break; } \
@ -700,11 +703,11 @@ static KrkValue _examineInternal(KrkCodeObject* func) {
return krk_pop();
}
KRK_FUNC(examine,{
KRK_Function(examine) {
FUNCTION_TAKES_EXACTLY(1);
CHECK_ARG(0,codeobject,KrkCodeObject*,func);
return _examineInternal(func);
})
}
#undef SIMPLE
#undef OPERANDB

21
src/exceptions.c
View File

@ -36,14 +36,14 @@
*
* @param arg Optional string to attach to the exception object.
*/
KRK_METHOD(Exception,__init__,{
KRK_Method(Exception,__init__) {
if (argc > 1) {
krk_attachNamedValue(&self->fields, "arg", argv[1]);
}
krk_attachNamedValue(&self->fields, "__cause__", NONE_VAL());
krk_attachNamedValue(&self->fields, "__context__", NONE_VAL());
return argv[0];
})
}
/**
* @brief Create a string representation of an Exception.
@ -52,7 +52,7 @@ KRK_METHOD(Exception,__init__,{
*
* Generates a string representation of the form @c "Exception(arg)" .
*/
KRK_METHOD(Exception,__repr__,{
KRK_Method(Exception,__repr__) {
KrkValue arg;
struct StringBuilder sb = {0};
@ -69,7 +69,7 @@ KRK_METHOD(Exception,__repr__,{
pushStringBuilder(&sb, ')');
return finishStringBuilder(&sb);
})
}
/**
* @brief Obtain a descriptive string from an exception.
@ -79,7 +79,7 @@ KRK_METHOD(Exception,__repr__,{
* For most exceptions, this is the 'arg' value attached at initialization
* and is printed during a traceback after the name of the exception type.
*/
KRK_METHOD(Exception,__str__,{
KRK_Method(Exception,__str__) {
KrkValue arg;
if (!krk_tableGet(&self->fields, OBJECT_VAL(S("arg")), &arg) || IS_NONE(arg)) {
return OBJECT_VAL(S(""));
@ -93,11 +93,10 @@ KRK_METHOD(Exception,__str__,{
} else {
return arg;
}
})
}
KRK_METHOD(KeyError,__str__,{
KRK_Method(KeyError,__str__) {
if (!IS_INSTANCE(argv[0])) return NONE_VAL(); /* uh oh */
KrkInstance * self = AS_INSTANCE(argv[0]);
KrkValue arg;
if (krk_tableGet(&self->fields, OBJECT_VAL(S("arg")), &arg)) {
KrkClass * type = krk_getType(arg);
@ -107,7 +106,7 @@ KRK_METHOD(KeyError,__str__,{
}
}
return FUNC_NAME(Exception,__str__)(argc,argv,hasKw);
})
}
/**
* @brief Generate printable text for a syntax error.
@ -120,7 +119,7 @@ KRK_METHOD(KeyError,__str__,{
* {str(Exception)} for syntax errors and they handle the rest. This is a bit
* of a kludge, but it works for now.
*/
KRK_METHOD(SyntaxError,__str__,{
KRK_Method(SyntaxError,__str__) {
/* .arg */
KrkValue file, line, lineno, colno, arg, func, width;
if (!krk_tableGet(&self->fields, OBJECT_VAL(S("file")), &file) || !IS_STRING(file)) goto _badSyntaxError;
@ -169,7 +168,7 @@ KRK_METHOD(SyntaxError,__str__,{
_badSyntaxError:
return OBJECT_VAL(S("SyntaxError: invalid syntax"));
})
}
/**

91
src/fileio.c
View File

@ -49,7 +49,7 @@ struct Directory {
#define CURRENT_CTYPE struct File *
#define CURRENT_NAME self
KRK_FUNC(open,{
KRK_Function(open) {
FUNCTION_TAKES_AT_LEAST(1);
FUNCTION_TAKES_AT_MOST(2);
CHECK_ARG(0,str,KrkString*,filename);
@ -93,11 +93,11 @@ KRK_FUNC(open,{
krk_pop();
krk_pop();
return OBJECT_VAL(fileObject);
})
}
#define BLOCK_SIZE 1024
KRK_METHOD(File,__str__,{
KRK_Method(File,__str__) {
METHOD_TAKES_NONE();
KrkValue filename;
KrkValue modestr;
@ -109,9 +109,9 @@ KRK_METHOD(File,__str__,{
KrkString * out = krk_copyString(tmp, len);
free(tmp);
return OBJECT_VAL(out);
})
}
KRK_METHOD(File,readline,{
KRK_Method(File,readline) {
METHOD_TAKES_NONE();
FILE * file = self->filePtr;
@ -152,9 +152,9 @@ _finish_line: (void)0;
KrkString * out = krk_copyString(buffer,sizeRead);
free(buffer);
return OBJECT_VAL(out);
})
}
KRK_METHOD(File,readlines,{
KRK_Method(File,readlines) {
METHOD_TAKES_NONE();
KrkValue myList = krk_list_of(0,NULL,0);
krk_push(myList);
@ -171,9 +171,9 @@ KRK_METHOD(File,readlines,{
krk_pop(); /* myList */
return myList;
})
}
KRK_METHOD(File,read,{
KRK_Method(File,read) {
METHOD_TAKES_AT_MOST(1);
krk_integer_type sizeToRead = -1;
@ -225,9 +225,9 @@ KRK_METHOD(File,read,{
KrkString * out = krk_copyString(buffer,sizeRead);
free(buffer);
return OBJECT_VAL(out);
})
}
KRK_METHOD(File,write,{
KRK_Method(File,write) {
METHOD_TAKES_EXACTLY(1);
if (!IS_STRING(argv[1])) return TYPE_ERROR(str,argv[1]);
/* Find the file ptr reference */
@ -238,29 +238,33 @@ KRK_METHOD(File,write,{
}
return INTEGER_VAL(fwrite(AS_CSTRING(argv[1]), 1, AS_STRING(argv[1])->length, file));
})
}
KRK_METHOD(File,close,{
KRK_Method(File,close) {
METHOD_TAKES_NONE();
FILE * file = self->filePtr;
if (file) fclose(file);
self->filePtr = NULL;
})
return NONE_VAL();
}
KRK_METHOD(File,flush,{
KRK_Method(File,flush) {
METHOD_TAKES_NONE();
FILE * file = self->filePtr;
if (file) fflush(file);
})
return NONE_VAL();
}
KRK_METHOD(File,__init__,{
KRK_Method(File,__init__) {
return krk_runtimeError(vm.exceptions->typeError, "File objects can not be instantiated; use fileio.open() to obtain File objects.");
})
}
KRK_METHOD(File,__enter__,{})
KRK_METHOD(File,__exit__,{
KRK_Method(File,__enter__) {
return NONE_VAL();
}
KRK_Method(File,__exit__) {
return FUNC_NAME(File,close)(1,argv,0);
})
}
static void makeFileInstance(KrkInstance * module, const char name[], FILE * file) {
KrkInstance * fileObject = krk_newInstance(File);
@ -278,7 +282,7 @@ static void makeFileInstance(KrkInstance * module, const char name[], FILE * fil
krk_pop(); /* fileObject */
}
KRK_METHOD(BinaryFile,readline,{
KRK_Method(BinaryFile,readline) {
METHOD_TAKES_NONE();
FILE * file = self->filePtr;
@ -319,9 +323,9 @@ _finish_line: (void)0;
KrkBytes * out = krk_newBytes(sizeRead, (unsigned char*)buffer);
free(buffer);
return OBJECT_VAL(out);
})
}
KRK_METHOD(BinaryFile,readlines,{
KRK_Method(BinaryFile,readlines) {
METHOD_TAKES_NONE();
KrkValue myList = krk_list_of(0,NULL,0);
krk_push(myList);
@ -338,9 +342,9 @@ KRK_METHOD(BinaryFile,readlines,{
krk_pop(); /* myList */
return myList;
})
}
KRK_METHOD(BinaryFile,read,{
KRK_Method(BinaryFile,read) {
METHOD_TAKES_AT_MOST(1);
krk_integer_type sizeToRead = -1;
@ -393,9 +397,9 @@ KRK_METHOD(BinaryFile,read,{
KrkBytes * out = krk_newBytes(sizeRead, (unsigned char*)buffer);
free(buffer);
return OBJECT_VAL(out);
})
}
KRK_METHOD(BinaryFile,write,{
KRK_Method(BinaryFile,write) {
METHOD_TAKES_EXACTLY(1);
if (!IS_BYTES(argv[1])) return TYPE_ERROR(bytes,argv[1]);
/* Find the file ptr reference */
@ -406,7 +410,7 @@ KRK_METHOD(BinaryFile,write,{
}
return INTEGER_VAL(fwrite(AS_BYTES(argv[1])->bytes, 1, AS_BYTES(argv[1])->length, file));
})
}
#undef CURRENT_CTYPE
@ -426,7 +430,7 @@ static void _dir_sweep(KrkInstance * self) {
}
}
KRK_FUNC(opendir,{
KRK_Function(opendir) {
FUNCTION_TAKES_EXACTLY(1);
CHECK_ARG(0,str,KrkString*,path);
@ -440,11 +444,11 @@ KRK_FUNC(opendir,{
dirObj->dirPtr = dir;
return krk_pop();
})
}
#define CURRENT_CTYPE struct Directory *
KRK_METHOD(Directory,__call__,{
KRK_Method(Directory,__call__) {
METHOD_TAKES_NONE();
if (!self->dirPtr) return argv[0];
struct dirent * entry = readdir(self->dirPtr);
@ -457,22 +461,23 @@ KRK_METHOD(Directory,__call__,{
krk_attachNamedValue(AS_DICT(outDict), "inode", INTEGER_VAL(entry->d_ino));
return krk_pop();
})
}
KRK_METHOD(Directory,__iter__,{
KRK_Method(Directory,__iter__) {
METHOD_TAKES_NONE();
return argv[0];
})
}
KRK_METHOD(Directory,close,{
KRK_Method(Directory,close) {
METHOD_TAKES_NONE();
if (self->dirPtr) {
closedir(self->dirPtr);
self->dirPtr = NULL;
}
})
return NONE_VAL();
}
KRK_METHOD(Directory,__repr__,{
KRK_Method(Directory,__repr__) {
METHOD_TAKES_NONE();
KrkValue path;
if (!krk_tableGet(&self->inst.fields, OBJECT_VAL(S("path")), &path) || !IS_STRING(path))
@ -484,12 +489,14 @@ KRK_METHOD(Directory,__repr__,{
KrkString * out = krk_copyString(tmp, len);
free(tmp);
return OBJECT_VAL(out);
})
}
KRK_METHOD(Directory,__enter__,{})
KRK_METHOD(Directory,__exit__,{
KRK_Method(Directory,__enter__) {
return NONE_VAL();
}
KRK_Method(Directory,__exit__) {
return FUNC_NAME(Directory,close)(1,argv,0);
})
}
_noexport
void _createAndBind_fileioMod(void) {

14
src/kuroko.c
View File

@ -39,12 +39,13 @@ static int enableRline = 1;
static int exitRepl = 0;
static int pasteEnabled = 0;
KRK_FUNC(exit,{
KRK_Function(exit) {
FUNCTION_TAKES_NONE();
exitRepl = 1;
})
return NONE_VAL();
}
KRK_FUNC(paste,{
KRK_Function(paste) {
FUNCTION_TAKES_AT_MOST(1);
if (argc) {
CHECK_ARG(0,bool,int,enabled);
@ -53,7 +54,8 @@ KRK_FUNC(paste,{
pasteEnabled = !pasteEnabled;
}
fprintf(stderr, "Pasting is %s.\n", pasteEnabled ? "enabled" : "disabled");
})
return NONE_VAL();
}
static int doRead(char * buf, size_t bufSize) {
#ifndef NO_RLINE
@ -115,7 +117,7 @@ _exit:
* In an interactive session, presents the configured prompt without
* a trailing linefeed.
*/
KRK_FUNC(input,{
KRK_Function(input) {
FUNCTION_TAKES_AT_MOST(1);
char * prompt = "";
@ -143,7 +145,7 @@ KRK_FUNC(input,{
}
return readLine(prompt, promptLength, syntaxHighlighter);
})
}
#ifndef NO_RLINE
/**

29
src/kuroko/util.h
View File

@ -64,6 +64,8 @@
#define FUNC_NAME(klass, name) _ ## klass ## _ ## name
#define FUNC_SIG(klass, name) _noexport KrkValue FUNC_NAME(klass,name) (int argc, const KrkValue argv[], int hasKw)
/* These forms are deprecated. */
#define KRK_METHOD(klass, name, ...) FUNC_SIG(klass, name) { \
static __attribute__ ((unused)) const char* _method_name = # name; \
CHECK_ARG(0,klass,CURRENT_CTYPE,CURRENT_NAME); \
@ -81,6 +83,33 @@
#define BIND_PROP(klass,method) krk_defineNativeProperty(&klass->methods, #method, _ ## klass ## _ ## method)
#define BIND_FUNC(module,func) krk_defineNative(&module->fields, #func, _krk_ ## func)
#define KRK_Method_internal_name(klass, name) \
_krk_method_ ## klass ## _ ## name
#define KRK_Method_internal_sig(klass, name) \
static inline KrkValue KRK_Method_internal_name(klass,name) (const char * _method_name, CURRENT_CTYPE CURRENT_NAME, int argc, const KrkValue argv[], int hasKw)
#define KRK_Method(klass, name) \
KRK_Method_internal_sig(klass, name); \
FUNC_SIG(klass, name) { \
static const char * _method_name = # name; \
CHECK_ARG(0,klass,CURRENT_CTYPE,CURRENT_NAME); \
return KRK_Method_internal_name(klass,name)(_method_name, CURRENT_NAME, argc, argv, hasKw); \
} \
KRK_Method_internal_sig(klass,name)
#define KRK_Function_internal_name(name) \
_krk_function_ ## name
#define KRK_Function_internal_sig(name) \
static inline KrkValue KRK_Function_internal_name(name) (const char * _method_name, int argc, const KrkValue argv[], int hasKw)
#define KRK_Function(name) \
KRK_Function_internal_sig(name); \
static KrkValue _krk_ ## name (int argc, const KrkValue argv[], int hasKw) { \
static const char* _method_name = # name; \
return KRK_Function_internal_name(name)(_method_name,argc,argv,hasKw); \
} \
KRK_Function_internal_sig(name)
/**
* @brief Inline flexible string array.
*/

14
src/memory.c
View File

@ -558,21 +558,23 @@ size_t krk_collectGarbage(void) {
return out;
}
KRK_FUNC(collect,{
KRK_Function(collect) {
FUNCTION_TAKES_NONE();
if (&krk_currentThread != vm.threads) return krk_runtimeError(vm.exceptions->valueError, "only the main thread can do that");
return INTEGER_VAL(krk_collectGarbage());
})
}
KRK_FUNC(pause,{
KRK_Function(pause) {
FUNCTION_TAKES_NONE();
vm.globalFlags |= (KRK_GLOBAL_GC_PAUSED);
})
return NONE_VAL();
}
KRK_FUNC(resume,{
KRK_Function(resume) {
FUNCTION_TAKES_NONE();
vm.globalFlags &= ~(KRK_GLOBAL_GC_PAUSED);
})
return NONE_VAL();
}
_noexport
void _createAndBind_gcMod(void) {

9
src/modules/module_random.c
View File

@ -32,15 +32,15 @@ void _srand(unsigned int seed) {
w = 88675123;
}
KRK_FUNC(random,{
KRK_Function(random) {
FUNCTION_TAKES_NONE();
double r = (double)_rand() / (double)(RAND_MAX);
return FLOATING_VAL(r);
})
}
KRK_FUNC(seed,{
KRK_Function(seed) {
FUNCTION_TAKES_AT_MOST(1);
int seed;
@ -55,7 +55,8 @@ KRK_FUNC(seed,{
}
_srand(seed);
})
return NONE_VAL();
}
KrkValue krk_module_onload_random(void) {
KrkInstance * module = krk_newInstance(vm.baseClasses->moduleClass);

61
src/modules/module_socket.c
View File

@ -50,7 +50,7 @@ struct socket {
} \
}
KRK_METHOD(socket,__init__,{
KRK_Method(socket,__init__) {
METHOD_TAKES_AT_MOST(3);
/* Complex argument processing time... */
@ -70,7 +70,7 @@ KRK_METHOD(socket,__init__,{
self->proto = proto;
return argv[0];
})
}
static char * _af_name(int afval) {
static char tmp[30];
@ -102,12 +102,12 @@ static char * _sock_type(int type) {
}
}
KRK_METHOD(socket,__repr__,{
KRK_Method(socket,__repr__) {
char tmp[4096];
size_t len = snprintf(tmp, 4096, "<socket.socket fd=%d, family=%s, type=%s, proto=%d>",
self->sockfd, _af_name(self->family), _sock_type(self->type), self->proto);
return OBJECT_VAL(krk_copyString(tmp,len));
})
}
static int socket_parse_address(struct socket * self, KrkValue address, struct sockaddr_storage *sock_addr, socklen_t *sock_size) {
if (self->family == AF_INET) {
@ -179,7 +179,7 @@ static int socket_parse_address(struct socket * self, KrkValue address, struct s
return 1;
}
KRK_METHOD(socket,connect,{
KRK_Method(socket,connect) {
METHOD_TAKES_EXACTLY(1);
struct sockaddr_storage sock_addr;
@ -198,9 +198,11 @@ KRK_METHOD(socket,connect,{
if (result < 0) {
return krk_runtimeError(SocketError, "Socket error: %s", strerror(errno));
}
})
KRK_METHOD(socket,bind,{
return NONE_VAL();
}
KRK_Method(socket,bind) {
METHOD_TAKES_EXACTLY(1);
struct sockaddr_storage sock_addr;
@ -219,9 +221,11 @@ KRK_METHOD(socket,bind,{
if (result < 0) {
return krk_runtimeError(SocketError, "Socket error: %s", strerror(errno));
}
})
KRK_METHOD(socket,listen,{
return NONE_VAL();
}
KRK_Method(socket,listen) {
METHOD_TAKES_AT_MOST(1);
int backlog = 0;
if (argc > 1) {
@ -233,9 +237,11 @@ KRK_METHOD(socket,listen,{
if (result < 0) {
return krk_runtimeError(SocketError, "Socket error: %s", strerror(errno));
}
})
KRK_METHOD(socket,accept,{
return NONE_VAL();
}
KRK_Method(socket,accept) {
struct sockaddr_storage addr;
socklen_t addrlen;
@ -280,9 +286,9 @@ KRK_METHOD(socket,accept,{
krk_pop();
return krk_pop();
})
}
KRK_METHOD(socket,shutdown,{
KRK_Method(socket,shutdown) {
METHOD_TAKES_EXACTLY(1);
CHECK_ARG(1,int,krk_integer_type,how);
@ -291,9 +297,11 @@ KRK_METHOD(socket,shutdown,{
if (result < 0) {
return krk_runtimeError(SocketError, "Socket error: %s", strerror(errno));
}
})
KRK_METHOD(socket,recv,{
return NONE_VAL();
}
KRK_Method(socket,recv) {
METHOD_TAKES_AT_LEAST(1);
METHOD_TAKES_AT_MOST(2);
CHECK_ARG(1,int,krk_integer_type,bufsize);
@ -313,9 +321,9 @@ KRK_METHOD(socket,recv,{
KrkBytes * out = krk_newBytes(result,buf);
free(buf);
return OBJECT_VAL(out);
})
}
KRK_METHOD(socket,send,{
KRK_Method(socket,send) {
METHOD_TAKES_AT_LEAST(1);
METHOD_TAKES_AT_MOST(2);
CHECK_ARG(1,bytes,KrkBytes*,buf);
@ -331,9 +339,9 @@ KRK_METHOD(socket,send,{
}
return INTEGER_VAL(result);
})
}
KRK_METHOD(socket,sendto,{
KRK_Method(socket,sendto) {
METHOD_TAKES_AT_LEAST(1);
METHOD_TAKES_AT_MOST(3);
CHECK_ARG(1,bytes,KrkBytes*,buf);
@ -360,14 +368,14 @@ KRK_METHOD(socket,sendto,{
}
return INTEGER_VAL(result);
})
}
KRK_METHOD(socket,fileno,{
KRK_Method(socket,fileno) {
return INTEGER_VAL(self->sockfd);
})
}
KRK_METHOD(socket,setsockopt,{
KRK_Method(socket,setsockopt) {
METHOD_TAKES_EXACTLY(3);
CHECK_ARG(1,int,krk_integer_type,level);
CHECK_ARG(2,int,krk_integer_type,optname);
@ -387,13 +395,14 @@ KRK_METHOD(socket,setsockopt,{
return krk_runtimeError(SocketError, "Socket error: %s", strerror(errno));
}
})
return NONE_VAL();
}
KRK_FUNC(htons,{
KRK_Function(htons) {
FUNCTION_TAKES_EXACTLY(1);
CHECK_ARG(0,int,krk_integer_type,value);
return INTEGER_VAL(htons(value));
})
}
KrkValue krk_module_onload_socket(void) {
KrkInstance * module = krk_newInstance(vm.baseClasses->moduleClass);

4
src/modules/module_timeit.c
View File

@ -11,7 +11,7 @@
#include <kuroko/object.h>
#include <kuroko/util.h>
KRK_FUNC(timeit,{
KRK_Function(timeit) {
KrkValue number;
int times = 1000000;
if (hasKw && krk_tableGet_fast(AS_DICT(argv[argc]), S("number"), &number)) {
@ -32,7 +32,7 @@ KRK_FUNC(timeit,{
double after = (double)tv_after.tv_sec + (double)tv_after.tv_usec / 1000000.0;
return FLOATING_VAL(after-before);
})
}
KrkValue krk_module_onload_timeit(void) {
KrkInstance * module = krk_newInstance(vm.baseClasses->moduleClass);

4
src/modules/module_wcwidth.c
View File

@ -11,11 +11,11 @@ static
#include "../wcwidth._h"
#endif
KRK_FUNC(wcwidth,{
KRK_Function(wcwidth) {
FUNCTION_TAKES_EXACTLY(1);
CHECK_ARG(0,int,krk_integer_type,codepoint);
return INTEGER_VAL(wcwidth(codepoint));
})
}
KrkValue krk_module_onload_wcwidth(void) {
KrkInstance * module = krk_newInstance(vm.baseClasses->moduleClass);

28
src/obj_base.c
View File

@ -9,10 +9,10 @@
#define IS_type(o) (1)
#define AS_type(o) (o)
#define CURRENT_CTYPE KrkValue
KRK_METHOD(type,__init__,{
KRK_Method(type,__init__) {
METHOD_TAKES_EXACTLY(1);
return OBJECT_VAL(krk_getType(argv[1]));
})
}
#undef IS_type
#undef AS_type
#undef CURRENT_CTYPE
@ -22,23 +22,23 @@ KRK_METHOD(type,__init__,{
#define CURRENT_CTYPE KrkClass *
KRK_METHOD(type,__base__,{
KRK_Method(type,__base__) {
return self->base ? OBJECT_VAL(self->base) : NONE_VAL();
})
}
KRK_METHOD(type,__name__,{
KRK_Method(type,__name__) {
return self->name ? OBJECT_VAL(self->name) : NONE_VAL();
})
}
KRK_METHOD(type,__file__,{
KRK_Method(type,__file__) {
return self->filename ? OBJECT_VAL(self->filename) : NONE_VAL();
})
}
KRK_METHOD(type,__doc__,{
KRK_Method(type,__doc__) {
return self->docstring ? OBJECT_VAL(self->docstring) : NONE_VAL();
})
}
KRK_METHOD(type,__str__,{
KRK_Method(type,__str__) {
/* Determine if this class has a module */
KrkValue module = NONE_VAL();
krk_tableGet(&self->methods, OBJECT_VAL(S("__module__")), &module);
@ -59,9 +59,9 @@ KRK_METHOD(type,__str__,{
KrkString * out = krk_copyString(tmp,l);
free(tmp);
return OBJECT_VAL(out);
})
}
KRK_METHOD(type,__subclasses__,{
KRK_Method(type,__subclasses__) {
KrkValue myList = krk_list_of(0,NULL,0);
krk_push(myList);
@ -72,7 +72,7 @@ KRK_METHOD(type,__subclasses__,{
}
return krk_pop();
})
}
_noexport
void _createAndBind_type(void) {

89
src/obj_bytes.c
View File

@ -15,7 +15,7 @@ struct ByteArray {
#undef IS_bytes
#define IS_bytes(o) (IS_BYTES(o) || krk_isInstanceOf(o, vm.baseClasses->bytesClass))
KRK_METHOD(bytes,__init__,{
KRK_Method(bytes,__init__) {
if (argc < 2) {
return OBJECT_VAL(krk_newBytes(0,NULL));
}
@ -51,12 +51,12 @@ KRK_METHOD(bytes,__init__,{
}
return krk_runtimeError(vm.exceptions->typeError, "Can not convert '%s' to bytes", krk_typeName(argv[1]));
})
}
#undef IS_bytes
#define IS_bytes(o) IS_BYTES(o)
KRK_METHOD(bytes,__hash__,{
KRK_Method(bytes,__hash__) {
METHOD_TAKES_NONE();
uint32_t hash = 0;
/* This is the so-called "sdbm" hash. It comes from a piece of
@ -65,12 +65,11 @@ KRK_METHOD(bytes,__hash__,{
hash = (int)self->bytes[i] + (hash << 6) + (hash << 16) - hash;
}
return INTEGER_VAL(hash);
})
}
/* bytes objects are not interned; need to do this the old-fashioned way. */
KRK_METHOD(bytes,__eq__,{
KRK_Method(bytes,__eq__) {
if (!IS_BYTES(argv[1])) return BOOLEAN_VAL(0);
KrkBytes * self = AS_BYTES(argv[0]);
KrkBytes * them = AS_BYTES(argv[1]);
if (self->length != them->length) return BOOLEAN_VAL(0);
if (self->obj.hash != them->obj.hash) return BOOLEAN_VAL(0);
@ -78,11 +77,11 @@ KRK_METHOD(bytes,__eq__,{
if (self->bytes[i] != them->bytes[i]) return BOOLEAN_VAL(0);
}
return BOOLEAN_VAL(1);
})
}
#define AT_END() (self->length == 0 || i == self->length - 1)
KRK_METHOD(bytes,__repr__,{
KRK_Method(bytes,__repr__) {
struct StringBuilder sb = {0};
pushStringBuilder(&sb, 'b');
@ -119,9 +118,9 @@ KRK_METHOD(bytes,__repr__,{
pushStringBuilder(&sb, '\'');
return finishStringBuilder(&sb);
})
}
KRK_METHOD(bytes,__getitem__,{
KRK_Method(bytes,__getitem__) {
METHOD_TAKES_EXACTLY(1);
if (IS_INTEGER(argv[1])) {
@ -154,21 +153,21 @@ KRK_METHOD(bytes,__getitem__,{
} else {
return TYPE_ERROR(int or slice, argv[1]);
}
})
}
KRK_METHOD(bytes,__len__,{
KRK_Method(bytes,__len__) {
return INTEGER_VAL(AS_BYTES(argv[0])->length);
})
}
KRK_METHOD(bytes,__contains__,{
KRK_Method(bytes,__contains__) {
METHOD_TAKES_EXACTLY(1);
return krk_runtimeError(vm.exceptions->notImplementedError, "not implemented");
})
}
KRK_METHOD(bytes,decode,{
KRK_Method(bytes,decode) {
METHOD_TAKES_NONE();
return OBJECT_VAL(krk_copyString((char*)AS_BYTES(argv[0])->bytes, AS_BYTES(argv[0])->length));
})
}
struct _bytes_join_context {
struct StringBuilder * sb;
@ -197,7 +196,7 @@ static int _bytes_join_callback(void * context, const KrkValue * values, size_t
return 0;
}
KRK_METHOD(bytes,join,{
KRK_Method(bytes,join) {
METHOD_TAKES_EXACTLY(1);
struct StringBuilder sb = {0};
@ -210,9 +209,9 @@ KRK_METHOD(bytes,join,{
}
return finishStringBuilderBytes(&sb);
})
}
KRK_METHOD(bytes,__add__,{
KRK_Method(bytes,__add__) {
METHOD_TAKES_EXACTLY(1);
CHECK_ARG(1,bytes,KrkBytes*,them);
@ -221,11 +220,11 @@ KRK_METHOD(bytes,__add__,{
pushStringBuilderStr(&sb, (char*)them->bytes, them->length);
return finishStringBuilderBytes(&sb);
})
}
FUNC_SIG(bytesiterator,__init__);
KRK_METHOD(bytes,__iter__,{
KRK_Method(bytes,__iter__) {
METHOD_TAKES_NONE();
KrkInstance * output = krk_newInstance(vm.baseClasses->bytesiteratorClass);
@ -234,7 +233,7 @@ KRK_METHOD(bytes,__iter__,{
krk_pop();
return OBJECT_VAL(output);
})
}
#undef CURRENT_CTYPE
@ -252,15 +251,15 @@ static void _bytesiterator_gcscan(KrkInstance * self) {
krk_markValue(((struct BytesIterator*)self)->l);
}
KRK_METHOD(bytesiterator,__init__,{
KRK_Method(bytesiterator,__init__) {
METHOD_TAKES_EXACTLY(1);
CHECK_ARG(1,bytes,KrkBytes*,bytes);
self->l = argv[1];
self->i = 0;
return argv[0];
})
}
KRK_METHOD(bytesiterator,__call__,{
KRK_Method(bytesiterator,__call__) {
KrkValue _list = self->l;
size_t _counter = self->i;
if (!IS_BYTES(_list) || _counter >= AS_BYTES(_list)->length) {
@ -269,7 +268,7 @@ KRK_METHOD(bytesiterator,__call__,{
self->i = _counter + 1;
return INTEGER_VAL(AS_BYTES(_list)->bytes[_counter]);
}
})
}
#undef CURRENT_CTYPE
#define CURRENT_CTYPE struct ByteArray *
@ -278,7 +277,7 @@ static void _bytearray_gcscan(KrkInstance * self) {
krk_markValue(((struct ByteArray*)self)->actual);
}
KRK_METHOD(bytearray,__init__,{
KRK_Method(bytearray,__init__) {
METHOD_TAKES_AT_MOST(1);
if (argc < 2) {
self->actual = OBJECT_VAL(krk_newBytes(0,NULL));
@ -290,19 +289,19 @@ KRK_METHOD(bytearray,__init__,{
return krk_runtimeError(vm.exceptions->valueError, "expected bytes");
}
return argv[0];
})
}
#undef IS_bytearray
#define IS_bytearray(o) (krk_isInstanceOf(o,vm.baseClasses->bytearrayClass) && IS_BYTES(AS_bytearray(o)->actual))
/* bytes objects are not interned; need to do this the old-fashioned way. */
KRK_METHOD(bytearray,__eq__,{
KRK_Method(bytearray,__eq__) {
if (!IS_bytearray(argv[1])) return BOOLEAN_VAL(0);
struct ByteArray * them = AS_bytearray(argv[1]);
return BOOLEAN_VAL(krk_valuesEqual(self->actual, them->actual));
})
}
KRK_METHOD(bytearray,__repr__,{
KRK_Method(bytearray,__repr__) {
METHOD_TAKES_NONE();
struct StringBuilder sb = {0};
pushStringBuilderStr(&sb, "bytearray(", 10);
@ -317,9 +316,9 @@ KRK_METHOD(bytearray,__repr__,{
pushStringBuilderStr(&sb, AS_STRING(repred_bytes)->chars, AS_STRING(repred_bytes)->length);
pushStringBuilder(&sb,')');
return finishStringBuilder(&sb);
})
}
KRK_METHOD(bytearray,__getitem__,{
KRK_Method(bytearray,__getitem__) {
METHOD_TAKES_EXACTLY(1);
if (IS_INTEGER(argv[1])) {
@ -352,9 +351,9 @@ KRK_METHOD(bytearray,__getitem__,{
} else {
return TYPE_ERROR(int or slice, argv[1]);
}
})
}
KRK_METHOD(bytearray,__setitem__,{
KRK_Method(bytearray,__setitem__) {
METHOD_TAKES_EXACTLY(2);
CHECK_ARG(1,int,krk_integer_type,asInt);
CHECK_ARG(2,int,krk_integer_type,val);
@ -366,27 +365,27 @@ KRK_METHOD(bytearray,__setitem__,{
AS_BYTES(self->actual)->bytes[asInt] = val;
return INTEGER_VAL(AS_BYTES(self->actual)->bytes[asInt]);
})
}
KRK_METHOD(bytearray,__len__,{
KRK_Method(bytearray,__len__) {
return INTEGER_VAL(AS_BYTES(self->actual)->length);
})
}
KRK_METHOD(bytearray,__contains__,{
KRK_Method(bytearray,__contains__) {
METHOD_TAKES_EXACTLY(1);
CHECK_ARG(1,int,krk_integer_type,val);
for (size_t i = 0; i < AS_BYTES(self->actual)->length; ++i) {
if (AS_BYTES(self->actual)->bytes[i] == val) return BOOLEAN_VAL(1);
}
return BOOLEAN_VAL(0);
})
}
KRK_METHOD(bytearray,decode,{
KRK_Method(bytearray,decode) {
METHOD_TAKES_NONE();
return OBJECT_VAL(krk_copyString((char*)AS_BYTES(self->actual)->bytes, AS_BYTES(self->actual)->length));
})
}
KRK_METHOD(bytearray,__iter__,{
KRK_Method(bytearray,__iter__) {
METHOD_TAKES_NONE();
KrkInstance * output = krk_newInstance(vm.baseClasses->bytesiteratorClass);
@ -395,7 +394,7 @@ KRK_METHOD(bytearray,__iter__,{
krk_pop();
return OBJECT_VAL(output);
})
}
_noexport

123
src/obj_dict.c
View File

@ -92,7 +92,7 @@ static int unpackKeyValuePair(void * self, const KrkValue * pairs, size_t count)
return 0;
}
KRK_METHOD(dict,__init__,{
KRK_Method(dict,__init__) {
METHOD_TAKES_AT_MOST(1);
krk_initTable(&self->entries);
@ -104,9 +104,9 @@ KRK_METHOD(dict,__init__,{
krk_tableAddAll(AS_DICT(argv[argc]), &self->entries);
}
return argv[0];
})
}
KRK_METHOD(dict,__getitem__,{
KRK_Method(dict,__getitem__) {
METHOD_TAKES_EXACTLY(1);
KrkValue out;
if (!krk_tableGet(&self->entries, argv[1], &out)) {
@ -114,15 +114,15 @@ KRK_METHOD(dict,__getitem__,{
KEY_ERROR(argv[1]);
}
return out;
})
}
KRK_METHOD(dict,__setitem__,{
KRK_Method(dict,__setitem__) {
METHOD_TAKES_EXACTLY(2);
krk_tableSet(&self->entries, argv[1], argv[2]);
return argv[2];
})
}
KRK_METHOD(dict,__or__,{
KRK_Method(dict,__or__) {
METHOD_TAKES_EXACTLY(1);
CHECK_ARG(1,dict,KrkDict*,them);
KrkValue outDict = krk_dict_of(0,NULL,0);
@ -130,33 +130,34 @@ KRK_METHOD(dict,__or__,{
krk_tableAddAll(&self->entries, AS_DICT(outDict));
krk_tableAddAll(&them->entries, AS_DICT(outDict));
return krk_pop();
})
}
KRK_METHOD(dict,__delitem__,{
KRK_Method(dict,__delitem__) {
METHOD_TAKES_EXACTLY(1);
if (!krk_tableDelete(&self->entries, argv[1])) {
if (!IS_NONE(krk_currentThread.currentException)) return NONE_VAL();
KEY_ERROR(argv[1]);
}
})
return NONE_VAL();
}
KRK_METHOD(dict,__len__,{
KRK_Method(dict,__len__) {
METHOD_TAKES_NONE();
return INTEGER_VAL(self->entries.count);
})
}
KRK_METHOD(dict,__contains__,{
KRK_Method(dict,__contains__) {
METHOD_TAKES_EXACTLY(1);
KrkValue _unused;
return BOOLEAN_VAL(krk_tableGet(&self->entries, argv[1], &_unused));
})
}
KRK_METHOD(dict,capacity,{
KRK_Method(dict,capacity) {
METHOD_TAKES_NONE();
return INTEGER_VAL(self->entries.capacity);
})
}
KRK_METHOD(dict,__repr__,{
KRK_Method(dict,__repr__) {
METHOD_TAKES_NONE();
if (((KrkObj*)self)->flags & KRK_OBJ_FLAGS_IN_REPR) return OBJECT_VAL(S("{...}"));
((KrkObj*)self)->flags |= KRK_OBJ_FLAGS_IN_REPR;
@ -197,31 +198,32 @@ KRK_METHOD(dict,__repr__,{
pushStringBuilder(&sb,'}');
((KrkObj*)self)->flags &= ~(KRK_OBJ_FLAGS_IN_REPR);
return finishStringBuilder(&sb);
})
}
KRK_METHOD(dict,copy,{
KRK_Method(dict,copy) {
METHOD_TAKES_NONE();
KrkValue dictOut = krk_dict_of(0,NULL,0);
krk_push(dictOut);
krk_tableAddAll(&self->entries, AS_DICT(dictOut));
return krk_pop();
})
}
KRK_METHOD(dict,clear,{
KRK_Method(dict,clear) {
METHOD_TAKES_NONE();
krk_freeTable(&self->entries);
})
return NONE_VAL();
}
KRK_METHOD(dict,get,{
KRK_Method(dict,get) {
METHOD_TAKES_AT_LEAST(1);
METHOD_TAKES_AT_MOST(2);
KrkValue out = NONE_VAL();
if (argc > 2) out = argv[2];
krk_tableGet(&self->entries, argv[1], &out);
return out;
})
}
KRK_METHOD(dict,setdefault,{
KRK_Method(dict,setdefault) {
METHOD_TAKES_AT_LEAST(1);
METHOD_TAKES_AT_MOST(2);
KrkValue out = NONE_VAL();
@ -233,9 +235,9 @@ KRK_METHOD(dict,setdefault,{
}
return out;
})
}
KRK_METHOD(dict,update,{
KRK_Method(dict,update) {
METHOD_TAKES_AT_MOST(1);
if (argc > 1) {
/* TODO sequence */
@ -245,47 +247,48 @@ KRK_METHOD(dict,update,{
if (hasKw) {
krk_tableAddAll(AS_DICT(argv[argc]), &self->entries);
}
})
return NONE_VAL();
}
KRK_METHOD(dict,__ior__,{
KRK_Method(dict,__ior__) {
METHOD_TAKES_EXACTLY(1);
CHECK_ARG(1,dict,KrkDict*,other);
krk_tableAddAll(&other->entries, &self->entries);
return argv[0];
})
}
FUNC_SIG(dictkeys,__init__);
KRK_METHOD(dict,keys,{
KRK_Method(dict,keys) {
METHOD_TAKES_NONE();
KrkInstance * output = krk_newInstance(vm.baseClasses->dictkeysClass);
krk_push(OBJECT_VAL(output));
FUNC_NAME(dictkeys,__init__)(2, (KrkValue[]){krk_peek(0), argv[0]},0);
krk_pop();
return OBJECT_VAL(output);
})
}
FUNC_SIG(dictitems,__init__);
KRK_METHOD(dict,items,{
KRK_Method(dict,items) {
METHOD_TAKES_NONE();
KrkInstance * output = krk_newInstance(vm.baseClasses->dictitemsClass);
krk_push(OBJECT_VAL(output));
FUNC_NAME(dictitems,__init__)(2, (KrkValue[]){krk_peek(0), argv[0]},0);
krk_pop();
return OBJECT_VAL(output);
})
}
FUNC_SIG(dictvalues,__init__);
KRK_METHOD(dict,values,{
KRK_Method(dict,values) {
METHOD_TAKES_NONE();
KrkInstance * output = krk_newInstance(vm.baseClasses->dictvaluesClass);
krk_push(OBJECT_VAL(output));
FUNC_NAME(dictvalues,__init__)(2, (KrkValue[]){krk_peek(0), argv[0]},0);
krk_pop();
return OBJECT_VAL(output);
})
}
KrkValue krk_dict_nth_key_fast(size_t capacity, KrkTableEntry * entries, size_t index) {
size_t found = 0;
@ -304,21 +307,21 @@ static void _dictitems_gcscan(KrkInstance * self) {
krk_markValue(((struct DictItems*)self)->dict);
}
KRK_METHOD(dictitems,__init__,{
KRK_Method(dictitems,__init__) {
METHOD_TAKES_EXACTLY(1);
CHECK_ARG(1,dict,KrkDict*,source);
self->dict = argv[1];
self->i = 0;
return argv[0];
})
}
KRK_METHOD(dictitems,__iter__,{
KRK_Method(dictitems,__iter__) {
METHOD_TAKES_NONE();
self->i = 0;
return argv[0];
})
}
KRK_METHOD(dictitems,__call__,{
KRK_Method(dictitems,__call__) {
do {
if (self->i >= AS_DICT(self->dict)->capacity) return argv[0];
if (!IS_KWARGS(AS_DICT(self->dict)->entries[self->i].key)) {
@ -332,9 +335,9 @@ KRK_METHOD(dictitems,__call__,{
}
self->i++;
} while (1);
})
}
KRK_METHOD(dictitems,__repr__,{
KRK_Method(dictitems,__repr__) {
METHOD_TAKES_NONE();
if (((KrkObj*)self)->flags & KRK_OBJ_FLAGS_IN_REPR) return OBJECT_VAL(S("dictitems([...])"));
((KrkObj*)self)->flags |= KRK_OBJ_FLAGS_IN_REPR;
@ -379,7 +382,7 @@ KRK_METHOD(dictitems,__repr__,{
pushStringBuilderStr(&sb,"])",2);
((KrkObj*)self)->flags &= ~(KRK_OBJ_FLAGS_IN_REPR);
return finishStringBuilder(&sb);
})
}
#undef CURRENT_CTYPE
#define CURRENT_CTYPE struct DictKeys *
@ -388,21 +391,21 @@ static void _dictkeys_gcscan(KrkInstance * self) {
krk_markValue(((struct DictKeys*)self)->dict);
}
KRK_METHOD(dictkeys,__init__,{
KRK_Method(dictkeys,__init__) {
METHOD_TAKES_EXACTLY(1);
CHECK_ARG(1,dict,KrkDict*,source);
self->dict = argv[1];
self->i = 0;
return argv[0];
})
}
KRK_METHOD(dictkeys,__iter__,{
KRK_Method(dictkeys,__iter__) {
METHOD_TAKES_NONE();
self->i = 0;
return argv[0];
})
}
KRK_METHOD(dictkeys,__call__,{
KRK_Method(dictkeys,__call__) {
METHOD_TAKES_NONE();
do {
if (self->i >= AS_DICT(self->dict)->capacity) return argv[0];
@ -413,9 +416,9 @@ KRK_METHOD(dictkeys,__call__,{
}
self->i++;
} while (1);
})
}
KRK_METHOD(dictkeys,__repr__,{
KRK_Method(dictkeys,__repr__) {
METHOD_TAKES_NONE();
if (((KrkObj*)self)->flags & KRK_OBJ_FLAGS_IN_REPR) return OBJECT_VAL(S("dictkeys([...])"));
((KrkObj*)self)->flags |= KRK_OBJ_FLAGS_IN_REPR;
@ -445,7 +448,7 @@ KRK_METHOD(dictkeys,__repr__,{
pushStringBuilderStr(&sb,"])",2);
((KrkObj*)self)->flags &= ~(KRK_OBJ_FLAGS_IN_REPR);
return finishStringBuilder(&sb);
})
}
#undef CURRENT_CTYPE
#define CURRENT_CTYPE struct DictValues *
@ -454,21 +457,21 @@ static void _dictvalues_gcscan(KrkInstance * self) {
krk_markValue(((struct DictValues*)self)->dict);
}
KRK_METHOD(dictvalues,__init__,{
KRK_Method(dictvalues,__init__) {
METHOD_TAKES_EXACTLY(1);
CHECK_ARG(1,dict,KrkDict*,source);
self->dict = argv[1];
self->i = 0;
return argv[0];
})
}
KRK_METHOD(dictvalues,__iter__,{
KRK_Method(dictvalues,__iter__) {
METHOD_TAKES_NONE();
self->i = 0;
return argv[0];
})
}
KRK_METHOD(dictvalues,__call__,{
KRK_Method(dictvalues,__call__) {
METHOD_TAKES_NONE();
do {
if (self->i >= AS_DICT(self->dict)->capacity) return argv[0];
@ -479,9 +482,9 @@ KRK_METHOD(dictvalues,__call__,{
}
self->i++;
} while (1);
})
}
KRK_METHOD(dictvalues,__repr__,{
KRK_Method(dictvalues,__repr__) {
METHOD_TAKES_NONE();
if (((KrkObj*)self)->flags & KRK_OBJ_FLAGS_IN_REPR) return OBJECT_VAL(S("dictvalues([...])"));
((KrkObj*)self)->flags |= KRK_OBJ_FLAGS_IN_REPR;
@ -511,7 +514,7 @@ KRK_METHOD(dictvalues,__repr__,{
pushStringBuilderStr(&sb,"])",2);
((KrkObj*)self)->flags &= ~(KRK_OBJ_FLAGS_IN_REPR);
return finishStringBuilder(&sb);
})
}
_noexport
void _createAndBind_dictClass(void) {

128
src/obj_function.c
View File

@ -60,7 +60,7 @@ FUNC_SIG(function,__init__) {
return krk_runtimeError(vm.exceptions->typeError, "function object is not instantiable");
}
KRK_METHOD(function,__doc__,{
KRK_Method(function,__doc__) {
ATTRIBUTE_NOT_ASSIGNABLE();
if (IS_NATIVE(self) && AS_NATIVE(self)->doc) {
@ -68,9 +68,11 @@ KRK_METHOD(function,__doc__,{
} else if (IS_CLOSURE(self) && AS_CLOSURE(self)->function->docstring) {
return OBJECT_VAL(AS_CLOSURE(self)->function->docstring);
}
})
KRK_METHOD(function,__name__,{
return NONE_VAL();
}
KRK_Method(function,__name__) {
ATTRIBUTE_NOT_ASSIGNABLE();
if (IS_NATIVE(self)) {
@ -80,17 +82,19 @@ KRK_METHOD(function,__name__,{
}
return OBJECT_VAL(S(""));
})
}
KRK_METHOD(function,__qualname__,{
KRK_Method(function,__qualname__) {
ATTRIBUTE_NOT_ASSIGNABLE();
if (IS_CLOSURE(self) && AS_CLOSURE(self)->function->qualname) {
return OBJECT_VAL(AS_CLOSURE(self)->function->qualname);
}
})
KRK_METHOD(function,_ip_to_line,{
return NONE_VAL();
}
KRK_Method(function,_ip_to_line) {
METHOD_TAKES_EXACTLY(1);
CHECK_ARG(1,int,krk_integer_type,ip);
@ -99,9 +103,9 @@ KRK_METHOD(function,_ip_to_line,{
size_t line = krk_lineNumber(&AS_CLOSURE(self)->function->chunk, ip);
return INTEGER_VAL(line);
})
}
KRK_METHOD(function,__str__,{
KRK_Method(function,__str__) {
METHOD_TAKES_NONE();
struct StringBuilder sb = {0};
@ -126,9 +130,9 @@ KRK_METHOD(function,__str__,{
pushStringBuilder(&sb,'>');
return finishStringBuilder(&sb);
})
}
KRK_METHOD(function,__file__,{
KRK_Method(function,__file__) {
ATTRIBUTE_NOT_ASSIGNABLE();
if (IS_NATIVE(self)) return OBJECT_VAL(S("<builtin>"));
@ -136,26 +140,26 @@ KRK_METHOD(function,__file__,{
return AS_CLOSURE(self)->function->chunk.filename ?
OBJECT_VAL(AS_CLOSURE(self)->function->chunk.filename) :
OBJECT_VAL(S(""));
})
}
KRK_METHOD(function,__args__,{
KRK_Method(function,__args__) {
ATTRIBUTE_NOT_ASSIGNABLE();
if (!IS_CLOSURE(self)) return OBJECT_VAL(krk_newTuple(0));
KrkTuple * tuple = functionArgs(AS_CLOSURE(self)->function);
return OBJECT_VAL(tuple);
})
}
KRK_METHOD(function,__annotations__,{
KRK_Method(function,__annotations__) {
ATTRIBUTE_NOT_ASSIGNABLE();
if (!IS_CLOSURE(self)) return NONE_VAL();
return AS_CLOSURE(self)->annotations;
})
}
KRK_METHOD(function,__code__,{
KRK_Method(function,__code__) {
ATTRIBUTE_NOT_ASSIGNABLE();
if (!IS_CLOSURE(self)) return NONE_VAL();
return OBJECT_VAL(AS_CLOSURE(self)->function);
})
}
#undef CURRENT_CTYPE
#define CURRENT_CTYPE KrkCodeObject*
@ -164,12 +168,12 @@ FUNC_SIG(codeobject,__init__) {
return krk_runtimeError(vm.exceptions->typeError, "codeobject object is not instantiable");
}
KRK_METHOD(codeobject,__name__,{
KRK_Method(codeobject,__name__) {
ATTRIBUTE_NOT_ASSIGNABLE();
return self->name ? OBJECT_VAL(self->name) : OBJECT_VAL(S(""));
})
}
KRK_METHOD(codeobject,__str__,{
KRK_Method(codeobject,__str__) {
METHOD_TAKES_NONE();
KrkValue s = FUNC_NAME(codeobject,__name__)(1,argv,0);
if (!IS_STRING(s)) return NONE_VAL();
@ -183,16 +187,16 @@ KRK_METHOD(codeobject,__str__,{
krk_pop();
return s;
})
}
KRK_METHOD(codeobject,_ip_to_line,{
KRK_Method(codeobject,_ip_to_line) {
METHOD_TAKES_EXACTLY(1);
CHECK_ARG(1,int,krk_integer_type,ip);
size_t line = krk_lineNumber(&self->chunk, ip);
return INTEGER_VAL(line);
})
}
KRK_METHOD(codeobject,__constants__,{
KRK_Method(codeobject,__constants__) {
ATTRIBUTE_NOT_ASSIGNABLE();
krk_push(OBJECT_VAL(krk_newTuple(self->chunk.constants.count)));
memcpy(AS_TUPLE(krk_peek(0))->values.values,
@ -200,17 +204,17 @@ KRK_METHOD(codeobject,__constants__,{
sizeof(KrkValue) * self->chunk.constants.count);
AS_TUPLE(krk_peek(0))->values.count = self->chunk.constants.count;
return krk_pop();
})
}
KRK_METHOD(codeobject,co_code,{
KRK_Method(codeobject,co_code) {
return OBJECT_VAL(krk_newBytes(self->chunk.count, self->chunk.code));
})
}
KRK_METHOD(codeobject,co_argcount,{
KRK_Method(codeobject,co_argcount) {
return INTEGER_VAL(self->potentialPositionals);
})
}
KRK_METHOD(codeobject,__locals__,{
KRK_Method(codeobject,__locals__) {
krk_push(OBJECT_VAL(krk_newTuple(self->localNameCount)));
for (size_t i = 0; i < self->localNameCount; ++i) {
krk_push(OBJECT_VAL(krk_newTuple(4)));
@ -222,10 +226,10 @@ KRK_METHOD(codeobject,__locals__,{
krk_pop();
}
return krk_pop();
})
}
/* Python-compatibility */
KRK_METHOD(codeobject,co_flags,{
KRK_Method(codeobject,co_flags) {
ATTRIBUTE_NOT_ASSIGNABLE();
int out = 0;
@ -239,13 +243,13 @@ KRK_METHOD(codeobject,co_flags,{
if (self->obj.flags & KRK_OBJ_FLAGS_CODEOBJECT_IS_COROUTINE) out |= 0x80;
return INTEGER_VAL(out);
})
}
KRK_METHOD(codeobject,__args__,{
KRK_Method(codeobject,__args__) {
ATTRIBUTE_NOT_ASSIGNABLE();
KrkTuple * tuple = functionArgs(self);
return OBJECT_VAL(tuple);
})
}
#undef CURRENT_CTYPE
@ -260,22 +264,22 @@ FUNC_SIG(method,__init__) {
return OBJECT_VAL(krk_newBoundMethod(argv[2],AS_OBJECT(argv[1])));
}
KRK_METHOD(method,__name__,{
KRK_Method(method,__name__) {
ATTRIBUTE_NOT_ASSIGNABLE();
return IS_function(OBJECT_VAL(self->method)) ? FUNC_NAME(function,__name__)(1,(KrkValue[]){OBJECT_VAL(self->method)},0) : OBJECT_VAL(S("?"));
})
}
KRK_METHOD(method,__qualname__,{
KRK_Method(method,__qualname__) {
ATTRIBUTE_NOT_ASSIGNABLE();
return IS_function(OBJECT_VAL(self->method)) ? FUNC_NAME(function,__qualname__)(1,(KrkValue[]){OBJECT_VAL(self->method)},0) : OBJECT_VAL(S("?"));
})
}
KRK_METHOD(method,_ip_to_line,{
KRK_Method(method,_ip_to_line) {
METHOD_TAKES_EXACTLY(1);
return IS_function(OBJECT_VAL(self->method)) ? FUNC_NAME(function,_ip_to_line)(2,(KrkValue[]){OBJECT_VAL(self->method),argv[1]},0) : OBJECT_VAL(S("?"));
})
}
KRK_METHOD(method,__str__,{
KRK_Method(method,__str__) {
METHOD_TAKES_NONE();
KrkValue s = FUNC_NAME(method,__qualname__)(1,argv,0);
if (!IS_STRING(s)) s = FUNC_NAME(method,__name__)(1,argv,0);
@ -293,58 +297,58 @@ KRK_METHOD(method,__str__,{
free(tmp);
krk_pop();
return s;
})
}
KRK_METHOD(method,__file__,{
KRK_Method(method,__file__) {
ATTRIBUTE_NOT_ASSIGNABLE();
return IS_function(OBJECT_VAL(self->method)) ? FUNC_NAME(function,__file__)(1,(KrkValue[]){OBJECT_VAL(self->method)},0) : OBJECT_VAL(S("?"));
})
}
KRK_METHOD(method,__args__,{
KRK_Method(method,__args__) {
ATTRIBUTE_NOT_ASSIGNABLE();
return IS_function(OBJECT_VAL(self->method)) ? FUNC_NAME(function,__args__)(1,(KrkValue[]){OBJECT_VAL(self->method)},0) : OBJECT_VAL(S("?"));
})
}
KRK_METHOD(method,__doc__,{
KRK_Method(method,__doc__) {
ATTRIBUTE_NOT_ASSIGNABLE();
return IS_function(OBJECT_VAL(self->method)) ? FUNC_NAME(function,__doc__)(1,(KrkValue[]){OBJECT_VAL(self->method)},0) : OBJECT_VAL(S("?"));
})
}
KRK_METHOD(method,__annotations__,{
KRK_Method(method,__annotations__) {
ATTRIBUTE_NOT_ASSIGNABLE();
return IS_function(OBJECT_VAL(self->method)) ? FUNC_NAME(function,__annotations__)(1,(KrkValue[]){OBJECT_VAL(self->method)},0) : OBJECT_VAL(S("?"));
})
}
KRK_METHOD(method,__code__,{
KRK_Method(method,__code__) {
ATTRIBUTE_NOT_ASSIGNABLE();
return IS_function(OBJECT_VAL(self->method)) ? FUNC_NAME(function,__code__)(1,(KrkValue[]){OBJECT_VAL(self->method)},0) : OBJECT_VAL(S("?"));
})
}
KRK_METHOD(method,__func__,{
KRK_Method(method,__func__) {
ATTRIBUTE_NOT_ASSIGNABLE();
return OBJECT_VAL(self->method);
})
}
KRK_METHOD(method,__self__,{
KRK_Method(method,__self__) {
ATTRIBUTE_NOT_ASSIGNABLE();
return OBJECT_VAL(self->receiver);
})
}
KRK_FUNC(staticmethod,{
KRK_Function(staticmethod) {
FUNCTION_TAKES_EXACTLY(1);
CHECK_ARG(0,CLOSURE,KrkClosure*,method);
method->obj.flags &= ~(KRK_OBJ_FLAGS_FUNCTION_MASK);
method->obj.flags |= KRK_OBJ_FLAGS_FUNCTION_IS_STATIC_METHOD;
return argv[0];
})
}
KRK_FUNC(classmethod,{
KRK_Function(classmethod) {
FUNCTION_TAKES_EXACTLY(1);
CHECK_ARG(0,CLOSURE,KrkClosure*,method);
method->obj.flags &= ~(KRK_OBJ_FLAGS_FUNCTION_MASK);
method->obj.flags |= KRK_OBJ_FLAGS_FUNCTION_IS_CLASS_METHOD;
return argv[0];
})
}
_noexport
void _createAndBind_functionClass(void) {

24
src/obj_gen.c
View File

@ -84,7 +84,7 @@ FUNC_SIG(generator,__init__) {
return krk_runtimeError(vm.exceptions->typeError, "cannot create '%s' instances", "generator");
}
KRK_METHOD(generator,__repr__,{
KRK_Method(generator,__repr__) {
METHOD_TAKES_NONE();
char * typeStr = "generator";
@ -103,14 +103,14 @@ KRK_METHOD(generator,__repr__,{
(void*)self);
return OBJECT_VAL(krk_takeString(tmp,lenActual));
})
}
KRK_METHOD(generator,__iter__,{
KRK_Method(generator,__iter__) {
METHOD_TAKES_NONE();
return OBJECT_VAL(self);
})
}
KRK_METHOD(generator,__call__,{
KRK_Method(generator,__call__) {
METHOD_TAKES_AT_MOST(1);
if (!self->ip) return OBJECT_VAL(self);
/* Prepare frame */
@ -175,28 +175,28 @@ KRK_METHOD(generator,__call__,{
krk_currentThread.stackTop = krk_currentThread.stack + frame->slots;
return result;
})
}
KRK_METHOD(generator,send,{
KRK_Method(generator,send) {
METHOD_TAKES_EXACTLY(1);
if (!self->started && !IS_NONE(argv[1])) {
return krk_runtimeError(vm.exceptions->typeError, "Can not send non-None value to just-started generator");
}
return FUNC_NAME(generator,__call__)(argc,argv,0);
})
}
KRK_METHOD(generator,__finish__,{
KRK_Method(generator,__finish__) {
METHOD_TAKES_NONE();
return self->result;
})
}
/*
* For compatibility with Python...
*/
KRK_METHOD(generator,gi_running,{
KRK_Method(generator,gi_running) {
METHOD_TAKES_NONE();
return BOOLEAN_VAL(self->running);
})
}
int krk_getAwaitable(void) {
if (IS_generator(krk_peek(0)) && AS_generator(krk_peek(0))->type == KRK_OBJ_FLAGS_CODEOBJECT_IS_COROUTINE) {

103
src/obj_list.c
View File

@ -46,7 +46,7 @@ KrkValue krk_list_of(int argc, const KrkValue argv[], int hasKw) {
#define CURRENT_CTYPE KrkList *
#define CURRENT_NAME self
KRK_METHOD(list,__getitem__,{
KRK_Method(list,__getitem__) {
METHOD_TAKES_EXACTLY(1);
if (IS_INTEGER(argv[1])) {
CHECK_ARG(1,int,krk_integer_type,index);
@ -93,9 +93,9 @@ KRK_METHOD(list,__getitem__,{
} else {
return TYPE_ERROR(int or slice,argv[1]);
}
})
}
KRK_METHOD(list,__eq__,{
KRK_Method(list,__eq__) {
METHOD_TAKES_EXACTLY(1);
if (!IS_list(argv[1])) return NOTIMPL_VAL();
KrkList * them = AS_list(argv[1]);
@ -104,16 +104,17 @@ KRK_METHOD(list,__eq__,{
if (!krk_valuesEqual(self->values.values[i], them->values.values[i])) return BOOLEAN_VAL(0);
}
return BOOLEAN_VAL(1);
})
}
KRK_METHOD(list,append,{
KRK_Method(list,append) {
METHOD_TAKES_EXACTLY(1);
pthread_rwlock_wrlock(&self->rwlock);
krk_writeValueArray(&self->values, argv[1]);
pthread_rwlock_unlock(&self->rwlock);
})
return NONE_VAL();
}
KRK_METHOD(list,insert,{
KRK_Method(list,insert) {
METHOD_TAKES_EXACTLY(2);
CHECK_ARG(1,int,krk_integer_type,index);
pthread_rwlock_wrlock(&self->rwlock);
@ -126,9 +127,10 @@ KRK_METHOD(list,insert,{
);
self->values.values[index] = argv[2];
pthread_rwlock_unlock(&self->rwlock);
})
return NONE_VAL();
}
KRK_METHOD(list,__repr__,{
KRK_Method(list,__repr__) {
METHOD_TAKES_NONE();
if (((KrkObj*)self)->flags & KRK_OBJ_FLAGS_IN_REPR) return OBJECT_VAL(S("[...]"));
((KrkObj*)self)->flags |= KRK_OBJ_FLAGS_IN_REPR;
@ -154,8 +156,7 @@ KRK_METHOD(list,__repr__,{
pushStringBuilder(&sb,']');
((KrkObj*)self)->flags &= ~(KRK_OBJ_FLAGS_IN_REPR);
return finishStringBuilder(&sb);
})
}
static int _list_extend_callback(void * context, const KrkValue * values, size_t count) {
KrkValueArray * positionals = context;
@ -172,7 +173,7 @@ static int _list_extend_callback(void * context, const KrkValue * values, size_t
return 0;
}
KRK_METHOD(list,extend,{
KRK_Method(list,extend) {
METHOD_TAKES_EXACTLY(1);
pthread_rwlock_wrlock(&self->rwlock);
KrkValueArray * positionals = AS_LIST(argv[0]);
@ -184,10 +185,10 @@ KRK_METHOD(list,extend,{
krk_unpackIterable(other, positionals, _list_extend_callback);
pthread_rwlock_unlock(&self->rwlock);
})
#undef unpackArray
return NONE_VAL();
}
KRK_METHOD(list,__init__,{
KRK_Method(list,__init__) {
METHOD_TAKES_AT_MOST(1);
krk_initValueArray(AS_LIST(argv[0]));
pthread_rwlock_init(&self->rwlock, NULL);
@ -195,9 +196,9 @@ KRK_METHOD(list,__init__,{
_list_extend(2,(KrkValue[]){argv[0],argv[1]},0);
}
return argv[0];
})
}
KRK_METHOD(list,__mul__,{
KRK_Method(list,__mul__) {
METHOD_TAKES_EXACTLY(1);
CHECK_ARG(1,int,krk_integer_type,howMany);
@ -210,14 +211,14 @@ KRK_METHOD(list,__mul__,{
}
return krk_pop();
})
}
KRK_METHOD(list,__len__,{
KRK_Method(list,__len__) {
METHOD_TAKES_NONE();
return INTEGER_VAL(self->values.count);
})
}
KRK_METHOD(list,__contains__,{
KRK_Method(list,__contains__) {
METHOD_TAKES_EXACTLY(1);
pthread_rwlock_rdlock(&self->rwlock);
for (size_t i = 0; i < self->values.count; ++i) {
@ -229,9 +230,9 @@ KRK_METHOD(list,__contains__,{
}
pthread_rwlock_unlock(&self->rwlock);
return BOOLEAN_VAL(0);
})
}
KRK_METHOD(list,pop,{
KRK_Method(list,pop) {
METHOD_TAKES_AT_MOST(1);
pthread_rwlock_wrlock(&self->rwlock);
krk_integer_type index = self->values.count - 1;
@ -254,9 +255,9 @@ KRK_METHOD(list,pop,{
pthread_rwlock_unlock(&self->rwlock);
return outItem;
}
})
}
KRK_METHOD(list,__setitem__,{
KRK_Method(list,__setitem__) {
METHOD_TAKES_EXACTLY(2);
if (IS_INTEGER(argv[1])) {
CHECK_ARG(1,int,krk_integer_type,index);
@ -299,10 +300,9 @@ KRK_METHOD(list,__setitem__,{
} else {
return TYPE_ERROR(int or slice, argv[1]);
}
})
}
KRK_METHOD(list,__delitem__,{
KRK_Method(list,__delitem__) {
METHOD_TAKES_EXACTLY(1);
if (IS_INTEGER(argv[1])) {
@ -325,9 +325,11 @@ KRK_METHOD(list,__delitem__,{
} else {
return TYPE_ERROR(int or slice, argv[1]);
}
})
KRK_METHOD(list,remove,{
return NONE_VAL();
}
KRK_Method(list,remove) {
METHOD_TAKES_EXACTLY(1);
pthread_rwlock_wrlock(&self->rwlock);
for (size_t i = 0; i < self->values.count; ++i) {
@ -342,16 +344,17 @@ KRK_METHOD(list,remove,{
}
pthread_rwlock_unlock(&self->rwlock);
return krk_runtimeError(vm.exceptions->valueError, "not found");
})
}
KRK_METHOD(list,clear,{
KRK_Method(list,clear) {
METHOD_TAKES_NONE();
pthread_rwlock_wrlock(&self->rwlock);
krk_freeValueArray(&self->values);
pthread_rwlock_unlock(&self->rwlock);
})
return NONE_VAL();
}
KRK_METHOD(list,index,{
KRK_Method(list,index) {
METHOD_TAKES_AT_LEAST(1);
METHOD_TAKES_AT_MOST(3);
@ -389,9 +392,9 @@ KRK_METHOD(list,index,{
pthread_rwlock_unlock(&self->rwlock);
return krk_runtimeError(vm.exceptions->valueError, "not found");
})
}
KRK_METHOD(list,count,{
KRK_Method(list,count) {
METHOD_TAKES_EXACTLY(1);
krk_integer_type count = 0;
@ -403,17 +406,17 @@ KRK_METHOD(list,count,{
pthread_rwlock_unlock(&self->rwlock);
return INTEGER_VAL(count);
})
}
KRK_METHOD(list,copy,{
KRK_Method(list,copy) {
METHOD_TAKES_NONE();
pthread_rwlock_rdlock(&self->rwlock);
KrkValue result = krk_list_of(self->values.count, self->values.values, 0);
pthread_rwlock_unlock(&self->rwlock);
return result;
})
}
KRK_METHOD(list,reverse,{
KRK_Method(list,reverse) {
METHOD_TAKES_NONE();
pthread_rwlock_wrlock(&self->rwlock);
for (size_t i = 0; i < (self->values.count) / 2; i++) {
@ -423,7 +426,7 @@ KRK_METHOD(list,reverse,{
}
pthread_rwlock_unlock(&self->rwlock);
return NONE_VAL();
})
}
static int _list_sorter(const void * _a, const void * _b) {
KrkValue a = *(KrkValue*)_a;
@ -438,15 +441,17 @@ static int _list_sorter(const void * _a, const void * _b) {
return 0;
}
KRK_METHOD(list,sort,{
KRK_Method(list,sort) {
METHOD_TAKES_NONE();
pthread_rwlock_wrlock(&self->rwlock);
qsort(self->values.values, self->values.count, sizeof(KrkValue), _list_sorter);
pthread_rwlock_unlock(&self->rwlock);
})
KRK_METHOD(list,__add__,{
return NONE_VAL();
}
KRK_Method(list,__add__) {
METHOD_TAKES_EXACTLY(1);
if (!IS_list(argv[1])) return TYPE_ERROR(list,argv[1]);
@ -455,11 +460,11 @@ KRK_METHOD(list,__add__,{
pthread_rwlock_unlock(&self->rwlock);
FUNC_NAME(list,extend)(2,(KrkValue[]){outList,argv[1]},0); /* extend */
return outList;
})
}
FUNC_SIG(listiterator,__init__);
KRK_METHOD(list,__iter__,{
KRK_Method(list,__iter__) {
METHOD_TAKES_NONE();
KrkInstance * output = krk_newInstance(vm.baseClasses->listiteratorClass);
@ -468,7 +473,7 @@ KRK_METHOD(list,__iter__,{
krk_pop();
return OBJECT_VAL(output);
})
}
#undef CURRENT_CTYPE
@ -486,13 +491,13 @@ static void _listiterator_gcscan(KrkInstance * self) {
krk_markValue(((struct ListIterator*)self)->l);
}
KRK_METHOD(listiterator,__init__,{
KRK_Method(listiterator,__init__) {
METHOD_TAKES_EXACTLY(1);
CHECK_ARG(1,list,KrkList*,list);
self->l = argv[1];
self->i = 0;
return argv[0];
})
}
FUNC_SIG(listiterator,__call__) {
static __attribute__ ((unused)) const char* _method_name = "__call__";

88
src/obj_long.c
View File

@ -1174,7 +1174,7 @@ static void _long_gcsweep(KrkInstance * self) {
krk_long_clear(((struct BigInt*)self)->value);
}
KRK_METHOD(long,__init__,{
KRK_Method(long,__init__) {
METHOD_TAKES_AT_MOST(1);
if (argc < 2) {
make_long(0,self);
@ -1197,7 +1197,7 @@ KRK_METHOD(long,__init__,{
}
/* our value should be set */
return argv[0];
})
}
/**
* Float conversions.
@ -1218,9 +1218,9 @@ static double krk_long_get_double(const KrkLong * value) {
return out;
}
KRK_METHOD(long,__float__,{
KRK_Method(long,__float__) {
return FLOATING_VAL(krk_long_get_double(self->value));
})
}
static KrkValue _krk_long_truediv(KrkLong * top, KrkLong * bottom) {
if (bottom->width == 0) return krk_runtimeError(vm.exceptions->valueError, "float division by zero");
@ -1244,39 +1244,39 @@ static KrkValue checked_float_div(double top, double bottom) {
return FLOATING_VAL(top/bottom);
}
KRK_METHOD(long,__truediv__,{
KRK_Method(long,__truediv__) {
krk_long tmp;
if (IS_long(argv[1])) krk_long_init_copy(tmp, AS_long(argv[1])->value);
else if (IS_INTEGER(argv[1])) krk_long_init_si(tmp, AS_INTEGER(argv[1]));
else if (IS_FLOATING(argv[1])) return checked_float_div(krk_long_get_double(self->value), AS_FLOATING(argv[1]));
else return NOTIMPL_VAL();
return _krk_long_truediv(self->value,tmp);
})
}
KRK_METHOD(long,__rtruediv__,{
KRK_Method(long,__rtruediv__) {
krk_long tmp;
if (IS_long(argv[1])) krk_long_init_copy(tmp, AS_long(argv[1])->value);
else if (IS_INTEGER(argv[1])) krk_long_init_si(tmp, AS_INTEGER(argv[1]));
else if (IS_FLOATING(argv[1])) return checked_float_div(AS_FLOATING(argv[1]), krk_long_get_double(self->value));
else return NOTIMPL_VAL();
return _krk_long_truediv(tmp,self->value);
})
}
#define PRINTER(name,base,prefix) \
KRK_METHOD(long,__ ## name ## __,{ \
KRK_Method(long,__ ## name ## __) { \
size_t size; \
char * rev = krk_long_to_str(self->value, base, prefix, &size); \
return OBJECT_VAL(krk_takeString(rev,size)); \
})
}
PRINTER(str,10,"")
PRINTER(hex,16,"x0")
PRINTER(oct,8,"o0")
PRINTER(bin,2,"b0")
KRK_METHOD(long,__hash__,{
KRK_Method(long,__hash__) {
return INTEGER_VAL((uint32_t)(krk_long_medium(self->value)));
})
}
static KrkValue make_long_obj(KrkLong * val) {
krk_integer_type maybe = 0;
@ -1309,12 +1309,12 @@ KrkValue krk_parse_int(const char * start, size_t width, unsigned int base) {
return make_long_obj(&_value);
}
KRK_METHOD(long,__int__,{
KRK_Method(long,__int__) {
return INTEGER_VAL(krk_long_medium(self->value));
})
}
#define BASIC_BIN_OP_FLOATS(name, long_func, MAYBE_FLOAT, MAYBE_FLOAT_INV) \
KRK_METHOD(long,__ ## name ## __,{ \
KRK_Method(long,__ ## name ## __) { \
krk_long tmp; \
if (IS_long(argv[1])) krk_long_init_copy(tmp, AS_long(argv[1])->value); \
else if (IS_INTEGER(argv[1])) krk_long_init_si(tmp, AS_INTEGER(argv[1])); \
@ -1322,8 +1322,8 @@ KRK_METHOD(long,__int__,{
else return NOTIMPL_VAL(); \
long_func(tmp,self->value,tmp); \
return make_long_obj(tmp); \
}) \
KRK_METHOD(long,__r ## name ## __,{ \
} \
KRK_Method(long,__r ## name ## __) { \
krk_long tmp; \
if (IS_long(argv[1])) krk_long_init_copy(tmp, AS_long(argv[1])->value); \
else if (IS_INTEGER(argv[1])) krk_long_init_si(tmp, AS_INTEGER(argv[1])); \
@ -1331,7 +1331,7 @@ KRK_METHOD(long,__int__,{
else return NOTIMPL_VAL(); \
long_func(tmp,tmp,self->value); \
return make_long_obj(tmp); \
}) \
} \
_noexport \
KrkValue krk_long_coerced_ ## name (krk_integer_type a, krk_integer_type b) { \
krk_long tmp_res, tmp_a, tmp_b; \
@ -1455,7 +1455,7 @@ BASIC_BIN_OP(floordiv,_krk_long_div)
BASIC_BIN_OP(pow,_krk_long_pow)
#define COMPARE_OP(name, comp) \
KRK_METHOD(long,__ ## name ## __,{ \
KRK_Method(long,__ ## name ## __) { \
krk_long tmp; \
if (IS_long(argv[1])) krk_long_init_copy(tmp, AS_long(argv[1])->value); \
else if (IS_INTEGER(argv[1])) krk_long_init_si(tmp, AS_INTEGER(argv[1])); \
@ -1464,7 +1464,7 @@ BASIC_BIN_OP(pow,_krk_long_pow)
int cmp = krk_long_compare(self->value,tmp); \
krk_long_clear(tmp); \
return BOOLEAN_VAL(cmp comp 0); \
})
}
COMPARE_OP(lt, <)
COMPARE_OP(gt, >)
@ -1475,11 +1475,11 @@ COMPARE_OP(eq, ==)
#undef BASIC_BIN_OP
#undef COMPARE_OP
KRK_METHOD(long,__len__,{
KRK_Method(long,__len__) {
return INTEGER_VAL(krk_long_sign(self->value));
})
}
KRK_METHOD(long,__invert__,{
KRK_Method(long,__invert__) {
KrkLong tmp, one;
krk_long_init_copy(&tmp, self->value);
krk_long_init_si(&one, 1);
@ -1487,21 +1487,21 @@ KRK_METHOD(long,__invert__,{
krk_long_set_sign(&tmp, tmp.width > 0 ? -1 : 1);
krk_long_clear(&one);
return make_long_obj(&tmp);
})
}
KRK_METHOD(long,__neg__,{
KRK_Method(long,__neg__) {
KrkLong tmp;
krk_long_init_copy(&tmp, self->value);
krk_long_set_sign(&tmp, tmp.width > 0 ? -1 : 1);
return make_long_obj(&tmp);
})
}
KRK_METHOD(long,__abs__,{
KRK_Method(long,__abs__) {
KrkLong tmp;
krk_long_init_copy(&tmp, self->value);
krk_long_set_sign(&tmp, 1);
return make_long_obj(&tmp);
})
}
static KrkValue long_bit_count(KrkLong * val) {
size_t count = 0;
@ -1516,9 +1516,9 @@ static KrkValue long_bit_count(KrkLong * val) {
return make_long_obj(&tmp);
}
KRK_METHOD(long,bit_count,{
KRK_Method(long,bit_count) {
return long_bit_count(self->value);
})
}
static KrkValue long_bit_length(KrkLong * val) {
size_t bits = _bits_in(val);
@ -1527,9 +1527,9 @@ static KrkValue long_bit_length(KrkLong * val) {
return make_long_obj(&tmp);
}
KRK_METHOD(long,bit_length,{
KRK_Method(long,bit_length) {
return long_bit_length(self->value);
})
}
static KrkValue long_to_bytes(KrkLong * val, size_t argc, const KrkValue argv[], int hasKw) {
static const char _method_name[] = "to_bytes";
@ -1648,10 +1648,10 @@ static KrkValue long_to_bytes(KrkLong * val, size_t argc, const KrkValue argv[],
return krk_pop();
}
KRK_METHOD(long,to_bytes,{
KRK_Method(long,to_bytes) {
METHOD_TAKES_AT_LEAST(2);
return long_to_bytes(self->value, argc, argv, hasKw);
})
}
/**
* @fn long._digit_count()
@ -1661,11 +1661,11 @@ KRK_METHOD(long,to_bytes,{
* @return The number of digits in the internal representation of the long.
* The result will be negative if the long is negative.
*/
KRK_METHOD(long,_digit_count,{
KRK_Method(long,_digit_count) {
krk_long result; /* since it's a ssize_t */
krk_long_init_si(result, self->value[0].width);
return make_long_obj(result);
})
}
/**
* @fn long._get_digit(index)
@ -1677,7 +1677,7 @@ KRK_METHOD(long,_digit_count,{
* @param index Digit to get. May be an @c int or a @c long >= 0 and <= 2.
* @return An int representation of the unsigned digit @p index of the long.
*/
KRK_METHOD(long,_get_digit,{
KRK_Method(long,_get_digit) {
METHOD_TAKES_EXACTLY(1);
KrkLong * _self = self->value;
@ -1702,7 +1702,7 @@ KRK_METHOD(long,_get_digit,{
}
return INTEGER_VAL(_self->digits[index]);
})
}
#undef CURRENT_CTYPE
#define CURRENT_CTYPE krk_integer_type
@ -1713,29 +1713,29 @@ KRK_METHOD(long,_get_digit,{
* Convert to a @c long and just use those versions...
*/
KRK_METHOD(int,bit_count,{
KRK_Method(int,bit_count) {
krk_long value;
krk_long_init_si(value, self);
KrkValue out = long_bit_count(value);
krk_long_clear(value);
return out;
})
}
KRK_METHOD(int,bit_length,{
KRK_Method(int,bit_length) {
krk_long value;
krk_long_init_si(value, self);
KrkValue out = long_bit_length(value);
krk_long_clear(value);
return out;
})
}
KRK_METHOD(int,to_bytes,{
KRK_Method(int,to_bytes) {
krk_long value;
krk_long_init_si(value, self);
KrkValue out = long_to_bytes(value, argc, argv, hasKw);
krk_long_clear(value);
return out;
})
}
#undef BIND_METHOD
/* These class names conflict with C types, so we need to cheat a bit */

176
src/obj_numeric.c
View File

@ -40,31 +40,31 @@ FUNC_SIG(int,__init__) {
return krk_runtimeError(vm.exceptions->typeError, "%s() argument must be a string or a number, not '%s'", "int", krk_typeName(argv[1]));
}
KRK_METHOD(int,__str__,{
KRK_Method(int,__str__) {
char tmp[100];
size_t l = snprintf(tmp, 100, PRIkrk_int, self);
return OBJECT_VAL(krk_copyString(tmp, l));
})
}
KRK_METHOD(int,__int__,{ return argv[0]; })
KRK_METHOD(int,__float__,{ return FLOATING_VAL(self); })
KRK_Method(int,__int__) { return argv[0]; }
KRK_Method(int,__float__) { return FLOATING_VAL(self); }
KRK_METHOD(int,__chr__,{
KRK_Method(int,__chr__) {
unsigned char bytes[5] = {0};
size_t len = krk_codepointToBytes(self, bytes);
return OBJECT_VAL(krk_copyString((char*)bytes, len));
})
}
KRK_METHOD(int,__eq__,{
KRK_Method(int,__eq__) {
METHOD_TAKES_EXACTLY(1);
if (likely(IS_INTEGER(argv[1]))) return self == AS_INTEGER(argv[1]);
else if (IS_FLOATING(argv[1])) return self == AS_FLOATING(argv[1]);
return NOTIMPL_VAL();
})
}
KRK_METHOD(int,__hash__,{
KRK_Method(int,__hash__) {
return INTEGER_VAL((uint32_t)AS_INTEGER(argv[0]));
})
}
/**
* We _could_ use the __builtin_XXX_overflow(_p) functions gcc+clang provide,
@ -93,33 +93,33 @@ OVERFLOW_CHECKED_INT_OPERATION(sub,-)
OVERFLOW_CHECKED_INT_OPERATION(mul,*)
#define BASIC_BIN_OP(name,operator) \
KRK_METHOD(int,__ ## name ## __,{ \
KRK_Method(int,__ ## name ## __) { \
if (likely(IS_INTEGER(argv[1]))) return krk_int_op_ ## name(self, AS_INTEGER(argv[1])); \
else if (likely(IS_FLOATING(argv[1]))) return FLOATING_VAL((double)self operator AS_FLOATING(argv[1])); \
return NOTIMPL_VAL(); \
}) \
KRK_METHOD(int,__r ## name ## __,{ \
} \
KRK_Method(int,__r ## name ## __) { \
if (likely(IS_INTEGER(argv[1]))) return krk_int_op_ ## name(AS_INTEGER(argv[1]), self); \
else if (likely(IS_FLOATING(argv[1]))) return FLOATING_VAL(AS_FLOATING(argv[1]) operator (double)self); \
return NOTIMPL_VAL(); \
})
}
#define INT_ONLY_BIN_OP(name,operator) \
KRK_METHOD(int,__ ## name ## __,{ \
KRK_Method(int,__ ## name ## __) { \
if (likely(IS_INTEGER(argv[1]))) return INTEGER_VAL(self operator AS_INTEGER(argv[1])); \
return NOTIMPL_VAL(); \
}) \
KRK_METHOD(int,__r ## name ## __,{ \
} \
KRK_Method(int,__r ## name ## __) { \
if (likely(IS_INTEGER(argv[1]))) return INTEGER_VAL(AS_INTEGER(argv[1]) operator self); \
return NOTIMPL_VAL(); \
})
}
#define COMPARE_OP(name,operator) \
KRK_METHOD(int,__ ## name ## __,{ \
KRK_Method(int,__ ## name ## __) { \
if (likely(IS_INTEGER(argv[1]))) return BOOLEAN_VAL(self operator AS_INTEGER(argv[1])); \
else if (likely(IS_FLOATING(argv[1]))) return BOOLEAN_VAL((double)self operator AS_FLOATING(argv[1])); \
return NOTIMPL_VAL(); \
})
}
BASIC_BIN_OP(add,+)
BASIC_BIN_OP(sub,-)
@ -130,14 +130,14 @@ INT_ONLY_BIN_OP(and,&)
#define DEFER_TO_LONG(name) \
extern KrkValue krk_long_coerced_ ## name (krk_integer_type a, krk_integer_type b); \
KRK_METHOD(int,__ ## name ## __,{ \
KRK_Method(int,__ ## name ## __) { \
if (likely(IS_INTEGER(argv[1]))) return krk_long_coerced_ ## name (self, AS_INTEGER(argv[1])); \
return NOTIMPL_VAL(); \
}) \
KRK_METHOD(int,__r ## name ## __,{ \
} \
KRK_Method(int,__r ## name ## __) { \
if (likely(IS_INTEGER(argv[1]))) return krk_long_coerced_ ## name (AS_INTEGER(argv[1]), self); \
return NOTIMPL_VAL(); \
})
}
DEFER_TO_LONG(lshift)
DEFER_TO_LONG(rshift)
@ -152,7 +152,7 @@ COMPARE_OP(ge, >=)
#undef INT_ONLY_BIN_OP
#undef COMPARE_OP
KRK_METHOD(int,__truediv__,{
KRK_Method(int,__truediv__) {
METHOD_TAKES_EXACTLY(1);
if (likely(IS_INTEGER(argv[1]))) {
krk_integer_type b = AS_INTEGER(argv[1]);
@ -164,15 +164,15 @@ KRK_METHOD(int,__truediv__,{
return FLOATING_VAL((double)self / b);
}
return NOTIMPL_VAL();
})
}
KRK_METHOD(int,__rtruediv__,{
KRK_Method(int,__rtruediv__) {
METHOD_TAKES_EXACTLY(1);
if (unlikely(self == 0)) return krk_runtimeError(vm.exceptions->zeroDivisionError, "integer division by zero");
else if (likely(IS_INTEGER(argv[1]))) return FLOATING_VAL((double)AS_INTEGER(argv[1]) / (double)self);
else if (likely(IS_FLOATING(argv[1]))) return FLOATING_VAL(AS_FLOATING(argv[1]) / (double)self);
return NOTIMPL_VAL();
})
}
#ifdef __TINYC__
#include <math.h>
@ -214,20 +214,20 @@ static KrkValue _krk_int_mod(krk_integer_type a, krk_integer_type b) {
}
KRK_METHOD(int,__mod__,{
KRK_Method(int,__mod__) {
METHOD_TAKES_EXACTLY(1);
if (likely(IS_INTEGER(argv[1]))) return _krk_int_mod(self, AS_INTEGER(argv[1]));
return NOTIMPL_VAL();
})
}
KRK_METHOD(int,__rmod__,{
KRK_Method(int,__rmod__) {
METHOD_TAKES_EXACTLY(1);
if (likely(IS_INTEGER(argv[1]))) return _krk_int_mod(AS_INTEGER(argv[1]), self);
return NOTIMPL_VAL();
})
}
KRK_METHOD(int,__floordiv__,{
KRK_Method(int,__floordiv__) {
METHOD_TAKES_EXACTLY(1);
if (likely(IS_INTEGER(argv[1]))) {
return _krk_int_div(self,AS_INTEGER(argv[1]));
@ -237,33 +237,33 @@ KRK_METHOD(int,__floordiv__,{
return FLOATING_VAL(__builtin_floor((double)self / b));
}
return NOTIMPL_VAL();
})
}
KRK_METHOD(int,__rfloordiv__,{
KRK_Method(int,__rfloordiv__) {
METHOD_TAKES_EXACTLY(1);
if (unlikely(self == 0)) return krk_runtimeError(vm.exceptions->zeroDivisionError, "integer division by zero");
else if (likely(IS_INTEGER(argv[1]))) return _krk_int_div(AS_INTEGER(argv[1]), self);
else if (likely(IS_FLOATING(argv[1]))) return FLOATING_VAL(__builtin_floor(AS_FLOATING(argv[1]) / (double)self));
return NOTIMPL_VAL();
})
}
KRK_METHOD(int,__hex__,{
KRK_Method(int,__hex__) {
METHOD_TAKES_NONE();
char tmp[20];
unsigned long long val = self < 0 ? -self : self;
size_t len = snprintf(tmp, 20, "%s0x%llx", self < 0 ? "-" : "", val);
return OBJECT_VAL(krk_copyString(tmp,len));
})
}
KRK_METHOD(int,__oct__,{
KRK_Method(int,__oct__) {
METHOD_TAKES_NONE();
char tmp[20];
unsigned long long val = self < 0 ? -self : self;
size_t len = snprintf(tmp, 20, "%s0o%llo", self < 0 ? "-" : "", val);
return OBJECT_VAL(krk_copyString(tmp,len));
})
}
KRK_METHOD(int,__bin__,{
KRK_Method(int,__bin__) {
METHOD_TAKES_NONE();
unsigned long long val = self;
if (self < 0) val = -val;
@ -288,19 +288,19 @@ KRK_METHOD(int,__bin__,{
}
return finishStringBuilder(&sb);
})
}
KRK_METHOD(int,__invert__,{
KRK_Method(int,__invert__) {
return INTEGER_VAL(~self);
})
}
KRK_METHOD(int,__neg__,{
KRK_Method(int,__neg__) {
return INTEGER_VAL(-self);
})
}
KRK_METHOD(int,__abs__,{
KRK_Method(int,__abs__) {
return self < 0 ? INTEGER_VAL(-self) : INTEGER_VAL(self);
})
}
#undef CURRENT_CTYPE
#define CURRENT_CTYPE double
@ -331,8 +331,8 @@ FUNC_SIG(float,__init__) {
return krk_runtimeError(vm.exceptions->typeError, "%s() argument must be a string or a number, not '%s'", "float", krk_typeName(argv[1]));
}
KRK_METHOD(float,__int__,{ return INTEGER_VAL(self); })
KRK_METHOD(float,__float__,{ return argv[0]; })
KRK_Method(float,__int__) { return INTEGER_VAL(self); }
KRK_Method(float,__float__) { return argv[0]; }
static int isDigits(const char * c) {
while (*c) {
@ -342,55 +342,55 @@ static int isDigits(const char * c) {
return 1;
}
KRK_METHOD(float,__str__,{
KRK_Method(float,__str__) {
char tmp[100];
size_t l = snprintf(tmp, 97, "%.16g", self);
if (!strstr(tmp,".") && isDigits(tmp)) {
l = snprintf(tmp,100,"%.16g.0",self);
}
return OBJECT_VAL(krk_copyString(tmp, l));
})
}
KRK_METHOD(float,__eq__,{
KRK_Method(float,__eq__) {
METHOD_TAKES_EXACTLY(1);
if (IS_INTEGER(argv[1])) return self == (double)AS_INTEGER(argv[1]);
else if (IS_FLOATING(argv[1])) return self == AS_FLOATING(argv[1]);
return NOTIMPL_VAL();
})
}
KRK_METHOD(float,__hash__,{
KRK_Method(float,__hash__) {
return INTEGER_VAL((uint32_t)self);
})
}
KRK_METHOD(float,__neg__,{
KRK_Method(float,__neg__) {
return FLOATING_VAL(-self);
})
}
KRK_METHOD(float,__abs__,{
KRK_Method(float,__abs__) {
return self < 0.0 ? FLOATING_VAL(-self) : INTEGER_VAL(self);
})
}
#define BASIC_BIN_OP(name,operator) \
KRK_METHOD(float,__ ## name ## __,{ \
KRK_Method(float,__ ## name ## __) { \
METHOD_TAKES_EXACTLY(1); \
if (likely(IS_FLOATING(argv[1]))) return FLOATING_VAL(self operator AS_FLOATING(argv[1])); \
else if (likely(IS_INTEGER(argv[1]))) return FLOATING_VAL(self operator (double)AS_INTEGER(argv[1])); \
return NOTIMPL_VAL(); \
}) \
KRK_METHOD(float,__r ## name ## __,{ \
} \
KRK_Method(float,__r ## name ## __) { \
METHOD_TAKES_EXACTLY(1); \
if (likely(IS_FLOATING(argv[1]))) return FLOATING_VAL(AS_FLOATING(argv[1]) operator self); \
else if (likely(IS_INTEGER(argv[1]))) return FLOATING_VAL((double)AS_INTEGER(argv[1]) operator self); \
return NOTIMPL_VAL(); \
})
}
#define COMPARE_OP(name,operator) \
KRK_METHOD(float,__ ## name ## __,{ \
KRK_Method(float,__ ## name ## __) { \
METHOD_TAKES_EXACTLY(1); \
if (likely(IS_FLOATING(argv[1]))) return BOOLEAN_VAL(self operator AS_FLOATING(argv[1])); \
else if (likely(IS_INTEGER(argv[1]))) return BOOLEAN_VAL(self operator (double)AS_INTEGER(argv[1])); \
return NOTIMPL_VAL(); \
})
}
BASIC_BIN_OP(add,+)
BASIC_BIN_OP(sub,-)
@ -403,7 +403,7 @@ COMPARE_OP(ge, >=)
#undef BASIC_BIN_OP
#undef COMPARE_OP
KRK_METHOD(float,__truediv__,{
KRK_Method(float,__truediv__) {
METHOD_TAKES_EXACTLY(1);
if (likely(IS_FLOATING(argv[1]))) {
double b = AS_FLOATING(argv[1]);
@ -415,17 +415,17 @@ KRK_METHOD(float,__truediv__,{
return FLOATING_VAL(self / (double)b);
}
return NOTIMPL_VAL();
})
}
KRK_METHOD(float,__rtruediv__,{
KRK_Method(float,__rtruediv__) {
METHOD_TAKES_EXACTLY(1);
if (unlikely(self == 0.0)) return krk_runtimeError(vm.exceptions->zeroDivisionError, "float division by zero");
else if (likely(IS_FLOATING(argv[1]))) return FLOATING_VAL(AS_FLOATING(argv[1]) / self);
else if (likely(IS_INTEGER(argv[1]))) return FLOATING_VAL((double)AS_INTEGER(argv[1]) / self);
return NOTIMPL_VAL();
})
}
KRK_METHOD(float,__floordiv__,{
KRK_Method(float,__floordiv__) {
METHOD_TAKES_EXACTLY(1);
if (likely(IS_INTEGER(argv[1]))) {
krk_integer_type b = AS_INTEGER(argv[1]);
@ -437,15 +437,15 @@ KRK_METHOD(float,__floordiv__,{
return FLOATING_VAL(__builtin_floor(self / b));
}
return NOTIMPL_VAL();
})
}
KRK_METHOD(float,__rfloordiv__,{
KRK_Method(float,__rfloordiv__) {
METHOD_TAKES_EXACTLY(1);
if (unlikely(self == 0.0)) return krk_runtimeError(vm.exceptions->zeroDivisionError, "float division by zero");
else if (likely(IS_INTEGER(argv[1]))) return FLOATING_VAL((double)AS_INTEGER(argv[1]) / self);
else if (IS_FLOATING(argv[1])) return FLOATING_VAL(__builtin_floor(AS_FLOATING(argv[1]) / self));
return NOTIMPL_VAL();
})
}
#undef CURRENT_CTYPE
#define CURRENT_CTYPE krk_integer_type
@ -457,28 +457,28 @@ FUNC_SIG(bool,__init__) {
return BOOLEAN_VAL(!krk_isFalsey(argv[1]));
}
KRK_METHOD(bool,__str__,{
KRK_Method(bool,__str__) {
return OBJECT_VAL((self ? S("True") : S("False")));
})
}
FUNC_SIG(NoneType,__init__) {
if (argc > 1) return krk_runtimeError(vm.exceptions->argumentError, "%s takes no arguments", "NoneType");
return NONE_VAL();
}
KRK_METHOD(NoneType,__str__,{
KRK_Method(NoneType,__str__) {
return OBJECT_VAL(S("None"));
})
}
KRK_METHOD(NoneType,__hash__,{
KRK_Method(NoneType,__hash__) {
return INTEGER_VAL((uint32_t)AS_INTEGER(argv[0]));
})
}
KRK_METHOD(NoneType,__eq__,{
KRK_Method(NoneType,__eq__) {
METHOD_TAKES_EXACTLY(1);
if (IS_NONE(argv[1])) return BOOLEAN_VAL(1);
return NOTIMPL_VAL();
})
}
#define IS_NotImplementedType(o) IS_NOTIMPL(o)
#define AS_NotImplementedType(o) (1)
@ -488,19 +488,19 @@ FUNC_SIG(NotImplementedType,__init__) {
return NOTIMPL_VAL();
}
KRK_METHOD(NotImplementedType,__str__,{
KRK_Method(NotImplementedType,__str__) {
return OBJECT_VAL(S("NotImplemented"));
})
}
KRK_METHOD(NotImplementedType,__hash__,{
KRK_Method(NotImplementedType,__hash__) {
return INTEGER_VAL(0);
})
}
KRK_METHOD(NotImplementedType,__eq__,{
KRK_Method(NotImplementedType,__eq__) {
METHOD_TAKES_EXACTLY(1);
if (IS_NOTIMPL(argv[1])) return BOOLEAN_VAL(1);
return NOTIMPL_VAL();
})
}
#undef BIND_METHOD
/* These class names conflict with C types, so we need to cheat a bit */

20
src/obj_range.c
View File

@ -35,7 +35,7 @@ FUNC_SIG(rangeiterator,__init__);
#define CURRENT_NAME self
#define CURRENT_CTYPE struct Range *
KRK_METHOD(range,__init__,{
KRK_Method(range,__init__) {
METHOD_TAKES_AT_LEAST(1);
METHOD_TAKES_AT_MOST(3);
self->min = 0;
@ -57,9 +57,9 @@ KRK_METHOD(range,__init__,{
}
}
return argv[0];
})
}
KRK_METHOD(range,__repr__,{
KRK_Method(range,__repr__) {
METHOD_TAKES_NONE();
krk_integer_type min = self->min;
krk_integer_type max = self->max;
@ -73,9 +73,9 @@ KRK_METHOD(range,__repr__,{
len = snprintf(tmp,1024,"range(" PRIkrk_int "," PRIkrk_int "," PRIkrk_int ")", min, max, step);
}
return OBJECT_VAL(krk_copyString(tmp,len));
})
}
KRK_METHOD(range,__iter__,{
KRK_Method(range,__iter__) {
KrkInstance * output = krk_newInstance(rangeiterator);
krk_integer_type min = self->min;
krk_integer_type max = self->max;
@ -86,12 +86,12 @@ KRK_METHOD(range,__iter__,{
krk_pop();
return OBJECT_VAL(output);
})
}
#undef CURRENT_CTYPE
#define CURRENT_CTYPE struct RangeIterator *
KRK_METHOD(rangeiterator,__init__,{
KRK_Method(rangeiterator,__init__) {
METHOD_TAKES_EXACTLY(3);
CHECK_ARG(1,int,krk_integer_type,i);
CHECK_ARG(2,int,krk_integer_type,max);
@ -100,9 +100,9 @@ KRK_METHOD(rangeiterator,__init__,{
self->max = max;
self->step = step;
return argv[0];
})
}
KRK_METHOD(rangeiterator,__call__,{
KRK_Method(rangeiterator,__call__) {
METHOD_TAKES_NONE();
krk_integer_type i = self->i;
if (self->step > 0 ? (i >= self->max) : (i <= self->max)) {
@ -111,7 +111,7 @@ KRK_METHOD(rangeiterator,__call__,{
self->i = i + self->step;
return INTEGER_VAL(i);
}
})
}
_noexport
void _createAndBind_rangeClass(void) {

64
src/obj_set.c
View File

@ -56,22 +56,22 @@ static int _set_init_callback(void * context, const KrkValue * values, size_t co
return 0;
}
KRK_METHOD(set,__init__,{
KRK_Method(set,__init__) {
METHOD_TAKES_AT_MOST(1);
krk_initTable(&self->entries);
if (argc == 2) {
if (krk_unpackIterable(argv[1], self, _set_init_callback)) return NONE_VAL();
}
return argv[0];
})
}
KRK_METHOD(set,__contains__,{
KRK_Method(set,__contains__) {
METHOD_TAKES_EXACTLY(1);
KrkValue _unused;
return BOOLEAN_VAL(krk_tableGet(&self->entries, argv[1], &_unused));
})
}
KRK_METHOD(set,__repr__,{
KRK_Method(set,__repr__) {
METHOD_TAKES_NONE();
if (((KrkObj*)self)->flags & KRK_OBJ_FLAGS_IN_REPR) return OBJECT_VAL("{...}");
if (!self->entries.capacity) return OBJECT_VAL(S("set()"));
@ -100,9 +100,9 @@ KRK_METHOD(set,__repr__,{
pushStringBuilder(&sb,'}');
((KrkObj*)self)->flags &= ~(KRK_OBJ_FLAGS_IN_REPR);
return finishStringBuilder(&sb);
})
}
KRK_METHOD(set,__and__,{
KRK_Method(set,__and__) {
METHOD_TAKES_EXACTLY(1);
CHECK_ARG(1,set,struct Set*,them);
@ -128,9 +128,9 @@ KRK_METHOD(set,__and__,{
}
return krk_pop();
})
}
KRK_METHOD(set,__xor__,{
KRK_Method(set,__xor__) {
METHOD_TAKES_EXACTLY(1);
CHECK_ARG(1,set,struct Set*,them);
@ -172,10 +172,10 @@ KRK_METHOD(set,__xor__,{
}
return krk_pop();
})
}
KRK_METHOD(set,__or__,{
KRK_Method(set,__or__) {
METHOD_TAKES_EXACTLY(1);
CHECK_ARG(1,set,struct Set*,them);
@ -187,14 +187,14 @@ KRK_METHOD(set,__or__,{
krk_tableAddAll(&them->entries, &AS_set(outSet)->entries);
return krk_pop();
})
}
KRK_METHOD(set,__len__,{
KRK_Method(set,__len__) {
METHOD_TAKES_NONE();
return INTEGER_VAL(self->entries.count);
})
}
KRK_METHOD(set,__eq__,{
KRK_Method(set,__eq__) {
METHOD_TAKES_EXACTLY(1);
if (!IS_set(argv[1]))
return NOTIMPL_VAL();
@ -210,52 +210,56 @@ KRK_METHOD(set,__eq__,{
}
return BOOLEAN_VAL(1);
})
}
KRK_METHOD(set,add,{
KRK_Method(set,add) {
METHOD_TAKES_EXACTLY(1);
krk_tableSet(&self->entries, argv[1], BOOLEAN_VAL(1));
})
return NONE_VAL();
}
KRK_METHOD(set,remove,{
KRK_Method(set,remove) {
METHOD_TAKES_EXACTLY(1);
if (!krk_tableDelete(&self->entries, argv[1]))
return krk_runtimeError(vm.exceptions->keyError, "key error");
})
return NONE_VAL();
}
KRK_METHOD(set,discard,{
KRK_Method(set,discard) {
METHOD_TAKES_EXACTLY(1);
krk_tableDelete(&self->entries, argv[1]);
})
return NONE_VAL();
}
KRK_METHOD(set,clear,{
KRK_Method(set,clear) {
METHOD_TAKES_NONE();
krk_freeTable(&self->entries);
krk_initTable(&self->entries);
})
return NONE_VAL();
}
FUNC_SIG(setiterator,__init__);
KRK_METHOD(set,__iter__,{
KRK_Method(set,__iter__) {
METHOD_TAKES_NONE();
KrkInstance * output = krk_newInstance(setiterator);
krk_push(OBJECT_VAL(output));
FUNC_NAME(setiterator,__init__)(2,(KrkValue[]){krk_peek(0), argv[0]}, 0);
return krk_pop();
})
}
#undef CURRENT_CTYPE
#define CURRENT_CTYPE struct SetIterator *
KRK_METHOD(setiterator,__init__,{
KRK_Method(setiterator,__init__) {
METHOD_TAKES_EXACTLY(1);
CHECK_ARG(1,set,void*,source);
self->set = argv[1];
self->i = 0;
return argv[0];
})
}
KRK_METHOD(setiterator,__call__,{
KRK_Method(setiterator,__call__) {
METHOD_TAKES_NONE();
if (unlikely(!IS_set(self->set))) return argv[0];
@ -269,7 +273,7 @@ KRK_METHOD(setiterator,__call__,{
}
self->i++;
} while (1);
})
}
KrkValue krk_set_of(int argc, const KrkValue argv[], int hasKw) {
KrkValue outSet = OBJECT_VAL(krk_newInstance(set));

20
src/obj_slice.c
View File

@ -95,7 +95,7 @@ int krk_extractSlicer(const char * _method_name, KrkValue slicerVal, krk_integer
#define CURRENT_CTYPE struct KrkSlice *
#define CURRENT_NAME self
KRK_METHOD(slice,__init__,{
KRK_Method(slice,__init__) {
METHOD_TAKES_AT_LEAST(1);
METHOD_TAKES_AT_MOST(3);
@ -113,9 +113,9 @@ KRK_METHOD(slice,__init__,{
}
}
return argv[0];
})
}
KRK_METHOD(slice,__repr__,{
KRK_Method(slice,__repr__) {
METHOD_TAKES_NONE();
if (((KrkObj*)self)->flags & KRK_OBJ_FLAGS_IN_REPR) return OBJECT_VAL("slice(...)");
((KrkObj*)self)->flags |= KRK_OBJ_FLAGS_IN_REPR;
@ -148,22 +148,22 @@ KRK_METHOD(slice,__repr__,{
pushStringBuilder(&sb,')');
((KrkObj*)self)->flags &= ~(KRK_OBJ_FLAGS_IN_REPR);
return finishStringBuilder(&sb);
})
}
KRK_METHOD(slice,start,{
KRK_Method(slice,start) {
ATTRIBUTE_NOT_ASSIGNABLE();
return self->start;
})
}
KRK_METHOD(slice,end,{
KRK_Method(slice,end) {
ATTRIBUTE_NOT_ASSIGNABLE();
return self->end;
})
}
KRK_METHOD(slice,step,{
KRK_Method(slice,step) {
ATTRIBUTE_NOT_ASSIGNABLE();
return self->step;
})
}
_noexport
void _createAndBind_sliceClass(void) {

164
src/obj_str.c
View File

@ -25,14 +25,14 @@ static KrkValue FUNC_NAME(striterator,__init__)(int,const KrkValue[],int);
#define CODEPOINT_BYTES(cp) (cp < 0x80 ? 1 : (cp < 0x800 ? 2 : (cp < 0x10000 ? 3 : 4)))
KRK_METHOD(str,__ord__,{
KRK_Method(str,__ord__) {
METHOD_TAKES_NONE();
if (self->codesLength != 1)
return krk_runtimeError(vm.exceptions->typeError, "ord() expected a character, but string of length %d found", (int)self->codesLength);
return INTEGER_VAL(krk_unicodeCodepoint(self,0));
})
}
KRK_METHOD(str,__init__,{
KRK_Method(str,__init__) {
/* Ignore argument which would have been an instance */
if (argc < 2) {
return OBJECT_VAL(S(""));
@ -43,9 +43,9 @@ KRK_METHOD(str,__init__,{
krk_push(argv[1]);
if (!krk_getType(argv[1])->_tostr) return krk_runtimeError(vm.exceptions->typeError, "Can not convert %s to str", krk_typeName(argv[1]));
return krk_callDirect(krk_getType(argv[1])->_tostr, 1);
})
}
KRK_METHOD(str,__add__,{
KRK_Method(str,__add__) {
METHOD_TAKES_EXACTLY(1);
CHECK_ARG(1,str,KrkString*,them);
const char * a;
@ -82,34 +82,34 @@ KRK_METHOD(str,__add__,{
KrkString * result = krk_takeStringVetted(chars, length, cpLength, type, hash);
if (needsPop) krk_pop();
return OBJECT_VAL(result);
})
}
KRK_METHOD(str,__hash__,{
KRK_Method(str,__hash__) {
return INTEGER_VAL(self->obj.hash);
})
}
KRK_METHOD(str,__len__,{
KRK_Method(str,__len__) {
return INTEGER_VAL(self->codesLength);
})
}
KRK_METHOD(str,__setitem__,{
KRK_Method(str,__setitem__) {
return krk_runtimeError(vm.exceptions->typeError, "Strings are not mutable.");
})
}
/* str.__int__(base=10) */
KRK_METHOD(str,__int__,{
KRK_Method(str,__int__) {
METHOD_TAKES_AT_MOST(1);
int base = (argc < 2 || !IS_INTEGER(argv[1])) ? 0 : (int)AS_INTEGER(argv[1]);
return krk_parse_int(AS_CSTRING(argv[0]), AS_STRING(argv[0])->length, base);
})
}
/* str.__float__() */
KRK_METHOD(str,__float__,{
KRK_Method(str,__float__) {
METHOD_TAKES_NONE();
return FLOATING_VAL(strtod(AS_CSTRING(argv[0]),NULL));
})
}
KRK_METHOD(str,__getitem__,{
KRK_Method(str,__getitem__) {
METHOD_TAKES_EXACTLY(1);
if (IS_INTEGER(argv[1])) {
CHECK_ARG(1,int,krk_integer_type,asInt);
@ -167,10 +167,10 @@ KRK_METHOD(str,__getitem__,{
} else {
return TYPE_ERROR(int or slice, argv[1]);
}
})
}
/* str.format(**kwargs) */
KRK_METHOD(str,format,{
KRK_Method(str,format) {
KrkValue kwargs = NONE_VAL();
if (hasKw) {
kwargs = argv[argc];
@ -310,9 +310,9 @@ _freeAndDone:
FREE_ARRAY(char,stringBytes,stringCapacity);
free(workSpace);
return NONE_VAL();
})
}
KRK_METHOD(str,__mul__,{
KRK_Method(str,__mul__) {
METHOD_TAKES_EXACTLY(1);
if (!IS_INTEGER(argv[1])) return NOTIMPL_VAL();
CHECK_ARG(1,int,krk_integer_type,howMany);
@ -330,13 +330,13 @@ KRK_METHOD(str,__mul__,{
*c = '\0';
return OBJECT_VAL(krk_takeString(out, totalLength));
})
}
KRK_METHOD(str,__rmul__,{
KRK_Method(str,__rmul__) {
METHOD_TAKES_EXACTLY(1);
if (IS_INTEGER(argv[1])) return FUNC_NAME(str,__mul__)(argc,argv,hasKw);
return NOTIMPL_VAL();
})
}
struct _str_join_context {
struct StringBuilder * sb;
@ -366,7 +366,7 @@ static int _str_join_callback(void * context, const KrkValue * values, size_t co
}
/* str.join(list) */
KRK_METHOD(str,join,{
KRK_Method(str,join) {
METHOD_TAKES_EXACTLY(1);
struct StringBuilder sb = {0};
@ -378,7 +378,7 @@ KRK_METHOD(str,join,{
}
return finishStringBuilder(&sb);
})
}
static int isWhitespace(char c) {
return (c == ' ' || c == '\t' || c == '\n' || c == '\r');
@ -393,7 +393,7 @@ static int substringMatch(const char * haystack, size_t haystackLen, const char
}
/* str.__contains__ */
KRK_METHOD(str,__contains__,{
KRK_Method(str,__contains__) {
METHOD_TAKES_EXACTLY(1);
if (IS_NONE(argv[1])) return BOOLEAN_VAL(0);
CHECK_ARG(1,str,KrkString*,needle);
@ -403,7 +403,7 @@ KRK_METHOD(str,__contains__,{
}
}
return BOOLEAN_VAL(0);
})
}
static int charIn(char c, const char * str) {
for (const char * s = str; *s; s++) {
@ -439,21 +439,21 @@ static KrkValue _string_strip_shared(int argc, const KrkValue argv[], int which)
return OBJECT_VAL(krk_copyString(&AS_CSTRING(argv[0])[start], end-start));
}
KRK_METHOD(str,strip,{
KRK_Method(str,strip) {
METHOD_TAKES_AT_MOST(1); /* TODO */
return _string_strip_shared(argc,argv,0);
})
KRK_METHOD(str,lstrip,{
}
KRK_Method(str,lstrip) {
METHOD_TAKES_AT_MOST(1); /* TODO */
return _string_strip_shared(argc,argv,1);
})
KRK_METHOD(str,rstrip,{
}
KRK_Method(str,rstrip) {
METHOD_TAKES_AT_MOST(1); /* TODO */
return _string_strip_shared(argc,argv,2);
})
}
#define strCompare(name,lop,iop,rop) \
KRK_METHOD(str,name,{ \
KRK_Method(str,name) { \
METHOD_TAKES_EXACTLY(1); \
if (!IS_STRING(argv[1])) { \
return NOTIMPL_VAL(); \
@ -467,14 +467,14 @@ KRK_METHOD(str,rstrip,{
if (a[i] iop b[i]) return BOOLEAN_VAL(0); \
} \
return BOOLEAN_VAL((aLen rop bLen)); \
})
}
strCompare(__gt__,>,<,>)
strCompare(__lt__,<,>,<)
strCompare(__ge__,>,<,>=)
strCompare(__le__,<,>,<=)
KRK_METHOD(str,__mod__,{
KRK_Method(str,__mod__) {
METHOD_TAKES_EXACTLY(1);
KrkTuple * myTuple;
@ -578,10 +578,10 @@ _notEnough:
_exception:
discardStringBuilder(&sb);
return NONE_VAL();
})
}
/* str.split() */
KRK_METHOD(str,split,{
KRK_Method(str,split) {
METHOD_TAKES_AT_MOST(2);
if (argc > 1) {
if (!IS_STRING(argv[1])) {
@ -668,9 +668,9 @@ KRK_METHOD(str,split,{
krk_pop();
return myList;
})
}
KRK_METHOD(str,replace,{
KRK_Method(str,replace) {
METHOD_TAKES_AT_LEAST(2);
METHOD_TAKES_AT_MOST(3);
CHECK_ARG(1,str,KrkString*,oldStr);
@ -705,14 +705,14 @@ KRK_METHOD(str,replace,{
KrkValue tmp = OBJECT_VAL(krk_copyString(stringBytes, stringLength));
if (stringBytes) FREE_ARRAY(char,stringBytes,stringCapacity);
return tmp;
})
}
#define WRAP_INDEX(index) \
if (index < 0) index += self->codesLength; \
if (index < 0) index = 0; \
if (index >= (krk_integer_type)self->codesLength) index = self->codesLength
KRK_METHOD(str,find,{
KRK_Method(str,find) {
METHOD_TAKES_AT_LEAST(1);
METHOD_TAKES_AT_MOST(3);
CHECK_ARG(1,str,KrkString*,substr);
@ -752,29 +752,29 @@ KRK_METHOD(str,find,{
}
return INTEGER_VAL(-1);
})
}
KRK_METHOD(str,index,{
KRK_Method(str,index) {
KrkValue result = FUNC_NAME(str,find)(argc,argv,hasKw);
if (IS_INTEGER(result) && AS_INTEGER(result) == -1) {
return krk_runtimeError(vm.exceptions->valueError, "substring not found");
}
return result;
})
}
KRK_METHOD(str,startswith,{
KRK_Method(str,startswith) {
METHOD_TAKES_EXACTLY(1); /* I know the Python versions of these take optional start, end... */
CHECK_ARG(1,str,KrkString*,prefix);
return BOOLEAN_VAL(substringMatch(self->chars,self->length,prefix->chars,prefix->length));
})
}
KRK_METHOD(str,endswith,{
KRK_Method(str,endswith) {
METHOD_TAKES_EXACTLY(1); /* I know the Python versions of these take optional start, end... */
CHECK_ARG(1,str,KrkString*,suffix);
if (suffix->length > self->length) return BOOLEAN_VAL(0);
return BOOLEAN_VAL(substringMatch(self->chars + (self->length - suffix->length),
suffix->length, suffix->chars, suffix->length));
})
}
/**
* str.__repr__()
@ -782,7 +782,7 @@ KRK_METHOD(str,endswith,{
* Strings are special because __str__ should do nothing but __repr__
* should escape characters like quotes.
*/
KRK_METHOD(str,__repr__,{
KRK_Method(str,__repr__) {
METHOD_TAKES_NONE();
size_t stringCapacity = 0;
size_t stringLength = 0;
@ -836,17 +836,17 @@ KRK_METHOD(str,__repr__,{
KrkValue tmp = OBJECT_VAL(krk_copyString(stringBytes, stringLength));
if (stringBytes) FREE_ARRAY(char,stringBytes,stringCapacity);
return tmp;
})
}
KRK_METHOD(str,encode,{
KRK_Method(str,encode) {
METHOD_TAKES_NONE();
return OBJECT_VAL(krk_newBytes(AS_STRING(argv[0])->length, (uint8_t*)AS_CSTRING(argv[0])));
})
}
KRK_METHOD(str,__str__,{
KRK_Method(str,__str__) {
METHOD_TAKES_NONE();
return argv[0];
})
}
void krk_addObjects(void) {
KrkValue tmp = FUNC_NAME(str,__add__)(2, (KrkValue[]){krk_peek(1), krk_peek(0)},0);
@ -854,7 +854,7 @@ void krk_addObjects(void) {
krk_push(tmp);
}
KRK_METHOD(str,__iter__,{
KRK_Method(str,__iter__) {
METHOD_TAKES_NONE();
KrkInstance * output = krk_newInstance(vm.baseClasses->striteratorClass);
@ -863,7 +863,7 @@ KRK_METHOD(str,__iter__,{
krk_pop();
return OBJECT_VAL(output);
})
}
#define CHECK_ALL(test) do { \
krk_unicodeString(self); \
@ -872,35 +872,35 @@ KRK_METHOD(str,__iter__,{
if (!(test)) { return BOOLEAN_VAL(0); } \
} return BOOLEAN_VAL(1); } while (0)
KRK_METHOD(str,isalnum,{
KRK_Method(str,isalnum) {
CHECK_ALL( (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') );
})
}
KRK_METHOD(str,isalpha,{
KRK_Method(str,isalpha) {
CHECK_ALL( (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') );
})
}
KRK_METHOD(str,isdigit,{
KRK_Method(str,isdigit) {
CHECK_ALL( (c >= '0' && c <= '9') );
})
}
KRK_METHOD(str,isxdigit,{
KRK_Method(str,isxdigit) {
CHECK_ALL( (c >= 'A' && c <= 'F') || (c >= 'a' && c <= 'f') || (c >= '0' && c <= '9') );
})
}
KRK_METHOD(str,isspace, {
KRK_Method(str,isspace) {
CHECK_ALL( (c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == '\v') );
})
}
KRK_METHOD(str,islower, {
KRK_Method(str,islower) {
CHECK_ALL( (c >= 'a' && c <= 'z') );
})
}
KRK_METHOD(str,isupper, {
KRK_Method(str,isupper) {
CHECK_ALL( (c >= 'A' && c <= 'Z') );
})
}
KRK_METHOD(str,lower, {
KRK_Method(str,lower) {
METHOD_TAKES_NONE();
struct StringBuilder sb = {0};
@ -913,9 +913,9 @@ KRK_METHOD(str,lower, {
}
return finishStringBuilder(&sb);
})
}
KRK_METHOD(str,upper, {
KRK_Method(str,upper) {
METHOD_TAKES_NONE();
struct StringBuilder sb = {0};
@ -928,9 +928,9 @@ KRK_METHOD(str,upper, {
}
return finishStringBuilder(&sb);
})
}
KRK_METHOD(str,title, {
KRK_Method(str,title) {
METHOD_TAKES_NONE();
struct StringBuilder sb = {0};
@ -950,20 +950,20 @@ KRK_METHOD(str,title, {
}
return finishStringBuilder(&sb);
})
}
#undef CURRENT_CTYPE
#define CURRENT_CTYPE KrkInstance *
KRK_METHOD(striterator,__init__,{
KRK_Method(striterator,__init__) {
METHOD_TAKES_EXACTLY(1);
CHECK_ARG(1,str,KrkString*,base);
krk_push(OBJECT_VAL(self));
krk_attachNamedObject(&self->fields, "s", (KrkObj*)base);
krk_attachNamedValue(&self->fields, "i", INTEGER_VAL(0));
return krk_pop();
})
}
KRK_METHOD(striterator,__call__,{
KRK_Method(striterator,__call__) {
METHOD_TAKES_NONE();
KrkValue _str;
KrkValue _counter;
@ -985,7 +985,7 @@ KRK_METHOD(striterator,__call__,{
}
_corrupt:
return krk_runtimeError(vm.exceptions->typeError, "Corrupt str iterator: %s", errorStr);
})
}
_noexport
void _createAndBind_strClass(void) {

48
src/obj_tuple.c
View File

@ -59,20 +59,20 @@ KrkValue krk_tuple_of(int argc, const KrkValue argv[], int hasKw) {
#define CURRENT_CTYPE KrkTuple *
#define CURRENT_NAME self
KRK_METHOD(tuple,__contains__,{
KRK_Method(tuple,__contains__) {
METHOD_TAKES_EXACTLY(1);
for (size_t i = 0; i < self->values.count; ++i) {
if (krk_valuesEqual(self->values.values[i], argv[1])) return BOOLEAN_VAL(1);
}
return BOOLEAN_VAL(0);
})
}
KRK_METHOD(tuple,__len__,{
KRK_Method(tuple,__len__) {
METHOD_TAKES_NONE();
return INTEGER_VAL(self->values.count);
})
}
KRK_METHOD(tuple,__getitem__,{
KRK_Method(tuple,__getitem__) {
METHOD_TAKES_EXACTLY(1);
if (IS_INTEGER(argv[1])) {
CHECK_ARG(1,int,krk_integer_type,index);
@ -111,9 +111,9 @@ KRK_METHOD(tuple,__getitem__,{
} else {
return TYPE_ERROR(int or slice, argv[1]);
}
})
}
KRK_METHOD(tuple,__eq__,{
KRK_Method(tuple,__eq__) {
METHOD_TAKES_EXACTLY(1);
if (!IS_tuple(argv[1])) return NOTIMPL_VAL();
KrkTuple * them = AS_tuple(argv[1]);
@ -122,9 +122,9 @@ KRK_METHOD(tuple,__eq__,{
if (!krk_valuesEqual(self->values.values[i], them->values.values[i])) return BOOLEAN_VAL(0);
}
return BOOLEAN_VAL(1);
})
}
KRK_METHOD(tuple,__lt__,{
KRK_Method(tuple,__lt__) {
METHOD_TAKES_EXACTLY(1);
if (!IS_tuple(argv[1])) return NOTIMPL_VAL();
KrkTuple * them = AS_tuple(argv[1]);
@ -139,9 +139,9 @@ KRK_METHOD(tuple,__lt__,{
/* continue on == */
}
return BOOLEAN_VAL((self->values.count < them->values.count));
})
}
KRK_METHOD(tuple,__gt__,{
KRK_Method(tuple,__gt__) {
METHOD_TAKES_EXACTLY(1);
if (!IS_tuple(argv[1])) return NOTIMPL_VAL();
KrkTuple * them = AS_tuple(argv[1]);
@ -155,9 +155,9 @@ KRK_METHOD(tuple,__gt__,{
if (IS_BOOLEAN(ltComp) && AS_BOOLEAN(ltComp)) return BOOLEAN_VAL(0);
}
return BOOLEAN_VAL((self->values.count > them->values.count));
})
}
KRK_METHOD(tuple,__le__,{
KRK_Method(tuple,__le__) {
METHOD_TAKES_EXACTLY(1);
if (!IS_tuple(argv[1])) return NOTIMPL_VAL();
KrkTuple * them = AS_tuple(argv[1]);
@ -172,9 +172,9 @@ KRK_METHOD(tuple,__le__,{
/* continue on == */
}
return BOOLEAN_VAL((self->values.count <= them->values.count));
})
}
KRK_METHOD(tuple,__ge__,{
KRK_Method(tuple,__ge__) {
METHOD_TAKES_EXACTLY(1);
if (!IS_tuple(argv[1])) return NOTIMPL_VAL();
KrkTuple * them = AS_tuple(argv[1]);
@ -188,9 +188,9 @@ KRK_METHOD(tuple,__ge__,{
if (IS_BOOLEAN(ltComp) && AS_BOOLEAN(ltComp)) return BOOLEAN_VAL(0);
}
return BOOLEAN_VAL((self->values.count >= them->values.count));
})
}
KRK_METHOD(tuple,__repr__,{
KRK_Method(tuple,__repr__) {
if (((KrkObj*)self)->flags & KRK_OBJ_FLAGS_IN_REPR) return OBJECT_VAL(S("(...)"));
((KrkObj*)self)->flags |= KRK_OBJ_FLAGS_IN_REPR;
/* String building time. */
@ -216,9 +216,9 @@ KRK_METHOD(tuple,__repr__,{
pushStringBuilder(&sb, ')');
((KrkObj*)self)->flags &= ~(KRK_OBJ_FLAGS_IN_REPR);
return finishStringBuilder(&sb);
})
}
KRK_METHOD(tuple,__add__,{
KRK_Method(tuple,__add__) {
METHOD_TAKES_EXACTLY(1);
if (!IS_tuple(argv[1]))
return krk_runtimeError(vm.exceptions->typeError,
@ -235,7 +235,7 @@ KRK_METHOD(tuple,__add__,{
out->values.values[out->values.count++] = other->values.values[i];
}
return krk_pop();
})
}
/**
* @brief Iterator over the values in a tuple.
@ -270,15 +270,15 @@ static KrkValue _tuple_iter_call(int argc, const KrkValue argv[], int hasKw) {
}
}
KRK_METHOD(tuple,__iter__,{
KRK_Method(tuple,__iter__) {
KrkInstance * output = krk_newInstance(vm.baseClasses->tupleiteratorClass);
krk_push(OBJECT_VAL(output));
_tuple_iter_init(2, (KrkValue[]){krk_peek(0), argv[0]}, 0);
krk_pop();
return OBJECT_VAL(output);
})
}
KRK_METHOD(tuple,__hash__,{
KRK_Method(tuple,__hash__) {
if (self->obj.flags & KRK_OBJ_FLAGS_VALID_HASH) {
return INTEGER_VAL(self->obj.hash);
}
@ -295,7 +295,7 @@ KRK_METHOD(tuple,__hash__,{
return INTEGER_VAL(self->obj.hash);
_unhashable:
return NONE_VAL();
})
}
_noexport
void _createAndBind_tupleClass(void) {

4
src/obj_typing.c
View File

@ -47,7 +47,7 @@ static KrkValue typeToString(KrkValue val) {
}
}
KRK_FUNC(__class_getitem__,{
KRK_Function(__class_getitem__) {
FUNCTION_TAKES_EXACTLY(2);
if (!IS_CLASS(argv[0])) return TYPE_ERROR(class,argv[0]);
@ -62,6 +62,6 @@ KRK_FUNC(__class_getitem__,{
krk_pop();
pushStringBuilder(&sb,']');
return finishStringBuilder(&sb);
})
}
NativeFn KrkGenericAlias = FUNC_NAME(krk,__class_getitem__);

187
src/os.c
View File

@ -30,7 +30,7 @@ static KrkClass * stat_result = NULL;
#define S_KEY(key,val) krk_attachNamedObject(AS_DICT(result), #key, (KrkObj*)val);
#ifndef _WIN32
KRK_FUNC(uname,{
KRK_Function(uname) {
struct utsname buf;
if (uname(&buf) < 0) return NONE_VAL();
@ -44,9 +44,9 @@ KRK_FUNC(uname,{
DO_KEY(machine);
return krk_pop();;
})
}
#else
KRK_FUNC(uname,{
KRK_Function(uname) {
KrkValue result = krk_dict_of(0, NULL, 0);
krk_push(result);
@ -88,7 +88,7 @@ KRK_FUNC(uname,{
S_KEY(nodename,krk_copyString(buffer,dwSize));
return krk_pop();
})
}
#endif
static KrkClass * Environ;
@ -109,7 +109,7 @@ static int _setVar(KrkString * key, KrkString * val) {
#endif
}
KRK_METHOD(Environ,__setitem__,{
KRK_Method(Environ,__setitem__) {
METHOD_TAKES_EXACTLY(2);
CHECK_ARG(1,str,KrkString*,key);
CHECK_ARG(2,str,KrkString*,val);
@ -122,7 +122,7 @@ KRK_METHOD(Environ,__setitem__,{
}
return krk_runtimeError(OSError, "%s", strerror(errno));
})
}
static void _unsetVar(KrkString * str) {
#ifndef _WIN32
@ -136,14 +136,14 @@ static void _unsetVar(KrkString * str) {
#endif
}
KRK_METHOD(Environ,__delitem__,{
KRK_Method(Environ,__delitem__) {
METHOD_TAKES_EXACTLY(1);
CHECK_ARG(1,str,KrkString*,key);
_unsetVar(key);
krk_push(argv[0]);
krk_push(argv[1]);
return krk_callDirect(vm.baseClasses->dictClass->_delitem, 2);
})
}
static void _loadEnviron(KrkInstance * module) {
/* Create a new class to subclass `dict` */
@ -193,74 +193,77 @@ static void _loadEnviron(KrkInstance * module) {
}
KRK_FUNC(system,{
KRK_Function(system) {
FUNCTION_TAKES_EXACTLY(1);
CHECK_ARG(0,str,KrkString*,cmd);
return INTEGER_VAL(system(cmd->chars));
})
}
KRK_FUNC(getcwd,{
KRK_Function(getcwd) {
FUNCTION_TAKES_NONE();
char buf[4096]; /* TODO PATH_MAX? */
if (!getcwd(buf, 4096)) return krk_runtimeError(OSError, "%s", strerror(errno));
return OBJECT_VAL(krk_copyString(buf, strlen(buf)));
})
}
KRK_FUNC(chdir,{
KRK_Function(chdir) {
FUNCTION_TAKES_EXACTLY(1);
CHECK_ARG(0,str,KrkString*,newDir);
if (chdir(newDir->chars)) return krk_runtimeError(OSError, "%s", strerror(errno));
})
return NONE_VAL();
}
KRK_FUNC(getpid,{
KRK_Function(getpid) {
FUNCTION_TAKES_NONE();
return INTEGER_VAL(getpid());
})
}
KRK_FUNC(strerror,{
KRK_Function(strerror) {
FUNCTION_TAKES_EXACTLY(1);
CHECK_ARG(0,int,krk_integer_type,errorNo);
char *s = strerror(errorNo);
if (!s) return NONE_VAL();
return OBJECT_VAL(krk_copyString(s,strlen(s)));
})
}
KRK_FUNC(access,{
KRK_Function(access) {
FUNCTION_TAKES_EXACTLY(2);
CHECK_ARG(0,str,KrkString*,path);
CHECK_ARG(1,int,krk_integer_type,mask);
if (access(path->chars, mask) == 0) return BOOLEAN_VAL(1);
return BOOLEAN_VAL(0);
})
}
KRK_FUNC(abort,{
KRK_Function(abort) {
abort();
})
}
KRK_FUNC(exit,{
KRK_Function(exit) {
FUNCTION_TAKES_EXACTLY(1);
CHECK_ARG(0,int,krk_integer_type,retcode);
exit(retcode);
})
}
KRK_FUNC(remove,{
KRK_Function(remove) {
FUNCTION_TAKES_EXACTLY(1);
CHECK_ARG(0,str,KrkString*,path);
if (remove(path->chars) != 0) {
return krk_runtimeError(OSError, "%s", strerror(errno));
}
})
return NONE_VAL();
}
KRK_FUNC(truncate,{
KRK_Function(truncate) {
FUNCTION_TAKES_EXACTLY(2);
CHECK_ARG(0,str,KrkString*,path);
CHECK_ARG(1,int,krk_integer_type,length);
if (truncate(path->chars, length) != 0) {
return krk_runtimeError(OSError, "%s", strerror(errno));
}
})
return NONE_VAL();
}
KRK_FUNC(dup,{
KRK_Function(dup) {
FUNCTION_TAKES_EXACTLY(1);
CHECK_ARG(0,int,krk_integer_type,fd);
int result = dup(fd);
@ -268,9 +271,9 @@ KRK_FUNC(dup,{
return krk_runtimeError(OSError, "%s", strerror(errno));
}
return INTEGER_VAL(result);
})
}
KRK_FUNC(dup2,{
KRK_Function(dup2) {
FUNCTION_TAKES_EXACTLY(2);
CHECK_ARG(0,int,krk_integer_type,fd);
CHECK_ARG(1,int,krk_integer_type,fd2);
@ -279,15 +282,15 @@ KRK_FUNC(dup2,{
return krk_runtimeError(OSError, "%s", strerror(errno));
}
return INTEGER_VAL(result);
})
}
KRK_FUNC(isatty,{
KRK_Function(isatty) {
FUNCTION_TAKES_EXACTLY(1);
CHECK_ARG(0,int,krk_integer_type,fd);
return BOOLEAN_VAL(isatty(fd));
})
}
KRK_FUNC(lseek,{
KRK_Function(lseek) {
FUNCTION_TAKES_EXACTLY(3);
CHECK_ARG(0,int,krk_integer_type,fd);
CHECK_ARG(1,int,krk_integer_type,pos);
@ -297,9 +300,9 @@ KRK_FUNC(lseek,{
return krk_runtimeError(OSError, "%s", strerror(errno));
}
return INTEGER_VAL(result);
})
}
KRK_FUNC(open,{
KRK_Function(open) {
FUNCTION_TAKES_AT_LEAST(2);
FUNCTION_TAKES_AT_MOST(3);
CHECK_ARG(0,str,KrkString*,path);
@ -314,20 +317,21 @@ KRK_FUNC(open,{
return krk_runtimeError(OSError, "%s", strerror(errno));
}
return INTEGER_VAL(result);
})
}
KRK_FUNC(close,{
KRK_Function(close) {
FUNCTION_TAKES_EXACTLY(1);
CHECK_ARG(0,int,krk_integer_type,fd);
if (close(fd) == -1) {
return krk_runtimeError(OSError, "%s", strerror(errno));
}
})
return NONE_VAL();
}
#ifdef _WIN32
#define mkdir(p,m) mkdir(p); (void)m
#endif
KRK_FUNC(mkdir,{
KRK_Function(mkdir) {
FUNCTION_TAKES_AT_LEAST(1);
FUNCTION_TAKES_AT_MOST(2);
CHECK_ARG(0,str,KrkString*,path);
@ -340,9 +344,10 @@ KRK_FUNC(mkdir,{
if (result == -1) {
return krk_runtimeError(OSError, "%s", strerror(errno));
}
})
return NONE_VAL();
}
KRK_FUNC(read,{
KRK_Function(read) {
FUNCTION_TAKES_EXACTLY(2);
CHECK_ARG(0,int,krk_integer_type,fd);
CHECK_ARG(1,int,krk_integer_type,n);
@ -357,14 +362,14 @@ KRK_FUNC(read,{
free(tmp);
return krk_pop();
}
})
}
#ifndef IS_bytes
#define IS_bytes(o) IS_BYTES(o)
#define AS_bytes(o) AS_BYTES(o)
#endif
KRK_FUNC(write,{
KRK_Function(write) {
FUNCTION_TAKES_EXACTLY(2);
CHECK_ARG(0,int,krk_integer_type,fd);
CHECK_ARG(1,bytes,KrkBytes*,data);
@ -373,10 +378,10 @@ KRK_FUNC(write,{
return krk_runtimeError(OSError, "%s", strerror(errno));
}
return INTEGER_VAL(result);
})
}
#ifndef _WIN32
KRK_FUNC(pipe,{
KRK_Function(pipe) {
FUNCTION_TAKES_NONE();
int fds[2];
if (pipe(fds) == -1) {
@ -387,32 +392,33 @@ KRK_FUNC(pipe,{
AS_TUPLE(krk_peek(0))->values.values[1] = INTEGER_VAL(fds[1]);
AS_TUPLE(krk_peek(0))->values.count = 2;
return krk_pop();
})
}
KRK_FUNC(kill,{
KRK_Function(kill) {
FUNCTION_TAKES_EXACTLY(2);
int result = kill(AS_INTEGER(argv[0]), AS_INTEGER(argv[1]));
if (result == -1) {
return krk_runtimeError(OSError, "%s", strerror(errno));
}
return INTEGER_VAL(result);
})
}
KRK_FUNC(fork,{
KRK_Function(fork) {
FUNCTION_TAKES_NONE();
return INTEGER_VAL(fork());
})
}
KRK_FUNC(symlink,{
KRK_Function(symlink) {
FUNCTION_TAKES_EXACTLY(2);
CHECK_ARG(0,str,KrkString*,src);
CHECK_ARG(1,str,KrkString*,dst);
if (symlink(src->chars, dst->chars) != 0) {
return krk_runtimeError(OSError, "%s", strerror(errno));
}
})
return NONE_VAL();
}
KRK_FUNC(tcgetpgrp,{
KRK_Function(tcgetpgrp) {
FUNCTION_TAKES_EXACTLY(1);
CHECK_ARG(0,int,krk_integer_type,fd);
int result = tcgetpgrp(fd);
@ -420,9 +426,9 @@ KRK_FUNC(tcgetpgrp,{
return krk_runtimeError(OSError, "%s", strerror(errno));
}
return INTEGER_VAL(result);
})
}
KRK_FUNC(tcsetpgrp,{
KRK_Function(tcsetpgrp) {
FUNCTION_TAKES_EXACTLY(2);
CHECK_ARG(0,int,krk_integer_type,fd);
CHECK_ARG(1,int,krk_integer_type,pgrp);
@ -430,9 +436,10 @@ KRK_FUNC(tcsetpgrp,{
if (result == -1) {
return krk_runtimeError(OSError, "%s", strerror(errno));
}
})
return NONE_VAL();
}
KRK_FUNC(ttyname,{
KRK_Function(ttyname) {
FUNCTION_TAKES_EXACTLY(1);
CHECK_ARG(0,int,krk_integer_type,fd);
char * result = ttyname(fd);
@ -440,9 +447,9 @@ KRK_FUNC(ttyname,{
return krk_runtimeError(OSError, "%s", strerror(errno));
}
return OBJECT_VAL(krk_copyString(result,strlen(result)));
})
}
KRK_FUNC(get_terminal_size,{
KRK_Function(get_terminal_size) {
FUNCTION_TAKES_AT_MOST(1);
int fd = 1;
if (argc > 0) {
@ -462,7 +469,7 @@ KRK_FUNC(get_terminal_size,{
AS_TUPLE(krk_peek(0))->values.values[1] = INTEGER_VAL(wsz.ws_row);
AS_TUPLE(krk_peek(0))->values.count = 2;
return krk_pop();
})
}
#endif
static int makeArgs(int count, const KrkValue * values, char *** argsOut, const char * _method_name) {
@ -480,7 +487,7 @@ static int makeArgs(int count, const KrkValue * values, char *** argsOut, const
return 0;
}
KRK_FUNC(execl,{
KRK_Function(execl) {
FUNCTION_TAKES_AT_LEAST(1);
CHECK_ARG(0,str,KrkString*,path);
char ** args;
@ -490,9 +497,9 @@ KRK_FUNC(execl,{
return krk_runtimeError(OSError, "%s", strerror(errno));
}
return krk_runtimeError(OSError, "Expected to not return from exec, but did.");
})
}
KRK_FUNC(execlp,{
KRK_Function(execlp) {
FUNCTION_TAKES_AT_LEAST(1);
CHECK_ARG(0,str,KrkString*,filename);
char ** args;
@ -502,9 +509,9 @@ KRK_FUNC(execlp,{
return krk_runtimeError(OSError, "%s", strerror(errno));
}
return krk_runtimeError(OSError, "Expected to not return from exec, but did.");
})
}
KRK_FUNC(execle,{
KRK_Function(execle) {
FUNCTION_TAKES_AT_LEAST(1);
CHECK_ARG(0,str,KrkString*,path);
CHECK_ARG((argc-1),list,KrkList*,envp);
@ -521,9 +528,9 @@ KRK_FUNC(execle,{
return krk_runtimeError(OSError, "%s", strerror(errno));
}
return krk_runtimeError(OSError, "Expected to not return from exec, but did.");
})
}
KRK_FUNC(execv,{
KRK_Function(execv) {
FUNCTION_TAKES_EXACTLY(2);
CHECK_ARG(0,str,KrkString*,filename);
CHECK_ARG(1,list,KrkList*,args);
@ -534,9 +541,9 @@ KRK_FUNC(execv,{
return krk_runtimeError(OSError, "%s", strerror(errno));
}
return krk_runtimeError(OSError, "Expected to not return from exec, but did.");
})
}
KRK_FUNC(execvp,{
KRK_Function(execvp) {
FUNCTION_TAKES_EXACTLY(2);
CHECK_ARG(0,str,KrkString*,path);
CHECK_ARG(1,list,KrkList*,args);
@ -547,7 +554,7 @@ KRK_FUNC(execvp,{
return krk_runtimeError(OSError, "%s", strerror(errno));
}
return krk_runtimeError(OSError, "Expected to not return from exec, but did.");
})
}
#define SET(thing) krk_attachNamedValue(&out->fields, #thing, INTEGER_VAL(buf. thing))
#ifdef _WIN32
@ -556,7 +563,7 @@ KRK_FUNC(execvp,{
#else
#define STAT_STRUCT struct stat
#endif
KRK_FUNC(stat,{
KRK_Function(stat) {
FUNCTION_TAKES_EXACTLY(1);
CHECK_ARG(0,str,KrkString*,path);
STAT_STRUCT buf;
@ -579,7 +586,7 @@ KRK_FUNC(stat,{
/* TODO block sizes */
return krk_pop();
})
}
#undef SET
#define IS_stat_result(o) (krk_isInstanceOf(o,stat_result))
@ -591,7 +598,7 @@ KRK_FUNC(stat,{
krk_tableGet(&self->fields, OBJECT_VAL(S(#name)), &name); \
if (!IS_INTEGER(name)) return krk_runtimeError(vm.exceptions->valueError, "stat_result is invalid")
KRK_METHOD(stat_result,__repr__,{
KRK_Method(stat_result,__repr__) {
METHOD_TAKES_NONE();
getProp(st_dev);
getProp(st_ino);
@ -623,44 +630,44 @@ KRK_METHOD(stat_result,__repr__,{
krk_push(OBJECT_VAL(krk_copyString(buf,len)));
free(buf);
return krk_pop();
})
}
KRK_FUNC(S_ISBLK,{
KRK_Function(S_ISBLK) {
FUNCTION_TAKES_EXACTLY(1);
CHECK_ARG(0,int,krk_integer_type,mode);
return INTEGER_VAL(S_ISBLK(mode));
})
KRK_FUNC(S_ISCHR,{
}
KRK_Function(S_ISCHR) {
FUNCTION_TAKES_EXACTLY(1);
CHECK_ARG(0,int,krk_integer_type,mode);
return INTEGER_VAL(S_ISCHR(mode));
})
KRK_FUNC(S_ISDIR,{
}
KRK_Function(S_ISDIR) {
FUNCTION_TAKES_EXACTLY(1);
CHECK_ARG(0,int,krk_integer_type,mode);
return INTEGER_VAL(S_ISDIR(mode));
})
KRK_FUNC(S_ISFIFO,{
}
KRK_Function(S_ISFIFO) {
FUNCTION_TAKES_EXACTLY(1);
CHECK_ARG(0,int,krk_integer_type,mode);
return INTEGER_VAL(S_ISFIFO(mode));
})
KRK_FUNC(S_ISREG,{
}
KRK_Function(S_ISREG) {
FUNCTION_TAKES_EXACTLY(1);
CHECK_ARG(0,int,krk_integer_type,mode);
return INTEGER_VAL(S_ISREG(mode));
})
}
#ifndef _WIN32
KRK_FUNC(S_ISLNK,{
KRK_Function(S_ISLNK) {
FUNCTION_TAKES_EXACTLY(1);
CHECK_ARG(0,int,krk_integer_type,mode);
return INTEGER_VAL(S_ISLNK(mode));
})
KRK_FUNC(S_ISSOCK,{
}
KRK_Function(S_ISSOCK) {
FUNCTION_TAKES_EXACTLY(1);
CHECK_ARG(0,int,krk_integer_type,mode);
return INTEGER_VAL(S_ISSOCK(mode));
})
}
#endif
_noexport

39
src/threads.c
View File

@ -54,10 +54,10 @@ struct Lock {
pthread_mutex_t mutex;
};
KRK_FUNC(current_thread,{
KRK_Function(current_thread) {
if (&krk_currentThread == vm.threads) return NONE_VAL();
return krk_currentThread.stack[0];
})
}
#define IS_Thread(o) (krk_isInstanceOf(o, Thread))
#define AS_Thread(o) ((struct Thread *)AS_OBJECT(o))
@ -115,21 +115,22 @@ static void * _startthread(void * _threadObj) {
return NULL;
}
KRK_METHOD(Thread,tid,{
KRK_Method(Thread,tid) {
METHOD_TAKES_NONE(); /* Property, but can not be assigned. */
return INTEGER_VAL(self->tid);
})
}
KRK_METHOD(Thread,join,{
KRK_Method(Thread,join) {
if (self->threadState == &krk_currentThread)
return krk_runtimeError(ThreadError, "Thread can not join itself.");
if (!self->started)
return krk_runtimeError(ThreadError, "Thread has not been started.");
pthread_join(self->nativeRef, NULL);
})
return NONE_VAL();
}
KRK_METHOD(Thread,start,{
KRK_Method(Thread,start) {
METHOD_TAKES_NONE();
if (self->started)
@ -140,12 +141,12 @@ KRK_METHOD(Thread,start,{
pthread_create(&self->nativeRef, NULL, _startthread, (void*)self);
return argv[0];
})
}
KRK_METHOD(Thread,is_alive,{
KRK_Method(Thread,is_alive) {
METHOD_TAKES_NONE();
return BOOLEAN_VAL(self->alive);
})
}
#undef CURRENT_CTYPE
@ -153,11 +154,11 @@ KRK_METHOD(Thread,is_alive,{
#define AS_Lock(o) ((struct Lock *)AS_OBJECT(o))
#define CURRENT_CTYPE struct Lock *
KRK_METHOD(Lock,__init__,{
KRK_Method(Lock,__init__) {
METHOD_TAKES_NONE(); /* TODO lock options, like recursive or error-checked? */
pthread_mutex_init(&self->mutex, NULL);
return argv[0];
})
}
static inline void _pushLockStatus(struct Lock * self, struct StringBuilder * sb) {
#ifdef __GLIBC__
@ -174,7 +175,7 @@ static inline void _pushLockStatus(struct Lock * self, struct StringBuilder * sb
#endif
}
KRK_METHOD(Lock,__repr__,{
KRK_Method(Lock,__repr__) {
METHOD_TAKES_NONE();
struct StringBuilder sb = {0};
pushStringBuilderStr(&sb, "<Lock ", 6);
@ -190,16 +191,18 @@ KRK_METHOD(Lock,__repr__,{
pushStringBuilder(&sb,'>');
return finishStringBuilder(&sb);
})
}
KRK_METHOD(Lock,__enter__,{
KRK_Method(Lock,__enter__) {
METHOD_TAKES_NONE();
pthread_mutex_lock(&self->mutex);
})
return NONE_VAL();
}
KRK_METHOD(Lock,__exit__,{
KRK_Method(Lock,__exit__) {
pthread_mutex_unlock(&self->mutex);
})
return NONE_VAL();
}
_noexport
void _createAndBind_threadsMod(void) {

8
src/time.c
View File

@ -11,7 +11,7 @@
#include <kuroko/object.h>
#include <kuroko/util.h>
KRK_FUNC(sleep,{
KRK_Function(sleep) {
FUNCTION_TAKES_EXACTLY(1);
if (!IS_INTEGER(argv[0]) && !IS_FLOATING(argv[0])) {
@ -25,9 +25,9 @@ KRK_FUNC(sleep,{
usleep(usecs);
return BOOLEAN_VAL(1);
})
}
KRK_FUNC(time,{
KRK_Function(time) {
FUNCTION_TAKES_NONE();
struct timeval tv;
@ -36,7 +36,7 @@ KRK_FUNC(time,{
double out = (double)tv.tv_sec + (double)tv.tv_usec / 1000000.0;
return FLOATING_VAL(out);
})
}
_noexport
void _createAndBind_timeMod(void) {

33
src/vm.c
View File

@ -1244,7 +1244,7 @@ int krk_isFalsey(KrkValue value) {
}
#ifndef KRK_DISABLE_DEBUG
KRK_FUNC(set_tracing,{
KRK_Function(set_tracing) {
if (hasKw) {
KrkValue test;
if (krk_tableGet(AS_DICT(argv[argc]), OBJECT_VAL(S("tracing")), &test) && IS_INTEGER(test)) {
@ -1258,14 +1258,14 @@ KRK_FUNC(set_tracing,{
if (AS_INTEGER(test) == 1) vm.globalFlags |= KRK_GLOBAL_ENABLE_STRESS_GC; else krk_currentThread.flags &= ~KRK_GLOBAL_ENABLE_STRESS_GC; }
}
return BOOLEAN_VAL(1);
})
}
#else
KRK_FUNC(set_tracing,{
KRK_Function(set_tracing) {
return krk_runtimeError(vm.exceptions->typeError,"Debugging is not enabled in this build.");
})
}
#endif
KRK_FUNC(getsizeof,{
KRK_Function(getsizeof) {
if (argc < 1 || !IS_OBJECT(argv[0])) return INTEGER_VAL(0);
size_t mySize = 0;
switch (AS_OBJECT(argv[0])->type) {
@ -1348,25 +1348,25 @@ KRK_FUNC(getsizeof,{
default: break;
}
return INTEGER_VAL(mySize);
})
}
KRK_FUNC(set_clean_output,{
KRK_Function(set_clean_output) {
if (!argc || (IS_BOOLEAN(argv[0]) && AS_BOOLEAN(argv[0]))) {
vm.globalFlags |= KRK_GLOBAL_CLEAN_OUTPUT;
} else {
vm.globalFlags &= ~KRK_GLOBAL_CLEAN_OUTPUT;
}
return NONE_VAL();
})
}
KRK_FUNC(importmodule,{
KRK_Function(importmodule) {
FUNCTION_TAKES_EXACTLY(1);
if (!IS_STRING(argv[0])) return TYPE_ERROR(str,argv[0]);
if (!krk_doRecursiveModuleLoad(AS_STRING(argv[0]))) return NONE_VAL(); /* ImportError already raised */
return krk_pop();
})
}
KRK_FUNC(modules,{
KRK_Function(modules) {
FUNCTION_TAKES_NONE();
KrkValue moduleList = krk_list_of(0,NULL,0);
krk_push(moduleList);
@ -1376,20 +1376,21 @@ KRK_FUNC(modules,{
krk_writeValueArray(AS_LIST(moduleList), entry->key);
}
return krk_pop();
})
}
KRK_FUNC(unload,{
KRK_Function(unload) {
FUNCTION_TAKES_EXACTLY(1);
if (!IS_STRING(argv[0])) return TYPE_ERROR(str,argv[0]);
if (!krk_tableDelete(&vm.modules, argv[0])) {
return krk_runtimeError(vm.exceptions->keyError, "Module is not loaded.");
}
})
return NONE_VAL();
}
KRK_FUNC(inspect_value,{
KRK_Function(inspect_value) {
FUNCTION_TAKES_EXACTLY(1);
return OBJECT_VAL(krk_newBytes(sizeof(KrkValue),(uint8_t*)&argv[0]));
})
}
void krk_setMaximumRecursionDepth(size_t maxDepth) {
vm.maximumCallDepth = maxDepth;