parseargs.c

#include <kuroko/vm.h>
#include <kuroko/util.h>
 
static int matchType(const char * _method_name, KrkClass * type, KrkValue arg) {
    if (arg != KWARGS_VAL(0) && !krk_isInstanceOf(arg, type)) {
        krk_runtimeError(vm.exceptions->typeError, "%s() expects %s, not '%T'",
            _method_name, type ? type->name->chars : "unknown type", arg);
        return 0;
    }
    return 1;
}
 
int krk_parseVArgs(
        const char * _method_name,
        int argc, const KrkValue argv[], int hasKw,
        const char * fmt, const char ** names, va_list args) {
    int iarg = 0;           
    int oarg = 0;           
    int required = 1;       
    int acceptextrakws = 0; 
    const char * maybeColon = strchr(fmt, ':');
    if (maybeColon) {
        _method_name = maybeColon + 1;
    }
 
    if (*fmt == '.') {
        argv++;
        argc--;
        fmt++;
    }
 
    /* Required args */
    while (*fmt) {
        if (*fmt == ':') break;
        if (*fmt == '|') {
            if (!required) {
                krk_runtimeError(vm.exceptions->typeError, "format string has multiple |s");
                return 1;
            }
            required = 0;
            fmt++;
            continue;
        }
        if (*fmt == '*') {
            int * out_c = va_arg(args, int *);
            const KrkValue ** out_v = va_arg(args, const KrkValue **);
            *out_c = argc - iarg;
            *out_v = &argv[iarg];
            iarg = argc;
            required = 0;
            fmt++;
            continue;
        }
        if (*fmt == '$') {
            if (required) {
                krk_runtimeError(vm.exceptions->typeError, "$ must be after | or * in format string");
                return 1;
            }
            if (iarg < argc) break;
            fmt++;
            continue;
        }
        if (*fmt == '~') {
            acceptextrakws = 1;
            fmt++;
            continue;
        }
 
        int wasPositional = 0;
        KrkValue arg = KWARGS_VAL(0);
        krk_push(OBJECT_VAL(krk_copyString(names[oarg],strlen(names[oarg]))));
 
        if (iarg < argc) {
            /* Positional arguments are pretty straightforward. */
            arg = argv[iarg];
            iarg++;
            wasPositional = 1;
        } else if ((required && !hasKw) || (hasKw && !krk_tableGet_fast(AS_DICT(argv[argc]), AS_STRING(krk_peek(0)), &arg) && required)) {
            /* If keyword argument lookup failed and this is not an optional argument, raise an exception. */
            krk_runtimeError(vm.exceptions->typeError, "%s() missing required positional argument: '%S'",
                _method_name, AS_STRING(krk_peek(0)));
            goto _error;
        }
 
        if (hasKw && krk_tableDelete(AS_DICT(argv[argc]), krk_peek(0)) && wasPositional) {
            /* We remove all arguments from kwargs. If we got this argument from a positional argument,
             * and it was found during deletion, we raise a multiple-defs exception. */
            krk_runtimeError(vm.exceptions->typeError, "%s() got multiple values for argument '%S'",
                _method_name, AS_STRING(krk_peek(0)));
            goto _error;
        }
 
        char argtype = *fmt++;
 
        if (*fmt == '?') {
            /* "is present", useful for things where relying on a default isn't useful but you
             * still want to have all the type checking and automatic parsing. */
            fmt++;
            int * out = va_arg(args, int*);
            *out = arg != KWARGS_VAL(0);
        }
 
        if (*fmt == '!') {
            /* "of type", thrown an exception if the argument was present but was not
             * an instance of a given class. Originally just for @c O and @c V but
             * now available anywhere, though likely not useful for other types.
             * Maybe if you want @c p to only be a bool this could be useful? */
            fmt++;
            KrkClass * type = va_arg(args, KrkClass*);
            if (!matchType(_method_name, type, arg)) goto _error;
        }
 
        switch (argtype) {
            case 'O': {
                KrkObj ** out = va_arg(args, KrkObj**);
                if (arg != KWARGS_VAL(0)) {
                    if (IS_NONE(arg)) {
                        *out = NULL;
                    } else if (!IS_OBJECT(arg)) {
                        TYPE_ERROR(heap object,arg);
                        goto _error;
                    } else {
                        *out = AS_OBJECT(arg);
                    }
                }
                break;
            }
 
            case 'V': {
                KrkValue * out = va_arg(args, KrkValue*);
                if (arg != KWARGS_VAL(0)) {
                    *out = arg;
                }
                break;
            }
 
            case 'z': {
                char ** out = va_arg(args, char **);
                size_t * size = NULL;
                if (*fmt == '#') {
                    fmt++;
                    size = va_arg(args, size_t*);
                }
                if (arg != KWARGS_VAL(0)) {
                    if (arg == NONE_VAL()) {
                        *out = NULL;
                        if (size) *size = 0;
                    } else if (IS_STRING(arg)) {
                        *out = AS_CSTRING(arg);
                        if (size) *size = AS_STRING(arg)->length;
                    } else {
                        TYPE_ERROR(str or None,arg);
                        goto _error;
                    }
                }
                break;
            }
 
            case 's': {
                char ** out = va_arg(args, char **);
                size_t * size = NULL;
                if (*fmt == '#') {
                    fmt++;
                    size = va_arg(args, size_t*);
                }
                if (arg != KWARGS_VAL(0)) {
                    if (IS_STRING(arg)) {
                        *out = AS_CSTRING(arg);
                        if (size) *size = AS_STRING(arg)->length;
                    } else {
                        TYPE_ERROR(str,arg);
                        goto _error;
                    }
                }
                break;
            }
 
#define NUMERIC(c,type) case c: { type * out = va_arg(args, type*); if (arg != KWARGS_VAL(0)) { if (!krk_long_to_int(arg, sizeof(type), out)) goto _error; } break; }
            NUMERIC('b',unsigned char)
            NUMERIC('h',short)
            NUMERIC('H',unsigned short)
            NUMERIC('i',int)
            NUMERIC('I',unsigned int)
            NUMERIC('l',long)
            NUMERIC('k',unsigned long)
            NUMERIC('L',long long)
            NUMERIC('K',unsigned long long)
            NUMERIC('n',ssize_t)
            NUMERIC('N',size_t)
 
            
            case 'C': {
                int * out = va_arg(args, int*);
                if (arg != KWARGS_VAL(0)) {
                    if (!IS_STRING(arg) || AS_STRING(arg)->codesLength != 1) {
                        TYPE_ERROR(str of length 1,arg);
                        goto _error;
                    }
                    *out = krk_unicodeCodepoint(AS_STRING(arg),0);
                }
                break;
            }
 
#ifndef KRK_NO_FLOAT
            case 'f': {
                float * out = va_arg(args, float*);
                if (arg != KWARGS_VAL(0)) {
                    if (!IS_FLOATING(arg)) {
                        KrkClass * type = krk_getType(arg);
                        krk_push(arg);
                        if (!krk_bindMethod(type, S("__float__"))) {
                            krk_pop();
                            TYPE_ERROR(float,arg);
                            goto _error;
                        }
                        arg = krk_callStack(0);
                    }
                    *out = AS_FLOATING(arg);
                }
                break;
            }
 
            case 'd': {
                double * out = va_arg(args, double*);
                if (arg != KWARGS_VAL(0)) {
                    if (!IS_FLOATING(arg)) {
                        KrkClass * type = krk_getType(arg);
                        krk_push(arg);
                        if (!krk_bindMethod(type, S("__float__"))) {
                            krk_pop();
                            TYPE_ERROR(float,arg);
                            goto _error;
                        }
                        arg = krk_callStack(0);
                    }
                    *out = AS_FLOATING(arg);
                }
                break;
            }
#else
            case 'f':
            case 'd':
                krk_runtimeError(vm.exceptions->typeError, "no float support");
                goto _error;
#endif
 
            case 'p': {
                int * out = va_arg(args, int*);
                if (arg != KWARGS_VAL(0)) {
                    *out = !krk_isFalsey(arg);
                    if (krk_currentThread.flags & KRK_THREAD_HAS_EXCEPTION) goto _error;
                }
                break;
            }
 
            default: {
                krk_runtimeError(vm.exceptions->typeError, "unrecognized directive '%c' in format string", argtype);
                goto _error;
            }
        }
 
        krk_pop();
        oarg++;
    }
 
    if (iarg < argc) {
        krk_runtimeError(vm.exceptions->argumentError, "%s() takes %s %d argument%s (%d given)",
            _method_name, required ? "exactly" : "at most", oarg, oarg == 1 ? "" : "s", argc);
        return 0;
    }
 
    if (!acceptextrakws && hasKw && AS_DICT(argv[argc])->count) {
        for (size_t i = 0; i < AS_DICT(argv[argc])->capacity; ++i) {
            KrkTableEntry * entry = &AS_DICT(argv[argc])->entries[i];
            if (IS_STRING(entry->key)) {
                krk_runtimeError(vm.exceptions->typeError, "%s() got an unexpected keyword argument '%S'",
                    _method_name, AS_STRING(entry->key));
                return 0;
            }
        }
    }
 
    return 1;
 
_error:
    krk_pop(); /* name of argument with error */
    return 0;
}
 
int krk_parseArgs_impl(
        const char * _method_name,
        int argc, const KrkValue argv[], int hasKw,
        const char * format, const char ** names, ...) {
    va_list args;
    va_start(args, names);
    int result = krk_parseVArgs(_method_name,argc,argv,hasKw,format,names,args);
    va_end(args);
    return result;
}