C++ intlen函数代码示例

static int	ft_minus(long long int arg, t_env *env, int excep)
{
	int		i;

	i = 0;
	if (env->plus || env->space || arg < 0)
		i++;
	if (env->plus && arg >= 0)
		ft_putchar('+');
	else if (env->space && arg >= 0)
		ft_putchar(' ');
	ft_minus_two(arg, env);
	if (!excep)
		ft_putnbr_ll(arg);
	i += env->precision > intlen(arg) ? env->precision : intlen(arg);
	if (env->size)
	{
		while (i < env->size)
		{
			ft_putchar(' ');
			i++;
		}
	}
	i -= excep ? intlen(arg) : 0;
	return (i);
}

static int	ft_precision(long long int arg, t_env *env, int excep)
{
	int		i;
	int		j;

	i = 0;
	j = 0;
	if (env->plus || env->space || arg < 0)
		j = 1;
	if (env->plus && arg >= 0)
		ft_putchar('+');
	else if (env->space && arg >= 0)
		ft_putchar(' ');
	if (arg < 0)
	{
		ft_putchar('-');
		arg = -arg;
	}
	i = excep && arg == 0 ? 0 : intlen(arg);
	while (i < env->precision && !excep)
	{
		ft_putchar('0');
		i++;
	}
	if (!excep || (intlen(arg) > env->precision && excep && arg != 0))
		ft_putnbr_ll(arg);
	return (i + j);
}

/* Format a command according to the Redis protocol. This function takes the
 * number of arguments, an array with arguments and an array with their
 * lengths. If the latter is set to NULL, strlen will be used to compute the
 * argument lengths.
 */
int redisFormatCommandArgv(char **target, int argc, const char **argv, const size_t *argvlen) {
    char *cmd = NULL; /* final command */
    int pos; /* position in final command */
    size_t len;
    int totlen, j;

    /* Calculate number of bytes needed for the command */
    totlen = 1+intlen(argc)+2;
    for (j = 0; j < argc; j++) {
        len = argvlen ? argvlen[j] : strlen(argv[j]);
        totlen += 1+intlen(len)+2+len+2;
    }

    /* Build the command at protocol level */
    cmd = malloc(totlen+1);
    if (!cmd) redisOOM();
    pos = sprintf(cmd,"*%d\r\n",argc);
    for (j = 0; j < argc; j++) {
        len = argvlen ? argvlen[j] : strlen(argv[j]);
        pos += sprintf(cmd+pos,"$%zu\r\n",len);
        memcpy(cmd+pos,argv[j],len);
        pos += len;
        cmd[pos++] = '\r';
        cmd[pos++] = '\n';
    }
    assert(pos == totlen);
    cmd[totlen] = '\0';
    *target = cmd;
    return totlen;
}

char *int2str(int num) {
    char *ret;
    
    ret = (char *) malloc(intlen(num) + 1);

    snprintf(ret, intlen(num) + 1, "%d", num); // Flawfinder: ignore

    return(ret);
}

char *int2str(int num) {
    char *ret;
    
    ret = (char *) malloc(intlen(num) + 1);

    snprintf(ret, intlen(num) + 1, "%d", num);

    return(ret);
}

/* Test if the string is a rational */
int
isratstr(const char *s, int len)
{
        int offset;

        if ((offset = intlen(s, len)) == len)
                return 1;
        else if (offset == 0 || *(s+offset) != '/')
                return 0;
        s += (offset+1), len -= (offset+1);
        return (*s != '+' && *s != '-' ? intlen(s, len) == len : 0);
}

int				check_nbr(char *str, int *u, va_list arg)
{
	t_int		x;
	int			i;

	x.t = va_arg(arg, int);
	x.nbr = intlen(x.t);
	i = 0;
	while (str[i] >= '0' && str[i] <= '9')
		i++;
	if (str[0] == '0' || str[0] == ' ')
	{
		x.cou = ft_atoi(ft_strsub(str, 1, (i - 1)));
		while ((x.nbr - x.cou) < 0)
			x.cou = wzero(str, x.cou, &(*u));
		(*u) = (*u) + (ft_putnbr(x.t));
		i++;
	}
	else if (str[0] >= '0' && str[0] <= '9')
	{
		x.cou = ft_atoi(ft_strsub(str, 0, (i)));
		while ((x.nbr - x.cou) < 0)
			x.cou = wzero(str, x.cou, &(*u));
		(*u) = (*u) + (ft_putnbr(x.t));
		i++;
	}
	return (i);
}

char		*ft_itoa(int n)
{
	char	*s;
	int		sign;
	int		nlen;

	if (n == -2147483648)
		return (ft_strdup("-2147483648"));
	sign = (n < 0) ? 1 : 0;
	nlen = intlen(n, 0);
	if (!(s = (char*)malloc(sizeof(char) * (nlen + sign + 1))))
		return (NULL);
	s += (nlen + sign);
	*s = '\0';
	if (!n)
		*--s = '0';
	while (n != 0)
	{
		*--s = (n > 0) ? (n % 10) + '0' : ((-n) % 10) + '0';
		n /= 10;
	}
	if (sign == 1)
		*--s = '-';
	return (s);
}

/*
Undocumented.
*/
int copy_temporary(const int save, const bool direction) {
	for (int level = 0; level < exec_temporary_levels; level++) {
		const int offset = level * exec_temporary_parts;
		for (int part = 0; part < exec_temporary_parts; part++) {
			const int path = offset + part;
			const size_t size = strlen(cfg_exec_temporary_paths[path]) + 1
					+ intlen(save) + 1;
			char * const save_path = malloc(size);
			if (save_path == NULL) {
				probno = log_error(MALLOC_PROBLEM);
				return -1;
			}
			snprintf(save_path, size, "%s_%d",
					cfg_exec_temporary_paths[path], save);
			if (direction) {
				copy(save_path, cfg_exec_temporary_paths[path]);
			}
			else {
				copy(cfg_exec_temporary_paths[path], save_path);
			}
			free(save_path);
		}
	}
	return 0;
}

/* Helper function for redisvFormatCommand(). */
static void addArgument(sds a, char ***argv, int *argc, int *totlen) 
{
	(*argc)++;
	if ((*argv = zrealloc(*argv, sizeof(char*)*(*argc))) == NULL) return ;
	if (totlen) *totlen = *totlen+1+intlen(sdslen(a))+2+sdslen(a)+2;
	(*argv)[(*argc)-1] = a;
}

int			ft_print_signed_number(long long int arg, t_env *env)
{
	int		i;
	int		excep;

	i = 0;
	excep = (env->isprecision && env->precision == 0) ? 1 : 0;
	if (env->minus && ((env->precision < env->size && env->isprecision)
		|| !env->precision))
		i += ft_minus(arg, env, excep);
	else if (env->isprecision && env->precision >= env->size)
		i += ft_precision(arg, env, excep);
	else if (env->size)
		i += ft_size_sn(arg, env, excep);
	else if (env->plus || env->space)
		i += ft_cortex(arg, env, excep);
	else
	{
		if (!excep)
			ft_putnbr_ll(arg);
		i = excep ? 0 : intlen(arg);
		i += (arg < 0 ? 1 : 0);
		i += (arg == LLONG_MIN ? 18 : 0);
	}
	return (i);
}

void printNum(int a[LEN])
{
    int i;
	for ( i = intlen(a)-1; i >= 0; i--)
	{
		printf("%d", a[i]);
	}
}

ol_splay_tree_node *ols_find_tx_id(ol_splay_tree *tree, const transaction_id key) {
    const size_t klen = intlen(key);
    char *_key = tx_to_str(key);

    ol_splay_tree_node *node = ols_find(tree, _key, klen);
    free(_key);

    return node;
}

int ol_aol_write_cmd(ol_database *db, const char *cmd, ol_bucket *bct)
{
	int ret;
	if (strncmp(cmd, "JAR", 3) == 0) {
		/* I'LL RIGOR YER MORTIS */
		debug("Writing: \"%.*s\"", (int)bct->klen, bct->key);
		char aol_str[] =
		        ":%zu:%s"    /* cmd length, cmd */
		        ":%zu:%.*s"    /* klen size, key */
		        ":%zu:%.*s"    /* ctype size, content_type */
		        ":%d:%d"     /* sizeof(original_size), original_size */
		        ":%d:%d"     /* sizeof(size_t), data_size */
		        ":%d:%d";    /* sizeof(size_t), offset into file */
		ret = fprintf(db->aolfd, aol_str,
		              strlen(cmd),                                cmd,
		              bct->klen, (int)bct->klen,         bct->key,
		              bct->ctype_size, (int)bct->ctype_size,   bct->content_type,
		              intlen(bct->original_size),                 bct->original_size,
		              intlen(bct->data_size),                     bct->data_size,
		              intlen(bct->data_offset),                   bct->data_offset);
		check(ret > -1, "Error writing to file.");
		ret = fprintf(db->aolfd, "\n");
	} else if (strncmp(cmd, "SCOOP", 5) == 0) {
		ret = fprintf(db->aolfd, ":%zu:%s:%zu:%s\n",
		              strlen(cmd), cmd,
		              bct->klen, bct->key);
		check(ret > -1, "Error writing to file.");
	} else if (strncmp(cmd, "SPOIL", 5) == 0) {
		char exptime[21] = {'\0'};
		_serialize_time(bct->expiration, exptime);
		ret = fprintf(db->aolfd, ":%zu:%s:%zu:%s:%zu:%*s\n",
		              strlen(cmd), cmd,
		              bct->klen, bct->key,
		              strlen(exptime), 20, exptime);
		check(ret > -1, "Error writing to file.");
	} else {
		ol_log_msg(LOG_ERR, "No such command '%s'", cmd);
		return -1;
	}
	check(ret > -1, "Error writing to file.");
	return ol_aol_sync(db);
error:
	return -1;
}

/* remove the reference boost */
typeID dereference (typeID t)
{
	int *tt = open_typeID (t), *tn;
	if (tt [0] < REFERENCE_BASE)
		return t;
	tn = allocaint (intlen (tt) + 1);
	intcpy (tn, tt);
	tn [0] -= REFERENCE_BOOST;
	return enter_type (tn);
}