Add a proper type for obarrays

The new opaque type replaces the previous use of vectors for obarrays.
`obarray-make` now returns objects of this type.  Functions that take
obarrays continue to accept vectors for compatibility, now just using
their first slot to store an actual obarray object.

obarray-size and obarray-default-size now obsolete.

* lisp/obarray.el (obarray-default-size, obarray-size):
Declare obsolete.
(obarray-make, obarrayp, obarray-clear): Remove from here.
* src/fns.c (reduce_emacs_uint_to_hash_hash): Remove from here.
* src/lisp.h (struct Lisp_Obarray, OBARRAYP, XOBARRAY, CHECK_OBARRAY)
(make_lisp_obarray, obarray_size, check_obarray)
(obarray_iter_t, make_obarray_iter, obarray_iter_at_end)
(obarray_iter_step, obarray_iter_symbol, DOOBARRAY, knuth_hash): New.
(reduce_emacs_uint_to_hash_hash): Moved here.
* src/lread.c (check_obarray): Renamed and reworked as...
(checked_obarray_slow): ...this.
(intern_sym, Funintern, oblookup, map_obarray)
(Finternal__obarray_buckets): Adapt to new type.
(obarray_index, allocate_obarray, make_obarray, grow_obarray)
(obarray_default_bits, Fobarray_make, Fobarrayp, Fobarray_clear): New.
* etc/emacs_lldb.py (Lisp_Object):
* lisp/emacs-lisp/cl-macs.el (`(,type . ,pred)):
* lisp/emacs-lisp/cl-preloaded.el (cl--typeof-types):
* lisp/emacs-lisp/comp-common.el (comp-known-type-specifiers):
* lisp/emacs-lisp/comp.el (comp-known-predicates):
* src/alloc.c (cleanup_vector, process_mark_stack):
* src/data.c (Ftype_of, syms_of_data):
* src/minibuf.c (Ftry_completion, Fall_completions, Ftest_completion):
* src/pdumper.c (dump_obarray_buckets, dump_obarray, dump_vectorlike):
* src/print.c (print_vectorlike_unreadable):
* test/lisp/abbrev-tests.el (abbrev-make-abbrev-table-test):
* test/lisp/obarray-tests.el (obarrayp-test)
(obarrayp-unchecked-content-test, obarray-make-default-test)
(obarray-make-with-size-test):
Adapt to new type.

1 files changed, 36 insertions, 74 deletions

diff --git a/src/minibuf.c b/src/minibuf.c
index 7c0c9799a60..df6ca7ce1d8 100644
--- a/src/minibuf.c
+++ b/src/minibuf.c
@@ -1615,13 +1615,15 @@ or from one of the possible completions.  */)
   ptrdiff_t bestmatchsize = 0;
   /* These are in bytes, too.  */
   ptrdiff_t compare, matchsize;
+  if (VECTORP (collection))
+    collection = check_obarray (collection);
   enum { function_table, list_table, obarray_table, hash_table}
     type = (HASH_TABLE_P (collection) ? hash_table
-	    : VECTORP (collection) ? obarray_table
+	    : OBARRAYP (collection) ? obarray_table
 	    : ((NILP (collection)
 		|| (CONSP (collection) && !FUNCTIONP (collection)))
 	       ? list_table : function_table));
-  ptrdiff_t idx = 0, obsize = 0;
+  ptrdiff_t idx = 0;
   int matchcount = 0;
   Lisp_Object bucket, zero, end, tem;
 
@@ -1634,12 +1636,9 @@ or from one of the possible completions.  */)
 
   /* If COLLECTION is not a list, set TAIL just for gc pro.  */
   tail = collection;
+  obarray_iter_t obit;
   if (type == obarray_table)
-    {
-      collection = check_obarray (collection);
-      obsize = ASIZE (collection);
-      bucket = AREF (collection, idx);
-    }
+    obit = make_obarray_iter (XOBARRAY (collection));
 
   while (1)
     {
@@ -1658,24 +1657,10 @@ or from one of the possible completions.  */)
 	}
       else if (type == obarray_table)
 	{
-	  if (!EQ (bucket, zero))
-	    {
-	      if (!SYMBOLP (bucket))
-		error ("Bad data in guts of obarray");
-	      elt = bucket;
-	      eltstring = elt;
-	      if (XSYMBOL (bucket)->u.s.next)
-		XSETSYMBOL (bucket, XSYMBOL (bucket)->u.s.next);
-	      else
-		XSETFASTINT (bucket, 0);
-	    }
-	  else if (++idx >= obsize)
+	  if (obarray_iter_at_end (&obit))
 	    break;
-	  else
-	    {
-	      bucket = AREF (collection, idx);
-	      continue;
-	    }
+	  elt = eltstring = obarray_iter_symbol (&obit);
+	  obarray_iter_step (&obit);
 	}
       else /* if (type == hash_table) */
 	{
@@ -1858,10 +1843,12 @@ with a space are ignored unless STRING itself starts with a space.  */)
 {
   Lisp_Object tail, elt, eltstring;
   Lisp_Object allmatches;
+  if (VECTORP (collection))
+    collection = check_obarray (collection);
   int type = HASH_TABLE_P (collection) ? 3
-    : VECTORP (collection) ? 2
+    : OBARRAYP (collection) ? 2
     : NILP (collection) || (CONSP (collection) && !FUNCTIONP (collection));
-  ptrdiff_t idx = 0, obsize = 0;
+  ptrdiff_t idx = 0;
   Lisp_Object bucket, tem, zero;
 
   CHECK_STRING (string);
@@ -1872,12 +1859,9 @@ with a space are ignored unless STRING itself starts with a space.  */)
 
   /* If COLLECTION is not a list, set TAIL just for gc pro.  */
   tail = collection;
+  obarray_iter_t obit;
   if (type == 2)
-    {
-      collection = check_obarray (collection);
-      obsize = ASIZE (collection);
-      bucket = AREF (collection, idx);
-    }
+    obit = make_obarray_iter (XOBARRAY (collection));
 
   while (1)
     {
@@ -1896,24 +1880,10 @@ with a space are ignored unless STRING itself starts with a space.  */)
 	}
       else if (type == 2)
 	{
-	  if (!EQ (bucket, zero))
-	    {
-	      if (!SYMBOLP (bucket))
-		error ("Bad data in guts of obarray");
-	      elt = bucket;
-	      eltstring = elt;
-	      if (XSYMBOL (bucket)->u.s.next)
-		XSETSYMBOL (bucket, XSYMBOL (bucket)->u.s.next);
-	      else
-		XSETFASTINT (bucket, 0);
-	    }
-	  else if (++idx >= obsize)
+	  if (obarray_iter_at_end (&obit))
 	    break;
-	  else
-	    {
-	      bucket = AREF (collection, idx);
-	      continue;
-	    }
+	  elt = eltstring = obarray_iter_symbol (&obit);
+	  obarray_iter_step (&obit);
 	}
       else /* if (type == 3) */
 	{
@@ -2059,7 +2029,7 @@ If COLLECTION is a function, it is called with three arguments:
 the values STRING, PREDICATE and `lambda'.  */)
   (Lisp_Object string, Lisp_Object collection, Lisp_Object predicate)
 {
-  Lisp_Object tail, tem = Qnil, arg = Qnil;
+  Lisp_Object tem = Qnil, arg = Qnil;
 
   CHECK_STRING (string);
 
@@ -2069,38 +2039,30 @@ the values STRING, PREDICATE and `lambda'.  */)
       if (NILP (tem))
 	return Qnil;
     }
-  else if (VECTORP (collection))
+  else if (OBARRAYP (collection) || VECTORP (collection))
     {
+      collection = check_obarray (collection);
       /* Bypass intern-soft as that loses for nil.  */
       tem = oblookup (collection,
 		      SSDATA (string),
 		      SCHARS (string),
 		      SBYTES (string));
-      if (completion_ignore_case && !SYMBOLP (tem))
-	{
-	  for (ptrdiff_t i = ASIZE (collection) - 1; i >= 0; i--)
-	    {
-	      tail = AREF (collection, i);
-	      if (SYMBOLP (tail))
-		while (1)
-		  {
-		    if (BASE_EQ (Fcompare_strings (string, make_fixnum (0),
-						   Qnil,
-						   Fsymbol_name (tail),
-						   make_fixnum (0) , Qnil, Qt),
-				 Qt))
-		      {
-			tem = tail;
-			break;
-		      }
-		    if (XSYMBOL (tail)->u.s.next == 0)
-		      break;
-		    XSETSYMBOL (tail, XSYMBOL (tail)->u.s.next);
-		  }
-	    }
-	}
+      if (completion_ignore_case && !BARE_SYMBOL_P (tem))
+	DOOBARRAY (XOBARRAY (collection), it)
+	  {
+	    Lisp_Object obj = obarray_iter_symbol (&it);
+	    if (BASE_EQ (Fcompare_strings (string, make_fixnum (0),
+					   Qnil,
+					   Fsymbol_name (obj),
+					   make_fixnum (0) , Qnil, Qt),
+			 Qt))
+	      {
+		tem = obj;
+		break;
+	      }
+	  }
 
-      if (!SYMBOLP (tem))
+      if (!BARE_SYMBOL_P (tem))
 	return Qnil;
     }
   else if (HASH_TABLE_P (collection))