static WCHAR * merge_environment(WCHAR *old, WCHAR *add) { WCHAR **a_arg = env_to_arg(add); WCHAR **c_arg = env_to_arg(old); WCHAR *ret; int i, j; for(i = 0; c_arg[i] != NULL; ++i) ; for(j = 0; a_arg[j] != NULL; ++j) ; c_arg = erts_realloc(ERTS_ALC_T_TMP, c_arg, (i+j+1) * sizeof(WCHAR *)); for(j = 0; a_arg[j] != NULL; ++j){ WCHAR **tmp; WCHAR *current = a_arg[j]; WCHAR *eq_p = wcschr(current,L'='); int unset = (eq_p!=NULL && eq_p[1]==L'\0'); if ((tmp = find_arg(c_arg, current)) != NULL) { if (!unset) { *tmp = current; } else { *tmp = c_arg[--i]; c_arg[i] = NULL; } } else if (!unset) { c_arg[i++] = current; c_arg[i] = NULL; } } ret = arg_to_env(c_arg); erts_free(ERTS_ALC_T_TMP, c_arg); erts_free(ERTS_ALC_T_TMP, a_arg); return ret; }
static char* merge_environment(char *old, char *add) { char **a_arg = env_to_arg(add); char **c_arg = env_to_arg(old); char *ret; int i, j; for(i = 0; c_arg[i] != NULL; ++i) ; for(j = 0; a_arg[j] != NULL; ++j) ; c_arg = erts_realloc(ERTS_ALC_T_TMP, c_arg, (i+j+1) * sizeof(char *)); for(j = 0; a_arg[j] != NULL; ++j){ char **tmp; char *current = a_arg[j]; if ((tmp = find_arg(c_arg, current)) != NULL) { if (current[strlen(current)-1] != '=') { *tmp = current; } else { *tmp = c_arg[--i]; c_arg[i] = NULL; } } else if (current[strlen(current)-1] != '=') { c_arg[i++] = current; c_arg[i] = NULL; } } ret = arg_to_env(c_arg); erts_free(ERTS_ALC_T_TMP, c_arg); erts_free(ERTS_ALC_T_TMP, a_arg); return ret; }
static void *debug_realloc(ErtsAlcType_t type, void *ptr, Uint prev_size, Uint size) { void *p; size_t fill_size; void *fill_ptr; if (prev_size > size) { size_t fill_size = (size_t) (prev_size - size); void *fill_ptr = (void *) (((char *) ptr) + size); memset(fill_ptr, NoMansLandFill, fill_size); } p = erts_realloc(type, ptr, size); if (size > prev_size) { size_t fill_size = (size_t) (size - prev_size); void *fill_ptr = (void *) (((char *) p) + prev_size); memset(fill_ptr, CleanLandFill, fill_size); } return p; }
static int find_errcode(char *string, ErtsSysDdllError* err) { int i; if (err != NULL) { erts_sys_ddll_free_error(err); /* in case we ignored an earlier error */ err->str = my_strdup_in(ERTS_ALC_T_DDLL_TMP_BUF, string); return 0; } for(i=0;i<num_errcodes;++i) { if (!strcmp(string, errcodes[i])) { return i; } } if (num_errcodes_allocated == num_errcodes) { errcodes = (num_errcodes_allocated == 0) ? erts_alloc(ERTS_ALC_T_DDLL_ERRCODES, (num_errcodes_allocated = 10) * sizeof(char *)) : erts_realloc(ERTS_ALC_T_DDLL_ERRCODES, errcodes, (num_errcodes_allocated += 10) * sizeof(char *)); } errcodes[num_errcodes++] = my_strdup(string); return (num_errcodes - 1); }
static Eterm do_chksum(ChksumFun sumfun, Process *p, Eterm ioterm, int left, void *sum, int *res, int *err) { Eterm *objp; Eterm obj; int c; DECLARE_ESTACK(stack); unsigned char *bytes = NULL; int numbytes = 0; *err = 0; if (left <= 0 || is_nil(ioterm)) { DESTROY_ESTACK(stack); *res = 0; return ioterm; } if(is_binary(ioterm)) { Uint bitoffs; Uint bitsize; Uint size; Eterm res_term = NIL; unsigned char *bytes; byte *temp_alloc = NULL; ERTS_GET_BINARY_BYTES(ioterm, bytes, bitoffs, bitsize); if (bitsize != 0) { *res = 0; *err = 1; DESTROY_ESTACK(stack); return NIL; } if (bitoffs != 0) { bytes = erts_get_aligned_binary_bytes(ioterm, &temp_alloc); /* The call to erts_get_aligned_binary_bytes cannot fail as we'we already checked bitsize and that this is a binary */ } size = binary_size(ioterm); if (size > left) { Eterm *hp; ErlSubBin *sb; Eterm orig; Uint offset; /* Split the binary in two parts, of which we only process the first */ hp = HAlloc(p, ERL_SUB_BIN_SIZE); sb = (ErlSubBin *) hp; ERTS_GET_REAL_BIN(ioterm, orig, offset, bitoffs, bitsize); sb->thing_word = HEADER_SUB_BIN; sb->size = size - left; sb->offs = offset + left; sb->orig = orig; sb->bitoffs = bitoffs; sb->bitsize = bitsize; sb->is_writable = 0; res_term = make_binary(sb); size = left; } (*sumfun)(sum, bytes, size); *res = size; DESTROY_ESTACK(stack); erts_free_aligned_binary_bytes(temp_alloc); return res_term; } if (!is_list(ioterm)) { *res = 0; *err = 1; DESTROY_ESTACK(stack); return NIL; } /* OK a list, needs to be processed in order, handling each flat list-level as they occur, just like io_list_to_binary would */ *res = 0; ESTACK_PUSH(stack,ioterm); while (!ESTACK_ISEMPTY(stack) && left) { ioterm = ESTACK_POP(stack); if (is_nil(ioterm)) { /* ignore empty lists */ continue; } if(is_list(ioterm)) { L_Again: /* Restart with sublist, old listend was pushed on stack */ objp = list_val(ioterm); obj = CAR(objp); for(;;) { /* loop over one flat list of bytes and binaries until sublist or list end is encountered */ if (is_byte(obj)) { int bsize = 0; for(;;) { if (bsize >= numbytes) { if (!bytes) { bytes = erts_alloc(ERTS_ALC_T_TMP, numbytes = 500); } else { if (numbytes > left) { numbytes += left; } else { numbytes *= 2; } bytes = erts_realloc(ERTS_ALC_T_TMP, bytes, numbytes); } } bytes[bsize++] = (unsigned char) unsigned_val(obj); --left; ioterm = CDR(objp); if (!is_list(ioterm)) { break; } objp = list_val(ioterm); obj = CAR(objp); if (!is_byte(obj)) break; if (!left) { break; } } (*sumfun)(sum, bytes, bsize); *res += bsize; } else if (is_nil(obj)) { ioterm = CDR(objp); if (!is_list(ioterm)) { break; } objp = list_val(ioterm); obj = CAR(objp); } else if (is_list(obj)) { /* push rest of list for later processing, start again with sublist */ ESTACK_PUSH(stack,CDR(objp)); ioterm = obj; goto L_Again; } else if (is_binary(obj)) { int sres, serr; Eterm rest_term; rest_term = do_chksum(sumfun, p, obj, left, sum, &sres, &serr); *res += sres; if (serr != 0) { *err = 1; DESTROY_ESTACK(stack); if (bytes != NULL) erts_free(ERTS_ALC_T_TMP, bytes); return NIL; } left -= sres; if (rest_term != NIL) { Eterm *hp; hp = HAlloc(p, 2); obj = CDR(objp); ioterm = CONS(hp, rest_term, obj); left = 0; break; } ioterm = CDR(objp); if (is_list(ioterm)) { /* objp and obj need to be updated if loop is to continue */ objp = list_val(ioterm); obj = CAR(objp); } } else { *err = 1; DESTROY_ESTACK(stack); if (bytes != NULL) erts_free(ERTS_ALC_T_TMP, bytes); return NIL; } if (!left || is_nil(ioterm) || !is_list(ioterm)) { break; } } /* for(;;) */ } /* is_list(ioterm) */ if (!left) { #ifdef ALLOW_BYTE_TAIL if (is_byte(ioterm)) { /* inproper list with byte tail*/ Eterm *hp; hp = HAlloc(p, 2); ioterm = CONS(hp, ioterm, NIL); } #else ; #endif } else if (!is_list(ioterm) && !is_nil(ioterm)) { /* inproper list end */ #ifdef ALLOW_BYTE_TAIL if (is_byte(ioterm)) { unsigned char b[1]; b[0] = (unsigned char) unsigned_val(ioterm); (*sumfun)(sum, b, 1); ++(*res); --left; ioterm = NIL; } else #endif if is_binary(ioterm) { int sres, serr; ioterm = do_chksum(sumfun, p, ioterm, left, sum, &sres, &serr); *res +=sres; if (serr != 0) { *err = 1; DESTROY_ESTACK(stack); if (bytes != NULL) erts_free(ERTS_ALC_T_TMP, bytes); return NIL; } left -= sres; } else { *err = 1; DESTROY_ESTACK(stack); if (bytes != NULL) erts_free(ERTS_ALC_T_TMP, bytes); return NIL; } } } /* while left and not estack empty */
static ERTS_INLINE void * realloc_wrap(ErtsAlcType_t t, void *p, Uint ps, Uint s) { return erts_realloc(t, p, s); }