int signal_init(void) { struct sigaction action; ft_memset(&action, 0, sizeof(action)); action.sa_sigaction = &signal_handler; action.sa_flags = SA_SIGINFO | SA_RESTART; sigaction(SIGQUIT, &action, NULL); sigaction(SIGINT, &action, NULL); sigaction(SIGTSTP, &action, NULL); sigaction(SIGWINCH, &action, NULL); return (0); }
static int ft_test_memset2(char *str, char *str2, int n) { int res; res = 0; ft_memset(str, '{', n); memset(str2, '{', n); printf("After : \"%s\" , \"%s\"", str, str2); if (strcmp_bsd(str, str2)) ++res; ft_print_status(res); return (res); }
char *modetostr(mode_t st_mode) { char *str; str = (char*)malloc(sizeof(char) * 12); ft_memset(str, '-', 10); str[10] = '\0'; str[0] = mode(st_mode); modeusr(st_mode, str); modegrp(st_mode, str); modeoth(st_mode, str); return (str); }
static int copy_buf(char *buf, char **line, int is_reading) { char endbuf; int buffsize; int linesize; buffsize = size_buf(buf); linesize = ft_strlen(*line); if (!(*line = ft_memrealloc(*line, linesize, linesize + buffsize + 1))) return (-1); if (!ft_memcpy(*line + linesize, buf, buffsize)) return (-1); if (buffsize != GNL_BUFF_SIZE) { endbuf = buf[buffsize]; if (!ft_memmove(buf, buf + buffsize + 1, GNL_BUFF_SIZE - buffsize - 1) || !ft_memset(buf + GNL_BUFF_SIZE - buffsize - 1, 0, buffsize + 1)) return (-1); return ((is_reading || *buf || endbuf == '\n') ? 1 : 0); } return ((!ft_memset(buf, 0, buffsize)) ? -1 : 0); }
static void ft_flag_zero(char **regex_printed, char specifier) { int i; i = -1; while ((*regex_printed)[++i] == ' ') (*regex_printed)[i] = '0'; if (specifier == 'p' && !ft_strcmp(&(*regex_printed)[i], "0x0")) *regex_printed = ft_strjoin(&(*regex_printed)[i], ft_memset(ft_strnew(i + 1), '0', i)); ((*regex_printed)[i] == '-' && i > 0) ? ((*regex_printed)[0] = '-') : (0); ((*regex_printed)[i] == '-' && i > 0) ? ((*regex_printed)[i] = '0') : (0); }
static void set_pseudogram(char *pseudogram, struct pseudo_header *psh, struct tcphdr *header, int len, struct ip *ip_header, char *device) { t_flag *spoof = get_flag("spoof"); psh->source_address = (spoof && spoof->value) ? inet_addr(spoof->value) : inet_addr(device); psh->dest_address = ip_header->ip_dst.s_addr; psh->placeholder = 0; psh->protocol = IPPROTO_TCP; psh->length = htons(sizeof(struct tcphdr)); ft_memset(pseudogram, 0, len); ft_memcpy(pseudogram, psh, sizeof(struct pseudo_header)); ft_memcpy(pseudogram + sizeof(struct pseudo_header), header, sizeof(struct tcphdr)); }
char *ft_process_p_width(char *str, t_arg arg) { char *strp; if (arg.flag_minus) ft_process_p_width_flag_minus(&str, &strp, arg); else if (arg.flag_zero) { if (arg.width > ft_strlen(str)) { strp = ft_memalloc(arg.width - ft_strlen(str) + 1); strp = ft_memset(strp, '0', arg.width - ft_strlen(str)); str = ft_strjoin(str, strp); } } if (arg.width > ft_strlen(str)) { strp = ft_memalloc(arg.width - ft_strlen(str) + 1); strp = ft_memset(strp, ' ', arg.width - ft_strlen(str)); str = ft_strjoin(strp, str); } return (str); }
char *ft_strnew(size_t size) { char *res; size++; res = (char *)malloc(sizeof(char *) * size); if (res) { ft_memset(res, 0, size); return (res); } else return (NULL); }
char *ft_char_conv(t_options *stc, unsigned int c) { char *end_str; if (!(end_str = ft_strnew(stc->area ? stc->area : 1))) return (NULL); if (stc->area) { if (!(stc->fl & FT_LESS)) ft_memset(end_str, ((stc->fl & FT_ZERO) ? '0' : ' '), stc->area - 1); end_str[ft_strlen(end_str)] = (char)c; if ((stc->fl & FT_LESS)) ft_memset(end_str + 1, ' ', stc->area - 1); stc->sc = stc->area; } else { *end_str = (char)c; stc->sc = 1; } return (end_str); }
char *ft_strncpy(char *dest, const char *src, size_t n) { size_t i; i = 0; ft_memset(dest, '\0', n); while (src[i] && n > 0) { dest[i] = src[i]; i++; n--; } return (dest); }
int main() { char *actual, *expected; actual = (char *) ft_memalloc(sizeof(*actual) * BUFF_SIZE); expected = (char *) ft_memalloc(sizeof(*expected) * BUFF_SIZE); actual = ft_memset(actual, 'K', 8); expected = memset(expected, 'K', 8); if (ft_memcmp(actual, expected, 8) == 0) printf("OK\n"); else printf("memset ERROR! Expected: %s, actual: %s\n", expected, actual); return 0; }
void *ft_realloc(void *ptr, size_t size) { void *dup; dup = ft_memalloc(size); dup = ft_memset(dup, 0, size); if (ptr) { if (dup) ft_memcpy(dup, ptr, size); ft_memdel(&ptr); } return (dup); }
int ft_asprintf(char **ret, const char *format, ...) { t_dt data; ft_memset(&data, 0, sizeof(data)); data.tail = (char *)format; va_start(data.ap, format); data.write_method = ft_asprintf_write; ft_base(&data); ft_asprintf_write(&data); va_end(data.ap); *ret = (char *)data.stream; return (data.ret - data.less); }
char *ft_init_key(int a, int b, int c, int d) { char *key; if (!(key = (char *)malloc(sizeof(char) * 5))) return (NULL); ft_memset(key, 0, 5); key[0] = a; key[1] = b; key[2] = c; key[3] = d; key[4] = '\0'; return (key); }
t_prts *ft_handle_b_v(t_pmts pmts, t_prts **node, char *res) { char *tmp; size_t len; len = ft_strlen(res); tmp = ft_malloc_sz(pmts.value - len); tmp = ft_memset(tmp, 32, pmts.value - len); res = pmts.minus ? ft_strjoin_free(res, tmp, 3) : ft_strjoin_free(tmp, res, 3); (*node)->str = res; (*node)->len = ft_strlen(res); return (*node); }
void *ft_memalloc(size_t size) { void *dest; if (size <= 0) return (NULL); dest = malloc(size); if (dest == NULL) return (NULL); ft_memset(dest, 0, size); if (dest) return (dest); else return (NULL); }
void ft_case1_o(char **s, size_t l, t_pmts *p, t_prts **n) { char *tmp; size_t var; if (p->hash) p->prec_value -= 1; var = p->prec_value - l; tmp = ft_malloc_sz(var); tmp = ft_memset(tmp, 48, var); *s = ft_strjoin_free(tmp, *s, 3); (*n)->len = ft_strlen(*s); p->prec = 0; p->prec_value = 0; }
static char *ft_second(long double nbr) { int i; char *str; long double nb; i = 0; nb = nbr; while (nb > 0 && nb < 1) { i++; nb = nb * 10; nb = nb - (long long int)nb; } if (!(str = (i > 6) ? ft_strnew(i + 1) : ft_strnew(7))) return (NULL); if (i > 6) str = (char*)ft_memset(str, '0', i + 1); else str = (char*)ft_memset(str, '0', 7); str[0] = '.'; ft_fill_decimal(str, nbr, i); return (str); }
char static *ft_preci_b(char *bstr, int size) { char *str; int diff; diff = size - ft_strlen(bstr); str = ft_strnew(size); ft_memset(str, '0', size); while (str[diff] != '\0') { str[diff] = *bstr++; diff++; } return (str); }
int ft_print_wchar(va_list *list_args, t_args *arg) { wchar_t wchar; wchar = (wchar_t)va_arg(*list_args, wint_t); ft_memset(arg->conv, '\0', 3); if (arg->val_field && !arg->val_minus && arg->val_z) ft_printnchar(arg->field - ft_wcharlen(wchar), '0'); if (arg->val_field && !arg->val_minus && !arg->val_z) ft_printnchar(arg->field - ft_wcharlen(wchar), ' '); ft_putwchar(wchar); if (arg->val_field == 1 && arg->val_minus == 1) ft_printnchar(arg->field - ft_wcharlen(wchar), ' '); return (ft_retfield(arg, ft_wcharlen(wchar))); }
int key(int keycode, t_mlx *mlx) { float a; float b; mlx->imgview->addr = ft_memset(mlx->imgview->addr, 0, mlx->w * mlx->h * 4 - 1); mlx->imgmap->addr = ft_memset(mlx->imgmap->addr, 0, mlx->mapw * mlx->maph * 4 - 1); a = cos(mlx->deg * (PI / 180)) / 4; b = sin(mlx->deg * (PI / 180)) / 4; key1(keycode, mlx, a, b); key2(keycode, mlx, a, b); key3(keycode, mlx, a, b); key4(keycode, mlx, a, b); if (keycode == 53) str_exit(0, "ESC", mlx); if (keycode == 0) mlx->deg -= 5; if (keycode == 2) mlx->deg += 5; draw(mlx); return (0); }
char *ft_print_extra(char *format, char **regex_printed, char specifier, int size_s) { int i; int precision; int fieldwidth; char flags[5]; i = -1; ft_memset(&flags[0], 0, 5); precision = ft_precision(format, regex_printed, specifier, size_s); fieldwidth = ft_fieldwidth(format, regex_printed, specifier); ft_flags(format, specifier, precision, flags); ft_modif_flags(format, regex_printed, specifier, flags); return (*regex_printed); }
int main(int argc, char **argv) { t_data e; if ((argc == 2 || argc == 3) && argv[1] && ft_strstr(argv[1], ".fdf") && ft_memset(&e, 0, sizeof(e))) { if (argc == 2) option_case(argv[1], 1); if (argc == 3) option_case(argv[1], ft_atoi(argv[2])); } else put_usage_error(argv[0]); return (0); }
char *ft_strpad(const char *s, size_t pad_len, char pad_char, t_dir dir) { size_t len; char *pad; len = ft_strlen(s); if (pad_len <= len) return (ft_strdup(s)); pad = ft_strnew(pad_len); ft_memset(pad, pad_char, pad_len); if (dir == left) ft_memcpy(pad + pad_len - len, s, len); else ft_memcpy(pad, s, len); return (pad); }
t_arc *ft_init_miss(void *start, void *file, t_arc *tmp) { t_arc *ret; ret = (t_arc *)malloc(sizeof(*ret)); if (ret != NULL) { ft_memset(ret, '\0', sizeof(*ret)); ret->pos = -1; ret->off = file - start; ret->ar_hdr = start + ret->off; ret->next = NULL; ret->prev = tmp; } return (ret); }
t_line *ft_create_elem(int fd, char *buf) { t_line *ptr; ptr = (t_line *)malloc(sizeof(t_line)); ptr->read = (char **)malloc(sizeof(char *) * 10000000); ptr->read[0] = (char *)malloc(sizeof(char) * 10000000); ptr->read[0] = ft_memset(ptr->read[0], '\0', 10000000); ptr->fd = fd; ptr->next = NULL; ptr->line = 0; ptr->lasti = 0; ptr->lastj = 0; ft_fill_tab(buf, ptr); return (ptr); }
int filling(int c, int width) { char *str; int i; i = 0; if (width <= 0) return (0); if ((str = (char *)malloc(sizeof(char) * width + 1)) == NULL) return (-1); str[width] = '\0'; ft_memset(str, c, width); i += ft_putstr(str); free(str); return (i); }
int get_overf(char **line, char *overflow) { char *endl; endl = ft_strchr(overflow, '\n'); if (endl) { *endl = '\0'; *line = ft_strdup(overflow); ft_memmove(overflow, endl + 1, BUFF_SIZE - (endl - overflow)); return (1); } *line = ft_strdup(overflow); ft_memset(overflow, 0, BUFF_SIZE + 1); return (0); }
int read_line(char **buf, int fd) { char buffer[BUFF_SIZE + 1]; int read_bytes; read_bytes = 1; while (ft_strstr(*buf, "\n") == NULL && read_bytes != 0) { if ((read_bytes = read(fd, buffer, BUFF_SIZE)) == -1) return (-1); buffer[read_bytes] = '\0'; *buf = ft_strjoin(*buf, buffer); ft_memset(buffer, 0, read_bytes); } return (read_bytes); }
static void ft_flag_moins(char **regex_printed) { char *add; int i; i = 0; while ((*regex_printed)[i] == ' ') i++; if (i > 0) { add = ft_strjoin(ft_strdup(&(*regex_printed)[i]), (char*)ft_memset(ft_strnew(i), ' ', i)); free(*regex_printed); *regex_printed = ft_strdup(add); free(add); } }