PRINT_ARG_SPLITTING = False

        error = spye.MetacallException(self.func_name)
        out = spye.drv_output

        names_args = self.names_posargs + self.names_optargs
        names_validated = []

        posargs, optargs, varargs = args[:self.min_args], args[self.min_args:self.max_args], args[self.max_args:]

        if PRINT_ARG_SPLITTING:
            out.print_minute("Args splitting: min = %s, max = %s, %s -> posargs = %s, optargs = %s, varargs = %s, kwargs = [%s]",
                             self.min_args, self.max_args, list(args), list(posargs), list(optargs), list(varargs),
                             ", ".join(("%s -> %s" % (key, kwargs[key]) for key in kwargs)))

        validated_args = []

        out.print_minute("Checking %d positional arguments: [%s]", len(posargs), posargs)
        for i in range(len(posargs)):
            name = self.names_posargs[i]
            if name in kwargs:
                error.add("Positional argument also given as keyword argument: [%s]", name)
                raise error
            else:
                if name in self.arguments:
                    validated_args.append(arguments[name].validate(posargs[i]))
                else:
                    validated_args.append(posargs[i])
                names_validated.append(name)

        out.print_minute("Checking %d optional arguments: [%s]", len(optargs), optargs)
        for i in range(len(optargs)):
            name = self.names_optargs[i]
            if name in kwargs:
                error.add("Optional argument also given as keyword argument: [%s]", name)
                raise error
            else:
                if name in self.arguments:
                    validated_args.append(arguments[name].validate(optargs[i]))
                else:
                    validated_args.append(optargs[i])
                names_validated.append(name)

        num_args = len(posargs) + len(optargs)
        out.print_minute("Checking %d remaining arguments: [%s]",
                         self.max_args - num_args, ", ".join(names_args[num_args:self.max_args]))
        defaults_used = 0

        for i in range(num_args, self.max_args):
            name = names_args[i]
            if name in kwargs:
                if name in self.arguments:
                    validated_args.append(arguments[name].validate(kwargs[name]))
                else:
                    validated_args.append(kwargs[name])
                del kwargs[name]
                names_validated.append(name)
            else:
                if i - self.min_args >= 0:
                    defaults_used += 1
                    validated_args.append(self.defaults[i - self.min_args])

        if self.has_varargs and "*" in self.arguments:
            validated_varargs = self.arguments["*"].validate(varargs)
        else:
            validated_varargs = list(varargs)

        user_args = len(validated_args) - defaults_used
        if (user_args < self.min_args) or ((user_args > self.max_args) and not self.has_varargs):
            msg = "%d parameter%s given" % (user_args, ["s", ""][user_args == 1])
            if names_validated:
                msg += " (%s)" % ", ".join(names_validated)
            if self.has_varargs:
                msg += ", at least %d expected" % self.min_args
            else:
                if self.min_args <> self.max_args:
                    msg += ", between %d and %d expected" % (self.min_args, self.max_args)
                else:
                    msg += ", %d expected" % (self.max_args)

            msg += " (%s)" % self.str_params()

            error.add("%s", msg)
            raise error

        if not self.has_varargs and varargs:
            error.add("Variable arguments not accepted but [%s] given", ", ".join(map(repr, varargs)))

        if not self.has_kwargs and kwargs:
            error.add("Keyword arguments not accepted but [%s] given", ", ".join(kwargs.keys()))

        for i, arg in enumerate(validated_args):
            if hasattr(arg, 'valid') and not arg.valid:
                error.add("Argument %d (\"%s\") is not valid: %s", i+1, arg_names[i+1], arg.error)

        for i, arg in enumerate(validated_varargs):
            if hasattr(arg, 'valid') and not arg.valid:
                error.add("Optional argument %d of %d in \"%s\" is not valid: %s", i+1, len(validated_varargs), "*" + self.names_optargs[self.max_args - len(self.names_posargs)], arg.error)

        if error:
            return validated_args + validated_varargs, kwargs
        else:
            raise error