/* Save more of the C stack away, up to 'target_stop'.
*/
static void g_clear_stack(struct stacklet_s *g_target,
struct stacklet_thread_s *thrd)
{
struct stacklet_s *current = thrd->g_stack_chain_head;
char *target_stop = g_target->stack_stop;
check_valid(g_target);
/* save and unlink stacklets that are completely within
the area to clear. */
while (current != NULL && current->stack_stop <= target_stop) {
struct stacklet_s *prev = current->stack_prev;
check_valid(current);
current->stack_prev = NULL;
if (current != g_target) {
/* don't bother saving away g_target, because
it would be immediately restored */
g_save(current, current->stack_stop
#ifdef DEBUG_DUMP
, 1
#endif
);
}
current = prev;
}
/* save a partial stack */
if (current != NULL && current->stack_start < target_stop)
g_save(current, target_stop
#ifdef DEBUG_DUMP
, 1
#endif
);
thrd->g_stack_chain_head = current;
}
static void shrink_test(void) {
gpr_log(GPR_INFO, "shrink_test");
grpc_timer_heap pq;
size_t i;
size_t expected_size;
/* A large random number to allow for multiple shrinkages, at least 512. */
const size_t num_elements = (size_t)rand() % 2000 + 512;
grpc_timer_heap_init(&pq);
/* Create a priority queue with many elements. Make sure the Size() is
correct. */
for (i = 0; i < num_elements; ++i) {
GPR_ASSERT(i == pq.timer_count);
grpc_timer_heap_add(&pq, create_test_elements(1));
}
GPR_ASSERT(num_elements == pq.timer_count);
/* Remove elements until the Size is 1/4 the original size. */
while (pq.timer_count > num_elements / 4) {
grpc_timer *const te = pq.timers[pq.timer_count - 1];
grpc_timer_heap_remove(&pq, te);
gpr_free(te);
}
GPR_ASSERT(num_elements / 4 == pq.timer_count);
/* Expect that Capacity is in the right range:
Size * 2 <= Capacity <= Size * 4 */
GPR_ASSERT(pq.timer_count * 2 <= pq.timer_capacity);
GPR_ASSERT(pq.timer_capacity <= pq.timer_count * 4);
check_valid(&pq);
/* Remove the rest of the elements. Check that the Capacity is not more than
4 times the Size and not less than 2 times, but never goes below 16. */
expected_size = pq.timer_count;
while (pq.timer_count > 0) {
const size_t which = (size_t)rand() % pq.timer_count;
grpc_timer *te = pq.timers[which];
grpc_timer_heap_remove(&pq, te);
gpr_free(te);
expected_size--;
GPR_ASSERT(expected_size == pq.timer_count);
GPR_ASSERT(pq.timer_count * 2 <= pq.timer_capacity);
if (pq.timer_count >= 8) {
GPR_ASSERT(pq.timer_capacity <= pq.timer_count * 4);
} else {
GPR_ASSERT(16 <= pq.timer_capacity);
}
check_valid(&pq);
}
GPR_ASSERT(0 == pq.timer_count);
GPR_ASSERT(pq.timer_capacity >= 16 && pq.timer_capacity < 32);
grpc_timer_heap_destroy(&pq);
}
static void test1(void) {
grpc_alarm_heap pq;
const int num_test_elements = 200;
const int num_test_operations = 10000;
int i;
grpc_alarm *test_elements = create_test_elements(num_test_elements);
gpr_uint8 *inpq = gpr_malloc(num_test_elements);
grpc_alarm_heap_init(&pq);
memset(inpq, 0, num_test_elements);
GPR_ASSERT(grpc_alarm_heap_is_empty(&pq));
check_valid(&pq);
for (i = 0; i < num_test_elements; ++i) {
GPR_ASSERT(!contains(&pq, &test_elements[i]));
grpc_alarm_heap_add(&pq, &test_elements[i]);
check_valid(&pq);
GPR_ASSERT(contains(&pq, &test_elements[i]));
inpq[i] = 1;
check_pq_top(test_elements, &pq, inpq, num_test_elements);
}
for (i = 0; i < num_test_elements; ++i) {
/* Test that check still succeeds even for element that wasn't just
inserted. */
GPR_ASSERT(contains(&pq, &test_elements[i]));
}
GPR_ASSERT(pq.alarm_count == num_test_elements);
check_pq_top(test_elements, &pq, inpq, num_test_elements);
for (i = 0; i < num_test_operations; ++i) {
int elem_num = rand() % num_test_elements;
grpc_alarm *el = &test_elements[elem_num];
if (!inpq[elem_num]) { /* not in pq */
GPR_ASSERT(!contains(&pq, el));
el->deadline = random_deadline();
grpc_alarm_heap_add(&pq, el);
GPR_ASSERT(contains(&pq, el));
inpq[elem_num] = 1;
check_pq_top(test_elements, &pq, inpq, num_test_elements);
check_valid(&pq);
} else {
GPR_ASSERT(contains(&pq, el));
grpc_alarm_heap_remove(&pq, el);
GPR_ASSERT(!contains(&pq, el));
inpq[elem_num] = 0;
check_pq_top(test_elements, &pq, inpq, num_test_elements);
check_valid(&pq);
}
}
grpc_alarm_heap_destroy(&pq);
gpr_free(test_elements);
gpr_free(inpq);
}
bool check_valid(TreeNode* root, long long min_val,
long long max_val) {
if (!root) {
return true;
}
if (root->val <= min_val || root->val >= max_val) {
return false;
}
return check_valid(root->left, min_val, root->val) &&
check_valid(root->right, root->val, max_val);
}
int solve(t_pos *pos) {
if (check_valid(pos)) {
return solve_step(pos);
} else {
return IMPOSSIBLE;
}
}
void dake::gl::shader::load(const char *file)
{
check_valid();
FILE *fp = fopen(dake::gl::find_resource_filename(file).c_str(), "rb");
if (!fp) {
throw std::invalid_argument("Could not open the given shader file");
}
name = std::string(file);
fseek(fp, 0, SEEK_END);
size_t len = ftell(fp);
rewind(fp);
char *src = new char[len + 1];
if (fread(src, 1, len, fp) < len) {
const char *err = strerror(errno);
fclose(fp);
delete[] src;
throw std::runtime_error("Failed to read shader code from " + name
+ ": " + err);
}
src[len] = 0;
fclose(fp);
glShaderSource(id, 1, const_cast<const GLchar **>(&src), nullptr);
delete[] src;
}
bool dake::gl::program::link(void)
{
check_valid();
glLinkProgram(id);
GLint status;
glGetProgramiv(id, GL_LINK_STATUS, &status);
if (status == GL_TRUE) {
linked = true;
return true;
}
GLint illen;
glGetProgramiv(id, GL_INFO_LOG_LENGTH, &illen);
if (illen <= 1) {
throw std::runtime_error("Error linking shaders " + name + " to program: Reason unknown");
} else {
char *msg = new char[illen + 1];
glGetProgramInfoLog(id, illen, nullptr, msg);
msg[illen] = 0;
std::string msg_str(msg);
delete[] msg;
throw std::runtime_error("Error linking shaders " + name + " to program: " + msg_str);
}
}
bool dake::gl::shader::compile(void)
{
check_valid();
glCompileShader(id);
GLint status;
glGetShaderiv(id, GL_COMPILE_STATUS, &status);
if (status == GL_TRUE) {
compiled = true;
return true;
}
GLint illen;
glGetShaderiv(id, GL_INFO_LOG_LENGTH, &illen);
if (illen <= 1) {
throw std::runtime_error("Error compiling " + std::string(shader_type_string(t)) + " shader " + name + ": Reason unknown");
} else {
char *msg = new char[illen + 1];
glGetShaderInfoLog(id, illen, nullptr, msg);
msg[illen] = 0;
std::string msg_str(msg);
delete[] msg;
throw std::runtime_error("Error compiling " + std::string(shader_type_string(t)) + " shader " + name + ": " + msg_str);
}
return false;
}
int sudoki_bi()
{
char ***tab;
t_list *list;
t_present *present;
int i;
if ((tab = get_all_tab()) == NULL)
return (-1);
i = -1;
while (++i < my_tablen(tab))
{
if ((present = get_present(tab[i])) == NULL ||
(list = get_list(tab[i])) == NULL)
return (-1);
filler(tab[i], list, present);
if (check_valid(tab[i]) == 1)
error_aff_tab();
else
aff_table(tab[i]);
if (i < (my_tablen(tab) - 1))
write(1, "####################\n", 21);
free_function_bis(list, present);
}
free_function(tab);
return (0);
}
bool class_source_parser::parse_tag(){
while (!f_.eof()){
std::string line;
if (! getline(line) ) { return false; }
if (check_valid(line)) {
if (check_tag_begin(line)){
parse_tag();
}
if (check_tag_end(line)){
return true;
}
if (check_keys_begin(line)){
parse_keys();
}
if (check_allow_link(line)){
continue;
}
if (check_allow_global(line)){
continue;
}
if (check_remove_key(line)){
}
}else{
if (!current_.empty()){
// adding error messages for each unclosed entity
add_open_tag_error();
close_opened_tags();
}
return true;
}
}
return true;
}
bool class_source_parser::parse_block(){
while (!f_.eof()){
std::string line;
if (! getline(line) ) { return false; }
if ( check_valid(line)) {
if (check_allow_type(line)) continue;
if (check_remove_type(line)) continue;
if (check_parent_begin(line)) continue;
if (check_tag_begin(line)){
parse_tag();
continue;
}
check_parent_end(line);
}
else{
// wiki-block is closed. checking stack of opened tags
if (!current_.empty()){
add_open_tag_error();
close_opened_tags();
// continue working
}
// block is closed and all tags are closed.
return true;
}
}// end while
return false;
}
void updatePosition(world_description_t *aWorld, int theAction){
/* When the move would result in hitting an obstacles, the agent simply doesn't move */
int newRow = aWorld->agentRow;
int newCol = aWorld->agentCol;
if (theAction == 0){/*move down*/
newCol = aWorld->agentCol - 1;
}
if (theAction == 1){ /*move up*/
newCol = aWorld->agentCol + 1;
}
if (theAction == 2){/*move left*/
newRow = aWorld->agentRow - 1;
}
if (theAction == 3){/*move right*/
newRow = aWorld->agentRow + 1;
}
/*Check if new position is out of bounds or inside an obstacle */
if(check_valid(aWorld,newRow,newCol)){
aWorld->agentRow = newRow;
aWorld->agentCol = newCol;
}
}
static void test_specific(PeriodType pt, guint16 mult,
GDateMonth sm, GDateDay sd, GDateYear sy,
GDateMonth rm, GDateDay rd, GDateYear ry,
GDateMonth nm, GDateDay nd, GDateYear ny)
{
GDate start;
GDate ref, next, true_next;
Recurrence r;
g_date_set_dmy(&start, sd, sm, sy);
g_date_set_dmy(&ref, rd, rm, ry);
g_date_set_dmy(&true_next, nd, nm, ny);
recurrenceSet(&r, mult, pt, &start, WEEKEND_ADJ_NONE);
recurrenceNextInstance(&r, &ref, &next);
check_valid(&next, &ref, &start, mult, pt, WEEKEND_ADJ_NONE);
if (!test_equal(&next, &true_next))
{
gchar s1[21], s2[21], s3[21];
g_date_strftime(s1, 20, "%x", &start);
g_date_strftime(s2, 20, "%x", &ref);
g_date_strftime(s3, 20, "%x", &true_next);
printf("pt = %d; mult = %d; start = %s; ref = %s; true_next = %s\n",
pt, mult, s1, s2, s3);
}
}
/* This function only gets called when the process is running as a
* server and must handle connections from multiple clients. You have
* to look up the rel_t structure based on the address in the
* sockaddr_storage passed in. If this is a new connection (sequence
* number 1), you will need to allocate a new conn_t using rel_create
* (). (Pass rel_create NULL for the conn_t, so it will know to
* allocate a new connection.)
*/
void
rel_demux (const struct config_common *cc,
const struct sockaddr_storage *ss,
packet_t *pkt, size_t len)
{
if (!check_valid(pkt, len)) return;
rel_t * r = rel_list;
while (r) {
if (r->ss && addreq(ss, r->ss)) {
break;
}
r = r->next;
}
if (!r) {
if (ntohl(pkt->seqno) == 1) {
r = rel_create(NULL, ss, cc);
} else {
return;
}
}
rel_recvpkt(r, pkt, len);
}
config::const_attr_itors config::attribute_range() const
{
check_valid();
return const_attr_itors(const_attribute_iterator(values.begin()),
const_attribute_iterator(values.end()));
}
STATIC_NOINLINE
void g_initialstub(struct stacklet_thread_s *thrd,
stacklet_run_fn run, void *run_arg)
{
struct stacklet_s *result;
/* The following call returns twice! */
result = (struct stacklet_s *) _stacklet_switchstack(g_initial_save_state,
g_restore_state,
thrd);
if (result == NULL && thrd->g_source != NULL) {
/* First time it returns. Only g_initial_save_state() has run
and has created 'g_source'. Call run(). */
thrd->g_current_stack_stop = thrd->g_current_stack_marker;
result = run(thrd->g_source, run_arg);
/* Then switch to 'result'. */
check_valid(result);
thrd->g_target = result;
_stacklet_switchstack(g_destroy_state, g_restore_state, thrd);
_check_failed("we should not return here");
abort();
}
/* The second time it returns. */
}
int my_getnbr(const char *str)
{
char sign;
unsigned int i;
int length;
int result;
unsigned char overflow;
sign = '+';
i = 0;
length = my_strlen(str);
result = 0;
overflow = 0;
while (i < length && check_valid(str[i]) && !overflow)
{
if (str[i] == '+' || str[i] == '-')
{
add_sign(&sign, str[i]);
}
else
{
overflow = update_result(&result, str[i], sign);
}
i = i + 1;
}
return (result);
}
bool config::matches(const config &filter) const
{
check_valid(filter);
for (const attribute &i : filter.attribute_range())
{
const attribute_value *v = get(i.first);
if (!v || *v != i.second) return false;
}
for (const any_child &i : filter.all_children_range())
{
if (i.key == "not") {
if (matches(i.cfg)) return false;
continue;
}
bool found = false;
for (const config &j : child_range(i.key)) {
if (j.matches(i.cfg)) {
found = true;
break;
}
}
if(!found) return false;
}
return true;
}
config &config::add_child_at(const std::string &key, const config &val, unsigned index)
{
check_valid(val);
child_list& v = children[key];
if(index > v.size()) {
throw error("illegal index to add child at");
}
v.insert(v.begin()+index,new config(val));
bool inserted = false;
const child_pos value(children.find(key),index);
std::vector<child_pos>::iterator ord = ordered_children.begin();
for(; ord != ordered_children.end(); ++ord) {
if (ord->pos != value.pos) continue;
if (!inserted && ord->index == index) {
ord = ordered_children.insert(ord,value);
inserted = true;
} else if (ord->index >= index) {
ord->index++;
}
}
if(!inserted) {
ordered_children.push_back(value);
}
return *v[index];
}
void config::append_attributes(const config &cfg)
{
check_valid(cfg);
for (const attribute &v : cfg.values) {
values[v.first] = v.second;
}
}
config &config::find_child(const std::string &key, const std::string &name,
const std::string &value)
{
check_valid();
const child_map::iterator i = children.find(key);
if(i == children.end()) {
DBG_CF << "Key »" << name << "« value »" << value
<< "« pair not found as child of key »" << key << "«.\n";
return invalid;
}
const child_list::iterator j = std::find_if(i->second.begin(),
i->second.end(),
config_has_value(name,value));
if(j != i->second.end()) {
return **j;
} else {
DBG_CF << "Key »" << name << "« value »" << value
<< "« pair not found as child of key »" << key << "«.\n";
return invalid;
}
}
void get_neighbors(const int idx,
const int imgHeight, const int imgWidth,
int *p_neighbors, int *pnum_neighbors)
{
int pn_idx;
int nb_row_idx, nb_col_idx;
int row_idx, col_idx;
pixel2idx(idx, imgHeight, &row_idx, &col_idx);
(*pnum_neighbors) = 0;
int row_delta, col_delta;
for(row_delta =-1; row_delta<=1; row_delta++)
{
for(col_delta=-1; col_delta<=1; col_delta++)
{
nb_row_idx = row_idx+row_delta;
nb_col_idx = col_idx+col_delta;
if(check_valid(nb_row_idx, nb_col_idx,
row_idx, col_idx,
imgHeight, imgWidth))
{
idx2pixel(nb_row_idx, nb_col_idx, imgHeight, &pn_idx);
p_neighbors[(*pnum_neighbors)] = pn_idx;
(*pnum_neighbors)++;
}
}
}
}
void config::append_children(const config &cfg)
{
check_valid(cfg);
BOOST_FOREACH(const any_child &value, cfg.all_children_range()) {
add_child(value.key, value.cfg);
}
}
void config::append_children(const config &cfg, const std::string& key)
{
check_valid(cfg);
BOOST_FOREACH(const config &value, cfg.child_range(key)) {
add_child(key, value);
}
}
void config::append_children(const config &cfg, const std::string& key)
{
check_valid(cfg);
for (const config &value : cfg.child_range(key)) {
add_child(key, value);
}
}
void config::append_children(const config &cfg)
{
check_valid(cfg);
for (const any_child &value : cfg.all_children_range()) {
add_child(value.key, value.cfg);
}
}
void config::swap(config& cfg)
{
check_valid(cfg);
values.swap(cfg.values);
children.swap(cfg.children);
ordered_children.swap(cfg.ordered_children);
}
std::string config::debug() const
{
check_valid();
std::ostringstream outstream;
outstream << *this;
return outstream.str();
}
config config::get_diff(const config& c) const
{
check_valid(c);
config res;
get_diff(c, res);
return res;
}
void dake::gl::shader::source(const char *src)
{
check_valid();
name = "unknown";
glShaderSource(id, 1, const_cast<const GLchar **>(&src), nullptr);
}
