Collections (in particular, hashmaps)

.gitignore

@@ -57,7 +57,9 @@ history
 /config.status
 /configure
 /doc/asy-latex.i*
+/doc/asy-latex.hd
 /doc/asy.1
+/doc/asymptote_html/
 /glrender.d.54461
 /gsl.symbols.h
 /keywords.h
@@ -66,6 +68,10 @@ history
 /types.symbols.h
 *.dSYM
 .DS_Store
+/errors.temp
+/base/webgl/asygl.js
+/v3dheadertypes.py
+/v3dtypes.py
 
 ### TeX-related
 ## Core latex/pdflatex auxiliary files:
@@ -95,6 +101,9 @@ history
 /doc/**/asymptote.*
 !/doc/asymptote.texi
 /doc/options
+/doc/latexusage-?.asy
+/doc/latexusage-?.tex
+/doc/latexusage-*.pbsdat
 .asy_*
 
 ## Bibliography auxiliary files (bibtex/biblatex/biber):

CMakeLists.txt

@@ -1,5 +1,21 @@
 cmake_minimum_required(VERSION 3.27)
 
+if (NOT CMAKE_HOST_SYSTEM_PROCESSOR)
+    if (WIN32)
+        if(CMAKE_SIZEOF_VOID_P EQUAL 8)
+            set(CMAKE_HOST_SYSTEM_PROCESSOR "x86_64")
+        else()
+            set(CMAKE_HOST_SYSTEM_PROCESSOR "i386")
+        endif()
+    else()
+        execute_process(COMMAND uname -m OUTPUT_VARIABLE CMAKE_HOST_SYSTEM_PROCESSOR OUTPUT_STRIP_TRAILING_WHITESPACE)
+    endif()
+endif()
+message(STATUS "Host processor: ${CMAKE_HOST_SYSTEM_PROCESSOR}")
+if (NOT CMAKE_SYSTEM_PROCESSOR)
+    set(CMAKE_SYSTEM_PROCESSOR ${CMAKE_HOST_SYSTEM_PROCESSOR})
+endif()
+
 include(cmake-scripts/common.cmake)
 include(asy-pkg-version-suffix.cmake OPTIONAL RESULT_VARIABLE ASY_ADDR_VERSION_SUFFIX_FILE)
 include(cmake-scripts/options.cmake)

Makefile.in

@@ -11,8 +11,8 @@ GCOPTIONS = @GCOPTIONS@
 GCLIB = @GCLIB@
 GCPPLIB = @GCPPLIB@
 GCLIBS = $(GCPPLIB) $(GCLIB)
-LFLAGS = @LDFLAGS@
-LIBS = $(LFLAGS) @PTHREAD_LIBS@ @GLEW@ @LIBS@ $(GCLIBS) @LSPLIBS@
+LFLAGS = @LDFLAGS@ -Lhighwayhash/lib
+LIBS = $(LFLAGS) @PTHREAD_LIBS@ @GLEW@ @LIBS@ $(GCLIBS) @LSPLIBS@ -lhighwayhash
 CXX_STANDARD = @CXX_STANDARD@
 DOSLIBS = $(LIBS) -ltermcap -lwolfssl -lgdi32 -lwinmm -s -static
 LSP_BUILD_ROOT=@LSP_BUILD_ROOT@
@@ -29,7 +29,7 @@ PYUIC ?= pyuic5
 # We have to remove OpenGL, threading, GC, etc from this.
 SHAREDLIBS = $(filter-out -lglut -GL -pthread $(GCLIBS), $(LIBS))
 
-vpath %.cc prc
+vpath %.cc prc highwayhash
 vpath %.cc thirdparty_impl/tinyexr_impl/src
 vpath %.ui GUI/windows
 vpath %.py GUI/pyUIClass
@@ -59,7 +59,8 @@ COREFILES = $(CAMP) $(SYMBOL_FILES) $(PRC) $(TINYEXR_FILES) \
 	Delaunay predicates glrender tr shaders jsfile v3dfile \
 	EXRFiles GLTextures lspserv symbolmaps win32helpers win32pipestream \
 	win32xdr xstream \
-	lspdec lspexp lspfundec lspstm
+	lspdec lspexp lspfundec lspstm \
+	hashing
 
 FILES = $(COREFILES) main
 
@@ -93,7 +94,7 @@ DEFS = @DEFS@ @OPTIONS@ @PTHREAD_CFLAGS@ -DFFTWPP_SINGLE_THREAD -Wall -I.
 CFLAGS = @CFLAGS@
 OPTS = $(DEFS) @CPPFLAGS@ @CXXFLAGS@ $(CFLAGS) \
 	-Ibackports/optional/include \
-	-Iprc/include -I$(LSP_ROOT)/include
+	-Iprc/include -I$(LSP_ROOT)/include -Ihighwayhash
 GLEWOPTS = $(DEFS) @CPPFLAGS@ $(CFLAGS) -DGLEW_NO_GLU -DGLEW_BUILD -O1 -fPIC
 
 # Options for compiling the object files for the shared library.
@@ -136,7 +137,7 @@ endif
 
 export prefix docdir exampledir mandir infodir INSTALL MAKE DESTDIR TEXI2DVI
 
-asy: base/version.asy $(FILES:=.o) $(XNAME) revision.o @LSPLIB@ @GLEW@
+asy: base/version.asy $(FILES:=.o) $(XNAME) revision.o @LSPLIB@ @GLEW@ libhighwayhash.a
 	$(CXX) $(OPTS) -o $(NAME) $(FILES:=.o) revision.o $(LIBS)
 
 $(XNAME): $(PYFILES)
@@ -175,6 +176,9 @@ $(LSP_BUILD_ROOT)/liblspcpp.a:
 	@LSP_CMAKE_OPTIONS@
 	$(MAKE) -C $(LSP_BUILD_ROOT)
 
+libhighwayhash.a:
+	cd highwayhash && $(MAKE)
+
 all:	asy sty man faq asy-keywords.el
 
 $(GCLIB):
@@ -372,6 +376,7 @@ clean:	FORCE
 	-cd LspCpp && $(MAKE) distclean
 	-cd LspCpp && rm -rf liblspcpp.a Makefile CMakeFiles third_party/uri/src/CMakeFiles
 	-cd tinyexr && $(MAKE) clean
+	-cd highwayhash && $(MAKE) clean
 
 gc-clean: FORCE clean
 	-$(MAKE) -C $(GC) clean
@@ -394,6 +399,8 @@ cleaner: FORCE clean
 
 distclean: FORCE cleaner
 	cd doc && $(MAKE) distclean
+	cd highwayhash && $(MAKE) distclean
+
 
 cleanest: FORCE maintainer-clean
 maintainer-clean: FORCE distclean

base/collections/enumerate.asy

@@ -0,0 +1,46 @@
+typedef import(T);
+
+from collections.iter(T=T) access Iter_T, Iterable_T;
+from collections.genericpair(K=int, V=T) access
+    Pair_K_V as Pair_int_T,
+    makePair;
+from collections.iter(T=Pair_int_T) access
+    Iter_T as Iter_Pair_int_T,
+    Iterable_T as Iterable_Pair_int_T,
+    Iterable;
+
+Iterable_Pair_int_T enumerate(Iterable_T iterable) {
+  Iter_Pair_int_T iter() {
+    int i = 0;
+    Iter_T it = iterable.operator iter();
+    Iter_Pair_int_T result;
+    result.valid = it.valid;
+    result.get = new Pair_int_T() {
+      return makePair(i, it.get());
+    };
+    result.advance = new void() {
+      ++i;
+      it.advance();
+    };
+    return result;
+  }
+  return Iterable(iter);
+}
+
+Iterable_Pair_int_T enumerate(T[] array) {
+  Iter_Pair_int_T iter() {
+    int i = 0;
+    Iter_Pair_int_T result;
+    result.valid = new bool() {
+      return i < array.length;
+    };
+    result.get = new Pair_int_T() {
+      return makePair(i, array[i]);
+    };
+    result.advance = new void() {
+      ++i;
+    };
+    return result;
+  }
+  return Iterable(iter);
+}

base/collections/genericpair.asy

@@ -0,0 +1,20 @@
+typedef import(K, V);
+
+struct Pair_K_V {
+  restricted K k;
+  restricted V v;
+  void operator init(K k, V v) {
+    this.k = k;
+    this.v = v;
+  }
+  autounravel bool operator ==(Pair_K_V a, Pair_K_V b) {
+    // NOTE: This won't compile if K or V is an array type since == is
+    // vectorized for arrays. We could locally define a cast operator from
+    // bool[] to bool, but that would not behave as expected if comparing two
+    // arrays of different lengths. (We would get an error instead of false.)
+    return a.k == b.k && a.v == b.v;
+  }
+  int hash();  // To be overridden by the user.
+}
+
+Pair_K_V makePair(K k, V v) = Pair_K_V;

base/collections/hashmap.asy

@@ -0,0 +1,90 @@
+typedef import(K, V);
+
+from collections.map(K=K, V=V) access Map_K_V, Iter_K, Iter_K_V, Iterable_K;
+from collections.genericpair(K=K, V=V) access Pair_K_V, makePair;
+from collections.hashrepset(T=Pair_K_V) access
+    HashRepSet_T as HashRepSet_K_V;
+
+private Pair_K_V operator tuple(K k, V v) {
+  Pair_K_V pair = makePair(k, v); 
+  pair.hash = k.hash;
+  return pair;
+}
+
+struct HashMap_K_V {
+  struct _ { autounravel restricted Map_K_V map; }
+
+  private HashRepSet_K_V pairs = HashRepSet_K_V(
+    nullT=null,
+    equiv = new bool(Pair_K_V a, Pair_K_V b) {
+      // NOTE: This should never be called on a null pair.
+      return a.k == b.k;
+    },
+    isNullT = new bool(Pair_K_V kv) { return alias(kv, null); }
+  );
+
+  void operator init() {
+    using F = void();
+    ((F)map.operator init)();
+  }
+
+  // TODO: Change "isNullValue" to "isNullValue", and similar.
+
+  void operator init(V nullValue, bool isNullValue(V) = null) {
+    using F = void(V, bool isNullValue(V)=null);  // The default value here is ignored.
+    if (isNullValue == null) {
+      ((F)map.operator init)(nullValue);  // Let operator init supply its own default.
+    } else {
+      ((F)map.operator init)(nullValue, isNullValue);
+    }
+  }
+
+  map.size = pairs.size;
+
+  map.contains = new bool(K key) {
+    return pairs.contains((key, map.nullValue));
+  };
+
+  map.operator[] = new V(K key) {
+    Pair_K_V pair = pairs.get((key, map.nullValue));
+    if (!alias(pair, null)) {
+      return pair.v;
+    }
+    assert(map.isNullValue != null, 'Key not found in map');
+    return map.nullValue;
+  };
+
+  map.operator [=] = new void(K key, V value) {
+    if (map.isNullValue != null && map.isNullValue(value)) {
+      pairs.delete((key, value));
+    } else {
+      pairs.update((key, value));
+    }
+  };
+
+  map.delete = new void(K key) {
+    Pair_K_V removed = pairs.delete((key, map.nullValue));
+    assert(!alias(removed, null), 'Nonexistent key cannot be deleted');
+  };
+
+  map.operator iter = new Iter_K() {
+    Iter_K_V it = pairs.operator iter();
+    Iter_K result;
+    result.valid = it.valid;
+    result.advance = it.advance;
+    result.get = new K() { return it.get().k; };
+    return result;
+  };
+
+  autounravel Iterable_K operator cast(HashMap_K_V map) {
+    return Iterable_K(map.map.operator iter);
+  }
+  autounravel K[] operator ecast(HashMap_K_V map) {
+    return (K[])(Iterable_K)map;
+  }
+  autounravel Map_K_V operator cast(HashMap_K_V map) {
+    return map.map;
+  }
+
+  unravel map;
+}