struct array *array_part(struct array *within, uint32_t start, uint32_t length) { struct array *p = array_copy(within); array_remove(p, start+length, within->length-start-length); array_remove(p, 0, start); array_resize(p, p->length); return p; }
void free_(void *p) { t_chunk *c; t_mem *m; if (!p) return ; g_malloc_memory = g_malloc_memory ? GMEM : array_new(sizeof(t_chunk), 0); while ((c = (t_chunk *)array_next(g_malloc_memory))) { if ((char *)p < c->start || (char *)p > c->start + c->size) continue ; while ((m = (t_mem *)array_next(c->mem))) { if ((char *)p < m->start || (char *)p > m->start + m->size) continue ; array_remove(c->mem, c->mem->it - 1); c->mem->it = 0; g_malloc_memory->it = 0; if (c->mem->size == 0) array_remove(g_malloc_memory, g_malloc_memory->it); return ; } c->mem->it = 0; } g_malloc_memory->it = 0; free__(p); }
// remove clients that got marked as disconnected and finished zombies void network_cleanup_clients_and_zombies(void) { int i; Client *client; Zombie *zombie; // iterate backwards for simpler index handling for (i = _clients.count - 1; i >= 0; --i) { client = array_get(&_clients, i); if (client->disconnected) { log_debug("Removing disconnected client ("CLIENT_SIGNATURE_FORMAT")", client_expand_signature(client)); array_remove(&_clients, i, (ItemDestroyFunction)client_destroy); } } // iterate backwards for simpler index handling for (i = _zombies.count - 1; i >= 0; --i) { zombie = array_get(&_zombies, i); if (zombie->finished) { log_debug("Removing finished zombie (id: %u)", zombie->id); array_remove(&_zombies, i, (ItemDestroyFunction)zombie_destroy); } } }
Client *network_create_client(const char *name, IO *io) { Client *client; // append to client array client = array_append(&_clients); if (client == NULL) { log_error("Could not append to client array: %s (%d)", get_errno_name(errno), errno); return NULL; } // create new client that takes ownership of the I/O object if (client_create(client, name, io, _next_authentication_nonce++, NULL) < 0) { array_remove(&_clients, _clients.count - 1, NULL); return NULL; } log_info("Added new client ("CLIENT_SIGNATURE_FORMAT")", client_expand_signature(client)); return client; }
void as_destroy(struct addrspace *as) { /* * Clean up as needed. */ unsigned len, i; pt_destroy(as, as->pagetable); struct region *region_ptr; for (i = 0; i < PT_LEVEL_SIZE; i++) { if (as->pt_locks[i]) lock_destroy(as->pt_locks[i]); } len = array_num(as->as_regions); // for (i = len - 1; i > 0; i--){ // region_ptr = array_get(as->as_regions, i); // kfree(region_ptr); // array_remove(as->as_regions, i); // } i = len - 1; while (len > 0){ region_ptr = array_get(as->as_regions, i); kfree(region_ptr); array_remove(as->as_regions, i); if (i == 0) break; i--; } array_destroy(as->as_regions); kfree(as); }
void dij_note_rvalue( int later ) { /*variable number later is being used as an rvalue in this context, is this the first use? ie is this a parameter? if so make sure it has a slot. otherwise, we now know that it is not a return value, so move it out of that group.*/ if ( ! ( array_contains(write_code->parameters, write_code->num_parameters, later ) || array_contains(write_code->locals, write_code->num_locals, later ) ) ) { if( array_contains(write_code->returns, write_code->num_returns, later ) ) { write_code->returns = array_remove(write_code->returns, write_code->num_returns, later); write_code->locals = array_add(write_code->locals, write_code->num_locals, later); write_code->num_returns--; write_code->num_locals++; } else { write_code->parameters = array_add(write_code->parameters, write_code->num_parameters, later); write_code->num_parameters++; } } }
void thread_wakeup_one(const void *addr) { int result; // meant to be called with interrupts off assert(curspl>0); if (thread_hassleepers(addr)!=0){ struct thread *t = array_getguy(sleepers, 1); if (t->t_sleepaddr == addr) { // Remove from list array_remove(sleepers, 1); /* * Because we preallocate during thread_fork, * this should never fail. */ result = make_runnable(t); assert(result==0); } } }
/* * ASST1: Like thread_wakeup, but wake up at most one thread * sleeping on "sleep address" ADDR. */ void thread_wakeone(const void *addr) { int i, result; // meant to be called with interrupts off assert(curspl>0); // This is inefficient. Feel free to improve it. for (i=0; i<array_getnum(sleepers); i++) { struct thread *t = array_getguy(sleepers, i); if (t->t_sleepaddr == addr) { // Remove from list array_remove(sleepers, i); /* * Because we preallocate during thread_fork, * this should never fail. */ result = make_runnable(t); assert(result==0); break; } } }
void test_remove() { int *val_check = array_remove(array, 0); mu_assert(val_check != NULL, "Value check shouldn't be NULL"); mu_assert(*val_check == *value0, "Should be value0"); mu_assert(array_get(array, 0) == NULL, "Value0 should be NULL"); free(val_check); }
static void save_program_settings(void) { const gchar *program_name = *program_executable ? program_executable : program_load_script; if (*program_name) { RecentProgram *recent = (RecentProgram *) array_find(recent_programs, program_name, TRUE); GKeyFile *config = g_key_file_new(); char *configfile; if (!recent) { recent = (RecentProgram *) array_append(recent_programs); recent->name = g_strdup(program_name); for (recent->id = 1; recent->id < RECENT_COUNT; recent->id++) if ((recent_bitmap & (1 << recent->id)) == 0) break; recent_bitmap |= 1 << recent->id; } configfile = recent_file_name(recent->id); stash_foreach((GFunc) stash_group_save_to_key_file, config); breaks_save(config); watches_save(config); inspects_save(config); parse_save(config); utils_key_file_write_to_file(config, configfile); g_free(configfile); g_key_file_free(config); g_array_insert_vals(recent_programs, 0, ++recent, 1); array_remove(recent_programs, recent); recent_menu_create(); if (recent_programs->len > RECENT_COUNT) { recent_bitmap &= ~(1 << recent->id); array_remove(recent_programs, recent); } } }
static void state_remove(view *V, int i) { state *p; if ((p = (state *) array_remove(V->list, i, V->n, sizeof (state)))) { V->list = p; V->n -= 1; } }
/** * Unload and destroy test suites and associated data */ static void unload_suites(array_t *suites) { test_suite_t *suite; while (array_remove(suites, 0, &suite)) { destroy_suite(suite); } array_destroy(suites); }
/** * Destroy a single test suite and associated data */ static void destroy_suite(test_suite_t *suite) { test_case_t *tcase; while (array_remove(suite->tcases, 0, &tcase)) { array_destroy(tcase->functions); array_destroy(tcase->fixtures); } free(suite); }
int client_dispatch_packet(Client *client, Packet *packet, int force) { int i; Packet *pending_request; int found = -1; int rc = -1; if (!force) { for (i = 0; i < client->pending_requests.count; ++i) { pending_request = array_get(&client->pending_requests, i); if (pending_request->header.uid == packet->header.uid && pending_request->header.function_id == packet->header.function_id && pending_request->header.sequence_number == packet->header.sequence_number) { found = i; break; } } } if (force || found >= 0) { if (socket_send(client->socket, packet, packet->header.length) < 0) { log_error("Could not send response to client (socket: %d, peer: %s): %s (%d)", client->socket, client->peer, get_errno_name(errno), errno); goto cleanup; } if (force) { log_debug("Forced to sent response to client (socket: %d, peer: %s)", client->socket, client->peer); } else { log_debug("Sent response to client (socket: %d, peer: %s)", client->socket, client->peer); } } rc = 0; cleanup: if (found >= 0) { array_remove(&client->pending_requests, found, NULL); if (rc == 0) { rc = 1; } } return rc; }
void stress_test_array(int amt) { array arr; /* matey! */ gendata x; int i; arr = array_create(); assert(array_size(arr) == 0); printf("Adding %d items to an array...\n", amt); for (i = 0; i < amt; ++i) { x.num = i; arr = array_add(arr, x); assert(x.num == array_get_data(arr, (unsigned int)i).num); assert(array_size(arr) == (unsigned int)(i + 1)); } printf("Shrinking an array of %d items...\n", amt); for (i = amt - 1; i >= 0; --i) { assert(array_get_data(arr, (unsigned int)i).num == i); arr = array_remove(arr); assert(array_size(arr) == (unsigned int)i); } printf("Filling a pre-grown array of %d items...\n", amt); array_grow(arr, amt); assert(array_size(arr) == (unsigned int)amt); for (i = 0; i < amt; ++i) { x.num = i; arr = array_set_data(arr, (unsigned int)i, x); assert(x.num == array_get_data(arr, (unsigned int)i).num); } printf("Shrinking an array of %d items...\n", amt); for (i = amt - 1; i >= 0; --i) { assert(array_get_data(arr, (unsigned int)i).num == i); arr = array_shrink(arr, 1); assert(array_size(arr) == (unsigned int)i); /* Compactise at funky points */ if ((i % COMPACTISE_MODULO) == 0) { arr = array_compact(arr); /* Compactising should not change size */ assert(array_size(arr) == (unsigned int)i); } } array_destroy(arr, NULL); }
static int index_remove(struct db *db, const char *key) { struct db_entry *e; e = index_search(db, key); if (e == NULL) return 0; free(e->key); array_remove(db->entries, db->nr_entries, sizeof(struct db_entry), e - db->entries); db->nr_entries--; db->index_dirty = 1; return 1; }
void filetable_empty(struct array* ft) { int i; for (i = array_num(ft) -1 ; i >=0 ; i--) { struct filetable_entry* entry = (struct filetable_entry*) array_get(ft, i); filehandle_destroy(entry->ft_handle); // free memory allocated for the entry kfree(entry); // remove the entry from the filetable array_remove(ft, i); } }
static void on_recent_menu_item_activate(G_GNUC_UNUSED GtkMenuItem *menuitem, const gchar *name) { RecentProgram *recent = (RecentProgram *) array_find(recent_programs, name, TRUE); if (recent && utils_filenamecmp(recent->name, *program_executable ? program_executable : program_load_script)) { char *configfile = recent_file_name(recent->id); GKeyFile *config = g_key_file_new(); GError *gerror = NULL; gchar *message; if (g_key_file_load_from_file(config, configfile, G_KEY_FILE_NONE, &gerror)) { save_program_settings(); recent = (RecentProgram *) array_find(recent_programs, name, TRUE); stash_foreach((GFunc) stash_group_load_from_key_file, config); if ((unsigned) option_inspect_expand > EXPAND_MAX) option_inspect_expand = 100; breaks_load(config); watches_load(config); inspects_load(config); parse_load(config); message = g_strdup_printf(_("Loaded debug settings for %s."), recent->name); g_array_insert_vals(recent_programs, 0, ++recent, 1); array_remove(recent_programs, recent); recent_menu_create(); program_configure(); } else { message = g_strdup_printf(_("Could not load debug settings file %s: %s."), configfile, gerror->message); g_error_free(gerror); } if (menuitem) ui_set_statusbar(TRUE, "%s", message); else msgwin_status_add("%s", message); g_free(message); g_key_file_free(config); g_free(configfile); } }
static void removePagesWithinRegion(struct addrspace* as, struct region* reg) { int pageCount = array_num(as->as_pagetable); int i; for (i = 0; i < pageCount; i++) { struct page *pageCandidate = array_get(as->as_pagetable, i); if (pageCandidate != NULL && pageCandidate->pt_virtbase >= reg->rg_vaddr / PAGE_SIZE && pageCandidate->pt_virtbase <= (reg->rg_vaddr + reg->rg_size) / PAGE_SIZE) { array_remove(as->as_pagetable, i); freePage(pageCandidate); kfree(pageCandidate); i--; pageCount = array_num(as->as_pagetable); } } }
int hardware_remove_stack(Stack *stack) { int i; Stack *candidate; for (i = 0; i < _stacks.count; ++i) { candidate = *(Stack **)array_get(&_stacks, i); if (candidate == stack) { array_remove(&_stacks, i, NULL); return 0; } } log_error("Stack %s not found in stack array", stack->name); return -1; }
void conf_file_remove_option(ConfFile *conf_file, const char *name, bool prefix_match) { int i; ConfFileLine *line; int prefix_length = prefix_match ? strlen(name) : 0; // iterate backwards so that line removal doesn't affect the iteration index for (i = conf_file->lines.count - 1; i >= 0; --i) { line = array_get(&conf_file->lines, i); if (line->raw != NULL) { continue; } if ((prefix_match && strncasecmp(line->name, name, prefix_length) == 0) || strcasecmp(line->name, name) == 0) { array_remove(&conf_file->lines, i, conf_file_line_destroy); } } }
void inventory_remove_session(Session *session) { int i; Session *candidate; for (i = 0; i < _sessions.count; ++i) { candidate = *(Session **)array_get(&_sessions, i); if (candidate != session) { continue; } log_object_debug("Removing session (id: %u)", session->id); array_remove(&_sessions, i, inventory_destroy_session); return; } log_error("Could not find session (id: %u) to remove it", session->id); }
/* * Wake up one thread that is sleeping on "sleep address" * ADDR. */ void thread_wakeup_single(const void *addr) { int result; // meant to be called with interrupts off assert(curspl>0); // This is inefficient. Feel free to improve it. struct thread *t = array_getguy(sleepers, 0); if (t->t_sleepaddr == addr) { // Remove from list array_remove(sleepers, 0); result = make_runnable(t); assert(result==0); } }
void inventory_remove_object(Object *object) { int i; Object *candidate; for (i = 0; i < _objects[object->type].count; ++i) { candidate = *(Object **)array_get(&_objects[object->type], i); if (candidate != object) { continue; } log_object_debug("Removing %s object (id: %u)", object_get_type_name(object->type), object->id); array_remove(&_objects[object->type], i, inventory_destroy_object); return; } log_error("Could not find %s object (id: %u) to remove it", object_get_type_name(object->type), object->id); }
int main(int argc, char** argv) { if (2 > argc) { printf("Nombre de parametres insuffisants\n"); return 1; } int i,test=0; for(i=1;i<argc;i++) { if(*argv[i]=='-') test=1; } if (test==0) { printf("Nombre de parametres insuffisants\n"); return 1; } int *arr1 =(int*)malloc((argc-3)*sizeof(int)); int index=atoi(argv[argc-1]); unsigned int length=(argc-3); for(i=0;i<length;i++) { arr1[i]=atoi(argv[i+1]); } int* result = array_remove(arr1,index,&length); for(i=0;i<(length);i++) printf("%d ", *(result+i)); free(result); return 1; }
int usb_reopen(void) { int i; USBStack *usb_stack; log_debug("Reopening all USB devices"); // iterate backwards for simpler index handling and to avoid memmove in // array_remove call for (i = _usb_stacks.count - 1; i >= 0; --i) { usb_stack = array_get(&_usb_stacks, i); log_info("Temporarily removing USB device (bus: %u, device: %u) at index %d: %s", usb_stack->bus_number, usb_stack->device_address, i, usb_stack->base.name); stack_announce_disconnect(&usb_stack->base); array_remove(&_usb_stacks, i, (ItemDestroyFunction)usb_stack_destroy); } return usb_rescan(); }
int usb_rescan(void) { int i; USBStack *usb_stack; log_debug("Looking for added/removed USB devices"); // mark all known USB stacks as potentially removed for (i = 0; i < _usb_stacks.count; ++i) { usb_stack = array_get(&_usb_stacks, i); usb_stack->connected = false; } // enumerate all USB devices, mark all USB stacks that are still connected // and add USB stacks that are newly connected if (usb_enumerate() < 0) { return -1; } // remove all USB stacks that are not marked as connected. iterate backwards // so array_remove can be used without invalidating the current index for (i = _usb_stacks.count - 1; i >= 0; --i) { usb_stack = array_get(&_usb_stacks, i); if (usb_stack->connected) { continue; } log_info("Removing USB device (bus: %u, device: %u) at index %d: %s", usb_stack->bus_number, usb_stack->device_address, i, usb_stack->base.name); stack_announce_disconnect(&usb_stack->base); array_remove(&_usb_stacks, i, (ItemDestroyFunction)usb_stack_destroy); } return 0; }
static int reduceHeapSize(userptr_t amount, int32_t* retval, struct addrspace* as) { vaddr_t newStart = as->as_addrPtr + (vaddr_t) amount; vaddr_t oldStart = as->as_addrPtr; unsigned int regionCount = array_num(as->as_regions); unsigned int i; if (as->as_heapBase > newStart) { //kprintf("Invalid because it falls within code page %x\n", // codepage->rg_vaddr + codepage->rg_size); *retval = -1; return ENOMEM; } for (i = 0; i < regionCount; i++) { struct region* reg = array_get(as->as_regions, i); if (reg != NULL && reg->rg_vaddr >= as->as_stackBase && reg->rg_vaddr + reg->rg_size >= as->as_stackBase) { continue; } if (reg != NULL && reg->rg_vaddr >= newStart) { removePagesWithinRegion(as, reg); array_remove(as->as_regions, i); kfree(reg); i--; regionCount = array_num(as->as_regions); } else if (reg != NULL && reg->rg_vaddr <= newStart && reg->rg_vaddr + reg->rg_size >= newStart) { struct region tempReg; tempReg.rg_vaddr = newStart; tempReg.rg_size = newStart - (reg->rg_vaddr + reg->rg_size); reg->rg_size = newStart - reg->rg_vaddr; removePagesWithinRegion(as, &tempReg); } } as->as_addrPtr = newStart; *retval = oldStart; //kprintf("retval is = %x\n", as->as_addrPtr); return 0; }
static void killsenders(void) { struct sender *sdr; int n, i; assert(senders != NULL); n = array_getnum(senders); for (i=0; i<n; i++) { sdr = array_getguy(senders, i); assert(sdr != NULL); if (sdr->sdr_errors > 5) { printf("hub161: dropping %04x\n", sdr->sdr_addr); array_remove(senders, i); i--; n--; free(sdr); } } }
int network_create_zombie(Client *client) { Zombie *zombie; // append to zombie array zombie = array_append(&_zombies); if (zombie == NULL) { log_error("Could not append to zombie array: %s (%d)", get_errno_name(errno), errno); return -1; } // create new zombie that takes ownership of the pending requests if (zombie_create(zombie, client) < 0) { array_remove(&_zombies, _zombies.count - 1, NULL); return -1; } log_debug("Added new zombie (id: %u)", zombie->id); return 0; }