int conform_set_var(char *str)
{
int i;
int booleen;
i = 0;
booleen = 0;
if ((!str) || ((!ft_isalpha(str[0])) && str[0] != '_'))
return (0);
while (str[i])
{
if (!valid_char_var(str[i]))
return (0);
if (str[i] == '=')
booleen = 1;
i++;
}
return (booleen);
}
static int place_tetris(char *tetris, char *sol, int start, char letter)
{
int i;
int j;
i = 0;
while (!ft_isalpha(tetris[i]))
++i;
if (set_tetris(tetris, i, sol, start) == 4)
return (1);
reset_tetris(tetris);
j = 0;
while (sol[j])
{
if (sol[j] == letter)
sol[j] = '.';
++j;
}
return (0);
}
static int skip_space(const char *str)
{
int i;
i = 0;
if (str[i] == '\0')
return (0);
while (str[i] && is_char(str[i]) >= 1)
i++;
if (i > 1 && is_char(str[i]) == 2)
i--;
if (is_char(str[i]) == 1 && ft_isdigit((int)str[i + 1]) == 1)
i++;
while (str[i] && ft_isdigit((int)str[i]) == 1)
i++;
if (i > 0)
i--;
if (ft_isalpha(str[i]) == 1)
i--;
return (i);
}
void complete_word(char *word, size_t start)
{
char *end;
int i;
end = ft_strsub(word, start, ft_strlen(word) - start);
i = g_main_line.curs_x;
while (i < g_main_line.size_x && ft_isalpha(g_main_line.cmd[i]))
{
move_front();
i++;
}
g_main_line.cmd = ft_str_insert(g_main_line.cmd, end, g_main_line.curs_x);
g_main_line.curs_x += ft_strlen(end);
g_main_line.size_x += ft_strlen(end);
g_main_line.curs_x_win = (g_main_line.size_x + g_main_line.prompt)
% g_main_line.win_col;
g_main_line.curs_y = (g_main_line.size_x + g_main_line.prompt)
/ g_main_line.win_col;
print_line(0);
}
int is_correct_varname(char *name, int err, char *cmd)
{
int i;
if (ft_isalpha(*name) == 0)
{
ft_printf_fd(err, "%s: Variable name must begin with a letter.\n", cmd);
return (0);
}
i = 0;
while (name[i])
{
if (ft_isalnum(name[i]) == 0)
{
ft_printf_fd(err, "%s: %s\n", cmd, ERR1);
return (0);
}
i++;
}
return (1);
}
static char *isdollars(int *i, char *str)
{
int v;
char *tmp;
char *result;
v = *i + 1;
while (ft_isalpha(str[v]) && str[v])
++v;
result = search_var(g_var, ft_strsub(str, *i + 1, (v - *i - 1)));
*i = v - 1;
if (str[*i])
{
while (str[*i] != ' ' && str[*i])
++*i;
tmp = ft_strsub(str, v, (*i - v));
result = ft_strjoin(result, tmp);
ft_free(tmp);
}
return (result);
}
static int ft_check(char **av, int ac, char *opt)
{
int i;
int a;
i = -1;
while (++i < 5)
opt[i] = '0';
i = 0;
while (++i < ac && ((av[i][0] == '-') && ft_isalpha(av[i][1])))
ft_init_opt(opt, av[i][1]);
a = i;
while (av && av[i])
{
if (!ft_isint(av[i]))
return (0);
if (!ft_isdbl(ft_atoi(av[i]), av, i))
return (0);
i++;
}
return (a + 1);
}
void test_isalpha(void)
{
char *str = "ISALPHA";
printf("\033[1;33m%s\033[0m\n", str);
printf("Mon isalpha pour '-1' ->%d\n", ft_isalpha(-1));
printf("Le isalpha pour '-1' ->%d\n\n", isalpha(-1));
printf("Mon isalpha pour 'a' ->%d\n", ft_isalpha('a'));
printf("Le isalpha pour 'a' ->%d\n\n", isalpha('a'));
printf("Mon isalpha pour 'z' ->%d\n", ft_isalpha('z'));
printf("Le isalpha pour 'z' ->%d\n\n", isalpha('z'));
printf("Mon isalpha pour '0' ->%d\n", ft_isalpha('0'));
printf("Le isalpha pour '0' ->%d\n\n", isalpha('0'));
printf("Mon isalpha pour 64 ->%d\n", ft_isalpha(64));
printf("Le isalpha pour 64 ->%d\n\n", isalpha(64));
printf("Mon isalpha pour 122 ->%d\n", ft_isalpha(122));
printf("Le isalpha pour 122 ->%d\n\n", isalpha(122));
printf("Mon isalpha pour 96 ->%d\n", ft_isalpha(96));
printf("Le isalpha pour 96 ->%d\n", isalpha(96));
printf("\033[1;32m%s passed.\033[0m\n\n", str);
}
void dieze_x_no_moins(t_env2 *env2, char *c)
{
int i;
i = 0;
while (!(ft_isdigit(env2->str[i + 1]) || ft_isalpha(env2->str[i + 1])))
i++;
if (env2->str[i] == c[0] && env2->str[i + 1] == c[0])
{
env2->str[i] = c[0];
env2->str[i + 1] = c[1];
}
else if (env2->str[i] == ' ' && env2->str[i - 1] == ' ')
{
env2->str[i - 1] = c[0];
env2->str[i] = c[1];
}
else
{
env2->str[i] = c[1];
env2->str = ft_strjoin_free(env2->str, "0", env2->str);
}
}
int ft_win(char **tab)
{
int a;
int b;
a = g_h;
while (--a >= 0)
{
b = g_le;
while (--b >= 0)
{
if (ft_isalpha(tab[a][b]))
{
if (ft_winline(tab, a, b) || ft_diagwin(tab, a, b))
{
ft_whowin(tab[a][b]);
return (0);
}
}
}
}
return (1);
}
static int test_position(t_tetri *tetri, char map[50][50], int size)
{
int x;
int y;
x = 0;
while (x < 4)
{
y = 0;
while (y < 4)
{
if (tetri->tetri[x][y] == '#' && ((tetri->x + x >= size)
|| tetri->y + y >= size))
return (0);
if (tetri->tetri[x][y] == '#' &&
ft_isalpha(map[tetri->x + x][tetri->y + y]))
return (0);
y++;
}
x++;
}
return (1);
}
int conform_set_funct(char *s)
{
int i;
int len;
char *str;
i = 0;
str = ft_strepur(2, s, ' ', '\t');
if ((!str) || ((!ft_isalpha(str[0])) && str[0] != '_'))
return (ft_exit(str));
len = ft_strlen(str);
if ((search_parenth(str) != 2) || (str[len - 2] != '(') ||
(str[len - 1] != ')'))
return (ft_exit(str));
while (str[i])
{
if (!valid_char_funct(str[i]))
return (ft_exit(str));
i++;
}
ft_free(&str);
return (1);
}
void test_ft_isalpha(void)
{
int i = -1;
int res = 0;
int ft_res = 0;
while (++i < 127)
{
res += isalpha(i);
ft_res += ft_isalpha(i);
if (res != ft_res)
break;
}
if (i == 127)
ft_putstr("\033[32mAll test OK \033[m");
else
{
ft_putstr("\033[31mFAIL test ");
printf("%d\n", i);
ft_putstr("\033[m");
}
ft_putstr("\n");
}
int ft_isalnum(int c)
{
return (ft_isalpha(c) == 1 || ft_isdigit(c) == 1);
}
int main()
{
char *atoistr, *alnum;
int atoi_actual, atoi_expected;
int actual, expected;
char c;
// atoi
atoistr = "129723";
atoi_actual = ft_atoi(atoistr);
atoi_expected = atoi(atoistr);
if (atoi_actual == atoi_expected)
printf("OK\n");
else
printf("atoi ERROR! Expected: %d, actual: %d\n", (int) atoi_expected, (int) atoi_actual);
// isalpha
c = '1';
actual = ft_isalpha(c);
expected = isalpha(c);
if (actual == expected)
printf("OK\n");
else
printf("isalpha ERROR! Expected: %d, actual: %d\n", expected, actual);
// isdigit
c = 49;
actual = ft_isdigit(c);
expected = isdigit(c);
if (actual == expected)
printf("OK\n");
else
printf("isdigit ERROR! Expected: %d, actual: %d\n", expected, actual);
// isalnum
alnum = "lol123rofl90";
for (int i = 0; i < (int) ft_strlen(alnum); i++)
{
if (ft_isalnum(alnum[i]) != 1)
{
printf("isalnum ERROR! %c is not alphanumeric!\n", alnum[i]);
break ;
}
}
printf("OK\n");
// isascii
c = '\n';
actual = ft_isascii(c);
expected = isascii(c);
if (actual == expected)
printf("OK\n");
else
printf("isascii ERROR! Expected: %d, actual: %d\n", expected, actual);
// isprint
c = 'a';
actual = ft_isprint(c);
expected = isprint(c);
if (expected > 0 && actual > 0)
printf("OK\n");
else
printf("isprint ERROR! Expected: %d, actual: %d\n", expected, actual);
// toupper
alnum = "lol123rofl90";
for (int i = 0; i < (int) ft_strlen(alnum); i++)
{
if (ft_toupper(alnum[i]) != toupper(alnum[i]))
{
printf("toupper ERROR! at %c\n", alnum[i]);
break ;
}
}
printf("OK\n");
// tolower
alnum = "LOL123ROFL90";
for (int i = 0; i < (int) ft_strlen(alnum); i++)
{
if (ft_tolower(alnum[i]) != tolower(alnum[i]))
{
printf("tolower ERROR! at %c\n", alnum[i]);
break ;
}
}
printf("OK\n");
return 0;
}
int ft_toupper(int c)
{
if (ft_isalpha(c) && c >= 97)
c -= 32;
return (c);
}
t_bool ft_isalnum(char c)
{
return (ft_isdigit(c) || ft_isalpha(c));
}
int ft_toupper(int c)
{
if (ft_isalpha(c) == 1 && ft_isalpha(c - 32) == 1)
c = c - 32;
return (c);
}
int ft_isalnum(int c)
{
return ((ft_isalpha(c) || ft_isdigit(c)) ? TRUE : FALSE);
}
int ft_toupper(int c)
{
return (ft_isalpha(c) * (c >= 'a') * ('A' - 'a') + c);
}
int ft_isupper(int c)
{
if (ft_isalpha(c) && c > 64 && c < 91)
return (1);
return (0);
}
int ft_isalnum(int i)
{
if (ft_isalpha(i) || ft_isdigit(i))
return (TRUE);
return (FALSE);
}
int ft_isalnum(int c)
{
if ((ft_isdigit(c) != 0) || (ft_isalpha(c)) != 0)
return (1);
return (0);
}
int main(int ac, char **av)
{
/*
* Test ft_puts
*/
(void)ac;
ft_putchar(10);
puts("hello");
ft_putchar(10);
puts(NULL);
ft_putchar(10);
ft_puts("hello");
ft_putchar(10);
ft_puts(NULL);
ft_putchar(10);
/*
* Test ft_puts
*/
/*
* Test ft_bzero
*/
char str[] = "hello";
char str2[] = "hello";
printf("\n ft_bzero \n");
printf("Test 1 \n ft_bzero et bzero n = 1 et str : %s\n",str);
bzero(str, 1);
printf("Avec bzero et str[0] : %c\n",str[0]);
ft_bzero(str2, 1);
printf("Avec ft_bzero et str2[0] : %c\n",str2[0]);
printf("Avec bzero et str[3] : %c\n",str[3]);
printf("Avec ft_bzero et str[3] : %c\n\n",str[3]);
char str3[] = "hello";
char str4[] = "hello";
printf("Test 2 \n ft_bzero et bzero n = 4 et str : %s\n",str3);
bzero(str3, 4);
printf("Avec bzero et str[0] : %c\n",str3[0]);
ft_bzero(str4, 4);
printf("Avec ft_bzero et str2[0] : %c\n",str4[0]);
printf("Avec bzero et str[3] : %c\n",str3[3]);
printf("Avec ft_bzero et str[3] : %c\n",str4[3]);
printf("Avec bzero et str[4] : %c\n",str3[4]);
printf("Avec ft_bzero et str[4] : %c\n\n",str4[4]);
char str5[] = "hello";
char str6[] = "hello";
printf("Test 3 \n ft_bzero et bzero n = 9 et str : %s\n",str5);
bzero(str5, 9);
printf("Avec bzero et str[4] : %c\n",str5[4]);
ft_bzero(str6, 9);
printf("Avec ft_bzero et str2[4] : %c\n",str6[4]);
/*
* Fin ft_bzero
*/
/*
* ft_strcat
*/
char *src;
char *src2;
char *src3;
char *src4;
char dest[40] = "Please Cat";
char dest2[40] = "Please Cat";
src = "_meEeeeEeeE";
src2 = "_meEeeeEeeE";
printf("\n Test 1 ft_strcat\n");
printf("Dest : %s\nSize Dest: 40\nSrc : %s .\n", dest, src);
src3 = strcat(dest, src);
printf("strcat Dest : %s\n", src3);
src4 = ft_strcat(dest2, src2);
printf("ft_strcat Dest : %s\n", src4);
printf("\n And Re - ft_strcat\n");
strcat(dest, src);
printf("strcat Dest : %s\n", dest);
src3 = ft_strcat(dest2, src2);
printf("ft_strcat Dest : %s\n", src3);
/*
* Fin ft_strcat
*/
/*
* ft_isascii
*/
int a;
int z;
int nbr;
int weird;
int neg;
neg = -500;
a = 'a';
z = 'Z';
nbr = 57;
weird = 173;
printf("\n\nTest ascii\n");
printf("un = %c\ndeux = %c\ntrois = %c\nweird = %c\nneg = %d\n",a ,z, nbr, weird, neg);
printf("ft_isascii isascii\n");
printf("%d %d\n",ft_isascii(a), isascii(a));
printf("%d %d\n",ft_isascii(z), isascii(z));
printf("%d %d\n",ft_isascii(nbr), isascii(nbr));
printf("%d %d\n",ft_isascii(weird), isascii(weird));
printf("%d %d\n",ft_isascii(neg), isascii(neg));
/*while (neg < 500)
{
neg++;
ft_putchar(ft_isascii(neg) + 48);
}*/
/*
* Fin ft_isascii
*/
/*
* ft_isalpha
*/
int b;
int y;
int nb;
int weir;
b = 'a';
y = 94;
nb = 'Z';
weir = 173;
neg = -1;
printf("\n\nTest isalpha\n");
printf("un = %c\ndeux = %c\ntrois = %c\nweird = %c\nneg = %d\n",b ,y, nb, weir,neg);
printf("ft_isalpha isalpha\n");
printf("%d %d\n",ft_isalpha(b), isalpha(b));
printf("%d %d\n",ft_isalpha(y), isalpha(y));
printf("%d %d\n",ft_isalpha(nb), isalpha(nb));
printf("%d %d\n",ft_isalpha(weir), isalpha(weir));
printf("%d %d\n",ft_isalpha(neg), isalpha(neg));
/*
* Fin ft_isalpha
*/
/*
* ft_isdigit
*/
int c;
int x;
int nbt;
int weira;
c = 47;
x = 48;
nbt = 57;
weira = 58;
printf("\n\nTest isdigit\n");
printf("un = %c\ndeux = %c\ntrois = %c\nweird = %c\nneg = %d\n",c ,x, nbt, weira, neg);
printf("ft_isdigit isdigit\n");
printf("%d %d\n",ft_isdigit(c), isdigit(c));
printf("%d %d\n",ft_isdigit(x), isdigit(x));
printf("%d %d\n",ft_isdigit(nbt), isdigit(nbt));
printf("%d %d\n",ft_isdigit(weira), isdigit(weira));
printf("%d %d\n",ft_isdigit(neg), isdigit(neg));
/*
* Fin ft_isdigit
*/
/*
* ft_isalnum
*/
int d;
int w;
int nbq;
int weirb;
d = 69;
w = 48;
nbq = 57;
weirb = 92;
printf("\n\nTest isalnum\n");
printf("un = %c\ndeux = %c\ntrois = %c\nweird = %c\nneg = %d\n",d ,w, nbq, weirb, neg);
printf("ft_isalnum isalnum\n");
printf("%d %d\n",ft_isalnum(d), isalnum(d));
printf("%d %d\n",ft_isalnum(w), isalnum(w));
printf("%d %d\n",ft_isalnum(nbq), isalnum(nbq));
printf("%d %d\n",ft_isalnum(weirb), isalnum(weirb));
printf("%d %d\n",ft_isalnum(neg), isalnum(neg));
/*
* Fin ft_isalnum
*/
/*
* ft_isprint
*/
int e;
int v;
int nbs;
int weirc;
e = 32;
v = 126;
nbs = 12;
weirc = 380;
printf("\n\nTest isprint\n");
printf("un = %c\ndeux = %c\ntrois = %c\nweird = %c\nneg = %d\n",e ,v, nbs, weirc, neg);
printf("ft_isprint isprint\n");
printf("%d %d\n",ft_isprint(e), isprint(e));
printf("%d %d\n",ft_isprint(v), isprint(v));
printf("%d %d\n",ft_isprint(nbs), isprint(nbs));
printf("%d %d\n",ft_isprint(weirc), isprint(weirc));
printf("%d %d\n",ft_isprint(neg), isdigit(neg));
/*
* Fin ft_isprint
*/
/*
* ft_touppper
*/
e = 97;
v = 122;
nbs = 69;
weirc = 36;
printf("\n\nTest ft_toupper\n");
printf("un = %c\ndeux = %c\ntrois = %c\nweird = %c\nneg = %d\n",e ,v, nbs, weirc, neg);
printf("ft_toupper toupper\n");
printf("%c %c\n",ft_toupper((UC)e), toupper((UC)e));
printf("%c %c\n",ft_toupper(v), toupper(v));
printf("%c %c\n",ft_toupper(nbs), toupper(nbs));
printf("%c %c\n",ft_toupper(weirc), toupper(weirc));
printf("%c %c\n",ft_toupper(neg), toupper(neg));
/*
* Fin ft_toupper
*/
/*
* ft_tolower
*/
e = 65;
v = 90;
nbs = 122;
weirc = 36;
printf("\n\nTest ft_tolower\n");
printf("un = %c\ndeux = %c\ntrois = %c\nweird = %c\nneg = %d\n",e ,v, nbs, weirc, neg);
printf("ft_tolower tolower\n");
printf("%c %c\n",ft_tolower((UC)e), tolower((UC)e));
printf("%c %c\n",ft_tolower(v), tolower(v));
printf("%c %c\n",ft_tolower(nbs), tolower(nbs));
printf("%c %c\n",ft_tolower(weirc), tolower(weirc));
printf("%c %c\n",ft_tolower(neg), tolower(neg));
/*
* Fin ft_tolower
*/
ft_putchar('\n');
int l1;
int l2;
/*
* ft_strlen
*/
l1 = ft_strlen("yo Mamaa");
ft_putstr("yo Mamaa ft_strlen: ");
ft_putchar(l1 + 48);
ft_putchar('\n');
l2 = strlen("yo Mamaa");
ft_putstr("yo Mamaa strlen: ");
ft_putchar(l2 + 48);
ft_putchar('\n');
// l2 = strlen(NULL);
// ft_putchar(l2 + 48);
// ft_putchar('\n');
l1 = ft_strlen("\n");
ft_putstr(" ft_strlen: ");
ft_putchar(l1 + 48);
ft_putchar('\n');
l2 = strlen("\n");
ft_putstr(" strlen: ");
ft_putchar(l2 + 48);
ft_putchar('\n');
/*
* Fin ft_strlen
*/
/*
* debut ft_memset
*/
char *memtmp;
char *memtmporg;
char *vide;
char *videe;
printf("\nTEST ft_memset\n");
vide = malloc(sizeof(char *) * 5);
memtmporg = malloc(sizeof(char *) * 5);
videe = malloc(sizeof(char *) * 5);
memtmp = malloc(sizeof(char *) * 5);
ft_putstr(memtmporg);
ft_putchar('\n');
memset(memtmporg, 'A', 4);
ft_putstr(memtmporg);
ft_putchar('\n');
ft_memset(memtmp, 'B', 4);
ft_putstr(memtmp);
ft_putchar('\n');
/*
* Fin ft_memset
*/
/*
* debut ft_memcpy
*/
printf("\nTEST ft_memcpy\n");
memcpy(vide, memtmporg, 2);
ft_putstr(vide);
ft_putchar('\n');
ft_memcpy(videe, memtmp, 2);
ft_putstr(videe);
ft_putchar('\n');
/*
* fin ft_memcpy
*/
/* debut ft_strdup
*
*/
char *isdup;
char *todup;
char *mydup;
printf("\nTEST ft_strdup\n");
todup = "Dupme";
isdup = strdup(todup);
ft_putstr(isdup);
ft_putchar('\n');
mydup = ft_strdup(todup);
ft_putstr(mydup);
ft_putchar('\n');
/* [M@ft_putchar: debut ft_strdup
*
*/
/* debut ft_cat
*
*/
int fd;
printf("\nTEST ft_cat\n");
printf("\n sur 0\n");
ft_cat(0);
printf("\n sur ./src/ft_cat.s\n");
fd = open("./src/ft_cat.s", O_RDONLY);
ft_cat(fd);
close(fd);
printf("\n sur -42\n");
ft_cat(-42);
printf("\n sur __FILE__\n");
ft_cat(open(__FILE__, O_RDONLY));
printf("\n sur av[0]\n");
ft_cat(open(av[0], O_RDONLY));
/* fin ft_cat
*
*/
return (0);
}
int ft_isalnum(int c)
{
return (ft_isalpha(c) || ft_isdigit(c));
}
int ft_isalnum(int c)
{
if ((ft_isalpha(c) == 1) || (ft_isdigit(c) == 1))
return (1);
return (0);
}
int ft_toupper(int c)
{
if (ft_isalpha(c) && !ft_isupper(c))
return (c - 32);
return (c);
}
int main()
{
int fd;
int a = 0;
int b = 0;
char c = 0;
char src[] = "The unterzee does not forgive";
char dst1[100] = {0};
char dst2[100] = {0};
char strputs[] = "Hello";
const char *srcdup = "Hello";
char *dstdup1 = NULL;
char *dstdup2 = NULL;
strcat(dst1, "");
strcat(dst2, "");
strcat(dst1, src);
ft_strcat(dst2, src);
printf("strcat : %s\n", dst1);
printf("ft_strcat : %s\n", dst2);
dstdup1 = strdup(srcdup);
printf("strdup : %s\n", dst1);
free(dstdup1);
dstdup1 = NULL;
dstdup2 = ft_strdup(srcdup);
printf("ft_strdup : %s\n", dst2);
free(dstdup2);
dstdup2 = NULL;
memset((void*)dst1, 'a', 0);
ft_memset((void*)dst2, 'a', 0);
printf("memset : %s\n", dst1);
printf("ft_memset : %s\n", dst2);
bzero((void*)dst1, 15);
ft_bzero((void*)dst2, 15);
printf("bzero : ");
write(1, dst1, 20);
printf("\n");
printf("ft_bzero : ");
write(1, dst2, 20);
printf("\n");
memcpy((void*)dst1, (void*)src, 0);
ft_memcpy((void*)dst2, (void*)src, 0);
printf("memcpy : %s\n", dst1);
printf("ft_memcpy : %s\n", dst2);
a = ft_isalpha('p');
printf("ft_isalpha: ");
printf("%d\n", a);
a = ft_isascii(127);
printf("ft_isascii: ");
printf("%d\n", a);
a = ft_isdigit('p');
printf("ft_isdigit: ");
printf("%d\n", a);
a = ft_isprint(' ');
printf("ft_isprint: ");
printf("%d\n", a);
a = ft_isalnum('P');
printf("ft_isalnum: ");
printf("%d\n", a);
c = ft_tolower('A');
printf("ft_tolower: ");
printf("%c\n", c);
c = ft_toupper('P');
printf("ft_toupper: ");
printf("%c\n", c);
fd = open("test1.txt", O_RDONLY);
ft_cat(fd);
a = puts(strputs);
b = ft_puts(strputs);
printf("puts : ");
printf("%d\n", a);
printf("ft_puts : ");
printf("%d\n", b);
return (0);
}
int ft_isalnum(int c)
{
if (ft_isalpha(c) || ft_isdigit(c))
return (1);
return (0);
}
int ft_tolower(int c)
{
if (ft_isalpha(c) && ft_isupper(c))
c = c + 32;
return (c);
}
