char *utoa_drop_trailing_0(char *buf, Uint_ n_, unsigned &n_skipped) {
typedef typename signed_for_int<Uint_>::unsigned_t Uint;
Uint n=n_;
n_skipped=0;
if (!n) {
*--buf='0';
return buf;
} else {
Uint rem;
while (n) {
NDIV10MOD(rem, n);
if (rem) {
*--buf = digit_to_char(rem);
// some non-0 trailing digits; now output all digits.
while (n) {
NDIV10MOD(rem, n);
*--buf = digit_to_char(rem);
}
return buf;
}
++n_skipped;
}
assert(0);
return 0;
}
}
static void print_val (reg_t val)
{
reg_t mask;
byte_t start;
byte_t pos;
byte_t shift;
digit_t d;
mask = 0xF000;
shift = 12;
start = 0;
for (pos = 0; pos < 4; pos++)
{
d = (val & mask) >> shift;
if (d || start || pos == 3)
{
start = 1;
print_char (digit_to_char (d));
}
shift -= 4;
mask >>= 4;
}
print_char (13); // carriage return
print_char (10); // new line
}
static void print_stat (err_t err)
{
print_char ('S');
print_char (digit_to_char (err & 0xF));
print_char (13); // carriage return
print_char (10); // new line
}
char *ft_itoa(int n)
{
long big_n;
char *r;
char *it;
big_n = n;
if (big_n == 0)
r = "0";
else
{
r = malloc(nb_chars(big_n) + 1);
if (r)
{
it = r + nb_chars(big_n);
apply_sign(&big_n, r);
*it-- = '\0';
while (big_n)
{
*it-- = digit_to_char(big_n % 10);
big_n /= 10;
}
}
}
return (r);
}
char *ft_itoa_base(int value, int base)
{
int negative;
char *str;
int length;
int value2;
if (value == -2147483648)
return ("-2147483648");
negative = value < 0 && base == 10;
value = value < 0 ? value * -1 : value;
length = 1;
value2 = value;
while (value2 >= base)
{
value2 /= base;
length++;
}
str = (char*)malloc(sizeof(char) * ((length += negative) + 1));
str[0] = '-';
str[length] = '\0';
while (length-- > negative)
{
str[length] = digit_to_char(value % base);
value /= base;
}
return (str);
}
char *utoa(char *buf, Int n_) {
typedef typename signed_for_int<Int>::unsigned_t Uint;
Uint n=n_;
if (!n) {
*--buf='0';
} else {
Uint rem;
// 3digit lookup table, divide by 1000 faster?
while (n) {
NDIV10MOD(rem, n);
*--buf = digit_to_char(rem);
}
}
return buf;
}
void ft_putnbr_fd(int n, int fd)
{
if (n == -2147483648)
ft_putstr_fd("-2147483648", fd);
else if (n < 0)
{
ft_putchar_fd('-', fd);
ft_putnbr_fd(n * -1, fd);
}
else
{
if (n / 10 != 0)
{
ft_putnbr_fd(n / 10, fd);
}
ft_putchar_fd(digit_to_char(n % 10), fd);
}
}
void uint_to_str(size_t value, size_t base, char* buf) {
if(value == 0) {
string_copy(buf, "0", 1);
return;
}
//To do: adjust size?
//TODO: make independent of word size!
char buf2[16];
size_t len = 0;
while(value > 0) {
UintDivMod div = uintDivMod(value, base);
buf2[len] = digit_to_char(div.remainder);
++len;
value = div.quotient;
}
for(size_t i = 0; i < len; ++i) {
buf[i] = buf2[len - 1 - i];
}
buf[len] = '\0';
}
