parseargs.c

 
#include <kuroko/vm.h>
#include <kuroko/util.h>
 
_cold
static void raise_TypeError(const char * method_name, const char * expected, KrkValue arg, const char * argName) {
    krk_runtimeError(vm.exceptions->typeError,
        "%s()%s%s expects %s, not '%T'",
        method_name, (argName && *argName) ? " argument " : "", (argName && *argName) ? argName : "",
        expected, arg);
}
 
_cold
static const char * methodName(const char * method_name, const char * fmt) {
    const char * maybeColon = strchr(fmt, ':');
    return maybeColon ? maybeColon + 1 : method_name;
}
 
/* Just to avoid repeating ourselves... */
#define _method_name (methodName(orig_method_name, fmt))
 
static int extractKwArg(KrkTable * kwargs, KrkString * argName, KrkValue * out, KrkValueArray * refList) {
    if (!krk_tableGet_fast(kwargs, argName, out)) return 1;
    krk_writeValueArray(refList, *out);
    krk_tableDeleteExact(kwargs, OBJECT_VAL(argName));
    return 0;
}
 
int krk_parseVArgs(
        const char * orig_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; 
    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;
        }
 
        KrkValue arg = KWARGS_VAL(0);
 
        if (iarg < argc) {
            /* Positional arguments are pretty straightforward. */
            arg = argv[iarg];
            iarg++;
        } else if ((required && !hasKw) || (hasKw && extractKwArg(AS_DICT(argv[argc]), krk_copyString(names[oarg],strlen(names[oarg])), &arg, AS_LIST(argv[argc+1])) && 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, names[oarg]);
            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 = !krk_valuesSame(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 (!krk_valuesSame(arg, KWARGS_VAL(0)) && !krk_isInstanceOf(arg, type)) {
                raise_TypeError(_method_name, type ? type->name->chars : "unknown type", arg, names[oarg]);
                goto _error;
            }
        }
 
        switch (argtype) {
            case 'O': {
                KrkObj ** out = va_arg(args, KrkObj**);
                if (!krk_valuesSame(arg, KWARGS_VAL(0))) {
                    if (IS_NONE(arg)) {
                        *out = NULL;
                    } else if (!IS_OBJECT(arg)) {
                        raise_TypeError(_method_name, "heap object", arg, names[oarg]);
                        goto _error;
                    } else {
                        *out = AS_OBJECT(arg);
                    }
                }
                break;
            }
 
            case 'V': {
                KrkValue * out = va_arg(args, KrkValue*);
                if (!krk_valuesSame(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 (!krk_valuesSame(arg, KWARGS_VAL(0))) {
                    if (IS_NONE(arg)) {
                        *out = NULL;
                        if (size) *size = 0;
                    } else if (IS_STRING(arg)) {
                        *out = AS_CSTRING(arg);
                        if (size) *size = AS_STRING(arg)->length;
                    } else {
                        raise_TypeError(_method_name, "str or None", arg, names[oarg]);
                        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 (!krk_valuesSame(arg, KWARGS_VAL(0))) {
                    if (IS_STRING(arg)) {
                        *out = AS_CSTRING(arg);
                        if (size) *size = AS_STRING(arg)->length;
                    } else {
                        raise_TypeError(_method_name, "str", arg, names[oarg]);
                        goto _error;
                    }
                }
                break;
            }
 
#define NUMERIC(c,type) case c: { type * out = va_arg(args, type*); if (!krk_valuesSame(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 (!krk_valuesSame(arg, KWARGS_VAL(0))) {
                    if (!IS_STRING(arg) || AS_STRING(arg)->codesLength != 1) {
                        raise_TypeError(_method_name, "str of length 1", arg, names[oarg]);
                        goto _error;
                    }
                    *out = krk_unicodeCodepoint(AS_STRING(arg),0);
                }
                break;
            }
 
#ifndef KRK_NO_FLOAT
            case 'f': {
                float * out = va_arg(args, float*);
                if (!krk_valuesSame(arg, KWARGS_VAL(0))) {
                    if (!IS_FLOATING(arg)) {
                        KrkClass * type = krk_getType(arg);
                        krk_push(arg);
                        if (!krk_bindMethod(type, S("__float__"))) {
                            krk_pop();
                            raise_TypeError(_method_name, "float", arg, names[oarg]);
                            goto _error;
                        }
                        arg = krk_callStack(0);
                    }
                    *out = AS_FLOATING(arg);
                }
                break;
            }
 
            case 'd': {
                double * out = va_arg(args, double*);
                if (!krk_valuesSame(arg, KWARGS_VAL(0))) {
                    if (!IS_FLOATING(arg)) {
                        KrkClass * type = krk_getType(arg);
                        krk_push(arg);
                        if (!krk_bindMethod(type, S("__float__"))) {
                            krk_pop();
                            raise_TypeError(_method_name, "float", arg, names[oarg]);
                            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 (!krk_valuesSame(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;
            }
        }
 
        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)) {
                /* See if this was the name of an argument, which means it was already provided as a positional argument. */
                for (int j = 0; j < oarg; ++j) {
                    if (*names[j] && strlen(names[j]) == AS_STRING(entry->key)->length && !strcmp(names[j], AS_CSTRING(entry->key))) {
                        krk_runtimeError(vm.exceptions->typeError, "%s() got multiple values for argument '%s'",
                            _method_name, names[j]);
                        return 0;
                    }
                }
                /* Otherwise just say it was unexpected. */
                krk_runtimeError(vm.exceptions->typeError, "%s() got an unexpected keyword argument '%S'",
                    _method_name, AS_STRING(entry->key));
                return 0;
            }
        }
    }
 
    return 1;
 
_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;
}