Menu
▾
▴
clisp-cvs digest, Vol 1 #539 - 1 msg
|
From: <cli...@li...> - 2004-06-02 10:24:02
|
Send clisp-cvs mailing list submissions to cli...@li... To subscribe or unsubscribe via the World Wide Web, visit https://lists.sourceforge.net/lists/listinfo/clisp-cvs or, via email, send a message with subject or body 'help' to cli...@li... You can reach the person managing the list at cli...@li... When replying, please edit your Subject line so it is more specific than "Re: Contents of clisp-cvs digest..." CLISP CVS commits for today Today's Topics: 1. clisp/src io.d,1.227,1.228 hashtabl.d,1.82,1.83 lispbibl.d,1.510,1.511 predtype.d,1.109,1.110 spvw_circ.d,1.28,1.29 spvw_gcmark.d,1.4,1.5 spvw_weak.d,1.2,1.3 constobj.d,1.129,1.130 constsym.d,1.243,1.244 spvw_debug.d,1.47,1.48 ChangeLog,1.3118,1.3119 (Bruno Haible) --__--__-- Message: 1 From: Bruno Haible <ha...@us...> To: cli...@li... Subject: clisp/src io.d,1.227,1.228 hashtabl.d,1.82,1.83 lispbibl.d,1.510,1.511 predtype.d,1.109,1.110 spvw_circ.d,1.28,1.29 spvw_gcmark.d,1.4,1.5 spvw_weak.d,1.2,1.3 constobj.d,1.129,1.130 constsym.d,1.243,1.244 spvw_debug.d,1.47,1.48 ChangeLog,1.3118,1.3119 Date: Wed, 02 Jun 2004 10:22:17 +0000 Reply-To: cli...@li... Update of /cvsroot/clisp/clisp/src In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv24195/src Modified Files: io.d hashtabl.d lispbibl.d predtype.d spvw_circ.d spvw_gcmark.d spvw_weak.d constobj.d constsym.d spvw_debug.d ChangeLog Log Message: Synchronize the memory layout of weak and non-weak kvtable. Index: spvw_weak.d =================================================================== RCS file: /cvsroot/clisp/clisp/src/spvw_weak.d,v retrieving revision 1.2 retrieving revision 1.3 diff -u -d -r1.2 -r1.3 --- spvw_weak.d 22 May 2004 13:17:45 -0000 1.2 +++ spvw_weak.d 2 Jun 2004 10:22:12 -0000 1.3 @@ -134,6 +134,17 @@ var uintL n = (Lrecord_length(obj)-2) / 2; return 2*n; } + case Rectype_WeakHashedAlist_Key: + case Rectype_WeakHashedAlist_Value: { + var uintL n = (Lrecord_length(obj)-4) / 3; + return n; + } + case Rectype_WeakHashedAlist_Either: + return 0; + case Rectype_WeakHashedAlist_Both: { + var uintL n = (Lrecord_length(obj)-4) / 3; + return 2*n; + } default: abort(); } } @@ -219,6 +230,31 @@ } break; } + case Rectype_WeakHashedAlist_Key: { + var uintL n = (Lrecord_length(obj)-4) / 3; + var uintL i; + for (i = 0; i < n; i++) + add_watchable(&accumulator,obj,i,TheWeakHashedAlist(obj)->whal_data[3*i+0]); + break; + } + case Rectype_WeakHashedAlist_Value: { + var uintL n = (Lrecord_length(obj)-4) / 3; + var uintL i; + for (i = 0; i < n; i++) + add_watchable(&accumulator,obj,i,TheWeakHashedAlist(obj)->whal_data[3*i+1]); + break; + } + case Rectype_WeakHashedAlist_Either: + break; + case Rectype_WeakHashedAlist_Both: { + var uintL n = (Lrecord_length(obj)-4) / 3; + var uintL i; + for (i = 0; i < n; i++) { + add_watchable(&accumulator,obj,i,TheWeakHashedAlist(obj)->whal_data[3*i+0]); + add_watchable(&accumulator,obj,i,TheWeakHashedAlist(obj)->whal_data[3*i+1]); + } + break; + } default: abort(); } return accumulator; @@ -372,6 +408,79 @@ } break; } + case Rectype_WeakHashedAlist_Key: { + var uintL n = (Lrecord_length(obj)-4) / 3; + var uintL i; + if (index == (uintL)~(uintL)0) { + gc_mark_with_watchset(TheWeakHashedAlist(obj)->whal_itable); + for (i = 0; i < n; i++) { + var object key = TheWeakHashedAlist(obj)->whal_data[3*i+0]; + if (!eq(key,unbound) && (gcinvariant_object_p(key) || alive(key))) + gc_mark_with_watchset(TheWeakHashedAlist(obj)->whal_data[3*i+1]); + } + } else { + i = index; + var object key = TheWeakHashedAlist(obj)->whal_data[3*i+0]; + if (!eq(key,unbound) && (gcinvariant_object_p(key) || alive(key))) + gc_mark_with_watchset(TheWeakHashedAlist(obj)->whal_data[3*i+1]); + } + break; + } + case Rectype_WeakHashedAlist_Value: { + var uintL n = (Lrecord_length(obj)-4) / 3; + var uintL i; + if (index == (uintL)~(uintL)0) { + gc_mark_with_watchset(TheWeakHashedAlist(obj)->whal_itable); + for (i = 0; i < n; i++) { + var object value = TheWeakHashedAlist(obj)->whal_data[3*i+1]; + if (!eq(value,unbound) && (gcinvariant_object_p(value) || alive(value))) + gc_mark_with_watchset(TheWeakHashedAlist(obj)->whal_data[3*i+0]); + } + } else { + i = index; + var object value = TheWeakHashedAlist(obj)->whal_data[3*i+1]; + if (!eq(value,unbound) && (gcinvariant_object_p(value) || alive(value))) + gc_mark_with_watchset(TheWeakHashedAlist(obj)->whal_data[3*i+0]); + } + break; + } + case Rectype_WeakHashedAlist_Either: + if (index == (uintL)~(uintL)0) { + gc_mark_with_watchset(TheWeakHashedAlist(obj)->whal_itable); + } + break; + case Rectype_WeakHashedAlist_Both: { + var uintL n = (Lrecord_length(obj)-4) / 3; + var uintL i; + if (index == (uintL)~(uintL)0) { + gc_mark_with_watchset(TheWeakHashedAlist(obj)->whal_itable); + for (i = 0; i < n; i++) { + var object key = TheWeakHashedAlist(obj)->whal_data[3*i+0]; + var object value = TheWeakHashedAlist(obj)->whal_data[3*i+1]; + if (!eq(key,unbound) && !eq(value,unbound)) { + var bool key_alive = (gcinvariant_object_p(key) || alive(key)); + var bool value_alive = (gcinvariant_object_p(value) || alive(value)); + if (key_alive && !value_alive) + gc_mark_with_watchset(value); + if (!key_alive && value_alive) + gc_mark_with_watchset(key); + } + } + } else { + i = index; + var object key = TheWeakHashedAlist(obj)->whal_data[3*i+0]; + var object value = TheWeakHashedAlist(obj)->whal_data[3*i+1]; + if (!eq(key,unbound) && !eq(value,unbound)) { + var bool key_alive = (gcinvariant_object_p(key) || alive(key)); + var bool value_alive = (gcinvariant_object_p(value) || alive(value)); + if (key_alive && !value_alive) + gc_mark_with_watchset(value); + if (!key_alive && value_alive) + gc_mark_with_watchset(key); + } + } + break; + } default: abort(); } } @@ -583,6 +692,124 @@ } return keep; } + case Rectype_WeakHashedAlist_Key: { + var uintL n = (Lrecord_length(obj)-4) / 3; + { + var object itable = TheWeakHashedAlist(obj)->whal_itable; + if (!eq(itable,unbound) && !alive(itable)) + abort(); + } + if (!gcinvariant_object_p(TheWeakHashedAlist(obj)->whal_freelist)) + abort(); + var bool keep = false; + var uintL i; + for (i = 0; i < n; i++) { + var object key = TheWeakHashedAlist(obj)->whal_data[3*i+0]; + if (eq(key,unbound)) + ; + else if (gcinvariant_object_p(key) || alive(key)) + keep = true; + else { + TheWeakHashedAlist(obj)->whal_data[3*i+0] = unbound; + TheWeakHashedAlist(obj)->whal_data[3*i+1] = unbound; + TheWeakHashedAlist(obj)->whal_count = fixnum_inc(TheWeakHashedAlist(obj)->whal_count,-1); + } + if (!gcinvariant_object_p(TheWeakHashedAlist(obj)->whal_data[3*i+2])) + abort(); + } + return keep; + } + case Rectype_WeakHashedAlist_Value: { + var uintL n = (Lrecord_length(obj)-4) / 3; + { + var object itable = TheWeakHashedAlist(obj)->whal_itable; + if (!eq(itable,unbound) && !alive(itable)) + abort(); + } + if (!gcinvariant_object_p(TheWeakHashedAlist(obj)->whal_freelist)) + abort(); + var bool keep = false; + var uintL i; + for (i = 0; i < n; i++) { + var object value = TheWeakHashedAlist(obj)->whal_data[3*i+1]; + if (eq(value,unbound)) + ; + else if (gcinvariant_object_p(value) || alive(value)) + keep = true; + else { + TheWeakHashedAlist(obj)->whal_data[3*i+0] = unbound; + TheWeakHashedAlist(obj)->whal_data[3*i+1] = unbound; + TheWeakHashedAlist(obj)->whal_count = fixnum_inc(TheWeakHashedAlist(obj)->whal_count,-1); + } + if (!gcinvariant_object_p(TheWeakHashedAlist(obj)->whal_data[3*i+2])) + abort(); + } + return keep; + } + case Rectype_WeakHashedAlist_Either: { + var uintL n = (Lrecord_length(obj)-4) / 3; + { + var object itable = TheWeakHashedAlist(obj)->whal_itable; + if (!eq(itable,unbound) && !alive(itable)) + abort(); + } + if (!gcinvariant_object_p(TheWeakHashedAlist(obj)->whal_freelist)) + abort(); + var bool keep = false; + var uintL i; + for (i = 0; i < n; i++) { + var object key = TheWeakHashedAlist(obj)->whal_data[3*i+0]; + var object value = TheWeakHashedAlist(obj)->whal_data[3*i+1]; + if (eq(key,unbound) && eq(value,unbound)) + ; + else if ((!eq(key,unbound) && (gcinvariant_object_p(key) || alive(key))) + && (!eq(value,unbound) && (gcinvariant_object_p(value) || alive(value)))) + # both alive + keep = true; + else { + TheWeakHashedAlist(obj)->whal_data[3*i+0] = unbound; + TheWeakHashedAlist(obj)->whal_data[3*i+1] = unbound; + TheWeakHashedAlist(obj)->whal_count = fixnum_inc(TheWeakHashedAlist(obj)->whal_count,-1); + } + if (!gcinvariant_object_p(TheWeakHashedAlist(obj)->whal_data[3*i+2])) + abort(); + } + return keep; + } + case Rectype_WeakHashedAlist_Both: { + var uintL n = (Lrecord_length(obj)-4) / 3; + { + var object itable = TheWeakHashedAlist(obj)->whal_itable; + if (!eq(itable,unbound) && !alive(itable)) + abort(); + } + if (!gcinvariant_object_p(TheWeakHashedAlist(obj)->whal_freelist)) + abort(); + var bool keep = false; + var uintL i; + for (i = 0; i < n; i++) { + var object key = TheWeakHashedAlist(obj)->whal_data[3*i+0]; + var object value = TheWeakHashedAlist(obj)->whal_data[3*i+1]; + if (eq(key,unbound) && eq(value,unbound)) + ; + else { + bool key_alive = (!eq(key,unbound) && (gcinvariant_object_p(key) || alive(key))); + bool value_alive = (!eq(value,unbound) && (gcinvariant_object_p(value) || alive(value))); + if (key_alive || value_alive) { + # key or value alive; the other one must be kept alive too. + if (!(key_alive && value_alive)) abort(); + keep = true; + } else { + TheWeakHashedAlist(obj)->whal_data[3*i+0] = unbound; + TheWeakHashedAlist(obj)->whal_data[3*i+1] = unbound; + TheWeakHashedAlist(obj)->whal_count = fixnum_inc(TheWeakHashedAlist(obj)->whal_count,-1); + } + } + if (!gcinvariant_object_p(TheWeakHashedAlist(obj)->whal_data[3*i+2])) + abort(); + } + return keep; + } default: abort(); } } @@ -708,6 +935,10 @@ case Rectype_WeakAlist_Value: case Rectype_WeakAlist_Either: case Rectype_WeakAlist_Both: + case Rectype_WeakHashedAlist_Key: + case Rectype_WeakHashedAlist_Value: + case Rectype_WeakHashedAlist_Either: + case Rectype_WeakHashedAlist_Both: return true; default: abort(); } Index: ChangeLog =================================================================== RCS file: /cvsroot/clisp/clisp/src/ChangeLog,v retrieving revision 1.3118 retrieving revision 1.3119 diff -u -d -r1.3118 -r1.3119 --- ChangeLog 1 Jun 2004 16:30:01 -0000 1.3118 +++ ChangeLog 2 Jun 2004 10:22:13 -0000 1.3119 @@ -1,3 +1,45 @@ +2004-05-09 Bruno Haible <br...@cl...> + + Merge ht_kvtable and ht_ntable. For weak hash tables, use + WeakHashedAlist instead of WeakAlist. + * lispbibl.d (Rectype_WeakHashedAlist_Key, + Rectype_WeakHashedAlist_Value, Rectype_WeakHashedAlist_Either, + Rectype_WeakHashedAlist_Both): New enum items. + (Hashtable): Remove ht_ntable field. + (hashtable_length): Decrement. + (kvtable_data): Update. + (WeakHashedAlist): New type. + (TheWeakHashedAlist): New macro. + (Lrecord_nonweak_length): Update. + (map_hashtable, map_hashtable_nogc): Update. + * spvw_gcmark.d (gc_mark): Handle Rectype_WeakHashedAlist_*. + * spvw_weak.d (max_watchset_count, get_watchset, + propagate_through_weak, weak_clean_dead, weak_must_activate): Handle + Rectype_WeakHashedAlist_*. + * spvw_circ.d (get_circ_mark, get_circ_unmark): Handle + Rectype_WeakHashedAlist_*. + * spvw_debug.d (nobject_out1): Update. + * hashtabl.d (HT_GOOD_P): Remove ht_ntable check. + (rehash, hash_lookup_builtin, hash_lookup_user): Use KVptr+2 instead of + Nptr. + (hash_store): Likewise. + (hash_table_weak_type): ht_kvtable is now a Rectype_WeakHashedAlist_*. + (allocate_kvt): Allocate a vector with 3*maxcount entries, or a + WeakHashedAlist. + (prepare_resize): Don't allocate an ntable any more. + (resize): Fill extended kvtable instead of ntable. + (clrhash, MAPHASH, HASH-TABLE-COUNT): Update. + (SYS::HASH-TABLE-ITERATE): Update. + (SYS::%SET-HASH-TABLE-WEAK-P): Update. + (CLASS-TUPLE-GETHASH): Use KVptr+2 instead of the ntable. + * io.d (pr_kvtable): Update. + (pr_orecord): Update hashtable handling. Add Rectype_WeakHashedAlist_* + handling. + * predtype.d (hash_table_equalp): Update. + (TYPE-OF, CLASS-OF): Handle Rectype_WeakHashedAlist_*. + (enum_hs_internal_weak_hashed_alist): New enum item. + (heap_statistics_mapper): Handle Rectype_WeakHashedAlist_*. + 2004-06-01 Sam Steingold <sd...@gn...> more errors are recoverable Index: constsym.d =================================================================== RCS file: /cvsroot/clisp/clisp/src/constsym.d,v retrieving revision 1.243 retrieving revision 1.244 diff -u -d -r1.243 -r1.244 --- constsym.d 1 Jun 2004 10:34:20 -0000 1.243 +++ constsym.d 2 Jun 2004 10:22:12 -0000 1.244 @@ -1662,6 +1662,7 @@ LISPSYM(weak_and_mapping,"WEAK-AND-MAPPING",ext) /* type in PREDTYPE */ LISPSYM(weak_or_mapping,"WEAK-OR-MAPPING",ext) /* type in PREDTYPE */ LISPSYM(internal_weak_alist,"INTERNAL-WEAK-ALIST",system) /* type in PREDTYPE */ +LISPSYM(internal_weak_hashed_alist,"INTERNAL-WEAK-HASHED-ALIST",system) /* type in PREDTYPE */ LISPSYM(compiled_function,"COMPILED-FUNCTION",lisp) /* type in PREDTYPE */ LISPSYM(frame_pointer,"FRAME-POINTER",system) /* type in PREDTYPE */ LISPSYM(read_label,"READ-LABEL",system) /* type in PREDTYPE */ Index: hashtabl.d =================================================================== RCS file: /cvsroot/clisp/clisp/src/hashtabl.d,v retrieving revision 1.82 retrieving revision 1.83 diff -u -d -r1.82 -r1.83 --- hashtabl.d 1 Jun 2004 15:34:57 -0000 1.82 +++ hashtabl.d 2 Jun 2004 10:22:11 -0000 1.83 @@ -24,20 +24,21 @@ (hascode Key)] with lists. Due to the fact that the key-value-vector (again because of MAPHASH) should be uninfluenced on GC and GC changes the set of collisions, we need an additional index-vector, - called the next-vector, which lies "in parallel with" - the key-value-vector and which contains a "list"-structure. + called the next-vector, which is interlaced with the key-value-vector + and which contains a "list"-structure. sketch: key --> (hashcode key) as index in index-vector. Key1 --> 3, Key2 --> 1, Key4 --> 3. index-vector #( nix {indexkey2} nix {indexkey1,indexkey4} nix ... ) = #( nix 1 nix 0 nix ... ) - next-vector #( 3 nix leer nix leer ) - key-value-vector #( key1 val1 key2 val2 leer leer key4 val4 leer leer) + next-vector #( 3 nix leer nix leer) + key-value-vector #( key1 val1 3 key2 val2 nix leer leer leer key4 val4 nix leer leer leer) access to a (Key . Value) - pair works as follows: index := (aref Index-Vektor (hashcode Key)) until index = nix - if (eql Key (aref KVVektor 2*index)) return (aref KVVektor 2*index+1) + if (eql Key (aref KVVektor 3*index)) return (aref KVVektor 3*index+1) index := (aref Next-Vektor index) ; take "CDR" of the list + = (aref KVVektor 3*index+2) return notfound. If the index-vector is enlarged, all hashcodes and the content of index-vector and the content of next-vector have to be recalculated. @@ -78,8 +79,7 @@ ht_size uintL>0 = length of the ITABLE ht_maxcount Fixnum>0 = length of the NTABLE ht_itable index-vector of length SIZE, contains indices - ht_ntable next-vector of length MAXCOUNT, contains indices - ht_kvtable key-value-vector, vector of length 2*MAXCOUNT + ht_kvtable key-value-vector, vector of length 3*MAXCOUNT ht_freelist start-index of the free-list in next-vector ht_count number of entries in the table (for weak hash-tables, more precisely: total length of all lists in the @@ -101,10 +101,7 @@ posfixnump(TheHashtable(ht)->ht_mincount) && \ simple_vector_p(TheHashtable(ht)->ht_itable) && \ (vector_length(TheHashtable(ht)->ht_itable) == \ - TheHashtable(ht)->ht_size) && \ - simple_vector_p(TheHashtable(ht)->ht_ntable) && \ - (vector_length(TheHashtable(ht)->ht_ntable) == \ - posfixnum_to_L(TheHashtable(ht)->ht_maxcount))) + TheHashtable(ht)->ht_size)) /* Rotates a hashcode x by n bits to the left (0<n<32). rotate_left(n,x) */ @@ -925,23 +922,20 @@ dotimespL(count,count, { *ptr++ = nix; } ); } /* build up "list"-structure element-wise: */ - var object Nvektor = TheHashtable(ht)->ht_ntable; /* next-vector */ var object index = TheHashtable(ht)->ht_maxcount; /* MAXCOUNT */ var uintL maxcount = posfixnum_to_L(index); - var gcv_object_t* Nptr = &TheSvector(Nvektor)->data[maxcount]; - var gcv_object_t* KVptr = ht_kvt_data(ht) + 2*maxcount; /* end of kvtable */ + var gcv_object_t* KVptr = ht_kvt_data(ht) + 3*maxcount; /* end of kvtable */ var object freelist = nix; var object count = Fixnum_0; var bool user_defined_p = (ht_test_code(record_flags(TheHashtable(ht)))==0); while (!eq(index,Fixnum_0)) { /* index=0 -> loop finished */ /* traverse the key-value-vector and the next-vector. index = MAXCOUNT,...,0 (Fixnum), - Nptr = &TheSvector(Nvektor)->data[index], - KVptr = &TheSvector(kvtable)->data[index], + KVptr = &TheSvector(kvtable)->data[3*index], freelist = freelist up to now, count = pair-counter as fixnum. */ index = fixnum_inc(index,-1); /* decrement index */ - KVptr -= 2; + KVptr -= 3; var object key = KVptr[0]; /* next key */ if (!eq(key,leer)) { /* /= "leer" ? */ if (user_defined_p) @@ -953,19 +947,17 @@ var uintL maxcount1 = posfixnum_to_L(index)+1; ht = popSTACK(); Ivektor = TheHashtable(ht)->ht_itable; - Nvektor = TheHashtable(ht)->ht_ntable; - Nptr = &TheSvector(Nvektor)->data[maxcount1]; - KVptr = ht_kvt_data(ht) + 2*maxcount1; + KVptr = ht_kvt_data(ht) + 3*maxcount1; } /* "list", that starts at entry hashindex, in order to extend index: copy entry from index-vector to the next-vector end replace with index (a pointer to this location) : */ var gcv_object_t* Iptr = &TheSvector(Ivektor)->data[hashindex]; - *--Nptr = *Iptr; /* copy entry into the next-vector */ + KVptr[2] = *Iptr; /* copy entry into the next-vector */ *Iptr = index; /* and replace pointer to it */ count = fixnum_inc(count,1); /* count */ } else { /* lengthen freelist in the next-vector: */ - *--Nptr = freelist; freelist = index; + KVptr[2] = freelist; freelist = index; } } TheHashtable(ht)->ht_freelist = freelist; /* save freelist */ @@ -1000,10 +992,9 @@ while (!eq(*Nptr,nix)) { /* track "list" : "list" finished -> not found */ var int index = posfixnum_to_L(*Nptr); /* next index */ var gcv_object_t* Iptr = Nptr; - Nptr = /* pointer to entry in next-vector */ - TheSvector(TheHashtable(ht)->ht_ntable)->data + index; var gcv_object_t* KVptr = /* pointer to entries in key-value-vector */ - kvt_data + 2*index; + kvt_data + 3*index; + Nptr = &KVptr[2]; /* pointer to index of next entry */ var object key = KVptr[0]; if (eq(key,unbound)) { /* weak HT - obsolete key and value */ @@ -1061,10 +1052,9 @@ while (!eq(*Nptr,nix)) { /* track "list" : "list" finished -> not found */ var int index = posfixnum_to_L(*Nptr); /* next index */ var gcv_object_t* Iptr = Nptr; - Nptr = /* pointer to entry in next-vector */ - TheSvector(TheHashtable(ht)->ht_ntable)->data + index; var gcv_object_t* KVptr = /* pointer to entries in key-value-vector */ - kvt_data + 2*index; + kvt_data + 3*index; + Nptr = &KVptr[2]; /* pointer to index of next entry */ var object key = KVptr[0]; if (eq(key,unbound)) { /* weak HT - obsolete key and value */ @@ -1081,8 +1071,7 @@ i_n = Iptr - Nptr; pushSTACK(key); pushSTACK(obj); funcall(TheHashtable(ht)->ht_test,2); obj = popSTACK(); ht = popSTACK(); kvt_data = ht_kvt_data(ht); - Nptr = TheSvector(TheHashtable(ht)->ht_ntable)->data + index; - KVptr = kvt_data + 2*index; + KVptr = kvt_data + 3*index; Nptr = &KVptr[2]; Iptr = Nptr + i_n; if (!nullp(value1)) { /* object obj found */ @@ -1118,27 +1107,25 @@ #define hash_store(key,value) \ do { \ var uintL index = posfixnum_to_L(freelist); /* free index */ \ - var gcv_object_t* Nptr = /* address of the free entry in next-vector */ \ - &TheSvector(TheHashtable(ht)->ht_ntable)->data[index]; \ var object kvtable = TheHashtable(ht)->ht_kvtable; \ /* address of the free entries in key-value-vector: */ \ - var gcv_object_t* KVptr = kvtable_data(kvtable) + 2*index; \ + var gcv_object_t* KVptr = kvtable_data(kvtable) + 3*index; \ set_break_sem_2(); /* protect from breaks */ \ /* increment COUNT: */ \ TheHashtable(ht)->ht_count = fixnum_inc(TheHashtable(ht)->ht_count,1); \ if (!simple_vector_p(kvtable)) { /* ht_weak_p(ht) */ \ - TheWeakAlist(kvtable)->wal_count = fixnum_inc(TheWeakAlist(kvtable)->wal_count,1); \ + TheWeakHashedAlist(kvtable)->whal_count = fixnum_inc(TheWeakHashedAlist(kvtable)->whal_count,1); \ } \ - /* shorten free-list: */ \ - TheHashtable(ht)->ht_freelist = *Nptr; \ /* save key and value: */ \ *KVptr++ = key; *KVptr++ = value; \ + /* shorten free-list: */ \ + TheHashtable(ht)->ht_freelist = *KVptr; \ /* insert free list-element index into the "list" \ (put it after resize to the list-start, \ because Iptr points into the index-vector, \ else put it to the list-end, \ because hash_lookup was ended with *Iptr=nix): */ \ - *Nptr = *Iptr; *Iptr = freelist; \ + *KVptr = *Iptr; *Iptr = freelist; \ clr_break_sem_2(); /* allow breaks again */ \ } while(0) @@ -1151,13 +1138,13 @@ return NIL; else { switch (Record_type(kvt)) { - case Rectype_WeakAlist_Key: + case Rectype_WeakHashedAlist_Key: return S(Kkey); - case Rectype_WeakAlist_Value: + case Rectype_WeakHashedAlist_Value: return S(Kvalue); - case Rectype_WeakAlist_Either: + case Rectype_WeakHashedAlist_Either: return S(Keither); - case Rectype_WeakAlist_Both: + case Rectype_WeakHashedAlist_Both: return S(Kboth); default: NOTREACHED; } @@ -1172,26 +1159,29 @@ can trigger GC */ local inline object allocate_kvt (object weak, uintL maxcount) { if (nullp(weak)) - return allocate_vector(2*maxcount); + return allocate_vector(3*maxcount); else { var sintB rectype; if (eq(weak,S(Kkey))) # :KEY - rectype = Rectype_WeakAlist_Key; + rectype = Rectype_WeakHashedAlist_Key; else if (eq(weak,S(Kvalue))) # :VALUE - rectype = Rectype_WeakAlist_Value; + rectype = Rectype_WeakHashedAlist_Value; else if (eq(weak,S(Keither))) # :EITHER - rectype = Rectype_WeakAlist_Either; + rectype = Rectype_WeakHashedAlist_Either; else if (eq(weak,S(Kboth))) # :BOTH - rectype = Rectype_WeakAlist_Both; + rectype = Rectype_WeakHashedAlist_Both; else NOTREACHED; - var object kvt = allocate_lrecord(rectype,2+2*maxcount,lrecord_type); - TheWeakAlist(kvt)->wp_cdr = unbound; /* a GC-invariant dummy */ - TheWeakAlist(kvt)->wal_count = Fixnum_0; + var object kvt = allocate_lrecord(rectype,4+3*maxcount,lrecord_type); + TheWeakHashedAlist(kvt)->wp_cdr = unbound; /* a GC-invariant dummy */ + TheWeakHashedAlist(kvt)->whal_itable = unbound; + TheWeakHashedAlist(kvt)->whal_count = Fixnum_0; + TheWeakHashedAlist(kvt)->whal_freelist = nix; var uintL i; for (i = 0; i < maxcount; i++) { - TheWeakAlist(kvt)->wal_data[2*i+0] = unbound; - TheWeakAlist(kvt)->wal_data[2*i+1] = unbound; + TheWeakHashedAlist(kvt)->whal_data[3*i+0] = unbound; + TheWeakHashedAlist(kvt)->whal_data[3*i+1] = unbound; + TheWeakHashedAlist(kvt)->whal_data[3*i+2] = leer; } activate_weak(kvt); /* add to O(all_weakpointers) */ return kvt; @@ -1199,14 +1189,13 @@ } /* UP: Provides the numbers and vectors for a new hash-table. - prepare_resize(maxcount,mincount_threshold) + prepare_resize(maxcount,mincount_threshold,weak) > maxcount: wished new size MAXCOUNT > mincount_threshold: short-float MINCOUNT-THRESHOLD > weak: NIL or :KEY or :VALUE or :EITHER or :BOTH < result: maxcount - < stack-layout: MAXCOUNT, SIZE, MINCOUNT, - index-vector, next-vector, key-value-vector. - decreases STACK by 6 + < stack-layout: MAXCOUNT, SIZE, MINCOUNT, index-vector, key-value-vector. + decreases STACK by 5 can trigger GC */ local uintL prepare_resize (object maxcount, object mincount_threshold, object weak) { @@ -1231,7 +1220,6 @@ /* stack-layout: MAXCOUNT, SIZE, MINCOUNT. allocate new vectors: */ pushSTACK(allocate_vector(sizeL)); /* supply index-vector */ - pushSTACK(allocate_vector(maxcountL)); /* supply next-vector */ pushSTACK(allocate_kvt(weak,maxcountL)); /* supply key-value-vector */ /* finished. */ return maxcountL; @@ -1261,7 +1249,6 @@ hash_table_weak_type(ht)); /* no GC from now on! */ var object KVvektor = popSTACK(); /* new key-value-vector */ - var object Nvektor = popSTACK(); /* next-vector */ var object Ivektor = popSTACK(); /* index-vector */ var object mincount = popSTACK(); /* MINCOUNT */ var object size = popSTACK(); /* SIZE */ @@ -1281,6 +1268,7 @@ dotimesL(oldcount,oldcount, { var object nextkey = *oldKVptr++; /* next key */ var object nextvalue = *oldKVptr++; /* and value */ + oldKVptr++; if (!eq(nextkey,leer)) { /* take over the entry into the new key-value-vector: */ if (count==0) { /* is the new vector already full? */ @@ -1291,11 +1279,12 @@ } count--; *KVptr++ = nextkey; *KVptr++ = nextvalue; /* file in new vector */ + *KVptr++ = nix; counter = fixnum_inc(counter,1); /* and count */ } }); /* Mark 'count' pairs of the new key-value-vector as "leer" : */ - dotimesL(count,count, { *KVptr++ = leer; *KVptr++ = leer; } ); + dotimesL(count,count, { *KVptr++ = leer; *KVptr++ = leer; *KVptr++ = leer; } ); /* modify hash-table: */ set_break_sem_2(); /* protect from breaks */ set_ht_invalid(TheHashtable(ht)); /* table must still be reorganized */ @@ -1303,11 +1292,10 @@ TheHashtable(ht)->ht_itable = Ivektor; /* enter new index-vector */ TheHashtable(ht)->ht_maxcount = maxcount; /* enter new MAXCOUNT */ TheHashtable(ht)->ht_freelist = nix; /* dummy as free-list */ - TheHashtable(ht)->ht_ntable = Nvektor; /* enter new next-vector */ TheHashtable(ht)->ht_kvtable = KVvektor; /* enter new key-value-vector */ TheHashtable(ht)->ht_count = counter; /* enter COUNT (for consistency) */ if (!simple_vector_p(KVvektor)) - TheWeakAlist(KVvektor)->wal_count = counter; + TheWeakHashedAlist(KVvektor)->whal_count = counter; TheHashtable(ht)->ht_mincount = mincount; /* enter new MINCOUNT */ clr_break_sem_2(); /* allow breaks again */ return ht; @@ -1364,6 +1352,7 @@ var gcv_object_t* KVptr = ht_kvt_data(ht); dotimespL(count,count, { /* in each entry */ *KVptr++ = leer; *KVptr++ = leer; /* deplete key and value */ + *KVptr++ = leer; /* and next-index */ }); } } @@ -1566,7 +1555,6 @@ var object ht = allocate_hash_table(); /* new hash-tabelle */ /* fill: */ TheHashtable(ht)->ht_kvtable = popSTACK(); /* key-value-vector */ - TheHashtable(ht)->ht_ntable = popSTACK(); /* next-vector */ TheHashtable(ht)->ht_itable = popSTACK(); /* index-vector */ TheHashtable(ht)->ht_mincount = popSTACK(); /* MINCOUNT */ TheHashtable(ht)->ht_size = posfixnum_to_L(popSTACK()); /* SIZE */ @@ -1689,7 +1677,7 @@ VALUES1(KVptr[1] = popSTACK()); skipSTACK(2); } else { /* not found -> make new entry: */ var object freelist; - hash_prepare_store(1,2); /* ht==STACK_1, obj==STACK_2*/ + hash_prepare_store(1,2); /* ht==STACK_1, obj==STACK_2 */ hash_store(STACK_2,STACK_0); /* make entry */ VALUES1(popSTACK()); /* value as value */ skipSTACK(2); @@ -1733,8 +1721,8 @@ if (hash_lookup(ht,key,&KVptr,&Nptr,&Iptr)) { /* found -> drop from the hash-table: */ var object index = *Iptr; /* index in next-vector */ - /* with Nptr = &TheSvector(TheHashtable(ht)->ht_ntable)->data[index] - and KVptr = ht_kvt_data(ht) + [2*index] */ + /* with Nptr = ht_kvt_data(ht) + 3*index+2 + and KVptr = ht_kvt_data(ht) + 3*index */ ht = STACK_0; skipSTACK(2); set_break_sem_2(); /* protect from breaks */ *Iptr = *Nptr; /* shorten "list" */ @@ -1772,11 +1760,11 @@ var object ht = check_hashtable(STACK_0); /* hashtable argument */ /* traverse the key-value-vector in reverse direction and call the function for all key-value-pairs with key /= "leer" : */ - var uintL index = 2*posfixnum_to_L(TheHashtable(ht)->ht_maxcount); + var uintL index = 3*posfixnum_to_L(TheHashtable(ht)->ht_maxcount); STACK_0 = TheHashtable(ht)->ht_kvtable; /* key-value-vector */ /* stack-layout: function, key-value-vector. */ while (index) { - index -= 2; + index -= 3; var gcv_object_t* KVptr = kvtable_data(STACK_0) + index; if (!eq(KVptr[0],leer)) { /* key /= "leer" ? */ pushSTACK(KVptr[0]); /* key as the 1st argument */ @@ -1804,9 +1792,9 @@ var object count; if (ht_weak_p(ht)) # The TheHashtable(ht)->ht_count counts the number of used entries in the - # next-vector. This is >= TheWeakAlist(kvt)->wal_count. The latter is - # right because it is maintained by the GC. - count = TheWeakAlist(TheHashtable(ht)->ht_kvtable)->wal_count; + # next-vector. This is >= TheWeakHashedAlist(kvt)->whal_count. The latter + # is right because it is maintained by the GC. + count = TheWeakHashedAlist(TheHashtable(ht)->ht_kvtable)->whal_count; else count = TheHashtable(ht)->ht_count; VALUES1(count); /* fixnum COUNT as value */ @@ -1889,7 +1877,7 @@ if (index==0) /* index=0 -> no more elements */ break; Cdr(state) = fixnum_inc(Cdr(state),-1); /* decrement index */ - var gcv_object_t* KVptr = kvtable_data(table) + 2*index-2; + var gcv_object_t* KVptr = kvtable_data(table) + 3*index-3; if (!eq(KVptr[0],leer)) { /* Key /= "leer" ? */ VALUES3(T, KVptr[0], /* key as the 2nd value */ @@ -1926,15 +1914,15 @@ } ht = STACK_0; var object old_kvt = TheHashtable(ht)->ht_kvtable; - copy_mem_o(kvtable_data(new_kvt),kvtable_data(old_kvt),2*maxcount); + copy_mem_o(kvtable_data(new_kvt),kvtable_data(old_kvt),3*maxcount); if (!simple_vector_p(new_kvt)) - TheWeakAlist(new_kvt)->wal_count = - (simple_vector_p(old_kvt) ? TheHashtable(ht)->ht_count : TheWeakAlist(old_kvt)->wal_count); + TheWeakHashedAlist(new_kvt)->whal_count = + (simple_vector_p(old_kvt) ? TheHashtable(ht)->ht_count : TheWeakHashedAlist(old_kvt)->whal_count); TheHashtable(ht)->ht_kvtable = new_kvt; /* FIXME: When switching from a weak to a non-weak hash table, the lists in the next-vector need to be cleaned up: remove stale entries, so that ht_count is decremented to become equal to - TheWeakAlist(old_kvt)->wal_count. */ + TheWeakHashedAlist(old_kvt)->whal_count. */ } VALUES1(hash_table_weak_type(popSTACK())); } @@ -2067,14 +2055,13 @@ &TheSvector(TheHashtable(ht)->ht_itable)->data[hashindex]; while (!eq(*Nptr,nix)) { /* track "list" : "list" finished -> not found */ var uintL index = posfixnum_to_L(*Nptr); /* next index */ - Nptr = /* pointer to entry in next-vector */ - &TheSvector(TheHashtable(ht)->ht_ntable)->data[index]; var gcv_object_t* KVptr = /* pointer to entries in key-value-vector */ - ht_kvt_data(ht)+2*index; + ht_kvt_data(ht)+3*index; if (equal_tuple(KVptr[0],argcount,rest_args_pointer)) { /* compare key */ /* found */ VALUES1(KVptr[1]); goto fertig; /* Value as value */ } + Nptr = &KVptr[2]; /* pointer to index of next entry */ } } /* not found */ Index: spvw_circ.d =================================================================== RCS file: /cvsroot/clisp/clisp/src/spvw_circ.d,v retrieving revision 1.28 retrieving revision 1.29 diff -u -d -r1.28 -r1.29 --- spvw_circ.d 1 Jun 2004 10:25:38 -0000 1.28 +++ spvw_circ.d 2 Jun 2004 10:22:12 -0000 1.29 @@ -588,17 +588,17 @@ case Rectype_WeakAlist_Value: case Rectype_WeakAlist_Either: case Rectype_WeakAlist_Both: + case Rectype_WeakHashedAlist_Key: + case Rectype_WeakHashedAlist_Value: + case Rectype_WeakHashedAlist_Either: + case Rectype_WeakHashedAlist_Both: { - var uintL count = (Lrecord_length(obj)-2)/2; - if (count > 0) { - var gcv_object_t* ptr = &TheWeakAlist(obj)->wal_data[0]; - if (SP_overflow()) # check SP-depth - longjmp(env->abbruch_context,true); # abort - dotimespC(count,count, { - get_circ_mark(*ptr++,env); # mark key (recursive) - get_circ_mark(*ptr++,env); # mark value (recursive) - }); - } + var uintL count = Lrecord_length(obj)-1; # don't mark wp_cdr + # mark count>0 components, starting from recdata[1] + var gcv_object_t* ptr = &TheLrecord(obj)->recdata[1]; + if (SP_overflow()) # check SP-depth + longjmp(env->abbruch_context,true); # abort + dotimespC(count,count, { get_circ_mark(*ptr++,env); } ); # mark components (recursive) } goto m_end; default: break; @@ -949,17 +949,17 @@ case Rectype_WeakAlist_Value: case Rectype_WeakAlist_Either: case Rectype_WeakAlist_Both: + case Rectype_WeakHashedAlist_Key: + case Rectype_WeakHashedAlist_Value: + case Rectype_WeakHashedAlist_Either: + case Rectype_WeakHashedAlist_Both: { - var uintL count = (Lrecord_length(obj)-2)/2; - if (count > 0) { - var gcv_object_t* ptr = &TheWeakAlist(obj)->wal_data[0]; - if (SP_overflow()) # check SP-depth - longjmp(env->abbruch_context,true); # abort - dotimespC(count,count, { - get_circ_mark(*ptr++,env); # mark key (recursive) - get_circ_mark(*ptr++,env); # mark value (recursive) - }); - } + var uintL count = Lrecord_length(obj)-1; # don't mark wp_cdr + # mark count>0 components, starting from recdata[1] + var gcv_object_t* ptr = &TheLrecord(obj)->recdata[1]; + if (SP_overflow()) # check SP-depth + longjmp(env->abbruch_context,true); # abort + dotimespC(count,count, { get_circ_mark(*ptr++,env); } ); # mark components (recursive) } goto m_end; default: break; @@ -1186,15 +1186,14 @@ case Rectype_WeakAlist_Value: case Rectype_WeakAlist_Either: case Rectype_WeakAlist_Both: + case Rectype_WeakHashedAlist_Key: + case Rectype_WeakHashedAlist_Value: + case Rectype_WeakHashedAlist_Either: + case Rectype_WeakHashedAlist_Both: { - var uintL count = (Lrecord_length(obj)-2)/2; - if (count > 0) { - var gcv_object_t* ptr = &TheWeakAlist(obj)->wal_data[0]; - dotimespC(count,count, { - get_circ_unmark(*ptr++,env); # mark key (recursive) - get_circ_unmark(*ptr++,env); # mark value (recursive) - }); - } + var uintL count = Lrecord_length(obj)-1; + var gcv_object_t* ptr = &TheLrecord(obj)->recdata[1]; + dotimespC(count,count, { get_circ_unmark(*ptr++,env); } ); # unmark components (recursive) } goto u_end; default: break; Index: spvw_gcmark.d =================================================================== RCS file: /cvsroot/clisp/clisp/src/spvw_gcmark.d,v retrieving revision 1.4 retrieving revision 1.5 diff -u -d -r1.4 -r1.5 --- spvw_gcmark.d 26 May 2004 11:17:07 -0000 1.4 +++ spvw_gcmark.d 2 Jun 2004 10:22:12 -0000 1.5 @@ -297,7 +297,11 @@ case Rectype_WeakAlist_Key: case Rectype_WeakAlist_Value: case Rectype_WeakAlist_Either: - case Rectype_WeakAlist_Both: /* Lrecord */ + case Rectype_WeakAlist_Both: + case Rectype_WeakHashedAlist_Key: + case Rectype_WeakHashedAlist_Value: + case Rectype_WeakHashedAlist_Either: + case Rectype_WeakHashedAlist_Both: /* Lrecord */ down_lrecord(); default: /* Srecord/Xrecord */ down_sxrecord(); Index: lispbibl.d =================================================================== RCS file: /cvsroot/clisp/clisp/src/lispbibl.d,v retrieving revision 1.510 retrieving revision 1.511 diff -u -d -r1.510 -r1.511 --- lispbibl.d 1 Jun 2004 10:32:55 -0000 1.510 +++ lispbibl.d 2 Jun 2004 10:22:11 -0000 1.511 @@ -4168,6 +4168,10 @@ Rectype_WeakAlist_Value, Rectype_WeakAlist_Either, Rectype_WeakAlist_Both, + Rectype_WeakHashedAlist_Key, + Rectype_WeakHashedAlist_Value, + Rectype_WeakHashedAlist_Either, + Rectype_WeakHashedAlist_Both, rectype_for_broken_compilers_that_dont_like_trailing_commas }; @@ -4907,7 +4911,6 @@ #endif gcv_object_t ht_maxcount _attribute_aligned_object_; gcv_object_t ht_itable _attribute_aligned_object_; - gcv_object_t ht_ntable _attribute_aligned_object_; gcv_object_t ht_kvtable _attribute_aligned_object_; gcv_object_t ht_lookupfn _attribute_aligned_object_; gcv_object_t ht_hashcodefn _attribute_aligned_object_; @@ -4922,9 +4925,9 @@ uintL ht_size; } * Hashtable; #ifdef GENERATIONAL_GC - #define hashtable_length 15 -#else #define hashtable_length 14 +#else + #define hashtable_length 13 #endif #define hashtable_xlength (sizeof(*(Hashtable)0)-offsetofa(record_,recdata)-hashtable_length*sizeof(gcv_object_t)) # Mark a Hash Table as new to reorganize @@ -4960,7 +4963,7 @@ !simple_vector_p(TheHashtable(ht)->ht_kvtable) # Get a pointer to the kvtable data array. #define kvtable_data(kvt) \ - (simple_vector_p(kvt) ? TheSvector(kvt)->data : TheWeakAlist(kvt)->wal_data) + (simple_vector_p(kvt) ? TheSvector(kvt)->data : TheWeakHashedAlist(kvt)->whal_data) #define ht_kvt_data(ht) kvtable_data(TheHashtable(ht)->ht_kvtable) # Readtables @@ -5252,6 +5255,16 @@ } * MutableWeakAlist; #define mutableweakalist_length ((sizeof(*(MutableWeakAlist)0)-offsetofa(record_,recdata))/sizeof(gcv_object_t)) +# weak hashed alist (rectype = Rectype_WeakHashedAlist_{Key,Value,Either,Both}) +typedef struct { + LRECORD_HEADER + gcv_object_t wp_cdr _attribute_aligned_object_; # active weak-pointers form a chained list + gcv_object_t whal_itable _attribute_aligned_object_; # index-vector + gcv_object_t whal_count _attribute_aligned_object_; # remaining pairs + gcv_object_t whal_freelist _attribute_aligned_object_; # start index of freelist + gcv_object_t whal_data[unspecified] _attribute_aligned_object_; # (key, value, next) triples +} * WeakHashedAlist; + # Finalizer typedef struct { XRECORD_HEADER @@ -5944,6 +5957,7 @@ #define TheWeakOrMapping(obj) ((WeakOrMapping)(type_pointable(lrecord_type,obj))) #define TheMutableWeakAlist(obj) ((MutableWeakAlist)(type_pointable(orecord_type,obj))) #define TheWeakAlist(obj) ((WeakAlist)(type_pointable(lrecord_type,obj))) + #define TheWeakHashedAlist(obj) ((WeakHashedAlist)(type_pointable(lrecord_type,obj))) #define TheFinalizer(obj) ((Finalizer)(type_pointable(orecord_type,obj))) #ifdef SOCKET_STREAMS #define TheSocketServer(obj) ((Socket_server)(type_pointable(orecord_type,obj))) @@ -6102,6 +6116,7 @@ #define TheWeakOrMapping(obj) ((WeakOrMapping)(ngci_pointable(obj)-varobject_bias)) #define TheMutableWeakAlist(obj) ((MutableWeakAlist)(ngci_pointable(obj)-varobject_bias)) #define TheWeakAlist(obj) ((WeakAlist)(ngci_pointable(obj)-varobject_bias)) + #define TheWeakHashedAlist(obj) ((WeakHashedAlist)(ngci_pointable(obj)-varobject_bias)) #define TheFinalizer(obj) ((Finalizer)(ngci_pointable(obj)-varobject_bias)) #ifdef SOCKET_STREAMS #define TheSocketServer(obj) ((Socket_server)(ngci_pointable(obj)-varobject_bias)) @@ -6165,9 +6180,9 @@ : Xrecord_length(obj))) # Length of an Lrecord, ignoring weak pointers: #define Lrecord_nonweak_length(obj) \ - ((Record_type(obj) >= Rectype_WeakList \ - && Record_type(obj) <= Rectype_WeakAlist_Both) \ - ? 0 \ + ((Record_type(obj) >= Rectype_WeakList \ + && Record_type(obj) <= Rectype_WeakHashedAlist_Both) \ + ? 0 \ : Lrecord_length(obj)) # Length (number of objects) of a record, obj has to be a Record: #define Record_length(obj) \ @@ -12219,13 +12234,14 @@ # Calls 'statement', where key and value are a pair from the table. # The first form is necessary, if the statement can trigger GC. #define map_hashtable(ht,key,value,statement) \ - do { var object ht_from_map_hashtable = (ht); \ + do { \ + var object ht_from_map_hashtable = (ht); \ var uintL index_from_map_hashtable = \ - 2*posfixnum_to_L(TheHashtable(ht_from_map_hashtable)->ht_maxcount); \ + 3*posfixnum_to_L(TheHashtable(ht_from_map_hashtable)->ht_maxcount); \ pushSTACK(TheHashtable(ht_from_map_hashtable)->ht_kvtable); \ loop { \ if (index_from_map_hashtable==0) break; \ - index_from_map_hashtable -= 2; \ + index_from_map_hashtable -= 3; \ {var gcv_object_t* KVptr_from_map_hashtable = \ kvtable_data(STACK_0)+index_from_map_hashtable; \ var object key = KVptr_from_map_hashtable[0]; \ @@ -12236,14 +12252,15 @@ skipSTACK(1); \ } while(0) #define map_hashtable_nogc(ht,key,value,statement) \ - do { var object ht_from_map_hashtable = (ht); \ + do { \ + var object ht_from_map_hashtable = (ht); \ var uintL index_from_map_hashtable = \ posfixnum_to_L(TheHashtable(ht_from_map_hashtable)->ht_maxcount); \ var gcv_object_t* KVptr_from_map_hashtable = \ - ht_kvt_data(ht_from_map_hashtable) + 2*index_from_map_hashtable; \ + ht_kvt_data(ht_from_map_hashtable) + 3*index_from_map_hashtable; \ loop { \ if (index_from_map_hashtable==0) break; \ - index_from_map_hashtable--; KVptr_from_map_hashtable -= 2; \ + index_from_map_hashtable--; KVptr_from_map_hashtable -= 3; \ { var object key = KVptr_from_map_hashtable[0]; \ if (boundp(key)) { \ var object value = KVptr_from_map_hashtable[1]; \ Index: spvw_debug.d =================================================================== RCS file: /cvsroot/clisp/clisp/src/spvw_debug.d,v retrieving revision 1.47 retrieving revision 1.48 diff -u -d -r1.47 -r1.48 --- spvw_debug.d 27 May 2004 11:10:34 -0000 1.47 +++ spvw_debug.d 2 Jun 2004 10:22:12 -0000 1.48 @@ -185,7 +185,6 @@ break; } fputs("\n I=",out); XOUT(TheHashtable(obj)->ht_itable); - fputs("\n N=",out); XOUT(TheHashtable(obj)->ht_ntable); fputs("\n KV=",out); XOUT(TheHashtable(obj)->ht_kvtable); fputc(')',out); } else if (packagep(obj)) { Index: io.d =================================================================== RCS file: /cvsroot/clisp/clisp/src/io.d,v retrieving revision 1.227 retrieving revision 1.228 diff -u -d -r1.227 -r1.228 --- io.d 26 May 2004 11:17:05 -0000 1.227 +++ io.d 2 Jun 2004 10:22:09 -0000 1.228 @@ -7577,7 +7577,7 @@ loop { if (index==0) # finished kvtable? goto kvt_finish; - index -= 2; # decrease index + index -= 3; # decrease index if (boundp(kvtable_data(*kvt)[index+0])) /* Key /= "empty" ? */ break; } @@ -8459,7 +8459,7 @@ { var uintL count = posfixnum_to_L(TheHashtable(*obj_)->ht_count); var uintL index = # move Index into the Key-Value-Vector - 2*posfixnum_to_L(TheHashtable(obj)->ht_maxcount); + 3*posfixnum_to_L(TheHashtable(obj)->ht_maxcount); pushSTACK(TheHashtable(obj)->ht_kvtable); # Key-Value-Vector JUSTIFY_SPACE; # print Space # test for attaining of *PRINT-LINES* : @@ -9295,6 +9295,13 @@ CHECK_PRINT_READABLY(obj); write_sstring_case(stream_,O(printstring_internal_weak_alist)); break; + case Rectype_WeakHashedAlist_Key: + case Rectype_WeakHashedAlist_Value: + case Rectype_WeakHashedAlist_Either: + case Rectype_WeakHashedAlist_Both: # #<INTERNAL-WEAK-HASHED-ALIST> + CHECK_PRINT_READABLY(obj); + write_sstring_case(stream_,O(printstring_internal_weak_hashed_alist)); + break; default: pushSTACK(S(print)); fehler(serious_condition, Index: constobj.d =================================================================== RCS file: /cvsroot/clisp/clisp/src/constobj.d,v retrieving revision 1.129 retrieving revision 1.130 diff -u -d -r1.129 -r1.130 --- constobj.d 26 May 2004 11:17:06 -0000 1.129 +++ constobj.d 2 Jun 2004 10:22:12 -0000 1.130 @@ -278,6 +278,7 @@ LISPOBJ(hs_weak_and_mapping,"EXT::WEAK-AND-MAPPING") LISPOBJ(hs_weak_or_mapping,"EXT::WEAK-OR-MAPPING") LISPOBJ(hs_internal_weak_alist,"SYS::INTERNAL-WEAK-ALIST") + LISPOBJ(hs_internal_weak_hashed_alist,"SYS::INTERNAL-WEAK-HASHED-ALIST") LISPOBJ(hs_system_function,"EXT::SYSTEM-FUNCTION") LISPOBJ(hs_bignum,"BIGNUM") LISPOBJ(hs_ratio,"RATIO") @@ -568,6 +569,7 @@ LISPOBJ_S(printstring_weak_or_mapping,"WEAK-OR-MAPPING") LISPOBJ_S(printstring_broken_weak_or_mapping,"#<BROKEN WEAK-OR-MAPPING>") LISPOBJ_S(printstring_internal_weak_alist,"#<INTERNAL-WEAK-ALIST>") + LISPOBJ_S(printstring_internal_weak_hashed_alist,"#<INTERNAL-WEAK-HASHED-ALIST>") LISPOBJ_S(printstring_closure,"CLOSURE") LISPOBJ_S(printstring_generic_function,"GENERIC-FUNCTION") LISPOBJ_S(printstring_compiled_closure,"COMPILED-CLOSURE") Index: predtype.d =================================================================== RCS file: /cvsroot/clisp/clisp/src/predtype.d,v retrieving revision 1.109 retrieving revision 1.110 diff -u -d -r1.109 -r1.110 --- predtype.d 1 Jun 2004 10:32:55 -0000 1.109 +++ predtype.d 2 Jun 2004 10:22:12 -0000 1.110 @@ -920,11 +920,11 @@ /* have to traverse keys */ var uintL index = posfixnum_to_L(TheHashtable(ht1)->ht_maxcount); var gcv_object_t* KVptr = ht_kvt_data(ht1); - for (; index ; KVptr += 2, index--) + for (; index ; KVptr += 3, index--) if (!eq(KVptr[0],unbound) && !equalp(KVptr[1],gethash(KVptr[0],ht2))) return false; for (index = posfixnum_to_L(TheHashtable(ht2)->ht_maxcount), - KVptr = ht_kvt_data(ht2); index; KVptr += 2, index--) + KVptr = ht_kvt_data(ht2); index; KVptr += 3, index--) if (!eq(KVptr[0],unbound) && !equalp(KVptr[1],gethash(KVptr[0],ht1))) return false; return true; @@ -1688,6 +1688,11 @@ case Rectype_WeakAlist_Either: case Rectype_WeakAlist_Both: /* Weak-Alist */ value1 = S(internal_weak_alist); break; + case Rectype_WeakHashedAlist_Key: + case Rectype_WeakHashedAlist_Value: + case Rectype_WeakHashedAlist_Either: + case Rectype_WeakHashedAlist_Both: /* Weak-Hashed-Alist */ + value1 = S(internal_weak_hashed_alist); break; default: goto unknown; } break; @@ -1960,6 +1965,10 @@ case Rectype_WeakAlist_Value: /* Weak-Alist -> <t> */ case Rectype_WeakAlist_Either: /* Weak-Alist -> <t> */ case Rectype_WeakAlist_Both: /* Weak-Alist -> <t> */ + case Rectype_WeakHashedAlist_Key: /* Weak-Hashed-Alist -> <t> */ + case Rectype_WeakHashedAlist_Value: /* Weak-Hashed-Alist -> <t> */ + case Rectype_WeakHashedAlist_Either: /* Weak-Hashed-Alist -> <t> */ + case Rectype_WeakHashedAlist_Both: /* Weak-Hashed-Alist -> <t> */ value1 = O(class_t); break; default: goto unknown; } @@ -2576,6 +2585,7 @@ enum_hs_weak_and_mapping, enum_hs_weak_or_mapping, enum_hs_internal_weak_alist, + enum_hs_internal_weak_hashed_alist, enum_hs_system_function, enum_hs_bignum, enum_hs_ratio, @@ -2932,6 +2942,11 @@ case Rectype_WeakAlist_Either: case Rectype_WeakAlist_Both: /* Weak-Alist */ pighole = &locals->builtins[(int)enum_hs_internal_weak_alist]; break; + case Rectype_WeakHashedAlist_Key: + case Rectype_WeakHashedAlist_Value: + case Rectype_WeakHashedAlist_Either: + case Rectype_WeakHashedAlist_Both: /* Weak-Hashed-Alist */ + pighole = &locals->builtins[(int)enum_hs_internal_weak_hashed_alist]; break; default: pighole = &locals->builtins[(int)enum_hs_t]; break; } --__--__-- _______________________________________________ clisp-cvs mailing list cli...@li... https://lists.sourceforge.net/lists/listinfo/clisp-cvs End of clisp-cvs Digest |