void *realloc(void *ptr, size_t size) { int type; int ret; void *new_ptr; if (size == 0) { size = 1; new_ptr = do_realloc(ptr, size, TINY); return (new_ptr); } if (!ptr) return (NULL); if (pthread_mutex_lock(&g_mutex) < 0) return (ptr); ret = search_map(&type, ptr, size); pthread_mutex_unlock(&g_mutex); if (ret == 1) { new_ptr = do_realloc(ptr, size, type); return (new_ptr); } else if (ret == 0) return (ptr); return (ptr); }
/* Insert or update ap data in the hash table * returns 0 if the ap wasn't present * 1 otherwise */ char insert_ap(Wifi_AccessPoint * ap) { int key = ap->macaddr[5]; struct AP_HT_Entry *ht_entry; char same; struct AP_HT_Entry *to_insert = NULL; /* check if there's already an entry in the hash table */ if (ap_ht[key] == NULL) { to_insert = entry_from_ap(ap); ap_ht[key] = to_insert; } else { ht_entry = ap_ht[key]; /* Check if the AP is already known, walking the linked list */ while (!(same = macaddr_cmp(ap->macaddr, ht_entry->ap->macaddr)) && ht_entry->next) ht_entry = ht_entry->next; if (same == 0) { to_insert = entry_from_ap(ap); ht_entry->next = to_insert; } else { /* AP is already there, just update data */ ht_entry->tick = curtick; ht_entry->ap->channel = ap->channel; ht_entry->ap->rssi = ap->rssi; ht_entry->ap->flags = ap->flags; if (ap->ssid_len == 0) { memset(ht_entry->ap->ssid, 0, 32); } else { memcpy(ht_entry->ap->ssid, ap->ssid, (unsigned char)ap->ssid_len > 32 ? 32 : ap->ssid_len); } return 1; } } if (to_insert) { if (to_insert->ap->flags & WFLAG_APDATA_WPA) { do_realloc(WPA); insert_fast(WPA, to_insert); } else { if (to_insert->ap->flags & WFLAG_APDATA_WEP) { do_realloc(WEP); insert_fast(WEP, to_insert); } else { do_realloc(OPN); insert_fast(OPN, to_insert); } } } numap++; return 0; }
static kGCObject2 *new_ObjectArena2(GcManager *mng, size_t arenasize) { ObjectPageTable_t *oat; //KonohaContext *kctx = mng->kctx; size_t pageindex = MSGC(2).arena_table.size; if(unlikely(!(pageindex < MSGC(2).arena_table.capacity))) { size_t oldsize = MSGC(2).arena_table.capacity; size_t newsize = oldsize * 2; MSGC(2).arena_table.table = (ObjectPageTable_t *)do_realloc(MSGC(2).arena_table.table, oldsize * sizeof(ObjectPageTable_t), newsize * sizeof(ObjectPageTable_t)); MSGC(2).arena_table.capacity = newsize; } MSGC(2).arena_table.size += 1; DBG_ASSERT(sizeof(ObjectPage2_t) == K_PAGESIZE); oat = &MSGC(2).arena_table.table[pageindex]; ObjectArenaTable_Init2(mng, oat, arenasize); kGCObject2 *p = oat->head2->slots; p->ref5_tail = (kGCObject2 *)&(oat->bottom2[-1]); int i = 0; kGCObject2 *tmp = p; while(tmp != &oat->head2->slots[PageObjectSize(2)]) { tmp = tmp->ref; i++; } assert(i == PageObjectSize(2)); return p; }
charinfo * get_charinfo (internal_font_number f, integer c) { sa_tree_item glyph; charinfo *ci; if (proper_char_index(c)) { glyph = get_sa_item(Characters(f), c); if (!glyph) { /* this could be optimized using controlled growth */ font_bytes += sizeof(charinfo); glyph = ++font_tables[f]->charinfo_count; do_realloc(font_tables[f]->charinfo, (glyph+1), charinfo); memset (&(font_tables[f]->charinfo[glyph]),0,sizeof(charinfo)); font_tables[f]->charinfo[glyph].ef = 1000; /* init */ font_tables[f]->charinfo_size = glyph; set_sa_item(font_tables[f]->characters, c, glyph, 1); /* 1= global */ } return &(font_tables[f]->charinfo[glyph]); } else if (c == left_boundarychar) { if (left_boundary(f)==NULL) { ci = xcalloc(1,sizeof(charinfo)); font_bytes += sizeof(charinfo); set_left_boundary(f,ci); } return left_boundary(f); } else if (c == right_boundarychar) { if (right_boundary(f)==NULL) { ci = xcalloc(1,sizeof(charinfo)); font_bytes += sizeof(charinfo); set_right_boundary(f,ci); } return right_boundary(f); } return &(font_tables[f]->charinfo[0]); }
static int add_source (double ra, double dec, double weight, double energy) { Point_Source_Type *p; double cosx, cosy, cosz; /* Convert to God's units from arc-min */ ra = ra * (PI/(180.0 * 60.0)); dec = dec * (PI/(180.0 * 60.0)); if (Max_Num_Points == Num_Points) { Max_Num_Points += 32; p = (Point_Source_Type *)do_realloc ((char *)Point_Sources, Max_Num_Points * sizeof (Point_Source_Type)); if (p == NULL) { free_sources (); return -1; } Point_Sources = p; } p = Point_Sources + Num_Points; /* Note the the minus sign is to generate a vector pointing from the * source to the origin */ p->cosx = -cos (dec) * cos (ra); p->cosy = -cos (dec) * sin(ra); p->cosz = -sin (dec); p->weight = weight; p->energy = energy; Num_Points += 1; return 0; }
inline MemRef Allocator::realloc_(ref_type ref, const char* addr, size_t old_size, size_t new_size) { #ifdef REALM_DEBUG if (ref == m_debug_watch) REALM_TERMINATE("Allocator watch: Ref was reallocated"); #endif return do_realloc(ref, addr, old_size, new_size); }
/* Emit bytes to the instruction stream: */ static unsigned char *reserve( struct x86_function *p, int bytes ) { if (p->csr + bytes - p->store > (int) p->size) do_realloc(p); { unsigned char *csr = p->csr; p->csr += bytes; return csr; } }
static void mstack_Push(MarkStack *mstack, kObject *ref) { size_t ntail = (mstack->tail + 1) & mstack->capacity; if(unlikely(ntail == 0)) { size_t capacity = 1 << mstack->capacity_log2; size_t stacksize = sizeof(kObject *) * capacity; mstack->stack = (kObject**)do_realloc(mstack->stack, stacksize, stacksize * 2); mstack->capacity_log2 += 1; mstack->capacity = (1 << mstack->capacity_log2) - 1; ntail = (mstack->tail + 1) & mstack->capacity; } mstack->stack[mstack->tail] = ref; mstack->tail = ntail; }
void set_font_params(internal_font_number f, int b) { int i; i = font_params(f); if (i!=b) { font_bytes += (b-font_params(f))*sizeof(scaled); do_realloc(param_base(f), (b+1), integer); font_params(f) = b; if (b>i) { while (i<b) { i++; set_font_param(f,i,0); } } } }
void * realloc (void *ptr, size_t size) { return do_realloc (ptr, size); }
void reserve_new_slots(size_type num_slots) { const size_type new_count = count + num_slots; if(new_count > alloced) do_realloc(new_count * expand_multiplier); count = new_count; }
void push_vertex(vertex const& v, color const& c) { if(count == alloced) do_realloc(alloced * expand_multiplier); vertices[count].c = c; vertices[count].v = v; ++count; }
void push_vertex(vertex_with_color const& v) { if(count == alloced) do_realloc(alloced * expand_multiplier); vertices[count] = v; ++count; }