void point_and_line(t_env e, size_t x, size_t y) { ft_pixel_put(e, e.map[y][x].z, e.map[y][x].x, e.map[y][x].y); if (x != e.x - 1) if (is_map(e, x, y) || is_map(e, x + 1, y)) draw_segment(e, e.map[y][x], e.map[y][x + 1]); if (y != e.y - 1) if (is_map(e, x, y) || is_map(e, x, y + 1)) draw_segment(e, e.map[y][x], e.map[y + 1][x]); }
void test_main(void) { is(countof(hist_in), countof(fwd_map), "countof(hist_in) == countof(fwd_map)"); is(countof(hist_in), countof(rev_map), "countof(hist_in) == countof(rev_map)"); double map[countof(hist_in)]; hist_map(hist_in, countof(hist_in), map); is_map(map, fwd_map, countof(fwd_map), "fwd_map"); double imap[countof(hist_in)]; hist_inverse(map, imap, countof(hist_in)); is_map(imap, rev_map, countof(rev_map), "rev_map"); }
PyObject * next() { auto obj = read_next(); if( is_array( obj ) ) { if( obj.as.array_size ) { push_list( obj.as.array_size ); return nullptr; } return PyList_New( 0 ); } if( is_map( obj ) ) { if( obj.as.map_size ) { push_dict( obj.as.map_size ); return nullptr; } return PyDict_New(); } return read_simple( obj ); }
static BIF_RETTYPE persistent_term_info_trap(BIF_ALIST_1) { TrapData* trap_data = (TrapData *) BIF_ARG_1; Eterm res; Uint bump_reds; Binary* mbp; mbp = erts_magic_ref2bin(BIF_ARG_1); trap_data = ERTS_MAGIC_BIN_DATA(mbp); bump_reds = trap_data->remaining; res = do_info(BIF_P, trap_data); if (trap_data->remaining > 0) { ASSERT(res == am_ok); BUMP_ALL_REDS(BIF_P); BIF_TRAP1(&persistent_term_info_export, BIF_P, BIF_ARG_1); } else { /* * Decrement ref count (and possibly delete the hash table * and associated literal area). */ dec_table_refc(BIF_P, trap_data->table); trap_data->table = NULL; /* Prevent refc decrement */ BUMP_REDS(BIF_P, bump_reds); ASSERT(is_map(res)); BIF_RET(res); } }
/** * @brief Registers a timer into a context (table or a userdata). * @param timer A timer. * @param context_index Index of the table or userdata in the stack. * @param callback_index Index of the function to call when the timer finishes. */ void LuaContext::add_timer(Timer* timer, int context_index, int callback_index) { const void* context; if (lua_type(l, context_index) == LUA_TUSERDATA) { ExportableToLua** userdata = static_cast<ExportableToLua**>( lua_touserdata(l, context_index)); context = *userdata; } else { context = lua_topointer(l, context_index); } lua_pushvalue(l, callback_index); int callback_ref = create_ref(); timers[timer].callback_ref = callback_ref; timers[timer].context = context; Game* game = main_loop.get_game(); if (game != NULL) { // We are during a game: depending on the timer's context, // when the map is suspended, also suspend the timer or not. if (is_map(l, context_index) || is_entity(l, context_index) || is_item(l, context_index)) { timer->set_suspended_with_map(true); } } timer->increment_refcount(); }
BIF_RETTYPE is_map_1(BIF_ALIST_1) { if (is_map(BIF_ARG_1)) { BIF_RET(am_true); } BIF_RET(am_false); }
char* vec_char (vec_t *vec) { ensure_vec(vec, __func__); int count = vec->count; push(strf("[")); for (int i = 0; i < count; i++) { if (is_vec(vec_get(vec, i)[0])) push(strf("vec[]")); else if (is_map(vec_get(vec, i)[0])) push(strf("map[]")); else push(to_char(vec_get(vec, i)[0])); op_concat(); if (i < count-1) { push(strf(", ")); op_concat(); } } push(strf("]")); op_concat(); return pop(); }
static struct ovs_if *parse_iface(json_t *jresult, json_t *uuid) { struct ovs_if *iface; json_t *jif, *jarr; unsigned int i; if (!is_uuid(uuid)) return NULL; jif = json_object_get(jresult, "Interface"); jif = json_object_get(jif, json_string_value(json_array_get(uuid, 1))); jif = json_object_get(jif, "new"); iface = calloc(sizeof(*iface), 1); if (!iface) return NULL; iface->name = strdup(json_string_value(json_object_get(jif, "name"))); iface->type = strdup(json_string_value(json_object_get(jif, "type"))); jarr = json_object_get(jif, "options"); if (!strcmp(iface->type, "vxlan") && is_map(jarr)) { jarr = json_array_get(jarr, 1); for (i = 0; i < json_array_size(jarr); i++) { json_t *jkv; const char *key, *val; jkv = json_array_get(jarr, i); key = json_string_value(json_array_get(jkv, 0)); val = json_string_value(json_array_get(jkv, 1)); if (!strcmp(key, "local_ip")) iface->local_ip = strdup(val); else if (!strcmp(key, "remote_ip")) iface->remote_ip = strdup(val); } } else if (!strcmp(iface->type, "patch") && is_map(jarr)) { jarr = json_array_get(jarr, 1); for (i = 0; i < json_array_size(jarr); i++) { json_t *jkv; const char *key, *val; jkv = json_array_get(jarr, i); key = json_string_value(json_array_get(jkv, 0)); val = json_string_value(json_array_get(jkv, 1)); if (!strcmp(key, "peer")) iface->peer = strdup(val); } } return iface; }
/** * @brief Registers a timer into a context (table or a userdata). * @param timer A timer. * @param context_index Index of the table or userdata in the stack. * @param callback_index Index of the function to call when the timer finishes. */ void LuaContext::add_timer(Timer* timer, int context_index, int callback_index) { const void* context; if (lua_type(l, context_index) == LUA_TUSERDATA) { ExportableToLua** userdata = static_cast<ExportableToLua**>( lua_touserdata(l, context_index)); context = *userdata; } else { context = lua_topointer(l, context_index); } lua_pushvalue(l, callback_index); int callback_ref = create_ref(); #ifndef NDEBUG // Sanity check: check the uniqueness of the ref. std::map<Timer*, LuaTimerData>::iterator it; for (it = timers.begin(); it != timers.end(); ++it) { if (it->second.callback_ref == callback_ref) { Debug::die(StringConcat() << "Callback ref " << callback_ref << " is already used by a timer (duplicate luaL_unref?)"); } } #endif Debug::check_assertion(timers.find(timer) == timers.end(), "Duplicate timer in the system"); timers[timer].callback_ref = callback_ref; timers[timer].context = context; Game* game = main_loop.get_game(); if (game != NULL) { // We are during a game: depending on the timer's context, // suspend the timer or not. if (is_map(l, context_index) || is_entity(l, context_index) || is_item(l, context_index)) { // By default, we want the timer to be automatically suspended when a // camera movement, a dialog or the pause menu starts. timer->set_suspended_with_map(true); // But in the initial state, we override that rule. // We initially suspend the timer only during a dialog. // In particular, we don't want to suspend timers created during a // camera movement. // This would be very painful for users. bool initially_suspended = game->is_dialog_enabled(); timer->set_suspended(initially_suspended); } } timer->increment_refcount(); }
void theory_array_full::add_parent_map(theory_var v, enode* s) { if (m_params.m_array_cg && !s->is_cgr()) { return; } SASSERT(v != null_theory_var); SASSERT(is_map(s)); v = find(v); var_data * d = m_var_data[v]; var_data_full * d_full = m_var_data_full[v]; d_full->m_parent_maps.push_back(s); m_trail_stack.push(push_back_trail<theory_array, enode *, false>(d_full->m_parent_maps)); if (!m_params.m_array_weak && !m_params.m_array_delay_exp_axiom && d->m_prop_upward) { ptr_vector<enode>::iterator it = d->m_parent_selects.begin(); ptr_vector<enode>::iterator end = d->m_parent_selects.end(); for (; it != end; ++it) { if (!m_params.m_array_cg || (*it)->is_cgr()) { instantiate_select_map_axiom(*it, s); } } } }
bool Type::compatible(const Type& type) const { if (_types.size() == 0 or type._types.size() == 0) { return true; } if (is_any()) { return true; } if (this->is_primitive() && type.is_polymorphic()) { return false; } if (this->temporary and not type.temporary) { return false; // type not compatible with type&& } if (not this->constant and type.constant) { return false; // 'const type' not compatible with 'type' } if ((is_array() && type.is_array()) || (is_set() && type.is_set()) || (is_map() && type.is_map()) || (is_function() && type.is_function())) { return _types[0]->compatible(type._types[0].get()); } if (_types[0] != type._types[0]) { // 'Integer' is compatible with 'Float' if (this->is_real() and type.is_integer()) { return true; } // 'Boolean' is compatible with 'Integer' if (this->is_integer() and type.is_bool()) { return true; } // 'Integer' is compatible with 'Long' if (this->is_long() and type.is_integer()) { return true; } // All numbers types are compatible with the base 'Number' type if (dynamic_cast<const Number_type*>(_types[0].get()) and (type.is_integer() or type.is_long() or type.is_real())) { return true; } return false; } return true; }
void theory_array_full::add_map(theory_var v, enode* s) { if (m_params.m_array_cg && !s->is_cgr()) { return; } SASSERT(is_map(s)); v = find(v); var_data_full * d_full = m_var_data_full[v]; var_data * d = m_var_data[v]; // // TODO: defaulting to exhaustive up-propagation. // instead apply stratified filter. set_prop_upward(v,d); d_full->m_maps.push_back(s); m_trail_stack.push(push_back_trail<theory_array, enode *, false>(d_full->m_maps)); ptr_vector<enode>::iterator it = d->m_parent_selects.begin(); ptr_vector<enode>::iterator end = d->m_parent_selects.end(); for (; it != end; ++it) { SASSERT(is_select(*it)); instantiate_select_map_axiom(*it, s); } set_prop_upward(s); }
/** * \brief Registers a timer into a context (table or a userdata). * \param timer A timer. * \param context_index Index of the table or userdata in the stack. * \param callback_ref Lua ref to the function to call when the timer finishes. */ void LuaContext::add_timer( const TimerPtr& timer, int context_index, const ScopedLuaRef& callback_ref ) { const void* context; if (lua_type(l, context_index) == LUA_TUSERDATA) { ExportableToLuaPtr* userdata = static_cast<ExportableToLuaPtr*>( lua_touserdata(l, context_index) ); context = userdata->get(); } else { context = lua_topointer(l, context_index); } callback_ref.push(); #ifndef NDEBUG // Sanity check: check the uniqueness of the ref. for (const auto& kvp: timers) { if (kvp.second.callback_ref.get() == callback_ref.get()) { std::ostringstream oss; oss << "Callback ref " << callback_ref.get() << " is already used by a timer (duplicate luaL_unref?)"; Debug::die(oss.str()); } } #endif Debug::check_assertion(timers.find(timer) == timers.end(), "Duplicate timer in the system"); timers[timer].callback_ref = callback_ref; timers[timer].context = context; Game* game = main_loop.get_game(); if (game != nullptr) { // We are during a game: depending on the timer's context, // suspend the timer or not. if (is_map(l, context_index) || is_entity(l, context_index) || is_item(l, context_index)) { bool initially_suspended = false; // By default, we want the timer to be automatically suspended when a // camera movement, a dialog or the pause menu starts. if (!is_entity(l, context_index)) { // The timer normally gets suspended/resumed with the map. timer->set_suspended_with_map(true); // But in the initial state, we override that rule. // We initially suspend the timer only during a dialog. // In particular, we don't want to suspend timers created during a // camera movement. // This would be very painful for users. initially_suspended = game->is_dialog_enabled(); } else { // Entities are more complex: they also get suspended when disabled // and when far from the camera. Therefore, they don't simply follow // the map suspended state. EntityPtr entity = check_entity(l, context_index); initially_suspended = entity->is_suspended() || !entity->is_enabled(); } timer->set_suspended(initially_suspended); } } }
/** * \brief Registers a timer into a context (table or a userdata). * \param timer A timer. * \param context_index Index of the table or userdata in the stack. * \param callback_index Index of the function to call when the timer finishes. */ void LuaContext::add_timer(Timer* timer, int context_index, int callback_index) { const void* context; if (lua_type(l, context_index) == LUA_TUSERDATA) { ExportableToLua** userdata = static_cast<ExportableToLua**>( lua_touserdata(l, context_index)); context = *userdata; } else { context = lua_topointer(l, context_index); } lua_pushvalue(l, callback_index); int callback_ref = create_ref(); #ifndef NDEBUG // Sanity check: check the uniqueness of the ref. std::map<Timer*, LuaTimerData>::iterator it; for (it = timers.begin(); it != timers.end(); ++it) { if (it->second.callback_ref == callback_ref) { std::ostringstream oss; oss << "Callback ref " << callback_ref << " is already used by a timer (duplicate luaL_unref?)"; Debug::die(oss.str()); } } #endif Debug::check_assertion(timers.find(timer) == timers.end(), "Duplicate timer in the system"); timers[timer].callback_ref = callback_ref; timers[timer].context = context; Game* game = main_loop.get_game(); if (game != NULL) { // We are during a game: depending on the timer's context, // suspend the timer or not. if (is_map(l, context_index) || is_entity(l, context_index) || is_item(l, context_index)) { bool initially_suspended = false; // By default, we want the timer to be automatically suspended when a // camera movement, a dialog or the pause menu starts. if (!is_entity(l, context_index)) { // The timer normally get suspended/unsuspend with the map. timer->set_suspended_with_map(true); // But in the initial state, we override that rule. // We initially suspend the timer only during a dialog. // In particular, we don't want to suspend timers created during a // camera movement. // This would be very painful for users. initially_suspended = game->is_dialog_enabled(); } else { // Entities are more complex: they also get suspended when disabled // and when far from the camera. Therefore, they don't simply follow // the map suspended state. const MapEntity& entity = check_entity(l, context_index); initially_suspended = entity.is_suspended() || !entity.is_enabled(); } timer->set_suspended(initially_suspended); } } RefCountable::ref(timer); }
/// is var a collection type? bool is_collection() const { return is_vector() || is_map(); }