void testMY_REVSTR(void){
char* str = NULL;
str = my_strdup("testing");
if(temp_file != NULL){
CU_ASSERT(my_revstr(str) == 7);
CU_ASSERT_STRING_EQUAL(str, "gnitset");
CU_ASSERT(my_revstr(NULL) == -1);
}
}
void test_my_revstr()
{
my_str("Begin my_revstr \n");
char str[] = "hey!";
my_str(str);
char str1[] = "hello";
my_revstr(str);
my_str(str);
my_char('\n');
my_revstr(str1);
my_str(str1);
my_char('\n');
}
/*
** fonction principale
*/
char *soustraction(char *base, char *operators, char *expr1, char *expr2)
{
if (is_sup(base, expr1, expr2))
{
my_revstr(expr1);
my_revstr(expr2);
return (sub(base, operators, expr1, expr2, 0));
}
else
{
my_revstr(expr1);
my_revstr(expr2);
return (sub(base, operators, expr2, expr1, 1));
}
}
int put_convert_to_nbase(unsigned int nbr, int base, char b)
{
unsigned int quo;
char *result;
int j;
j = 0;
result = malloc(my_nbrlen(nbr) * 3 + 2);
if (result == NULL)
return (0);
while (nbr > 0)
{
quo = nbr / base;
while (nbr >= base)
nbr = nbr - base;
if (nbr > 9 && b == 0)
nbr = nbr + 7;
if (nbr > 9 && b == 1)
nbr = nbr + 39;
result[j] = nbr + '0';
j++;
nbr = quo;
}
result[j] = '\0';
my_putstr(my_revstr(result));
return (my_strlen(result));
}
int my_putnbr_base(int nbr, char *base)
{
int base_size;
char value[1024];
int i;
int my_nbr;
my_nbr = nbr;
init_tab(value);
base_size = my_strlen(base);
if (base_size <= 0)
return (my_nbr);
i = 0;
while (nbr > 0)
{
value[i++] = *(base + (nbr % base_size));
nbr /= base_size;
}
write(1, "\\", 1);
if (my_strlen(value) == 1)
write(1, "0", 1);
my_putstr(my_revstr(value));
return (my_nbr);
}
static char *edit_getword(t_line *line, int *pos)
{
t_line *tmp;
char *word;
int i;
i = -1;
*pos = 0;
tmp = line;
while (tmp && !tmp->status)
{
if (tmp->letter == ' ' || tmp->letter == '\t')
*pos += 1;
tmp = tmp->next;
}
if (edit_cp(line) == 0)
*pos += 1;
if (tmp == NULL ||
((word = xmalloc(sizeof(*word) * (edit_listlen(line) + 2))) == NULL))
return (my_strdup("*"));
word[++i] = '*';
while (tmp && (tmp->letter != ' ' && tmp->letter != '\t'))
{
word[++i] = tmp->letter;
tmp = tmp->prev;
}
return (my_revstr(word));
}
char *_op_sub(char *tab[2], t_base *base, char ops[7], int len[2])
{
char *buff;
int i;
int ret;
int tmp;
buff = xmalloc((MAX(len[0], len[1]) + 3) * sizeof(char));
my_memset(buff, 0x0, MAX(len[0], len[1]) + 3);
init_var(&i, &ret, &tmp);
while (len[0] >= min_ref(tab[0], ops) || len[1] >= min_ref(tab[1], ops))
{
if (len[0] >= min_ref(tab[0], ops) && len[1] >= min_ref(tab[1], ops))
tmp = base->value[tab[0][len[0]]] - base->value[tab[1][len[1]]] - ret;
else if (len[0] >= min_ref(tab[0], ops))
tmp = base->value[tab[0][len[0]]] - ret;
ret = (tmp < 0);
if (tmp < 0)
tmp += base->length;
buff[i++] = get_char_for_value(tmp % base->length, base);
--len[0];
--len[1];
}
if (ret > 0)
buff[i++] = get_char_for_value(ret % base->length, base);
return (my_revstr(my_strdup(buff)));
}
char *server_int_to_str(int value)
{
int i;
char *str;
int result;
i = -1;
if ((str = malloc(sizeof(char) * (20 + 1))) == NULL)
return (NULL);
if (value <= 0)
{
str[0] = '0';
str[1] = '\0';
return (str);
}
else
{
while (value != 0)
{
result = value % 10;
value = value / 10;
str[++i] = result + '0';
}
str[++i] = '\0';
}
return(my_revstr(str));
}
char *convert_base(char *nbr, char *base_from, char *base_to)
{
char *res;
int nb;
int i;
int neg;
res = malloc(sizeof(*res) * 100);
nb = my_getnbr_base(nbr, base_from);
neg = 0;
if (nb < 0 && (neg = 1))
nb *= -1;
i = 0;
do
{
res[i] = base_to[nb % my_strlen(base_to)];
nb /= my_strlen(base_to);
i++;
} while (nb > 0);
if (neg == 1)
{
res[i] = '-';
i++;
}
res[i] = '\0';
res = my_revstr(res);
return (res);
}
int my_putnbr_base(int nbr, char *base)
{
int base_size;
char value[1024];
int i;
int my_nbr;
my_nbr = nbr;
init_putnbr_base_tab(value);
base_size = my_strlen(base);
if (base_size <= 0)
return (my_nbr);
if (nbr < 0)
{
my_putstr("-");
nbr *= -1;
}
i = 0;
while (nbr > 0)
{
value[i++] = *(base + (nbr % base_size));
nbr /= base_size;
}
my_putstr(my_revstr(value));
return (my_nbr);
}
char *ajoute_moins(char *base, char *operators, char *expr)
{
char *new_expr;
int len;
len = my_strlen(expr);
if ((len == 1) && (expr[0] == base[0]))
return (expr);
if ((new_expr = malloc(sizeof(*new_expr) * len + 2)) == NULL)
exit(-1);
my_revstr(expr);
my_strcpy(new_expr, expr);
new_expr[len] = operators[OP_NEG_IDX];
new_expr[len + 1] = '\0';
my_revstr(new_expr);
return (new_expr);
}
char *end_convert_base(char *result, int sign, int i)
{
if (sign == 1)
result[i++] = '-';
result[i] = '\0';
result = my_revstr(result);
return (result);
}
void get_map()
{
extern t_client t;
char *str;
char *tmp;
int i;
int a;
t.k = 0;
a = 0;
tmp = xmalloc(56 * sizeof(*tmp));
tmp = my_strcat("bct ", int_to_char(t.x_map - 1));
tmp = my_strcat(tmp, " ");
tmp = my_strcat(tmp, int_to_char(t.y_map - 1));
t.contenu_map[t.k] = xmalloc(256 * sizeof(*t.contenu_map));
send(t.s, "mct\n", 4, 0);
str = xmalloc(256 * sizeof(*str));
t.tab = xmalloc(513 * sizeof(*t.tab));
str[0] = '\0';
t.tab[0] = '\0';
while ((t.size = recv(t.s, t.buf, 256, 0)) != -1)
{
if (my_strlen(str) != 0)
{
t.tab = my_strcat(t.tab, str);
str[0] = '\0';
}
if (t.buf[t.size - 1] != '\n')
{
for (i = 0;t.buf[t.size - 1] != '\n';t.size--, i++)
str[i] = t.buf[t.size - 1];
t.buf[t.size] = '\0';
t.tab = my_strcat(t.tab, t.buf);
str[i] = '\0';
str = my_revstr(str);
}
else
{
t.buf[t.size] = '\0';
t.tab = my_strcat(t.tab, t.buf);
}
if (t.tab)
if (get_infomap(tmp) == 1)
break;
t.tab[0] = '\0';
}
free(t.tab);
free(tmp);
free(str);
draw_map();
}
void conv_10_to_16(unsigned int nbr, char *val)
{
int i;
i = 0;
while (nbr >= 16)
{
val[i++] = HEXA[nbr % 16];
nbr = nbr / 16;
}
val[i++] = HEXA[nbr % 16];
val[i] = '\0';
my_revstr(val);
}
void my_put_nbr_bin(unsigned int nb)
{
char bin[33];
int i;
i = 0;
while (nb)
{
bin[i++] = '0' + nb % 2;
nb /= 2;
}
bin[i] = '\0';
my_revstr(bin);
my_putstr(bin);
}
void my_put_nbr_oct(unsigned int nb)
{
char oct[12];
int i;
i = 0;
while (nb)
{
oct[i++] = '0' + nb % 8;
nb /= 8;
}
while (i < 3)
oct[i++] = '0';
oct[i] = '\0';
my_revstr(oct);
my_putstr(oct);
}
int my_sprintu(va_list list, char *buffer)
{
unsigned int nb;
int n;
nb = va_arg(list, unsigned int);
my_sputunsigned(buffer, nb);
n = 0;
while (nb > 0)
{
nb = nb / 10;
n = n + 1;
}
buffer[n] = 0;
my_revstr(buffer);
return (n);
}
int my_sprintb(va_list list, char *buffer)
{
unsigned int nb;
int n;
nb = va_arg(list, unsigned int);
my_sput_nbr_base(buffer, nb, "01");
n = 0;
while (nb > 0)
{
nb = nb / 2;
n = n + 1;
}
buffer[n] = 0;
my_revstr(buffer);
return (n);
}
int my_sprintp(va_list list, char *buffer)
{
unsigned long int nb;
int n;
nb = va_arg(list, unsigned long int);
my_sputstr(buffer, "0x");
my_sput_16(&buffer[my_strlen("0x")], nb, "0123456789abcdef\0");
n = 2;
while (nb > 0)
{
nb = nb / 16;
n = n + 1;
}
buffer[n] = 0;
my_revstr(buffer);
return (n);
}
void my_put_nbr_hex(long int nb, int flag)
{
const char base[16] = "0123456789abcdef";
char hex[10];
int i;
i = 0;
while (nb)
{
hex[i++] = base[nb % 16];
if (flag && nb % 16 > 10)
hex[i - 1] = base[nb % 16] - ('a' - 'A');
nb /= 16;
}
hex[i] = '\0';
my_revstr(hex);
my_putstr(hex);
}
char *sub(char *base, char *operators, char *exprmax, char *exprmin, int flagmin)
{
int i;
char *stringfinale;
int res;
int retenu;
i = 0;
retenu = 0;
if ((stringfinale = malloc(sizeof(*stringfinale) * (my_strlen(exprmax) + 2))) == 0)
exit(-1);
while (exprmax[i] != '\0')
{
stringfinale[i] = calcul_res(base, indice_in_base(base, exprmax[i]), if_exist_exprmin(base, i, exprmin), &retenu);
i = i + 1;
}
check_ending_zero(base, retenu, &i, stringfinale);
check_flagmin(operators, stringfinale, &i, flagmin);
stringfinale[i] = '\0';
my_revstr(stringfinale);
return (stringfinale);
}
void my_itoa(int nbr, char *str)
{
int i;
int signe;
i = 0;
signe = nbr;
if (signe < 0)
nbr = -nbr;
while (nbr > 0)
{
str[i] = ((nbr % 10) + '0');
nbr = nbr / 10;
i = i + 1;
}
if (signe < 0)
{
str[i] = '-';
i = i + 1;
}
str[i] = '\0';
my_revstr(str);
}
char *ret_lg_nbr_base(void *var, char *base, char *ag)
{
char *ret;
char *b;
char *basef;
long nb;
if ((b = malloc(2 * sizeof(*b))) == NULL)
return (NULL);
b[1] = '\0';
nb = var;
ret = NULL;
basef = base;
check_ag_base(ag, &basef);
while (nb > 0)
{
b[0] = basef[nb % my_strlen(basef)];
ret = my_ev_strcat(ret, b);
nb /= my_strlen(basef);
}
free(b);
free(basef);
return (my_revstr(ret));
}
char *op_add(char *tab[2], t_base *base, char ops[7], int len[2])
{
int i;
char *buff;
int ret;
buff = xmalloc((MAX(len[0], len[1]) + 3) * sizeof(char));
my_memset(buff, 0x0, MAX(len[0], len[1]) + 3);
i = 0;
ret = 0;
while (len[0] >= min_ref(tab[0], ops) || len[1] >= min_ref(tab[1], ops))
{
ret += get_op_add_ret(len, tab, base, ops);
buff[i++] = get_char_for_value(ret % base->length, base);
ret /= base->length;
--len[0];
--len[1];
}
if (ret > 0)
buff[i++] = get_char_for_value(ret % base->length, base);
if (min_ref(tab[0], ops) == 1 && min_ref(tab[1], ops) == 1)
buff[i++] = '-';
return (my_revstr(my_strdup(buff)));
}
//test function for libmy
int main() {
//my_char takes in char and prints it
int i;
for (i = 0; i < 128; i++) { // testing my_char for all valid characters including null
my_char(i);
}
my_char(-1);
my_char(128); // should be too big
my_char("david");
my_char("");
my_char('\0');
//my_int takes in int and prints it
my_int(0);
my_int(1);
my_int(-1);
my_int(1000);
my_int(-1000);
my_int(2147483647); //max int on 32b machine
my_int(2147483648); //max + 1
my_int(-2147483647); //min int
my_int(-2147483648);//min int - 1
my_int("david");
my_int('D');
my_int(1.3);
my_int("");
my_int('\0');
//my_alpha has no input and prints alphabet
my_alpha();
//any parameter will cause it not to compile
//my_digits has no input and prints 0 - 9
my_digits();
//no return, can't pass anything in
//my_str
my_str(0);
my_str("david");
my_str("");
my_str("asdfkljasdflkjhasdflkjhasdfkljasdfkalsdjfalksjdaklsjdflkasjdaslkdaskjdfaskldjaskljd");
//my_str(65);
//my_str('\0');//null char
//my_str('A');
my_str("dav\0id"); //null char in string
//my_str(98723498723);
//my_revstr
my_revstr(0);
my_revstr("david");
my_revstr("");
my_revstr("asdfkljasdflkjhasdflkjhasdfkljasdfkalsdjfalksjdaklsjdflkasjdaslkdaskjdfaskldjaskljd");
//my_revstr(65);
//my_revstr('\0');//null char
//my_revstr('A');
my_revstr("dav\0id"); //null char in string
//my_revstr(98723498723);
//my_strindex
my_int(my_strindex("david", 'a'));
my_int(my_strindex("david", 'd')); // there are two of them
my_int(my_strindex("david", 'b')); // not in string
my_int(my_strindex("david", '\0'));
my_int(my_strindex("david", ""));
my_int(my_strindex("", 'a'));
my_int(my_strindex("dav\0id", 'i')); //should not find i
my_int(my_strindex(0, 0));
//my_strrindex
my_int(my_strrindex("david", 'a'));
my_int(my_strrindex("david", 'd')); // there are two of them
my_int(my_strrindex("david", 'b')); // not in string
my_int(my_strrindex("david", '\0'));
my_int(my_strrindex("david", ""));
my_int(my_strrindex("", 'a'));
my_int(my_strrindex("dav\0id", 'i')); //should not find i
my_int(my_strrindex(0, 0));
//my_strlen
my_int(my_strlen("david"));//should be 5
my_int(my_strlen("dav\0id"));
my_int(my_strlen(""));
my_int(my_strlen(" "));
//my_int(my_strlen('a'));
my_int(my_strlen(0));
//my_int(my_strlen(1234));
//my_num_base
my_num_base(0, 0);//print nothing
my_num_base(0, "david");
my_num_base(4, 0);
my_num_base(-4, 0);
my_num_base(4, "david");//should print d
my_num_base(-4, "david");//-d
my_num_base(5, "?");//?????
my_num_base(-5, "?");
//my_num_base("", "david");
my_num_base('z', "david");
}
