void test(int n, char *b)
{
printf("ft_putnbr_base(%i, %s) => \n", n, b);
ft_putnbr_base(n, b);
printf("\n________________________________________\n\n");
printf("ft_putnbr_base(+%i, %s) => \n", +n, b);
ft_putnbr_base(+n, b);
printf("\n________________________________________\n\n");
printf("ft_putnbr_base(%i, %s) => \n", -n, b);
ft_putnbr_base(-n, b);
printf("\n");
}
static void show_block(t_block *block)
{
size_t size;
size = block->size;
ft_putstr("0x");
ft_putnbr_base((size_t)block->addr, 16);
ft_putstr(" - 0x");
ft_putnbr_base((size_t)block->addr + size, 16);
ft_putstr(" : ");
ft_putnbr_base(size, 10);
ft_putstr(" octets\n");
}
void ft_putnbr_base(int nb, char *base)
{
if (nb >= ft_strlen(base))
{
ft_putnbr_base(nb / ft_strlen(base), base);
ft_putnbr_base(nb % ft_strlen(base), base);
}
else
{
// if (base[nb] >= 'a' && base[nb] <= 'f')
// ft_putchar('0');
ft_putchar(base[nb]);
}
}
void ft_putnbr_base(int nb, char *base)
{
int len;
len = ft_strlen(base);
if (nb < len)
{
ft_putchar(base[nb]);
}
else
{
ft_putnbr_base(nb / len, base);
ft_putnbr_base(nb % len, base);
}
}
void ft_putnbr_base(size_t n, size_t base)
{
if (n >= base)
{
ft_putnbr_base(n / base, base);
ft_putnbr_base(n % base, base);
}
else
{
if (n < 10)
ft_putchar(n + '0');
else
ft_putchar(n - 10 + 'a');
}
}
int print_X_MAJ(va_list list, int nbr)
{
size_t i;
char *str;
int size;
str = (char *)ft_memalloc(sizeof(char) * 100);
i = va_arg(list, int);
ft_putnbr_base(i, "0123456789ABCDEF", 0, str);
reverse(str);
size = ft_strlen(str);
if (nbr < size)
ft_putstr(str);
else
{
nbr = nbr - size;
while (nbr > 0)
{
write(1, " ", 1);
nbr--;
}
ft_putstr(str);
}
return (ft_strlen(str));
}
void *print_content_hexa(t_list_rb *root, t_list_rb **prev,
t_list_rb *lst, size_t malloc_size)
{
size_t size;
debug_stdout("INIT", FILE_LINE_FUNC);
debug_lst("lst", lst, __FILE__, __LINE__);
size = 0;
while (size < lst->content_size)
{
if (size)
{
if (!(size % 32))
ft_putchar('\n');
else if (!(size % 2))
ft_putchar(' ');
}
ft_putnbr_base(ft_ctoi(((unsigned char *)lst->content)[size]), 16, 2);
++size;
}
ft_putchar('\n');
(void)root;
(void)prev;
(void)malloc_size;
return (lst);
}
static void print_nlists_32(char *ptr, struct nlist **t_el,
char *st, int nsyms)
{
int i;
char c;
i = 0;
while (i < nsyms)
{
c = get_symbol(ptr, t_el[i], FT_NM_CPU_32);
if (c == 'A'
|| (c != 'u' && c != 'c' && *(st + t_el[i]->n_un.n_strx)
&& *(st + t_el[i]->n_un.n_strx) != '/'
&& (!t_el[i]->n_value
|| (i == nsyms - 1)
|| ((t_el[i]->n_value != t_el[i + 1]->n_value)
|| ft_strcmp(st + t_el[i]->n_un.n_strx,
st + t_el[i + 1]->n_un.n_strx)))))
{
if (c != 'U' && c != 'I')
ft_putnbr_base(t_el[i]->n_value, FT_NM_BASE, FT_NM_ADDR_LEN_32);
else
ft_putnchar(' ', FT_NM_ADDR_LEN_32);
format_print(t_el[i], st, c);
}
++i;
}
}
int ft_putnbr_base(intmax_t i, int base, int spec)
{
if (i < 0)
{
spec++;
ft_putchar('-');
i *= -1;
}
if (i < base)
spec = spec + ft_putchar(i >= 10 ? i + 87 : i | 0x30);
else if (i > base - 1)
{
spec = ft_putnbr_base(i / base, base, spec++);
ft_putnbr_base(i % base, base, spec++);
}
return (spec);
}
void ft_putnbr_base(int nbr, char *base)
{
if (nbr < 0)
{
ft_putchar('-');
nbr = -nbr;
}
if (nbr >= ft_strlen(base))
{
ft_putnbr_base(nbr / ft_strlen(base), base);
ft_putnbr_base(nbr % ft_strlen(base), base);
}
else
{
ft_putchar(base[nbr]);
}
}
void ft_putnbr_base(int nb, char *base)
{
if (nb < 0)
{
ft_putchar('-');
nb = -nb;
}
if (nb >= ft_strlen(base))
{
ft_putnbr_base(nb / ft_strlen(base), base);
ft_putnbr_base(nb % ft_strlen(base), base);
}
else
{
ft_putchar(base[nb]);
}
}
int ft_putnbr_basel(unsigned long long int n, unsigned int base,
unsigned int pad)
{
int ret;
ret = ft_putnbr_base(n, base, pad);
ret = ft_putchar('\n') == EXIT_SUCCESS ? ret : EXIT_FAILURE;
return (ret);
}
void ft_putnbr_base(int n, int base)
{
char *base_digits;
base_digits = "0123456789abcdefghijklmnopqrstuvwxyz";
if (n >= base)
ft_putnbr_base(n / base, base);
ft_putchar(base_digits[n % base]);
}
void ft_putnbr_base(long long nb, int base, int maj)
{
char *str;
str = maj ? "0123456789ABCDEF" : "0123456789abcdef";
if (nb < 0)
{
ft_putchar('-');
nb = -nb;
}
if (nb < base)
ft_putchar(str[nb]);
else
{
ft_putnbr_base(nb / base, base, maj);
ft_putnbr_base(nb % base, base, maj);
}
}
void ft_putnbr_base(int n, size_t base)
{
if (n < 0)
{
ft_putchar('-');
n *= -1;
}
if ((size_t)n >= base)
{
ft_putnbr_base(n / base, base);
ft_putnbr_base(n % base, base);
}
else
{
if (n < 10)
ft_putchar(n + '0');
else
ft_putchar(n - 10 + 'A');
}
}
void show_alloc_mem(void)
{
size_t total_size;
total_size = 0;
total_size += show_memory(g_memory.tiny, "TINY : ");
total_size += show_memory(g_memory.small, "SMALL : ");
total_size += show_memory(g_memory.large, "LARGE : ");
ft_putstr("Total : ");
ft_putnbr_base(total_size, 10);
ft_putstr(" octets\n");
}
void ft_putnbr_base(int nbr, char *base)
{
int lbase;
lbase = ft_strlen(base);
if (nbr < 0)
{
ft_putchar('-');
nbr *= -1;
}
if (nbr > lbase - 1)
{
ft_putnbr_base(nbr/lbase, base);
ft_putnbr_base(nbr%lbase, base);
}
else
{
ft_putchar(base[nbr]);
}
}
int ft_disp_int(t_elem list, intmax_t j, char *finder, intmax_t i)
{
if (finder[-1] == 'h' && finder[-2] == 'h')
return (ft_putnbr_base((char)i, 10, 0));
else if (finder[-1] == 'h')
return (ft_putnbr_base((short)i, 10, 0));
else if (finder[-1] == 'j')
return (i == LLONG_MIN ? ft_putstr("-9223372036854775808")
: ft_putnbr_base(i, 10, 0));
else if (finder[-1] == 'l' && finder[-2] == 'l')
return (i == LLONG_MIN ? ft_putstr("-9223372036854775808")
: ft_putnbr_base((long long)i, 10, 0));
else if (finder[-1] == 'l')
return (i == LLONG_MIN ? ft_putstr("-9223372036854775808")
: ft_putnbr_base((long)i, 10, 0));
else if (finder[-1] == 'z')
{
// printf ("|%zi|\n", (unsigned long)i);
return (i == LLONG_MIN ? ft_putstr("-9223372036854775808") :
ft_putnbr_base_unsigned((unsigned long)i, 10, 0));
}
else if ((finder[0] == 'd') || (finder[0] == 'i') || (finder[0] == 'D'))
return (ft_putnbr_base((int)i, 10, 0));
else if (list.point == -1 && j != 0)
i += ft_putchar(' ');
return (-1);
}
int ft_putnbr_pf(va_list ap, int nbb)
{
int i;
int nb;
int nb2;
i = 0;
nb = va_arg(ap, int);
nb2 = ft_return_nb_nb_di(nb, "0123456789");
while (i++ < nbb - nb2)
ft_putchar(' ');
return (ft_putnbr_base(nb, "0123456789") + i);
}
void ft_putnbr_base(int nbr, char *base)
{
if (check_base_condition(base))
{
if (nbr == -2147483648)
{
ft_putchar('-');
ft_putmaxneg_base(nbr, base);
return ;
}
if (nbr < 0)
{
ft_putchar('-');
nbr = -nbr;
}
if (nbr >= ft_strlen(base))
{
ft_putnbr_base(nbr / ft_strlen(base), base);
ft_putnbr_base(nbr % ft_strlen(base), base);
}
else
ft_putchar(base[nbr]);
}
}
void ft_putnbr_base(unsigned int n, unsigned int base)
{
char *val;
val = "0123456789ABCDEF";
if (base < 2 || base > 16)
return ;
if (n / base != 0)
{
ft_putnbr_base(n / base, base);
write(1, &val[n % base], 1);
}
else
write(1, &val[n % base], 1);
}
void ft_putnbr_base(int n, int base)
{
if (base == 10)
ft_putnbr(n);
else if (n < 0)
ft_putchar('0');
else
{
if (n >= base)
ft_putnbr_base(n / base, base);
if (n % base < 10)
ft_putchar((n % base) + 48);
else
ft_putchar((n % base) - 10 + 65);
}
}
int ft_signs_int(char *finder, t_elem list, intmax_t j, int i)
{
i = ft_signs_int_next(finder, list, j, i);
if (finder[0] != 'D' && list.zero && (int)j == 0 && ((list.plus != 0)
|| (list.whitespace != 0)))
i += ft_putchar('0');
if ((((finder[0] == 'i') || (finder[0] == 'd')) && list.point != -1) ||
(((finder[0] == 'i') || (finder[0] == 'd')) && list.point == -1 && j))
i += ft_disp_int(list, j, finder, j);
else if (finder[0] == 'D' && ((list.point != -1) ||
(list.point == -1 && (int)j != 0)))
i += (j < -9223372036854775807) ? ft_putstr("-9223372036854775808")
: ft_putnbr_base((long long)j, 10, 0);
if ((list.width > 0 && finder[0] == 'D' && list.width >
ft_lenbr_max((unsigned long)j) && list.minus != 0) || (list.width > 0
&& list.width > ft_lenbr((int)j) && list.minus != 0))
i += ft_handlewidth_digit(list, (long long)j, finder);
return (i);
}
int check_p(char c, t_args **arg, va_list ap)
{
int len;
unsigned long val;
int prec;
len = 0;
if (c == 'p')
{
val = (unsigned long)va_arg(ap, void*);
prec = ((*arg)->precision >= 0) ? (*arg)->precision : (*arg)->field - \
ft_nbrlen_base(val, 16, -1) - 2 + (val == 0);
len += ft_putnchar(' ', (!(*arg)->justify && !(*arg)->zero) ? \
(*arg)->field - ft_nbrlen_base(val, 16, -1) - 2 : 0);
len += ft_putstr("0x");
len += ft_putnbr_base(val, 16, ((*arg)->zero || \
(*arg)->precision >= 0) ? prec : -1, 0);
len += ft_putnchar(' ', ((*arg)->justify) ? (*arg)->field -\
ft_nbrlen_base(val, 16, -1) - 2 : 0);
}
int main(void)
{
char dest[50];
dest[0] = 'z';
dest[1] = 'b';
dest[2] = '\0';
dest[3] = 'p';
dest[4] = 'f';
dest[5] = 'f';
dest[6] = 'g';
dest[7] = 'h';
dest[8] = 'j';
dest[9] = 'k';
dest[10] = 'l';
dest[11] = 'm';
dest[12] = 'n';
dest[13] = 'o';
dest[14] = '\0';
char dest1[50];
dest1[0] = 'z';
dest1[1] = 'b';
dest1[2] = '\0';
dest1[3] = 'p';
dest1[4] = 'f';
dest1[5] = 'f';
dest1[6] = 'g';
dest1[7] = 'h';
dest1[8] = 'j';
dest1[9] = 'k';
dest1[10] = 'l';
dest1[11] = 'm';
dest1[12] = 'n';
dest1[13] = 'o';
dest1[14] = '\0';
ft_putnbr_base(214546984, "0123456789ABCDEF");
ft_putchar('\n');
return (0);
}
static size_t show_memory(t_block *block, char *type)
{
size_t size;
size = 0;
ft_putstr(type);
if (!block)
{
ft_putstr("is empty\n");
return (0);
}
ft_putstr("0x");
ft_putnbr_base((size_t)block->addr, 16);
write(1, "\n", 1);
while (block)
{
size += block->size;
show_block(block);
block = block->next;
}
return (size);
}
int ft_aff_pointer(char *finder, va_list op, t_elem list)
{
void *ptr;
int i;
i = 0;
(void)finder;
ptr = va_arg(op, void *);
if (list.width > 3 && list.minus == 0
&& list.width > ft_lenbr_base((long long)ptr, 16) + 2)
i = ft_putnchar(' ', list.width
- ft_lenbr_base((long long)ptr, 16) - 2);
i += ft_putstr("0x");
if (ptr != 0)
i += ft_putnbr_base((long long)ptr, 16, 0);
else if (!list.point && !list.sharp)
i += ft_putchar('0');
if (list.width > 3 && list.minus != 0
&& list.width > ft_lenbr_base((long long)ptr, 16) + 2)
i += ft_putnchar(' ', list.width
- ft_lenbr_base((long long)ptr, 16) - 2);
return (i);
}
void ft_putnbr_base(int n, int base)
{
char *c;
c = "0123456789abcdef";
if (n == -2147483648)
{
ft_putstr("-2147483648");
return ;
}
if (n < 0)
{
if (base == 10)
ft_putchar('-');
n = -n;
}
if (n < base)
ft_putchar(c[n]);
if (n >= base)
{
ft_putnbr_base(n / base, base);
ft_putchar(c[n % 10]);
}
}
void ft_putmem(void *adr)
{
write(1, "0x", 2);
ft_putnbr_base((size_t)adr, 16);
}
int print_d_l(va_list list, int nbr)
{
long int i;
int neg;
char *str;
int size;
neg = 0;
str = (char *)ft_memalloc(sizeof(char) * 100);
i = va_arg(list, long int);
if(i < 0)
{
neg = 1;
if (i <= -9223372036854775807)
return (print("9223372036854775808", nbr, 0, neg));
ft_putnbr_base(-i, "0123456789", 0, str);
}
else
{
if (i >= 9223372036854775807)
return (print("9223372036854775807", nbr, 0, neg));
ft_putnbr_base(i, "0123456789", 0, str);
}
reverse(str);
size = ft_strlen(str);
return (print(str, nbr, size, neg));
}
