void set_c(t_struct *f, va_list va)
{
wchar_t c;
char *larg;
int y;
larg = NULL;
c = f->type == 'C' || f->l == 1 ? va_arg(va, wchar_t) : va_arg(va, int);
y = f->type == 'C' || f->l == 1 ? ft_count_wchar(c) : 1;
if (f->larg > 0)
{
larg = place(f->larg - y, ' ');
if (f->moins == 1)
{
f->type == 'C' || f->l == 1 ? ft_putwchar(c) : ft_putchar(c);
ft_putstr(larg);
}
else
{
ft_putstr(larg);
f->type == 'C' || f->l == 1 ? ft_putwchar(c) : ft_putchar(c);
}
}
else
f->type == 'C' || f->l == 1 ? ft_putwchar(c) : ft_putchar(c);
set_c_gret(f, larg, c);
free(larg);
}
void print_wchar(va_list list, int *i)
{
wchar_t c;
c = va_arg(list, wchar_t);
i[1] += ft_putwchar(c);
}
void ft_deal_with_types_and_conversion_2(t_op *op, t_arg *lnk)
{
if (op->conv == 'o')
{
ft_create_padding(op, lnk);
ft_deal_with_octal_conversion(op, lnk);
}
else if (op->conv == 'x' || op->conv == 'X' || op->conv == 'p')
{
ft_deal_with_hexa_conversion(op, lnk);
}
else if (op->conv == 'c')
{
if (ft_strncmp(op->mod, "l", 1) == 0)
{
lnk->ps = 1;
ft_putwchar(lnk->i);
}
else
{
lnk->ps = 1;
ft_putchar(lnk->i);
}
}
ft_deal_with_types_and_conversion_3(op, lnk);
}
static int ft_printw(t_param *ptr, int ret)
{
if (ft_findflag(ptr, '-') != -1)
ret += ft_putwchar('\0');
while (ptr->width-- > 1)
{
if (ft_findflag(ptr, '0') != -1 || ft_findflag(ptr, 'O') != -1)
ft_putchar('0');
else
ft_putchar(' ');
ret++;
}
if (ft_findflag(ptr, '-') == -1)
ret += ft_putwchar('\0');
return (ret);
}
void ft_putwstr(wchar_t *str)
{
int i;
i = 0;
while (str[i])
ft_putwchar(str[i++]);
}
void ft_putwstr(wchar_t *str)
{
while (*str)
{
ft_putwchar(*str);
str++;
}
}
int flag_cc(va_list *llist, t_arg args)
{
wchar_t arg;
arg = va_arg(*llist, int);
(void)args;
ft_putwchar(arg);
return (wchar_lenght(arg));
}
void ft_putwcs(const wchar_t *str)
{
size_t i;
i = 0;
while (str[i])
{
ft_putwchar(str[i]);
i++;
}
}
void ft_putwstr(const wchar_t *wide_char)
{
int index;
index = 0;
while (wide_char[index] != '\0')
{
ft_putwchar(wide_char[index]);
index++;
}
}
void ft_putwstr(const wchar_t *ws)
{
const wchar_t *tmp;
tmp = ws;
while (*tmp)
{
ft_putwchar(*tmp);
tmp++;
}
}
void ft_putwstr(wchar_t *str)
{
int index;
index = 0;
while (str[index])
{
ft_putwchar(str[index]);
index++;
}
}
int ft_putwstr(wchar_t *str)
{
int i;
i = 0;
while (*str != '\0')
{
i += ft_putwchar(*str);
str++;
}
return (i);
}
void ft_putwstr(wchar_t *str)
{
size_t i;
size_t len;
i = 0;
len = ft_wstrlen(str);
while (i <= len)
{
ft_putwchar(str[i]);
i++;
}
}
int ft_putwstr(wchar_t *str)
{
int len;
len = 0;
while (*str)
{
ft_putwchar(*str);
len += ft_wclen(*str);
str++;
}
return (len);
}
int print_wchar(t_opt *opt, va_list *args)
{
wchar_t c;
int size;
c = va_arg(*args, wint_t);
size = ft_wcharlen(c);
print_width_before(opt, opt->min_w - 1);
ft_putwchar(c);
print_width_after(opt, opt->min_w - 1);
if (opt->min_w > 0)
return (opt->min_w);
return (size);
}
int printf_wchar(va_list ap, t_opts *opts)
{
int len;
wchar_t c;
c = va_arg(ap, wint_t);
len = ft_wclen(c);
if (!(opts->flags & MINUS))
len = printf_spaces(opts->min_width, len, opts->flags);
ft_putwchar(c);
if (opts->flags & MINUS)
len = printf_spaces(opts->min_width, len, opts->flags);
return (len);
}
int ft_putwstr(wchar_t *str)
{
int len;
int tmp;
len = 0;
while (str && *str)
{
if ((tmp = ft_putwchar(*str++)) == -1)
return (-1);
len += tmp;
}
return (len);
}
int ft_putwstr(wchar_t *s)
{
int i;
int count;
i = 0;
count = 0;
while (s[i] != '\0')
{
count += ft_putwchar(s[i]);
i++;
}
return (count);
}
int ft_putwstr(wchar_t *wstr)
{
int ret;
int cur;
ret = 0;
cur = 0;
while (wstr[cur])
{
ret += ft_putwchar(wstr[cur]);
cur++;
}
return (ret);
}
int putoptswstr(t_opts *opts, wchar_t *wstr)
{
int len;
len = ft_wstrlen(wstr);
ft_putwstr(wstr);
freewstr(wstr);
if (len == 0 && opts->type == 'C')
{
ft_putwchar(0);
return (1);
}
return (len);
}
int ft_print_wchar(va_list *list_args, t_args *arg)
{
wchar_t wchar;
wchar = (wchar_t)va_arg(*list_args, wint_t);
ft_memset(arg->conv, '\0', 3);
if (arg->val_field && !arg->val_minus && arg->val_z)
ft_printnchar(arg->field - ft_wcharlen(wchar), '0');
if (arg->val_field && !arg->val_minus && !arg->val_z)
ft_printnchar(arg->field - ft_wcharlen(wchar), ' ');
ft_putwchar(wchar);
if (arg->val_field == 1 && arg->val_minus == 1)
ft_printnchar(arg->field - ft_wcharlen(wchar), ' ');
return (ft_retfield(arg, ft_wcharlen(wchar)));
}
int printf_lc(int fd, t_print_param *pp, wchar_t c)
{
int total;
int arg_size;
total = 0;
arg_size = 1;
if ((pp->flags & PRINT_FLAG_LESS) == 0)
while (total < pp->field_width - arg_size)
total += ft_putchar(fd, pp->flags & PRINT_FLAG_ZERO ? '0' : ' ');
total += ft_putwchar(fd, c);
while (total < pp->field_width)
total += ft_putchar(fd, ' ');
return (total);
}
void ft_putwstr(t_add *flag, wchar_t const *s)
{
int i;
wchar_t *str;
if (!s)
str = ft_strwdup(L"(null)");
else
str = ft_strwdup(s);
i = 0;
if (flag->max < 0 && flag->prflag != -1)
while ((int)ft_strwlen(str) < flag->min--)
ft_putwchar(L' ', flag);
else if (flag->prflag != -1)
while (flag->max < flag->min--)
ft_putwchar(L' ', flag);
if (flag->max < 0)
flag->max = ft_strwlen(str);
while (str[i] != L'\0' && i < flag->max)
ft_putwchar(str[i++], flag);
if (flag->prflag == -1 || i < ++flag->min)
while (i++ < flag->min)
ft_putwchar(L' ', flag);
}
int call_putchar(const char *str, va_list args, t_docker *data)
{
int32_t argument;
if (data->length == l)
return (ft_putwchar(va_arg(args, wint_t), 0));
else
argument = va_arg(args, uint32_t);
if (data->width >= 1 && data->less == 0)
data->len = ftp_distrib_char(data, argument, data->len, 3);
else if (data->less == 1 && str)
data->len = ftp_distrib_char(data, argument, data->len, -1);
else
data->len = ftp_distrib_char(data, argument, data->len, 4);
return (0);
}
static size_t ft_putnwstr(wchar_t *wstr, size_t n)
{
size_t i;
size_t j;
j = 0;
i = 0;
while (i < n)
{
i += ft_wcharlen(wstr[j]);
if (i <= n)
ft_putwchar(wstr[j]);
j++;
}
return (i);
}
void pr_symb(wchar_t *str, int *fl, size_t *res, int i)
{
size_t k;
k = *res;
while (*str)
{
if (fl[6] > 0 && (int)(*res - k) >= fl[6])
break ;
ft_putwchar(*str, res);
str++;
if (fl[6] > 0 && (int)((*res - k) + ft_sizeof_wchar(*str)) > fl[6])
break ;
}
if (i)
pr_space_null(fl[5] - (*res - k), res, ' ');
}
void ft_putnwstr(const wchar_t *str, size_t len)
{
size_t i;
i = 0;
while (*str && i < len)
{
if (*str <= 0x7F)
i++;
else if (*str <= 0x7FF)
i += 2;
else if (*str <= 0xFFFF)
i += 3;
else if (*str <= 0x10FFFF)
i += 4;
if (i <= len)
ft_putwchar(*str++);
}
}
void ftpf_convert_c(va_list *ap, t_ftpf_env *e)
{
ftpf_manage_lenmod_c(ap, e);
ftpf_process_flags(e);
e->precision = 0;
ftpf_process_output_rules(e);
if (!e->neg)
ftpf_manage_field_width(e);
if (!ft_strcmp(e->mod, "l") || e->conversion == 'C')
ft_putwchar(e->param->wc);
else
ft_putchar(e->param->uc);
if (e->neg)
ftpf_manage_field_width(e);
if (e->error)
{
e->outputlen = -1;
e->field_width = -1;
}
}
void ft_putwstr(wchar_t *ws, int len)
{
int i;
i = 0;
while (ws[i] && len >= 0)
{
if (ws[i] <= 0x7F)
len -= 1;
else if (ws[i] <= 0x7FF)
len -= 2;
else if (ws[i] <= 0xFFFF)
len -= 3;
else
len -= 4;
if (len >= 0)
ft_putwchar(ws[i]);
i++;
}
}
int ft_putwstr(wchar_t *str, size_t len)
{
size_t i;
int ret;
i = 0;
ret = 0;
while (*str && i < len)
{
if (*str <= 0x7F)
i += 1;
else if (*str <= 0x7FF)
i += 2;
else if (*str <= 0xFFFF)
i += 3;
else
i += 4;
if (i > len)
break ;
ret += ft_putwchar(*str++);
}
return (ret);
}
