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;
}
