void ft_read_from_terminal(t_filler *list, t_map *a, t_pie *a_p) { char *s; s = (void*)0; a->i = 0; a_p->i = 0; list->pie_found = 0; get_next_line(0, &s); if (!ft_strncmp(s, "$$$ exec p", 9) && (s[10] == '1' || s[10] == '2')) ft_players_detection(list, s); ft_strdel(&s); while (get_next_line(0, &s) == 1) { if (!ft_strncmp(s, "Piece", 5)) { ft_array_piece_size(list, s); list->pie_found = 1; } else if (!ft_strncmp(s, "Plateau", 7)) ft_array_size(list, s); else if (ft_strncmp(s, "Piece", 5) && ft_strncmp(s, "Plateau", 7) && ft_strncmp(s, " 01", 6)) ft_array_creat(list, a, a_p, s); free(s); } }
/* * ft_destroy() * This will close and destroy all file descriptors in the file table. Should * only be called when the thread is exiting. In theory there shouldn't be * anything in here, except the stds, if they are attached to the thread. */ int ft_destroy(struct filetable* ft) { int i; for (i = ft_array_size(ft) - 1; i >= 0; i--) { ft_remove(ft, i); } kfree(ft); return 1; }
int ft_set(struct filetable* ft, struct filedescriptor* fd, int fti) { if (fti >= ft_array_size(ft)) { return 1; } array_setguy(ft->filedescriptor, fti, fd); if (ft_get(ft, fti) == fd) { return 1; } return 0; }
/* * ft_test() * This tests the implementation of the file table, insertion, deletion, fd recovery. * This test is not passable, it will crash the kernel. */ void ft_test(struct filetable* ft) { kprintf("filetable test begin\n"); kprintf("inserting file descriptors\n"); ft_attachstds(ft); kprintf("printing file descriptors\n"); int i = 0; for (i = 0; i < ft_array_size(ft); i++) { struct filedescriptor *fd; fd = ft_get(ft, i); kprintf("filetable index: %d\n", i); kprintf("fdn: %d ", fd->fdn); kprintf("\n"); } kprintf("inserting more file descriptors\n"); ft_attachstds(ft); kprintf("printing file descriptors\n"); for (i = 0; i < ft_array_size(ft); i++) { struct filedescriptor *fd; fd = ft_get(ft, i); kprintf("filetable index: %d ", i); kprintf("fdn: %d ", fd->fdn); kprintf("\n"); } kprintf("removing file descriptor 4\n"); ft_remove(ft, 4); kprintf("inserting more file descriptors\n"); ft_attachstds(ft); kprintf("printing file descriptors\n"); for (i = 0; i < ft_array_size(ft); i++) { struct filedescriptor *fd; fd = ft_get(ft, i); kprintf("filetable index: %d ", i); kprintf("fdn: %d ", fd->fdn); kprintf("\n"); } kprintf("inserting infinite number of file descriptors\n"); for (i = 0; i < 2147483647; i++) { kprintf("ft_array_size: %d\n", ft_array_size(ft)); ft_attachstds(ft); } panic("test end"); }
/* * ft_size() * This returns how many file descriptors are opened to the thread. */ int ft_size(struct filetable *ft) { assert(ft != NULL); int total = array_getnum(ft->filedescriptor); int i = 0; for (i = 0; i < ft_array_size(ft); i++) { if (ft_get(ft, i) == NULL) { total--; } } return total; }
/* * ft_test() * This tests the implementation of the file table, insertion, deletion, fd recovery. * This test is not passable, it will crash the kernel. */ void ft_test_list(struct filetable* ft) { kprintf("printing file descriptors\n"); int i = 0; for (i = 0; i < ft_array_size(ft); i++) { struct filedescriptor *fd; fd = ft_get(ft, i); kprintf("filetable index: %d ", i); if (fd != NULL) { kprintf("fdn: %d ", fd->fdn); } else { kprintf("fdn: NULL "); } kprintf("\n"); } }
/* * ft_add() * This adds the file descriptor to the file table, it does by checking if there * is a free file descriptor in the queue, if not, it will add to the end of the * array. This will recover and reuse closed file descriptor ids. */ int ft_add(struct filetable* ft, struct filedescriptor* fd) { int fdn = 0; for (fdn = 0; fdn < ft_array_size(ft) && fdn < OPEN_MAX; fdn++) { if (ft_get(ft, fdn) == NULL) { array_setguy(ft->filedescriptor, fdn, fd); return fdn; } } if (fdn == OPEN_MAX) { return -1; } if (array_add(ft->filedescriptor, fd) != 0) { //if error (ENOMEM) return -1; } fd->numOwners++; assert(fdn != 0); return fdn; }
/* * ft_get() * This gets the file descriptor from a file table and the given file descriptor id. */ struct filedescriptor *ft_get(struct filetable *ft, int fti) { if (fti < 0) { return NULL; } //Since the stds are not attached to the thread, if the fd <=2 is requested, //then we will attach the stds to the thread. if (fti < 3) { if (array_getguy(ft->filedescriptor, fti) == NULL) { ft_attachstds(ft); } } //Doesn't exist. if (fti >= ft_array_size(ft)) { //changed > to >= since there shouldn't be an element ARRAY_SIZE --Matt return NULL; } struct filedescriptor *ret = array_getguy(ft->filedescriptor, fti); return ret; }