rev 340 - in trunk: . include/prothon src

Author: mark
Date: 2004-04-13 22:13:13 -0400 (Tue, 13 Apr 2004)
New Revision: 340

Modified:
   trunk/STATUS.txt
   trunk/include/prothon/prothon.h
   trunk/src/builtins-dict.c
   trunk/src/builtins-int.c
   trunk/src/builtins-list.c
   trunk/src/object.c
   trunk/src/src.vcproj
Log:
added all Dict methods

Modified: trunk/STATUS.txt
===================================================================
--- trunk/STATUS.txt	2004-04-13 21:58:16 UTC (rev 339)
+++ trunk/STATUS.txt	2004-04-14 02:13:13 UTC (rev 340)
@@ -1,6 +1,8 @@
 
 ----------------------- TO-DO (highest priority first) ------------------------
 
+--- change all varnames to var_names
+
 --- add list comprehension
 
 --- flesh out dlls, list.sort!(), dict stuff, string %

Modified: trunk/include/prothon/prothon.h
===================================================================
--- trunk/include/prothon/prothon.h	2004-04-13 21:58:16 UTC (rev 339)
+++ trunk/include/prothon/prothon.h	2004-04-14 02:13:13 UTC (rev 340)
@@ -763,6 +763,16 @@
 // If the formal param list is empty, you can put NULL instead of the list.
 obj_p new_func_obj(isp ist, pr_func* func_ptr, obj_p label_def_list);
 
+// FPARMn: Convenience macros for formal params in function definitions
+#define FPARM1(lab1, val1)										\
+	list2(ist, sym(ist, #lab1), val1)
+#define FPARM2(lab1, val1, lab2, val2)							\
+	list4(ist, sym(ist, #lab1), val1, sym(ist, #lab2), val2)	
+#define FPARM3(lab1, val1, lab2, val2, lab3, val3)				\
+	list6(ist, sym(ist, #lab1), val1, sym(ist, #lab2), val2, sym(ist, #lab3), val3)
+#define FPARM4(lab1, val1, lab2, val2, lab3, val3, lab4, val4)	\
+	list8(ist, sym(ist, #lab1), val1, sym(ist, #lab2), val2, sym(ist, #lab3), val3, sym(ist, #lab4), val4)
+
 // FORM_RPARAM: convenience macro for single formal right parameter
 // Defines a formal label/default-value list that matches  func(rparam).
 // This is the call made in a binary operation such a a+b.  "a" is self and 
@@ -927,8 +937,10 @@
 #define if_wrlock(obj)	 if (write_lock(ist, obj)) 
 #define wrlock_brk(obj)	 if (write_lock(ist, obj)) break
 #define wrlock_rtrn(obj) if (write_lock(ist, obj)) return
+#define def_write_lock(obj)  read_unlock(ist, obj);      \
+	if_wrlock(obj) { read_lock(ist, obj); return NULL; }
+#define def_write_unlock(obj)  write_unlock(ist, obj); read_lock(ist, obj)
 
-
 //************************** IMMUTABLE BIT ***********************************
 // Each object has a bit called immutable.  This bit is effectively a write-protect
 // bit for the object.  When set the object cannot be modified.  Any attempt

Modified: trunk/src/builtins-dict.c
===================================================================
--- trunk/src/builtins-dict.c	2004-04-13 21:58:16 UTC (rev 339)
+++ trunk/src/builtins-dict.c	2004-04-14 02:13:13 UTC (rev 340)
@@ -64,6 +64,139 @@
 #include "object.h"
 #include <prothon/prothon_dll.h>
 
+//********************************* new_dict_obj ******************************
+obj_p new_dict_obj(isp ist, int initial_size){
+	obj_p dict_obj = new_object(ist, OBJ(DICT_PROTO));
+	dict_p dict;
+	initial_size = max(initial_size, DEFAULT_INITIAL_DICT_SIZE);
+	dict = obj_malloc(dict_obj, (DICT_OVERHEAD+initial_size)*sizeof(dict_t));
+	memset(dict, 0, (DICT_OVERHEAD+initial_size)*sizeof(dict_t));
+	dictsize(dict) = initial_size;
+	return dict_obj;
+}
+
+#define dict_wr_chk()				\
+if (ist->exception_obj) {			\
+	write_unlock(ist, dict_obj);	\
+	return FALSE;					\
+}
+
+//********************************* dict_add **********************************
+int dict_add(isp ist, obj_p dict_obj, obj_p key_in, obj_p value_in) {
+	i32_t i, hash, hash_in, match=FALSE;
+	obj_p key, rp[2];
+	dict_p dict, dp, hole=NULL;
+	rp[0]=0; rp[1]=key_in;
+	hash_in = hash_value(call_func(ist, key_in, SYM(__HASH__), 0, NULL, NULL));
+	dict_wr_chk();
+	dict = (dict_p) obj_data_p(dict_obj);
+	for (i=hash_in; (key=((dp=dictptr(dict,i))->entry.key)); i++){
+		hash = dp->entry.hash;
+		if (hash < 0) { hole = dp; continue; }
+		if ( hash == hash_in && 
+			call_func(ist, key, SYM(__EQ__QUES), 2, rp, NULL) == OBJ(PR_TRUE) ) {
+			match = PR_TRUE;
+			break;
+		}
+		dict_wr_chk();
+	}
+	dict_wr_chk();
+	if (!match) {
+		dictlen(dict)++;
+		if(hole) dp = hole;
+		dp->entry.hash = hash_in;
+		dp->entry.key  = key_in;
+	}
+	dp->entry.value = value_in;
+	return !match;
+}
+
+//********************************* dict_len **********************************
+size_t dict_len(isp ist, obj_p dict_obj){
+	size_t res;
+	rdlock_rtrn(dict_obj) 0;
+	res = dictlen(dict_d(dict_obj));
+	read_unlock(ist, dict_obj);
+	return res;
+}
+
+#define dict_rd_chk()			\
+if (ist->exception_obj) {		\
+	read_unlock(ist, dict_obj);	\
+	return NULL;				\
+}
+
+//********************************* dict_item **********************************
+obj_p dict_item(isp ist, obj_p dict_obj, obj_p key_in){
+	i32_t i, hash_in;
+	obj_p key, res, rp[2];
+	dict_p dict, dp;
+	rp[0]=0; rp[1]=key_in;
+	rdlock_rtrn(dict_obj) NULL;
+	hash_in = hash_value(call_func(ist, key_in, SYM(__HASH__), 0, NULL, NULL));
+	dict_rd_chk();
+	dict = (dict_p) obj_data_p(dict_obj);
+	for (i=hash_in; (key=((dp=dictptr(dict,i))->entry.key)); i++){
+		if ( dp->entry.hash == hash_in && 
+			 call_func(ist, key, SYM(__EQ__QUES), 2, rp, NULL) == OBJ(PR_TRUE) ) {
+			dict_rd_chk();
+			res = dp->entry.value;
+			read_unlock(ist, dict_obj);
+			return res;
+		}
+		dict_rd_chk();
+	}
+	read_unlock(ist, dict_obj);
+	return NULL;
+}
+
+//********************************* dict_keys_values **************************
+obj_p dict_keys_values(isp ist, obj_p dict_obj, int key_flg){
+	size_t i, size, len, llen, cnt=0;
+	int no_tuple = (key_flg == 4);
+	obj_p list_obj;
+	dict_p dict, dp;
+	rdlock_rtrn(dict_obj) NULL;
+	dict = dict_d(dict_obj);
+	size = dictsize(dict);
+	len  = dictlen(dict);
+	switch (key_flg) {
+		case 2:  llen = 2 * len; break;
+		case 4:  llen = 2;       break;
+		default: llen = len;     break;
+	}
+	list_obj = new_list_obj(ist, (int)llen);
+	for(i=0; i < size; i++) {
+		if ((dp=dictptr(dict,i))->entry.hash > 0) {
+			assert (cnt++ < len);
+			if (key_flg == 3) {
+				obj_p tuple = new_list_obj(ist, 2);
+				list_append(ist, tuple, dp->entry.key);
+				list_append(ist, tuple, dp->entry.value);
+				switch_proto(ist, tuple, OBJ(TUPLE_PROTO));
+				set_immutable(tuple);
+				list_append(ist, list_obj, tuple);
+			} else {
+				if (key_flg == 1 || key_flg == 2 || key_flg == 4)
+				list_append(ist, list_obj, dp->entry.key);
+				if (key_flg == 0 || key_flg == 2 || key_flg == 4)
+				list_append(ist, list_obj, dp->entry.value);
+			}
+			if (key_flg == 4) {
+				switch_proto(ist, list_obj, OBJ(TUPLE_PROTO));
+				set_immutable(list_obj);
+				dp->entry.hash = ENTRY_DELETED;
+			    dictlen(dict)--;
+				no_tuple = FALSE;
+				break;
+			}
+		}
+	}
+	if (no_tuple) return OBJ(NONE);
+	read_unlock(ist, dict_obj);
+	return list_obj;
+}
+
 MODULE_DECLARE(Dict);
 MODULE_DECLARE(DictGen);
 
@@ -145,6 +278,41 @@
 	return res_obj;
 }
 
+DEF(Dict, has_key_QUES, FPARM1(k, NULL)) {
+	obj_p res;
+	if (res = dict_item(ist, self, parms[1])) {
+		del_unlock(res);
+		return OBJ(PR_TRUE);
+	}
+	return OBJ(PR_FALSE);
+}
+
+DEF(Dict, get, FPARM2(k, NULL, x, OBJ(NONE))) {
+	obj_p res;
+	if (res = dict_item(ist, self, parms[1])) {
+		return res;
+	}
+	return parms[3];
+}
+
+DEF(Dict, __rin__QUES, FORM_RPARAM) {
+	obj_p res;
+	if (res = dict_item(ist, self, parms[1])) {
+		del_unlock(res);
+		return OBJ(PR_TRUE);
+	}
+	return OBJ(PR_FALSE);
+}
+
+DEF(Dict, __rnotin__QUES, FORM_RPARAM) {
+	obj_p res;
+	if (res = dict_item(ist, self, parms[1])) {
+		del_unlock(res);
+		return OBJ(PR_FALSE);
+	}
+	return OBJ(PR_TRUE);
+}
+
 DEF(Dict, __cdatalen__, NULL) {
 	return new_int_obj(ist, dict_size_bytes(self->data.ptr));
 }
@@ -186,9 +354,9 @@
 		raise_exception(ist, OBJ(INTERPRETER_EXC), "slice not allowed in dictionary indexing");	
 		return NULL;
 	}
-	read_unlock(ist, self);
+	def_write_lock(self);
 	dict_add(ist, self, list_item(ist, parms[1], 0), parms[3]);
-	read_lock(ist, self);
+	def_write_unlock(self);
 	return NULL;
 }
 
@@ -201,10 +369,10 @@
 		raise_exception(ist, OBJ(INTERPRETER_EXC), "slice not allowed in dictionary indexing");	
 		return NULL;
 	}
-	read_unlock(ist, self);  if_wrlock(self){read_lock(ist, self); return NULL;}
+	def_write_lock(self);
 	hash_in = hash_value(call_func(ist, key_in, SYM(__HASH__), 0, NULL, NULL));
 	if (ist->exception_obj) {	
-		write_unlock(ist, self);  read_lock(ist, self); 
+		def_write_unlock(self);
 		return NULL;
 	}
 	dict = (dict_p) self->data.ptr;
@@ -213,11 +381,11 @@
 			 call_func(ist, key, SYM(__EQ__QUES), 2, rp, NULL) == OBJ(PR_TRUE) ) {
 			dp->entry.hash = ENTRY_DELETED;
 			dictlen(dict)--;
-			write_unlock(ist, self);	 read_lock(ist, self); 
+			def_write_unlock(self);
 			return NULL;
 		}
 		if (ist->exception_obj) {	
-			write_unlock(ist, self);	 read_lock(ist, self); 
+			def_write_unlock(self);
 			return NULL;
 		}
 	}
@@ -225,6 +393,58 @@
 	return NULL;
 }
 
+DEF(Dict, items, NULL) {
+	return dict_keys_values(ist, self, 3 /*tuples*/);
+}
+
+DEF(Dict, keys, NULL) {
+	return dict_keys_values(ist, self, 1 /*keys*/);
+}
+
+DEF(Dict, values, NULL) {
+	return dict_keys_values(ist, self, 0 /*values*/);
+}
+
+DEF(Dict, clear_BANG, NULL) {
+	dict_p dict;
+	def_write_lock(self);
+	dict = dict_d(self);
+	memset(&(dict->entry), 0, dictsize(dict) * sizeof(dict_entry_t));
+	dictlen(dict) = 0;
+	def_write_unlock(self);
+	return self;
+}
+
+DEF(Dict, update_BANG, FPARM1(D1,NULL)) {
+	size_t i, llen;
+	obj_p list;
+
+	CHECK_TYPE_EXC(parms[1], OBJ(DICT_PROTO), "dict");
+	list = dict_keys_values(ist, parms[1], 2 /*list*/);
+	llen = list_len(ist, list);
+	def_write_lock(self);
+	for(i=0; i < llen; i += 2)
+		dict_add(ist, self, list_item(ist, list, (int) i), list_item(ist, list, (int) i+1));
+	def_write_unlock(self);
+	del_unlock(list);
+	return self;
+}
+
+DEF(Dict, setdefault_BANG, FPARM2(k, NULL, x, OBJ(NONE))) {
+	obj_p res;
+	if (res = dict_item(ist, self, parms[1])) {
+		return res;
+	}
+	def_write_lock(self);
+	dict_add(ist, self, parms[1], parms[3]);
+	def_write_unlock(self);
+	return parms[3];
+}
+
+DEF(Dict, popitem_BANG, NULL) {
+	return dict_keys_values(ist, self, 4 /*tuple*/);
+}
+
 DEF(Dict, __gen__, NULL) {
 	obj_p list_obj, gen_obj = new_object(ist, DictGen_OBJ);
 
@@ -258,18 +478,28 @@
 	return res;
 }
 
-
 MAIN_MODULE_INIT(Dict)
 {
 	MODULE_SUB_INIT(Dict);
 	MODULE_ADD_SYM(Dict, __init__);
 	MODULE_ADD_SYM(Dict, __str__);
-	MODULE_ADD_SYM(Dict, __cdatalen__);
+	MODULE_ADD_SYM(Dict, has_key_QUES);
+	MODULE_ADD_SYM(Dict, items);
+	MODULE_ADD_SYM(Dict, keys);
+	MODULE_ADD_SYM(Dict, values);
+	MODULE_ADD_SYM(Dict, get);
+	MODULE_ADD_SYM(Dict, clear_BANG);
+	MODULE_ADD_SYM(Dict, update_BANG);
+	MODULE_ADD_SYM(Dict, setdefault_BANG);
+	MODULE_ADD_SYM(Dict, popitem_BANG);
+	MODULE_ADD_SYM(Dict, __rin__QUES);
+	MODULE_ADD_SYM(Dict, __rnotin__QUES);
 	MODULE_ADD_SYM(Dict, __getitem__);
 	MODULE_ADD_SYM(Dict, __setitem__);
 	MODULE_ADD_SYM(Dict, __delitem__);
 	MODULE_ADD_SYM(Dict, __gen__);
 	MODULE_ADD_SYM(Dict, __objlist__);
+	MODULE_ADD_SYM(Dict, __cdatalen__);
 
 	MODULE_SUB_INIT(DictGen);
 	MODULE_ADD_SYM(DictGen, next);

Modified: trunk/src/builtins-int.c
===================================================================
--- trunk/src/builtins-int.c	2004-04-13 21:58:16 UTC (rev 339)
+++ trunk/src/builtins-int.c	2004-04-14 02:13:13 UTC (rev 340)
@@ -330,9 +330,9 @@
 		return NULL;
 	}
 	res = new_int_obj(ist, Int_value(self));
-	read_unlock(ist, self); if_wrlock(self){read_lock(ist, self); return NULL;}
+	def_write_lock(self);
 	Int_value(self)++;
-	write_unlock(ist, self); read_lock(ist, self); 
+	def_write_unlock(self);
 	return res;
 }
 

Modified: trunk/src/builtins-list.c
===================================================================
--- trunk/src/builtins-list.c	2004-04-13 21:58:16 UTC (rev 339)
+++ trunk/src/builtins-list.c	2004-04-14 02:13:13 UTC (rev 340)
@@ -122,7 +122,7 @@
 	obj_p slice = parms[1], value = parms[3];
 	i64_t i, new_len, exp_len, index1 = 0, index2 = 0, index3 = 0, slice1_empty=FALSE, slice2_empty=FALSE;
 	size_t val_len, self_len, slice_len = list_len(ist, slice);
-	read_unlock(ist, self); if_wrlock(self){read_lock(ist, self); return NULL;}
+	def_write_lock(self);
 	self_len = listlen(self);
 	slice_item1 = list_item(ist, slice,0);
 	if (slice_item1 == SLICEPARAM_EMPTY || slice_item1 == OBJ(NONE)) 
@@ -130,7 +130,7 @@
 	else {
 		if (!has_proto_QUES(ist, slice_item1, OBJ(INT_PROTO))) {
 			raise_exception(ist, OBJ(TYPE_EXC), "List slice index must be an integer");
-			write_unlock(ist, self); read_lock(ist, self); 
+			def_write_unlock(self); 
 			return NULL;
 		}
 		index1 = (int)(slice_item1->data.i64);
@@ -138,12 +138,12 @@
 		if (index1 < 0 || index1 >= self_len) {			
 			raise_exception(ist, OBJ(INDEX_EXC), "Index (%"APR_INT64_T_FMT") out of range",
 					(i64_t)index1);
-			write_unlock(ist, self);  read_lock(ist, self); 
+			def_write_unlock(self);
 			return NULL;									
 		}
 		if (slice_len == 1) {
 			listitem(self, index1) = value;
-			write_unlock(ist, self);  read_lock(ist, self); 
+			def_write_unlock(self);
 			return NULL;
 		}
 	}
@@ -151,7 +151,7 @@
 		 !has_proto_QUES(ist, value, OBJ(TUPLE_PROTO)) &&
 		 !has_proto_QUES(ist, value, OBJ(STRING_PROTO)) ) {
 		raise_exception(ist, OBJ(TYPE_EXC), "list slices may only be replaced with a sequence");
-		write_unlock(ist, self);  read_lock(ist, self); 
+		def_write_unlock(self);
 		return NULL;									
 	}
 	if (slice_len == 3) {
@@ -160,13 +160,13 @@
 		else {
 			if (!has_proto_QUES(ist, slice_item3, OBJ(INT_PROTO))) {
 				raise_exception(ist, OBJ(TYPE_EXC), "sequence slice index must be an integer");
-				write_unlock(ist, self);  read_lock(ist, self); 
+				def_write_unlock(self);
 				return NULL;
 			}
 			index3 = (int)(slice_item3->data.i64);
 			if (index3 == 0) {
 				raise_exception(ist, OBJ(INDEX_EXC), "slice step cannot be zero");
-				write_unlock(ist, self);  read_lock(ist, self); 
+				def_write_unlock(self);
 				return NULL;
 			}
 		}
@@ -177,7 +177,7 @@
 	else {
 		if (!has_proto_QUES(ist, slice_item2, OBJ(INT_PROTO))) {
 			raise_exception(ist, OBJ(TYPE_EXC), "sequence slice index must be an integer");
-			write_unlock(ist, self);  read_lock(ist, self); 
+			def_write_unlock(self);
 			return NULL;
 		}
 		index2 = (int)(slice_item2->data.i64);
@@ -185,7 +185,7 @@
 		if (index2 < 0 || index2 > self_len) {			
 			raise_exception(ist, OBJ(INDEX_EXC), "Second index (%"APR_INT64_T_FMT") out of range",
 					(i64_t)index2);
-			write_unlock(ist, self);  read_lock(ist, self); 
+			def_write_unlock(self);
 			return NULL;									
 		}
 	}
@@ -202,7 +202,7 @@
 	if (slice_len==3) {
 		if (exp_len != val_len) {
 			raise_exception(ist, OBJ(INDEX_EXC), "extended slice assignment lengths do not match");	
-			write_unlock(ist, self);   read_lock(ist, self); 
+			def_write_unlock(self);
 			return NULL;
 		}
 		if (index3 > 0)
@@ -226,7 +226,7 @@
 		for(i = index1, j=0; j < (int) val_len; i++, j++)
 			listitem(self, i) = seq_item(ist, value, j);
 	}
-	write_unlock(ist, self);   read_lock(ist, self); 
+	def_write_unlock(self);
 	return NULL;
 }
 
@@ -236,7 +236,7 @@
 	obj_p slice = parms[1];
 	i64_t i, new_len, index1 = 0, index2 = 0, index3 = 0, slice1_empty=FALSE, slice2_empty=FALSE;
 	size_t exp_len, self_len, slice_len = list_len(ist, slice);
-	read_unlock(ist, self);  if_wrlock(self){read_lock(ist, self); return NULL;}
+	def_write_lock(self);
 	self_len = listlen(self);
 	slice_item1 = list_item(ist, slice,0);
 	if (slice_item1 == SLICEPARAM_EMPTY || slice_item1 == OBJ(NONE)) 
@@ -244,7 +244,7 @@
 	else {
 		if (!has_proto_QUES(ist, slice_item1, OBJ(INT_PROTO))) {
 			raise_exception(ist, OBJ(TYPE_EXC), "List slice index must be an integer");
-			write_unlock(ist, self);  read_lock(ist, self); 
+			def_write_unlock(self);
 			return NULL;
 		}
 		index1 = (int)(slice_item1->data.i64);
@@ -252,7 +252,7 @@
 		if (index1 < 0 || index1 >= self_len) {			
 			raise_exception(ist, OBJ(INDEX_EXC), "Index (%"APR_INT64_T_FMT") out of range",
 					(i64_t)index1);
-			write_unlock(ist, self);   read_lock(ist, self); 
+			def_write_unlock(self);
 			return NULL;									
 		}
 		if (slice_len == 1) {
@@ -261,7 +261,7 @@
 					     &(((list_p)self->data.ptr)->item[index1+1]),
 						 (self_len-1 - (size_t)index1) * sizeof(list_item_t) );
 			listlen(self)--;
-			write_unlock(ist, self);   read_lock(ist, self); 
+			def_write_unlock(self);
 			return NULL;
 		}
 	}
@@ -271,13 +271,13 @@
 		else {
 			if (!has_proto_QUES(ist, slice_item3, OBJ(INT_PROTO))) {
 				raise_exception(ist, OBJ(TYPE_EXC), "sequence slice index must be an integer");
-				write_unlock(ist, self);   read_lock(ist, self); 
+				def_write_unlock(self);
 				return NULL;
 			}
 			index3 = (int)(slice_item3->data.i64);
 			if (index3 == 0) {
 				raise_exception(ist, OBJ(INDEX_EXC), "slice step cannot be zero");
-				write_unlock(ist, self);   read_lock(ist, self); 
+				def_write_unlock(self);
 				return NULL;
 			}
 		}
@@ -288,7 +288,7 @@
 	else {
 		if (!has_proto_QUES(ist, slice_item2, OBJ(INT_PROTO))) {
 			raise_exception(ist, OBJ(TYPE_EXC), "sequence slice index must be an integer");
-			write_unlock(ist, self);   read_lock(ist, self); 
+			def_write_unlock(self);
 			return NULL;
 		}
 		index2 = (int)(slice_item2->data.i64);
@@ -296,7 +296,7 @@
 		if (index2 < 0 || index2 > self_len) {			
 			raise_exception(ist, OBJ(INDEX_EXC), "Second index (%"APR_INT64_T_FMT") out of range",
 					(i64_t)index2);
-			write_unlock(ist, self);   read_lock(ist, self); 
+			def_write_unlock(self);
 			return NULL;									
 		}
 	}
@@ -330,11 +330,11 @@
 			memmove( &(((list_p)self->data.ptr)->item[index1]),
 					 &(((list_p)self->data.ptr)->item[index2]),
 					 (self_len - (size_t)index2) * sizeof(list_item_t) );
-		write_unlock(ist, self);   read_lock(ist, self); 
+		def_write_unlock(self);
 		return NULL;
 	}
 	listlen(self) -= exp_len;
-	write_unlock(ist, self);   read_lock(ist, self); 
+	def_write_unlock(self);
 	return NULL;
 }
 
@@ -377,7 +377,7 @@
 
 DEF(List, append_BANG, FORM_RPARAM) {
 	list_p lstp;
-	read_unlock(ist, self);  if_wrlock(self){read_lock(ist, self); return NULL;}
+	def_write_lock(self);
 	lstp = self->data.ptr;
 	if(lstplen(lstp) == lstpsize(lstp)) {
 		lstpsize(lstp) *= LIST_GROWTH_FACTOR;
@@ -385,14 +385,14 @@
 		self->data.ptr = lstp;
 	}
 	listitem(self, listlen(self)++) = parms[1];
-	write_unlock(ist, self);   read_lock(ist, self); 
+	def_write_unlock(self);
 	return self;
 }
 
 DEF(List, extend_BANG, FORM_RPARAM) {
 	list_p selfp, otherp;
 	size_t self_len, other_len;
-	read_unlock(ist, self);  if_wrlock(self){read_lock(ist, self); return NULL;}
+	def_write_lock(self);
 	if (!has_proto_QUES(ist, parms[1], OBJ(TUPLE_PROTO)) && !has_proto_QUES(ist, parms[1], List_OBJ)) {
 		raise_exception(ist, OBJ(TYPE_EXC), "extend parameter must be a tuple or list");
 		return NULL;
@@ -408,7 +408,7 @@
 	}
 	memcpy( selfp->item+self_len, otherp->item, other_len*sizeof(list_item_t));
 	lstplen(selfp) = self_len+other_len;
-	write_unlock(ist, self);   read_lock(ist, self); 
+	def_write_unlock(self);
 	return self;
 }
 
@@ -420,13 +420,13 @@
 		raise_exception(ist, OBJ(TYPE_EXC), "index (i) parameter must be an integer");
 		return NULL;
 	}
-	read_unlock(ist, self);  if_wrlock(self){read_lock(ist, self); return NULL;}
+	def_write_lock(self);
 	index = (int)parms[1]->data.i64;
 	selfp    = self->data.ptr;
 	self_len = lstplen(selfp);
 	if (index < 0 || index > self_len) {
 		raise_exception(ist, OBJ(INDEX_EXC), "index (i) parameter out of range");
-		write_unlock(ist, self);   read_lock(ist, self);
+		def_write_unlock(self);
 		return NULL;
 	}
 	if(lstplen(selfp) == lstpsize(selfp)) {
@@ -439,7 +439,7 @@
 				  (self_len - (size_t)index) * sizeof(list_item_t) ); 
 	listitem(self, index) = parms[3];
 	lstplen(selfp)++;
-	write_unlock(ist, self);   read_lock(ist, self); 
+	def_write_unlock(self);
 	return self;
 }
 
@@ -447,7 +447,7 @@
 	i64_t i;
 	size_t self_len;
 	list_p selfp;
-	read_unlock(ist, self);  if_wrlock(self){read_lock(ist, self); return NULL;}
+	def_write_lock(self);
 	selfp    = self->data.ptr;
 	self_len = lstplen(selfp);
 	for (i=0; i < self_len; i++) {
@@ -456,14 +456,14 @@
 	}
 	if (i == self_len) {
 		raise_exception(ist, OBJ(INDEX_EXC), "item not found to remove from list");
-		write_unlock(ist, self);   read_lock(ist, self); 
+		def_write_unlock(self);
 		return NULL;
 	}
 	if (i < self_len-1)
 		memmove( selfp->item+i, selfp->item+i+1, 
 		        (self_len - 1 - (size_t)i) * sizeof(list_item_t) ); 
 	lstplen(selfp)--;
-	write_unlock(ist, self);   read_lock(ist, self); 
+	def_write_unlock(self);
 	return self;
 }
 
@@ -476,7 +476,7 @@
 		raise_exception(ist, OBJ(TYPE_EXC), "pop index (i) parameter must be an integer");
 		return NULL;
 	}
-	read_unlock(ist, self);  if_wrlock(self){read_lock(ist, self); return NULL;}
+	def_write_lock(self);
 	selfp    = self->data.ptr;
 	self_len = lstplen(selfp);
 	if (parms[1] == OBJ(NONE))
@@ -485,7 +485,7 @@
 		index = (int)(parms[1]->data.i64);
 	if (index < 0 || index > self_len-1) {
 		raise_exception(ist, OBJ(INDEX_EXC), "index (i) parameter out of range");
-		write_unlock(ist, self);   read_lock(ist, self);
+		def_write_unlock(self);
 		return NULL;
 	}
 	res = listitem(self, index);
@@ -493,7 +493,7 @@
 		memmove( selfp->item+index, selfp->item+index+1, 
 				 (self_len - 1 - (size_t)index) * sizeof(list_item_t) ); 
 	lstplen(selfp)--;
-	write_unlock(ist, self);   read_lock(ist, self); 
+	def_write_unlock(self);
 	return res;
 }
 
@@ -501,7 +501,7 @@
 	size_t self_len;
 	list_p selfp;
 	list_item_t *p1, *p2;
-	read_unlock(ist, self);  if_wrlock(self){read_lock(ist, self); return NULL;}
+	def_write_lock(self);
 	selfp    = self->data.ptr;
 	self_len = lstplen(selfp);
 	p1 = selfp->item;
@@ -512,7 +512,7 @@
 		*p1 = tmp;
 		p1++; p2--;
 	}
-	write_unlock(ist, self);   read_lock(ist, self); 
+	def_write_unlock(self);
 	return self;
 }
 

Modified: trunk/src/object.c
===================================================================
--- trunk/src/object.c	2004-04-13 21:58:16 UTC (rev 339)
+++ trunk/src/object.c	2004-04-14 02:13:13 UTC (rev 340)
@@ -1144,116 +1144,6 @@
 	return list_obj;
 }
 
-//********************************* new_dict_obj ******************************
-obj_p new_dict_obj(isp ist, int initial_size){
-	obj_p dict_obj = new_object(ist, OBJ(DICT_PROTO));
-	dict_p dict;
-	initial_size = max(initial_size, DEFAULT_INITIAL_DICT_SIZE);
-	dict = obj_malloc(dict_obj, (DICT_OVERHEAD+initial_size)*sizeof(dict_t));
-	memset(dict, 0, (DICT_OVERHEAD+initial_size)*sizeof(dict_t));
-	dictsize(dict) = initial_size;
-	return dict_obj;
-}
-
-#define dict_wr_chk()				\
-if (ist->exception_obj) {			\
-	write_unlock(ist, dict_obj);	\
-	return FALSE;					\
-}
-
-//********************************* dict_add **********************************
-int dict_add(isp ist, obj_p dict_obj, obj_p key_in, obj_p value_in){
-	i32_t i, hash, hash_in, match=FALSE;
-	obj_p key, rp[2];
-	dict_p dict, dp, hole=NULL;
-	rp[0]=0; rp[1]=key_in;
-	wrlock_rtrn(dict_obj) FALSE;
-	hash_in = hash_value(call_func(ist, key_in, SYM(__HASH__), 0, NULL, NULL));
-	dict_wr_chk();
-	dict = (dict_p) obj_data_p(dict_obj);
-	for (i=hash_in; (key=((dp=dictptr(dict,i))->entry.key)); i++){
-		hash = dp->entry.hash;
-		if (hash < 0) { hole = dp; continue; }
-		if ( hash == hash_in && 
-			call_func(ist, key, SYM(__EQ__QUES), 2, rp, NULL) == OBJ(PR_TRUE) ) {
-			match = PR_TRUE;
-			break;
-		}
-		dict_wr_chk();
-	}
-	dict_wr_chk();
-	if (!match) {
-		dictlen(dict)++;
-		if(hole) dp = hole;
-		dp->entry.hash = hash_in;
-		dp->entry.key  = key_in;
-	}
-	dp->entry.value = value_in;
-	write_unlock(ist, dict_obj);
-	return !match;
-}
-
-//********************************* dict_len **********************************
-size_t dict_len(isp ist, obj_p dict_obj){
-	size_t res;
-	rdlock_rtrn(dict_obj) 0;
-	res = dictlen(dict_d(dict_obj));
-	read_unlock(ist, dict_obj);
-	return res;
-}
-
-#define dict_rd_chk()			\
-if (ist->exception_obj) {		\
-	read_unlock(ist, dict_obj);	\
-	return NULL;				\
-}
-
-//********************************* dict_item **********************************
-obj_p dict_item(isp ist, obj_p dict_obj, obj_p key_in){
-	i32_t i, hash_in;
-	obj_p key, res, rp[2];
-	dict_p dict, dp;
-	rp[0]=0; rp[1]=key_in;
-	rdlock_rtrn(dict_obj) NULL;
-	hash_in = hash_value(call_func(ist, key_in, SYM(__HASH__), 0, NULL, NULL));
-	dict_rd_chk();
-	dict = (dict_p) obj_data_p(dict_obj);
-	for (i=hash_in; (key=((dp=dictptr(dict,i))->entry.key)); i++){
-		if ( dp->entry.hash == hash_in && 
-			 call_func(ist, key, SYM(__EQ__QUES), 2, rp, NULL) == OBJ(PR_TRUE) ) {
-			dict_rd_chk();
-			res = dp->entry.value;
-			read_unlock(ist, dict_obj);
-			return res;
-		}
-		dict_rd_chk();
-	}
-	read_unlock(ist, dict_obj);
-	return NULL;
-}
-
-//********************************* dict_keys_values **************************
-obj_p dict_keys_values(isp ist, obj_p dict_obj, int key_flg){
-	size_t i, size, len, cnt=0;
-	obj_p list_obj;
-	dict_p dict, dp;
-	rdlock_rtrn(dict_obj) NULL;
-	dict = dict_d(dict_obj);
-	size = dictsize(dict);
-	len  = dictlen(dict);
-	list_obj = new_list_obj(ist, (int)dictlen(dict));
-	for(i=0; i < size; i++)
-		if ((dp=dictptr(dict,i))->entry.hash > 0) {
-			assert (cnt++ < len);
-			if (key_flg == 1 || key_flg == 2)
-				list_append(ist, list_obj, dp->entry.key);
-			if (key_flg == 0 || key_flg == 2)
-				list_append(ist, list_obj, dp->entry.value);
-		}
-	read_unlock(ist, dict_obj);
-	return list_obj;
-}
-
 //********************************* add_doc_to_obj ***********************************
 void add_doc_to_obj(isp ist, obj_p obj, char* str){
 	if (str[strlen(str)-1] == '\n') {

Modified: trunk/src/src.vcproj
===================================================================
--- trunk/src/src.vcproj	2004-04-13 21:58:16 UTC (rev 339)
+++ trunk/src/src.vcproj	2004-04-14 02:13:13 UTC (rev 340)
@@ -250,6 +250,9 @@
 				RelativePath="..\pr\defs.pr">
 			</File>
 			<File
+				RelativePath="..\pr\dict.pr">
+			</File>
+			<File
 				RelativePath="..\pr\file_test.pr">
 			</File>
 			<File