static bool flush_incoming_que_on_wr_signal(rfc_slot_t *slot) { while (!list_is_empty(slot->incoming_queue)) { BT_HDR *p_buf = list_front(slot->incoming_queue); switch (send_data_to_app(slot->fd, p_buf)) { case SENT_NONE: case SENT_PARTIAL: //monitor the fd to get callback when app is ready to receive data btsock_thread_add_fd(pth, slot->fd, BTSOCK_RFCOMM, SOCK_THREAD_FD_WR, slot->id); return true; case SENT_ALL: list_remove(slot->incoming_queue, p_buf); break; case SENT_FAILED: list_remove(slot->incoming_queue, p_buf); return false; } } //app is ready to receive data, tell stack to start the data flow //fix me: need a jv flow control api to serialize the call in stack APPL_TRACE_DEBUG("enable data flow, rfc_handle:0x%x, rfc_port_handle:0x%x, user_id:%d", slot->rfc_handle, slot->rfc_port_handle, slot->id); extern int PORT_FlowControl_MaxCredit(uint16_t handle, bool enable); PORT_FlowControl_MaxCredit(slot->rfc_port_handle, true); return true; }
void call_bind_rule( OBJECT * target_, OBJECT * boundname_ ) { LIST * const bind_rule = var_get( root_module(), constant_BINDRULE ); if ( !list_empty( bind_rule ) ) { OBJECT * target = object_copy( target_ ); OBJECT * boundname = object_copy( boundname_ ); if ( boundname && target ) { /* Prepare the argument list. */ FRAME frame[ 1 ]; frame_init( frame ); /* First argument is the target name. */ lol_add( frame->args, list_new( target ) ); lol_add( frame->args, list_new( boundname ) ); if ( lol_get( frame->args, 1 ) ) { OBJECT * rulename = list_front( bind_rule ); list_free( evaluate_rule( bindrule( rulename, root_module() ), rulename, frame ) ); } /* Clean up */ frame_free( frame ); } else { if ( boundname ) object_free( boundname ); if ( target ) object_free( target ); } } }
static int srunner_run_unchecked_setup (SRunner *sr, TCase *tc) { TestResult *tr; List *l; Fixture *f; int rval = 1; set_fork_status(CK_NOFORK); l = tc->unch_sflst; for (list_front(l); !list_at_end(l); list_advance(l)) { send_ctx_info(CK_CTX_SETUP); f = list_val(l); f->fun(); tr = receive_result_info_nofork (tc->name, "unchecked_setup", 0); if (tr->rtype != CK_PASS) { srunner_add_failure(sr, tr); rval = 0; break; } free(tr->file); free(tr->msg); free(tr); } set_fork_status(srunner_fork_status(sr)); return rval; }
static void srunner_iterate_tcase_tfuns (SRunner *sr, TCase *tc) { List *tfl; TF *tfun; TestResult *tr = NULL; tfl = tc->tflst; for (list_front(tfl); !list_at_end (tfl); list_advance (tfl)) { int i; tfun = list_val (tfl); for (i = tfun->loop_start; i < tfun->loop_end; i++) { log_test_start (sr, tc, tfun); switch (srunner_fork_status(sr)) { case CK_FORK: #ifdef _POSIX_VERSION tr = tcase_run_tfun_fork (sr, tc, tfun, i); #else /* _POSIX_VERSION */ eprintf("This version does not support fork", __FILE__, __LINE__); #endif /* _POSIX_VERSION */ break; case CK_NOFORK: tr = tcase_run_tfun_nofork (sr, tc, tfun, i); break; default: eprintf("Bad fork status in SRunner", __FILE__, __LINE__); } srunner_add_failure (sr, tr); log_test_end(sr, tr); } } }
void test__hash_multiset_find__hash_multiset_find_varg__libcstl_builtin_find(void** state) { hash_multiset_t* pt_hash_multiset = _create_hash_multiset("list_t<int>"); hash_multiset_iterator_t it_iter; list_t* plist = create_list(int); int i = 0; hash_multiset_init_ex(pt_hash_multiset, 0, _test__hash_private__libcstl_builtin_hash, NULL); list_init(plist); for(i = 0; i < 10; i++) { list_clear(plist); list_push_back(plist, i); hash_multiset_insert(pt_hash_multiset, plist); } list_clear(plist); list_push_back(plist, 6); it_iter = _hash_multiset_find(pt_hash_multiset, plist); assert_true(*(int*)list_front((list_t*)iterator_get_pointer(it_iter)) == 6); hash_multiset_destroy(pt_hash_multiset); list_destroy(plist); }
static TestResult * tcase_run_checked_setup (SRunner *sr, TCase *tc) { TestResult *tr = NULL; List *l; Fixture *f; enum fork_status fstat = srunner_fork_status(sr); l = tc->ch_sflst; if (fstat == CK_FORK) { send_ctx_info(CK_CTX_SETUP); } for (list_front(l); !list_at_end(l); list_advance(l)) { if (fstat == CK_NOFORK) { send_ctx_info(CK_CTX_SETUP); } f = list_val(l); f->fun(); /* Stop the setup and return the failure if nofork mode. */ if (fstat == CK_NOFORK) { tr = receive_result_info_nofork (tc->name, "checked_setup", 0); if (tr->rtype != CK_PASS) { break; } free(tr->file); free(tr->msg); free(tr); tr = NULL; } } return tr; }
static const char * cache_name( void ) { static OBJECT * name = 0; if ( !name ) { LIST * hcachevar = var_get( root_module(), constant_HCACHEFILE ); if ( !list_empty( hcachevar ) ) { TARGET * t = bindtarget( list_front( hcachevar ) ); pushsettings( root_module(), t->settings ); /* Do not expect the cache file to be generated, so pass 0 as the * third argument to search. Expect the location to be specified via * LOCATE, so pass 0 as the fourth arugment. */ object_free( t->boundname ); t->boundname = search( t->name, &t->time, 0, 0 ); popsettings( root_module(), t->settings ); name = object_copy( t->boundname ); } } return name ? object_str( name ) : 0; }
LIST * list_pop_front( LIST * l ) { unsigned size = list_length( l ); assert( size ); --size; object_free( list_front( l ) ); if ( size == 0 ) { list_dealloc( l ); return L0; } if ( ( ( size - 1 ) & size ) == 0 ) { LIST * const nl = list_alloc( size ); nl->impl.size = size; memcpy( list_begin( nl ), list_begin( l ) + 1, size * sizeof( OBJECT * ) ); list_dealloc( l ); return nl; } l->impl.size = size; memmove( list_begin( l ), list_begin( l ) + 1, size * sizeof( OBJECT * ) ); return l; }
/* Removes the front element from LIST and returns it. Undefined behavior if LIST is empty before removal. */ struct list_elem * list_pop_front (struct list *list) { struct list_elem *front = list_front (list); list_remove (front); return front; }
static void call_action_rule ( TARGET * target, int status, timing_info const * time, char const * executed_command, char const * command_output ) { LIST * action_rule; pushsettings( root_module(), target->settings ); action_rule = var_get( root_module(), constant_ACTION_RULE ); popsettings( root_module(), target->settings ); if ( !list_empty( action_rule ) ) { /* rule action-rule ( args * : target : command status start end user system : output ? ) */ /* Prepare the argument list. */ FRAME frame[ 1 ]; OBJECT * rulename = list_front( action_rule ); frame_init( frame ); /* args * :: $(__ACTION_RULE__[2-]) */ lol_add( frame->args, list_copy_range( action_rule, list_next( list_begin( action_rule ) ), list_end( action_rule ) ) ); /* target :: the name of the target */ lol_add( frame->args, list_new( object_copy( target->name ) ) ); /* command status start end user system :: info about the action command */ lol_add( frame->args, list_push_back( list_push_back( list_push_back( list_push_back( list_push_back( list_new( object_new( executed_command ) ), outf_int( status ) ), outf_time( &time->start ) ), outf_time( &time->end ) ), outf_double( time->user ) ), outf_double( time->system ) ) ); /* output ? :: the output of the action command */ if ( command_output ) lol_add( frame->args, list_new( object_new( command_output ) ) ); else lol_add( frame->args, L0 ); /* Call the rule. */ evaluate_rule( bindrule( rulename, root_module() ), rulename, frame ); /* Clean up. */ frame_free( frame ); } }
/* Removes the front element from LIST and returns it. Undefined behavior if LIST is empty before removal. */ struct list_elem * list_pop_front (struct list *list) { struct list_elem *front = list_front (list); list_remove (front); front->magic = BAD_LIST_ELEM_MAGIC__; return front; }
void thread_cleanup_and_exit (int status) { printf ("%s: exit(%d)\n", thread_name (), status); /* close all open file descriptors */ struct thread *t = thread_current (); struct list_elem *e; /* close all the files opened and free spaces allocated for the file list */ while (!list_empty (&t->file_list)) { e = list_pop_back (&t->file_list); struct file_elem *f_elem = list_entry (e, struct file_elem, elem); file_close (f_elem->file); free (f_elem); } /* free waited_children_list and children_list */ while (!list_empty (&t->children_list)) { e = list_pop_back (&t->children_list); struct child_elem *c_elem = list_entry (e, struct child_elem, elem); // free children from the global exit_list free_thread_from_exit_list (c_elem->pid); free (c_elem); } while (!list_empty (&t->waited_children_list)) { e = list_pop_back (&t->waited_children_list); struct wait_child_elem *w_elem = list_entry (e, struct wait_child_elem, elem); free (w_elem); } add_thread_to_exited_list (t->tid, status); /* allow file write to executable */ if (t->exec_file) { file_allow_write (t->exec_file); file_close (t->exec_file); } /* release all the locks that have not already been released */ while (!list_empty (&t->acquired_locks)) { struct list_elem *e = list_front (&t->acquired_locks); struct lock *l = list_entry (e, struct lock, elem); lock_release (l); } /* wake parent up if its waiting on it */ struct thread *parent = get_thread (thread_current ()->parent_id); if (parent) { sema_up (&parent->waiting_on_child_exit_sema); } thread_exit (); }
void list_apply (List *lp, void (*fp) (void *)) { if (lp == NULL || fp == NULL) return; for (list_front(lp); !list_at_end(lp); list_advance(lp)) fp (list_val(lp)); }
list* search_breadth_first(void* state, void* state_world, search_is_goal state_goal_func, search_gen_successors state_gen_func, search_link_parent state_link_func, search_goal_backtrace state_back_func, hash_func state_hash_alg, generic_comp state_comp_func, generic_cpy state_copy_func, generic_op state_free_func) { int found; void* current_state, *successor_state; list* state_queue, *successor_list, *path; hash_table* state_closed_set; state_queue = list_create(NULL, NULL, state_free_func); state_closed_set = hash_table_create(89, .75, state_hash_alg, state_comp_func, state_copy_func, state_free_func); current_state = state; list_push_front(state_queue, current_state); hash_table_insert(state_closed_set, current_state, 0); path = NULL; found = 0; while(!list_is_empty(state_queue) && !found) { current_state = list_back(state_queue); list_deque(state_queue); if(state_goal_func(current_state, state_world)) { current_state = state_copy_func(current_state); path = state_back_func(current_state); found = 1; } else { successor_list = state_gen_func(current_state, state_world); while(!list_is_empty(successor_list)) { successor_state = list_front(successor_list); if(!hash_table_contains(state_closed_set, successor_state)) { state_link_func(successor_state, current_state); hash_table_insert(state_closed_set, successor_state, 0); list_push_front(state_queue, successor_state); list_pop(successor_list); } else { list_remove_front(successor_list); } } list_kill(successor_list); } } hash_table_kill(state_closed_set); list_dissolve(state_queue); return path; }
// NOTE: must be called with monitor lock. static void reschedule_root_alarm(void) { bool timer_was_set = timer_set; assert(alarms != NULL); // If used in a zeroed state, disarms the timer struct itimerspec wakeup_time; memset(&wakeup_time, 0, sizeof(wakeup_time)); if (list_is_empty(alarms)) goto done; alarm_t *next = list_front(alarms); int64_t next_expiration = next->deadline - now(); if (next_expiration < TIMER_INTERVAL_FOR_WAKELOCK_IN_MS) { if (!timer_set) { int status = bt_os_callouts->acquire_wake_lock(WAKE_LOCK_ID); if (status != BT_STATUS_SUCCESS) { LOG_ERROR("%s unable to acquire wake lock: %d", __func__, status); goto done; } } wakeup_time.it_value.tv_sec = (next->deadline / 1000); wakeup_time.it_value.tv_nsec = (next->deadline % 1000) * 1000000LL; } else { if (!bt_os_callouts->set_wake_alarm(next_expiration, true, timer_callback, NULL)) LOG_ERROR("%s unable to set wake alarm for %" PRId64 "ms.", __func__, next_expiration); } done: timer_set = wakeup_time.it_value.tv_sec != 0 || wakeup_time.it_value.tv_nsec != 0; if (timer_was_set && !timer_set) { bt_os_callouts->release_wake_lock(WAKE_LOCK_ID); } if (timer_settime(timer, TIMER_ABSTIME, &wakeup_time, NULL) == -1) LOG_ERROR("%s unable to set timer: %s", __func__, strerror(errno)); // If next expiration was in the past (e.g. short timer that got context switched) // then the timer might have diarmed itself. Detect this case and work around it // by manually signalling the |alarm_expired| semaphore. // // It is possible that the timer was actually super short (a few milliseconds) // and the timer expired normally before we called |timer_gettime|. Worst case, // |alarm_expired| is signaled twice for that alarm. Nothing bad should happen in // that case though since the callback dispatch function checks to make sure the // timer at the head of the list actually expired. if (timer_set) { struct itimerspec time_to_expire; timer_gettime(timer, &time_to_expire); if (time_to_expire.it_value.tv_sec == 0 && time_to_expire.it_value.tv_nsec == 0) { LOG_ERROR("%s alarm expiration too close for posix timers, switching to guns", __func__); semaphore_post(alarm_expired); } } }
List *list_push_front(List *l, void *data) { l = list_front(l); l->prev = (List *) malloc(sizeof(List)); l->prev->data = data; l->prev->next = l; l->prev->prev = 0; return l->prev; }
/** * Access queue front data. */ void* queue_front(const queue_t* cpque_queue) { assert(cpque_queue != NULL); #ifdef CSTL_QUEUE_LIST_SEQUENCE return list_front(&cpque_queue->_t_sequence); #else return deque_front(&cpque_queue->_t_sequence); #endif }
static void srunner_run_teardown (List *l) { Fixture *f; for (list_front(l); !list_at_end(l); list_advance(l)) { f = list_val(l); send_ctx_info(CK_CTX_TEARDOWN); f->fun (); } }
void headers( TARGET * t ) { LIST * hdrscan; LIST * hdrrule; #ifndef OPT_HEADER_CACHE_EXT LIST * headlist = L0; #endif regexp * re[ MAXINC ]; int rec = 0; LISTITER iter, end; hdrscan = var_get( root_module(), constant_HDRSCAN ); if ( list_empty( hdrscan ) ) return; hdrrule = var_get( root_module(), constant_HDRRULE ); if ( list_empty( hdrrule ) ) return; if ( DEBUG_HEADER ) printf( "header scan %s\n", object_str( t->name ) ); /* Compile all regular expressions in HDRSCAN */ iter = list_begin( hdrscan ), end = list_end( hdrscan ); for ( ; ( rec < MAXINC ) && iter != end; iter = list_next( iter ) ) { re[ rec++ ] = regex_compile( list_item( iter ) ); } /* Doctor up call to HDRRULE rule */ /* Call headers1() to get LIST of included files. */ { FRAME frame[1]; frame_init( frame ); lol_add( frame->args, list_new( object_copy( t->name ) ) ); #ifdef OPT_HEADER_CACHE_EXT lol_add( frame->args, hcache( t, rec, re, hdrscan ) ); #else lol_add( frame->args, headers1( headlist, t->boundname, rec, re ) ); #endif if ( lol_get( frame->args, 1 ) ) { /* The third argument to HDRRULE is the bound name of * $(<) */ lol_add( frame->args, list_new( object_copy( t->boundname ) ) ); list_free( evaluate_rule( list_front( hdrrule ), frame ) ); } /* Clean up. */ frame_free( frame ); } }
static void write_handler(nl_event_t *ev) { nl_socket_t *sock; nl_stream_t *s; nl_buf_t *buf; int rc; sock = ev->data; log_trace("#%d write_handler", sock->fd); s = sock->data; while (!list_empty(s->tosend)) { buf = (nl_buf_t *)list_front(s->tosend); rc = nl_send(sock, buf->buf, buf->len); if (rc >= 0) { if ((size_t)rc < buf->len) { /* accurate pending bytes */ buf->len -= rc; memmove(buf->buf, buf->buf + rc, buf->len); if (s->cbs.on_sent) { s->cbs.on_sent(s, rc); } } else { /* accurate pending bytes */ list_pop_front(s->tosend); if (s->cbs.on_sent) { s->cbs.on_sent(s, rc); } free(buf->buf); } } else { /* rc < 0 */ if (!sock->error) { return; } else { s->error = 1; if (s->closing_ev.timer_set) { nl_event_del_timer(&s->closing_ev); } nl_stream_close(s); return; } } } /* tosend is empty */ nl_event_del(&s->sock.wev); if (s->closing_ev.timer_set) { nl_event_del_timer(&s->closing_ev); nl_stream_close(s); } }
TEST_F(ListTest, test_list_front) { int x[] = { 1, 2, 3, 4, 5 }; list_t *list = list_new(NULL); for (size_t i = 0; i < ARRAY_SIZE(x); ++i) list_append(list, &x[i]); EXPECT_EQ(list_front(list), &x[0]); list_free(list); }
static void srunner_send_evt (SRunner *sr, void *obj, enum cl_event evt) { List *l; Log *lg; l = sr->loglst; for (list_front(l); !list_at_end(l); list_advance(l)) { lg = list_val(l); fflush(lg->lfile); lg->lfun (sr, lg->lfile, lg->mode, obj, evt); fflush(lg->lfile); } }
/** * Properly frees a server_t */ static void server_free(server_t* server) { /* force a cleanup of each client */ while (!list_empty(&server->client_list)) { list_node_t* node = list_front(&server->client_list); client_t* client = container_of(node, client_t, node); server_client_cleanup(server, client); } object_free(&server->client_list); free(server->buffer); }
static int cache_maxage( void ) { int age = 100; LIST * var = var_get( root_module(), constant_HCACHEMAXAGE ); if ( !list_empty( var ) ) { age = atoi( object_str( list_front( var ) ) ); if ( age < 0 ) age = 0; } return age; }
static void suite_free (Suite *s) { List *l; if (s == NULL) return; l = s->tclst; for (list_front(l); !list_at_end(l); list_advance (l)) { tcase_free (list_val(l)); } list_free (s->tclst); free(s); }
static void srunner_fprint_results (FILE *file, SRunner *sr, enum print_output print_mode) { List *resultlst; resultlst = sr->resultlst; for (list_front(resultlst); !list_at_end(resultlst); list_advance(resultlst)) { TestResult *tr = list_val(resultlst); tr_fprint (file, tr, print_mode); } return; }
struct bstree *parser_analisar_tokens(list **lista) { struct lnode *no = list_front(*lista); tokens = lista; if (list_isempty(*lista)) { err("Lista de tokens vazia: nada para analisar."); exit(1); } parser_montar_arvore(no); debug("\033[1mÁrvore dos lexemas montada.\033[0m"); return tree; }
/* push the next MAKE1C state after a command is run. */ static void push_cmds( CMDLIST * cmds, int status ) { CMDLIST * cmd_iter; for( cmd_iter = cmds; cmd_iter; cmd_iter = cmd_iter->next ) { if ( cmd_iter->iscmd ) { CMD * next_cmd = cmd_iter->impl.cmd; /* Propagate the command status. */ if ( next_cmd->status < status ) next_cmd->status = status; if ( --next_cmd->asynccnt == 0 ) { /* Select the first target associated with the action. * This is safe because sibling CMDs cannot have targets * in common. */ TARGET * first_target = bindtarget( list_front( lol_get( &next_cmd->args, 0 ) ) ); first_target->cmds = (char *)next_cmd; push_state( &state_stack, first_target, NULL, T_STATE_MAKE1C ); } else if ( DEBUG_EXECCMD ) { TARGET * first_target = bindtarget( list_front( lol_get( &next_cmd->args, 0 ) ) ); printf( "Delaying %s %s: %d targets not ready\n", object_str( next_cmd->rule->name ), object_str( first_target->boundname ), next_cmd->asynccnt ); } } else { /* This is a target that we're finished updating */ TARGET * updated_target = cmd_iter->impl.t; if ( updated_target->status < status ) updated_target->status = status; updated_target->cmds = NULL; push_state( &state_stack, updated_target, NULL, T_STATE_MAKE1C ); } } }
void *fixed_queue_dequeue(fixed_queue_t *queue) { assert(queue != NULL); semaphore_wait(queue->dequeue_sem); pthread_mutex_lock(&queue->lock); void *ret = list_front(queue->list); list_remove(queue->list, ret); pthread_mutex_unlock(&queue->lock); semaphore_post(queue->enqueue_sem); return ret; }
/* * Typically, called after grow(...) or shrink(...). * Relocates all hashtable items from source array to the new array * in the hashtable. */ static void rehash(struct hashtable* h, struct list** source_array, unsigned int source_size) { unsigned int i; struct list* chain; struct kv_pair* item; for (i = 0; i < source_size; ++i) { chain = source_array[i]; assert(chain != NULL); if (list_getsize(chain) > 0) { item = (struct kv_pair*)list_front(chain); while (item) { hashtable_add(h, item->key, item->keylen, item->val); list_pop_front(chain); free(item); item = (struct kv_pair*)list_front(chain); } assert(list_getsize(chain) == 0); } } }