/* :nodoc: */
VALUE
rb_mod_init_copy(VALUE clone, VALUE orig)
{
rb_obj_init_copy(clone, orig);
if (!FL_TEST(CLASS_OF(clone), FL_SINGLETON)) {
RBASIC(clone)->klass = rb_singleton_class_clone(orig);
}
RCLASS_SUPER(clone) = RCLASS_SUPER(orig);
if (RCLASS_IV_TBL(orig)) {
ID id;
RCLASS_IV_TBL(clone) = st_copy(RCLASS_IV_TBL(orig));
CONST_ID(id, "__classpath__");
st_delete(RCLASS_IV_TBL(clone), (st_data_t*)&id, 0);
CONST_ID(id, "__classid__");
st_delete(RCLASS_IV_TBL(clone), (st_data_t*)&id, 0);
}
if (RCLASS_M_TBL(orig)) {
struct clone_method_data data;
data.tbl = RCLASS_M_TBL(clone) = st_init_numtable();
data.klass = clone;
st_foreach(RCLASS_M_TBL(orig), clone_method,
(st_data_t)&data);
}
return clone;
}
int main(void)
{
size_t max = 100;
size_t n = 20;
char buf[strsiz];
size_t i;
st_t st = st_init(max);
for (i = 0; i < n; i++) {
item_t t = newitem(randkey(), randstr(buf, strsiz));
st_insert(st, t);
}
st_sort(st, print);
printf("\nThe item with key 11 is: ");
print(st_search(st, 11));
printf("\nThe 4th smallest key is: ");
print(st_select(st, 4));
st_delete(st, st_search(st, 11));
printf("\n delete the item with key 11.\n");
st_sort(st, print);
/* delete all item */
while (!st_empty(st)) {
item_t x = st_select(st, 0);
printf("delete item: ");
print(x);
st_delete(st, st_select(st, 0));
}
st_finalize(&st);
return 0;
}
int osm_db_delete(IN osm_db_domain_t * p_domain, IN char *const p_key)
{
osm_log_t *p_log = p_domain->p_db->p_log;
osm_db_domain_imp_t *p_domain_imp =
(osm_db_domain_imp_t *) p_domain->p_domain_imp;
char *p_prev_val = NULL;
int res;
OSM_LOG_ENTER(p_log);
cl_spinlock_acquire(&p_domain_imp->lock);
if (st_delete(p_domain_imp->p_hash,
(void *) & p_key, (void *) & p_prev_val)) {
if (st_lookup(p_domain_imp->p_hash,
(st_data_t) p_key, (void *) & p_prev_val)) {
OSM_LOG(p_log, OSM_LOG_ERROR,
"key:%s still exists in:%s with value:%s\n",
p_key, p_domain_imp->file_name, p_prev_val);
res = 1;
} else {
free(p_key);
free(p_prev_val);
res = 0;
}
} else {
OSM_LOG(p_log, OSM_LOG_DEBUG,
"fail to find key:%s. delete failed\n", p_key);
res = 1;
}
cl_spinlock_release(&p_domain_imp->lock);
OSM_LOG_EXIT(p_log);
return res;
}
static void
remove_method(VALUE klass, ID mid)
{
st_data_t key, data;
rb_method_entry_t *me = 0;
if (klass == rb_cObject) {
rb_secure(4);
}
if (rb_safe_level() >= 4 && !OBJ_UNTRUSTED(klass)) {
rb_raise(rb_eSecurityError, "Insecure: can't remove method");
}
rb_check_frozen(klass);
if (mid == object_id || mid == id__send__ || mid == idInitialize) {
rb_warn("removing `%s' may cause serious problems", rb_id2name(mid));
}
if (!st_lookup(RCLASS_M_TBL(klass), mid, &data) ||
!(me = (rb_method_entry_t *)data) ||
(!me->def || me->def->type == VM_METHOD_TYPE_UNDEF)) {
rb_name_error(mid, "method `%s' not defined in %s",
rb_id2name(mid), rb_class2name(klass));
}
key = (st_data_t)mid;
st_delete(RCLASS_M_TBL(klass), &key, &data);
rb_vm_check_redefinition_opt_method(me, klass);
rb_clear_cache_for_undef(klass, mid);
rb_unlink_method_entry(me);
CALL_METHOD_HOOK(klass, removed, mid);
}
sbool_t sm_i_delete(sm_t *m, const sint_t k)
{
struct SMapIx ix;
struct SMapii ii;
struct SMapuu uu;
const stn_t *n;
stn_callback_t callback = NULL;
switch (m->f.type) {
case SM_I32I32:
RETURN_IF(k > SINT32_MAX || k < SINT32_MIN, S_FALSE);
ii.k = (sint32_t)k;
n = (const stn_t *)ⅈ
break;
case SM_U32U32:
RETURN_IF(k > SUINT32_MAX, S_FALSE);
uu.k = (suint32_t)k;
n = (const stn_t *)&uu;
break;
case SM_IntStr:
callback = aux_is_delete;
/* don't break */
case SM_IntInt: case SM_IntPtr:
ix.k = k;
n = (const stn_t *)&ix;
break;
default:
return S_FALSE;
}
return st_delete(m, n, callback);
}
static VALUE
find_class_path(VALUE klass)
{
struct fc_result arg;
arg.name = 0;
arg.path = 0;
arg.klass = klass;
arg.track = rb_cObject;
arg.prev = 0;
if (RCLASS_CONST_TBL(rb_cObject)) {
st_foreach_safe(RCLASS_CONST_TBL(rb_cObject), fc_i, (st_data_t)&arg);
}
if (arg.path == 0) {
st_foreach_safe(rb_class_tbl, fc_i, (st_data_t)&arg);
}
if (arg.path) {
st_data_t tmp = tmp_classpath;
if (!RCLASS_IV_TBL(klass)) {
RCLASS_IV_TBL(klass) = st_init_numtable();
}
st_insert(RCLASS_IV_TBL(klass), (st_data_t)classpath, arg.path);
st_delete(RCLASS_IV_TBL(klass), &tmp, 0);
return arg.path;
}
return Qnil;
}
static void
remove_method(VALUE klass, ID mid)
{
st_data_t key, data;
rb_method_entry_t *me = 0;
VALUE self = klass;
klass = RCLASS_ORIGIN(klass);
rb_frozen_class_p(klass);
if (mid == object_id || mid == id__send__ || mid == idInitialize) {
rb_warn("removing `%s' may cause serious problems", rb_id2name(mid));
}
if (!st_lookup(RCLASS_M_TBL(klass), mid, &data) ||
!(me = (rb_method_entry_t *)data) ||
(!me->def || me->def->type == VM_METHOD_TYPE_UNDEF) ||
UNDEFINED_REFINED_METHOD_P(me->def)) {
rb_name_error(mid, "method `%"PRIsVALUE"' not defined in %"PRIsVALUE,
rb_id2str(mid), rb_class_path(klass));
}
key = (st_data_t)mid;
st_delete(RCLASS_M_TBL(klass), &key, &data);
rb_vm_check_redefinition_opt_method(me, klass);
rb_clear_method_cache_by_class(klass);
rb_unlink_method_entry(me);
if (me->def->type == VM_METHOD_TYPE_REFINED) {
rb_add_refined_method_entry(klass, mid);
}
CALL_METHOD_HOOK(self, removed, mid);
}
static const rb_transcoder *
transcode_dispatch(const char* from_encoding, const char* to_encoding)
{
char *const key = transcoder_key(from_encoding, to_encoding);
st_data_t k, val = 0;
while (!st_lookup(transcoder_table, (k = (st_data_t)key), &val) &&
st_delete(transcoder_lib_table, &k, &val)) {
const char *const lib = (const char *)val;
int len = strlen(lib);
char path[sizeof(transcoder_lib_prefix) + MAX_TRANSCODER_LIBNAME_LEN];
xfree((char *)k);
if (len > MAX_TRANSCODER_LIBNAME_LEN) return NULL;
memcpy(path, transcoder_lib_prefix, sizeof(transcoder_lib_prefix) - 1);
memcpy(path + sizeof(transcoder_lib_prefix) - 1, lib, len + 1);
if (!rb_require(path)) return NULL;
}
if (!val) {
if (!st_lookup(transcoder_table, (st_data_t)key, &val)) {
/* multistep logic, via UTF-8 */
if (!encoding_equal(from_encoding, "UTF-8") &&
!encoding_equal(to_encoding, "UTF-8") &&
transcode_dispatch("UTF-8", to_encoding)) { /* check that we have a second step */
return transcode_dispatch(from_encoding, "UTF-8"); /* return first step */
}
return NULL;
}
}
return (rb_transcoder *)val;
}
static VALUE
classname(VALUE klass)
{
VALUE path = Qnil;
st_data_t n;
if (!klass) klass = rb_cObject;
if (RCLASS_IV_TBL(klass)) {
if (!st_lookup(RCLASS_IV_TBL(klass), (st_data_t)classpath, &n)) {
if (!st_lookup(RCLASS_IV_TBL(klass), (st_data_t)classid, &n)) {
return find_class_path(klass);
}
path = rb_str_dup(rb_id2str(SYM2ID((VALUE)n)));
OBJ_FREEZE(path);
st_insert(RCLASS_IV_TBL(klass), (st_data_t)classpath, (st_data_t)path);
n = classid;
st_delete(RCLASS_IV_TBL(klass), &n, 0);
}
else {
path = (VALUE)n;
}
if (TYPE(path) != T_STRING) {
rb_bug("class path is not set properly");
}
return path;
}
return find_class_path(klass);
}
/* :nodoc: */
VALUE
rb_mod_init_copy(VALUE clone, VALUE orig)
{
if (RB_TYPE_P(clone, T_CLASS)) {
class_init_copy_check(clone, orig);
}
if (!OBJ_INIT_COPY(clone, orig)) return clone;
if (!FL_TEST(CLASS_OF(clone), FL_SINGLETON)) {
RBASIC_SET_CLASS(clone, rb_singleton_class_clone(orig));
rb_singleton_class_attached(RBASIC(clone)->klass, (VALUE)clone);
}
RCLASS_SET_SUPER(clone, RCLASS_SUPER(orig));
RCLASS_EXT(clone)->allocator = RCLASS_EXT(orig)->allocator;
if (RCLASS_IV_TBL(orig)) {
st_data_t id;
if (RCLASS_IV_TBL(clone)) {
st_free_table(RCLASS_IV_TBL(clone));
}
RCLASS_IV_TBL(clone) = rb_st_copy(clone, RCLASS_IV_TBL(orig));
CONST_ID(id, "__tmp_classpath__");
st_delete(RCLASS_IV_TBL(clone), &id, 0);
CONST_ID(id, "__classpath__");
st_delete(RCLASS_IV_TBL(clone), &id, 0);
CONST_ID(id, "__classid__");
st_delete(RCLASS_IV_TBL(clone), &id, 0);
}
if (RCLASS_CONST_TBL(orig)) {
struct clone_const_arg arg;
if (RCLASS_CONST_TBL(clone)) {
rb_free_const_table(RCLASS_CONST_TBL(clone));
}
RCLASS_CONST_TBL(clone) = st_init_numtable();
arg.klass = clone;
arg.tbl = RCLASS_CONST_TBL(clone);
st_foreach(RCLASS_CONST_TBL(orig), clone_const_i, (st_data_t)&arg);
}
if (RCLASS_M_TBL(orig)) {
if (RCLASS_M_TBL_WRAPPER(clone)) {
rb_free_m_tbl_wrapper(RCLASS_M_TBL_WRAPPER(clone));
}
RCLASS_M_TBL_INIT(clone);
st_foreach(RCLASS_M_TBL(orig), clone_method_i, (st_data_t)clone);
}
return clone;
}
void
unregister_elem_class(void *ptr)
{
if (ptr) {
st_delete(seqblock_klass_table, (st_data_t*)&ptr, NULL);
unregister_object(ptr);
}
}
/* :nodoc: */
VALUE
rb_mod_init_copy(VALUE clone, VALUE orig)
{
if (RB_TYPE_P(clone, T_CLASS)) {
class_init_copy_check(clone, orig);
}
rb_obj_init_copy(clone, orig);
if (!FL_TEST(CLASS_OF(clone), FL_SINGLETON)) {
RBASIC(clone)->klass = rb_singleton_class_clone(orig);
rb_singleton_class_attached(RBASIC(clone)->klass, (VALUE)clone);
}
RCLASS_SUPER(clone) = RCLASS_SUPER(orig);
if (RCLASS_IV_TBL(orig)) {
st_data_t id;
if (RCLASS_IV_TBL(clone)) {
st_free_table(RCLASS_IV_TBL(clone));
}
RCLASS_IV_TBL(clone) = st_copy(RCLASS_IV_TBL(orig));
CONST_ID(id, "__classpath__");
st_delete(RCLASS_IV_TBL(clone), &id, 0);
CONST_ID(id, "__classid__");
st_delete(RCLASS_IV_TBL(clone), &id, 0);
}
if (RCLASS_CONST_TBL(orig)) {
if (RCLASS_CONST_TBL(clone)) {
rb_free_const_table(RCLASS_CONST_TBL(clone));
}
RCLASS_CONST_TBL(clone) = st_init_numtable();
st_foreach(RCLASS_CONST_TBL(orig), clone_const_i, (st_data_t)RCLASS_CONST_TBL(clone));
}
if (RCLASS_M_TBL(orig)) {
struct clone_method_data data;
if (RCLASS_M_TBL(clone)) {
rb_free_m_table(RCLASS_M_TBL(clone));
}
data.tbl = RCLASS_M_TBL(clone) = st_init_numtable();
data.klass = clone;
st_foreach(RCLASS_M_TBL(orig), clone_method,
(st_data_t)&data);
}
return clone;
}
/* call-seq:
* detach_singleton -> self
*
* If the receiver is a singleton class, it is transformed into a
* regular class and it is detached from the instance. Note that
* this means it becomes the class of the object to which it was previous
* attached. If the receiver is not a singleton class, has no effect.
* Returns the receiver. */
static VALUE evilr_detach_singleton(VALUE klass) {
if (IS_SINGLETON_CLASS(klass)) {
FL_UNSET(klass, FL_SINGLETON);
if (RCLASS_IV_TBL(klass)) {
st_delete(RCLASS_IV_TBL(klass), (st_data_t*)&evilr__attached, 0);
}
}
return klass;
}
int main() {
bootstrap();
run();
st_delete(&process->cwd);
free(process);
return 0;
}
/* Very primitive. */
static void
free_one_lock_list(lock_list *ll)
{
if (ll == NULL)
return;
free_boolexp(ll->key);
st_delete(ll->type, &lock_names);
free_lock(ll);
}
/** Add a lock to an object (primitive).
* Set the lock type on thing to boolexp.
* This is a primitive routine, to be called by other routines.
* It will go somewhat wonky if given a NULL boolexp.
* It will allocate memory if called with a string that is not already
* in the lock table.
* \param player the enactor, for permission checking.
* \param thing object on which to set the lock.
* \param type type of lock to set.
* \param key lock boolexp pointer (should not be NULL!).
* \param flags lock flags.
* \retval 0 failure.
* \retval 1 success.
*/
int
add_lock(dbref player, dbref thing, lock_type type, boolexp key, int flags)
{
lock_list *ll, **t;
lock_type real_type = type;
if (!GoodObject(thing)) {
return 0;
}
ll = getlockstruct_noparent(thing, type);
if (ll) {
if (!can_write_lock(player, thing, ll)) {
free_boolexp(key);
return 0;
}
/* We're replacing an existing lock. */
free_boolexp(ll->key);
ll->key = key;
ll->creator = player;
if (flags != -1)
ll->flags = flags;
} else {
ll = next_free_lock();
if (!ll) {
/* Oh, this sucks */
do_log(LT_ERR, 0, 0, "Unable to malloc memory for lock_list!");
} else {
real_type = st_insert(type, &lock_names);
ll->type = real_type;
ll->key = key;
ll->creator = player;
if (flags == -1) {
const lock_list *l2 = get_lockproto(real_type);
if (l2)
ll->flags = l2->flags;
else
ll->flags = 0;
} else {
ll->flags = flags;
}
if (!can_write_lock(player, thing, ll)) {
st_delete(real_type, &lock_names);
free_boolexp(key);
return 0;
}
t = &Locks(thing);
while (*t && strcasecmp(L_TYPE(*t), L_TYPE(ll)) < 0)
t = &L_NEXT(*t);
L_NEXT(ll) = *t;
*t = ll;
}
}
return 1;
}
void
cvseq_free(void *ptr)
{
if (ptr) {
CvSeq *seq = (CvSeq*)ptr;
st_delete(seqblock_klass_table, (st_data_t*)&ptr, NULL);
if (seq->storage)
cvReleaseMemStorage(&(seq->storage));
}
}
static void deleteProc(TreeNode *t) {
if (t==NULL) return;
else {
if (t->scope < depth) {
st_delete(t->scope);
depth = t->scope;
}
return;
}
}
static void
declare_transcoder(const char *to, const char *from, const char *lib)
{
const char *const key = transcoder_key(to, from);
st_data_t k = (st_data_t)key, val;
if (st_delete(transcoder_lib_table, &k, &val)) {
xfree((char *)k);
}
st_insert(transcoder_lib_table, (st_data_t)key, (st_data_t)lib);
}
/**Function********************************************************************
Synopsis [Deletes a set value by calling instead of unset command.]
Description [Deletes a set value by calling instead of unset command.]
SideEffects []
******************************************************************************/
void Cmd_FlagDeleteByName( Abc_Frame_t * pAbc, char * key )
{
char *value;
if ( !key )
return;
if ( st_delete( pAbc->tFlags, &key, &value ) )
{
FREE(key);
FREE(value);
}
}
/* Function buildSymtab constructs the symbol
* table by preorder traversal of the syntax tree
*/
void buildSymtab(TreeNode * syntaxTree)
{
syntaxTree->scope = 0;
fprintf(listing,"Scope Variable Name Location Type isArr ArrSize isFunc isParam Line Numbers\n");
fprintf(listing,"----- ------------- -------- ---- ----- ------- ------ ------- ------------\n");
traverse(syntaxTree,insertNode,checkNode);
if (TraceAnalyze)
{ //fprintf(listing,"\nSymbol table:\n\n");
//printSymTab(listing);
st_delete(-1);
}
}
sbool_t sm_s_delete(sm_t *m, const ss_t *k)
{
stn_callback_t callback = NULL;
struct SMapSx sx;
sx.k = (ss_t *)k; /* not going to be overwritten */
switch (m->f.type) {
case SM_StrInt: callback = aux_si_delete; break;
case SM_StrStr: callback = aux_ss_delete; break;
case SM_StrPtr: callback = aux_sp_delete; break;
}
return st_delete(m, (const stn_t *)&sx, callback);
}
static void
freelist_tramp(unsigned long rval)
{
struct obj_track *tracker = NULL;
if (track_objs) {
st_delete(objs, (st_data_t *) &rval, (st_data_t *) &tracker);
if (tracker) {
free(tracker->source);
free(tracker);
}
}
}
/**Function********************************************************************
Synopsis [Updates a set value by calling instead of set command.]
Description [Updates a set value by calling instead of set command.]
SideEffects []
******************************************************************************/
void Cmd_FlagUpdateValue( Abc_Frame_t * pAbc, char * key, char * value )
{
char * oldValue, * newValue;
if ( !key )
return;
if ( value )
newValue = Extra_UtilStrsav(value);
else
newValue = Extra_UtilStrsav("");
// newValue = NULL;
if ( st_delete(pAbc->tFlags, &key, &oldValue) )
FREE(oldValue);
st_insert( pAbc->tFlags, key, newValue );
}
/* :nodoc: */
VALUE
rb_mod_init_copy(VALUE clone, VALUE orig)
{
rb_obj_init_copy(clone, orig);
if (!FL_TEST(CLASS_OF(clone), FL_SINGLETON)) {
RBASIC(clone)->klass = singleton_class_clone_int(orig, clone);
}
RCLASS(clone)->super = RCLASS(orig)->super;
if (RCLASS(orig)->iv_tbl) {
ID id;
RCLASS(clone)->iv_tbl = st_copy(RCLASS(orig)->iv_tbl);
id = rb_intern("__classpath__");
st_delete(RCLASS(clone)->iv_tbl, (st_data_t*)&id, 0);
id = rb_intern("__classid__");
st_delete(RCLASS(clone)->iv_tbl, (st_data_t*)&id, 0);
}
if (RCLASS(orig)->m_tbl) {
RCLASS(clone)->m_tbl = st_init_numtable();
st_foreach(RCLASS(orig)->m_tbl, (int (*)(...))clone_method, clone);
}
return clone;
}
static void
freelist_tramp(unsigned long rval)
{
struct obj_track *tracker = NULL;
if (rb_add_freelist) {
rb_add_freelist(rval);
}
if (track_objs && objs) {
st_delete(objs, (st_data_t *) &rval, (st_data_t *) &tracker);
if (tracker) {
free(tracker);
}
}
}
static void
delete_unique_str(st_table *tbl, const char *str)
{
if (str) {
st_data_t n;
st_lookup(tbl, (st_data_t)str, &n);
if (n == 1) {
st_delete(tbl, (st_data_t *)&str, 0);
ruby_xfree((char *)str);
}
else {
st_insert(tbl, (st_data_t)str, n-1);
}
}
}
static void
delete_unique_str(st_table *tbl, const char *str)
{
if (str) {
st_data_t n;
if (st_lookup(tbl, (st_data_t)str, &n) == 0) rb_bug("delete_unique_str: unreachable");
if (n == 1) {
st_delete(tbl, (st_data_t *)&str, NULL);
ruby_xfree((char *)str);
}
else {
st_insert(tbl, (st_data_t)str, n-1);
}
}
}
void
avro_memoize_delete(avro_memoize_t *mem, void *key1, void *key2)
{
avro_memoize_key_t key;
key.key1 = key1;
key.key2 = key2;
union {
st_data_t data;
avro_memoize_key_t *key;
} real_key;
real_key.key = &key;
if (st_delete(mem->cache, &real_key.data, NULL)) {
avro_freet(avro_memoize_key_t, real_key.key);
}
}
static void
load_unlock(const char *ftptr, int done)
{
if (ftptr) {
st_data_t key = (st_data_t)ftptr;
st_data_t data;
st_table *loading_tbl = get_loading_table();
if (st_delete(loading_tbl, &key, &data)) {
VALUE barrier = (VALUE)data;
xfree((char *)key);
if (done)
rb_barrier_destroy(barrier);
else
rb_barrier_release(barrier);
}
}
}
