From 32bbf53d9c860c32fb9109a11459ccba6eba7110 Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Sun, 15 Aug 2021 11:06:52 -0600 Subject: [PATCH 01/55] [set] Minor rewrite one cmp() in term of other --- src/hb-set.hh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/hb-set.hh b/src/hb-set.hh index 8bb7f9f0b..e1bcf2b53 100644 --- a/src/hb-set.hh +++ b/src/hb-set.hh @@ -50,7 +50,7 @@ struct hb_set_t struct page_map_t { - int cmp (const page_map_t &o) const { return (int) o.major - (int) major; } + int cmp (const page_map_t &o) const { return cmp (o.major); } int cmp (uint32_t o_major) const { return (int) o_major - (int) major; } uint32_t major; From cb273fd17c436ada2b88aaecc585b62eb5203691 Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Sun, 15 Aug 2021 11:09:08 -0600 Subject: [PATCH 02/55] [set] Add page_t::set() --- src/hb-set.hh | 1 + 1 file changed, 1 insertion(+) diff --git a/src/hb-set.hh b/src/hb-set.hh index e1bcf2b53..82bbec1f3 100644 --- a/src/hb-set.hh +++ b/src/hb-set.hh @@ -75,6 +75,7 @@ struct hb_set_t void add (hb_codepoint_t g) { elt (g) |= mask (g); } void del (hb_codepoint_t g) { elt (g) &= ~mask (g); } + void set (hb_codepoint_t g, bool v) { if (v) add (g); else del (g); } bool get (hb_codepoint_t g) const { return elt (g) & mask (g); } void add_range (hb_codepoint_t a, hb_codepoint_t b) From 0dcd9b15d964c7eee3344525313c15a2ff4a16e4 Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Sun, 15 Aug 2021 11:11:10 -0600 Subject: [PATCH 03/55] [set] Add page_t::set_range() --- src/hb-set.hh | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/hb-set.hh b/src/hb-set.hh index 82bbec1f3..d16f35cc4 100644 --- a/src/hb-set.hh +++ b/src/hb-set.hh @@ -94,7 +94,6 @@ struct hb_set_t *lb |= ((mask (b) << 1) - 1); } } - void del_range (hb_codepoint_t a, hb_codepoint_t b) { elt_t *la = &elt (a); @@ -111,6 +110,8 @@ struct hb_set_t *lb &= ~((mask (b) << 1) - 1); } } + void set_range (hb_codepoint_t a, hb_codepoint_t b, bool v) + { if (v) add_range (a, b); else del_range (a, b); } bool is_equal (const page_t &other) const { From 4394ee1f1dd355b4e8c4e4ad8f310ed624c64e01 Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Sun, 15 Aug 2021 11:28:09 -0600 Subject: [PATCH 04/55] [set] Add inverted to page_t::get_min/max() --- src/hb-set.hh | 18 ++++++++++++------ 1 file changed, 12 insertions(+), 6 deletions(-) diff --git a/src/hb-set.hh b/src/hb-set.hh index d16f35cc4..e55337407 100644 --- a/src/hb-set.hh +++ b/src/hb-set.hh @@ -186,18 +186,24 @@ struct hb_set_t *codepoint = INVALID; return false; } - hb_codepoint_t get_min () const + hb_codepoint_t get_min (bool inverted = false) const { for (unsigned int i = 0; i < len (); i++) - if (v[i]) - return i * ELT_BITS + elt_get_min (v[i]); + { + elt_t e = inverted ? ~v[i] : v[i]; + if (e) + return i * ELT_BITS + elt_get_min (e); + } return INVALID; } - hb_codepoint_t get_max () const + hb_codepoint_t get_max (bool inverted = false) const { for (int i = len () - 1; i >= 0; i--) - if (v[i]) - return i * ELT_BITS + elt_get_max (v[i]); + { + elt_t e = inverted ? ~v[i] : v[i]; + if (e) + return i * ELT_BITS + elt_get_max (e); + } return 0; } From 9449cfeefd7e3b761c8035c45330abd7a5201604 Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Sun, 15 Aug 2021 11:35:33 -0600 Subject: [PATCH 05/55] [set] Simplify page_t::next/prev() --- src/hb-set.hh | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/src/hb-set.hh b/src/hb-set.hh index e55337407..789cbcfa3 100644 --- a/src/hb-set.hh +++ b/src/hb-set.hh @@ -145,10 +145,10 @@ struct hb_set_t unsigned int j = m & ELT_MASK; const elt_t vv = v[i] & ~((elt_t (1) << j) - 1); - for (const elt_t *p = &vv; i < len (); p = &v[++i]) - if (*p) + for (elt_t p = vv; i < len (); p = v[++i]) + if (p) { - *codepoint = i * ELT_BITS + elt_get_min (*p); + *codepoint = i * ELT_BITS + elt_get_min (p); return true; } @@ -171,16 +171,16 @@ struct hb_set_t ((elt_t (1) << (j + 1)) - 1) : (elt_t) -1; const elt_t vv = v[i] & mask; - const elt_t *p = &vv; + elt_t p = vv; while (true) { - if (*p) + if (p) { - *codepoint = i * ELT_BITS + elt_get_max (*p); + *codepoint = i * ELT_BITS + elt_get_max (p); return true; } if ((int) i <= 0) break; - p = &v[--i]; + p = v[--i]; } *codepoint = INVALID; From c88e7ec935caf31ca7db6b90ab0db514c1b65e45 Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Sun, 15 Aug 2021 11:39:31 -0600 Subject: [PATCH 06/55] [set] Add page_t::elt_maybe_invert() --- src/hb-set.hh | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/hb-set.hh b/src/hb-set.hh index 789cbcfa3..7f1429ddc 100644 --- a/src/hb-set.hh +++ b/src/hb-set.hh @@ -190,7 +190,7 @@ struct hb_set_t { for (unsigned int i = 0; i < len (); i++) { - elt_t e = inverted ? ~v[i] : v[i]; + elt_t e = elt_maybe_invert (v[i], inverted); if (e) return i * ELT_BITS + elt_get_min (e); } @@ -200,7 +200,7 @@ struct hb_set_t { for (int i = len () - 1; i >= 0; i--) { - elt_t e = inverted ? ~v[i] : v[i]; + elt_t e = elt_maybe_invert (v[i], inverted); if (e) return i * ELT_BITS + elt_get_max (e); } @@ -213,6 +213,7 @@ struct hb_set_t static unsigned int elt_get_min (const elt_t &elt) { return hb_ctz (elt); } static unsigned int elt_get_max (const elt_t &elt) { return hb_bit_storage (elt) - 1; } + static elt_t elt_maybe_invert (elt_t elt, bool inverted) { return inverted ? ~elt : elt; } typedef hb_vector_size_t vector_t; From 9bd64fa077ed1133ec96341335c62f91b3f9b9ce Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Sun, 15 Aug 2021 11:42:16 -0600 Subject: [PATCH 07/55] [set] Add "inverted" to page_t::next/prev() --- src/hb-set.hh | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/src/hb-set.hh b/src/hb-set.hh index 7f1429ddc..9c928dda1 100644 --- a/src/hb-set.hh +++ b/src/hb-set.hh @@ -133,7 +133,7 @@ struct hb_set_t return pop; } - bool next (hb_codepoint_t *codepoint) const + bool next (hb_codepoint_t *codepoint, bool inverted = false) const { unsigned int m = (*codepoint + 1) & MASK; if (!m) @@ -145,7 +145,9 @@ struct hb_set_t unsigned int j = m & ELT_MASK; const elt_t vv = v[i] & ~((elt_t (1) << j) - 1); - for (elt_t p = vv; i < len (); p = v[++i]) + for (elt_t p = elt_maybe_invert (vv, inverted); + i < len (); + p = elt_maybe_invert (v[++i], inverted)) if (p) { *codepoint = i * ELT_BITS + elt_get_min (p); @@ -155,7 +157,7 @@ struct hb_set_t *codepoint = INVALID; return false; } - bool previous (hb_codepoint_t *codepoint) const + bool previous (hb_codepoint_t *codepoint, bool inverted = false) const { unsigned int m = (*codepoint - 1) & MASK; if (m == MASK) @@ -171,7 +173,7 @@ struct hb_set_t ((elt_t (1) << (j + 1)) - 1) : (elt_t) -1; const elt_t vv = v[i] & mask; - elt_t p = vv; + elt_t p = elt_maybe_invert (vv, inverted); while (true) { if (p) @@ -180,7 +182,7 @@ struct hb_set_t return true; } if ((int) i <= 0) break; - p = v[--i]; + p = elt_maybe_invert (v[--i], inverted); } *codepoint = INVALID; From 0c3e02ee2d0b24d7fbed92ab2b51c3e98bbe69e8 Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Sun, 15 Aug 2021 12:10:13 -0600 Subject: [PATCH 08/55] [set] Add "inverted" to page_t::is_empty() --- src/hb-set.hh | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/hb-set.hh b/src/hb-set.hh index 9c928dda1..92952e727 100644 --- a/src/hb-set.hh +++ b/src/hb-set.hh @@ -65,10 +65,10 @@ struct hb_set_t constexpr unsigned len () const { return ARRAY_LENGTH_CONST (v); } - bool is_empty () const + bool is_empty (bool inverted = false) const { for (unsigned int i = 0; i < len (); i++) - if (v[i]) + if (elt_maybe_invert (v[i], inverted)) return false; return true; } From 9b390f8c40eb80871778b13de7e987bd0e8bedad Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Sun, 15 Aug 2021 12:34:55 -0600 Subject: [PATCH 09/55] [set] Move page_t into hb-bit-page.hh --- src/Makefile.sources | 1 + src/hb-bit-page.hh | 212 +++++++++++++++++++++++++++++++++++++++++++ src/hb-set.hh | 190 ++------------------------------------ src/meson.build | 1 + 4 files changed, 221 insertions(+), 183 deletions(-) create mode 100644 src/hb-bit-page.hh diff --git a/src/Makefile.sources b/src/Makefile.sources index f5717a67a..64a6274dd 100644 --- a/src/Makefile.sources +++ b/src/Makefile.sources @@ -19,6 +19,7 @@ HB_BASE_sources = \ hb-array.hh \ hb-atomic.hh \ hb-bimap.hh \ + hb-bit-page.hh \ hb-blob.cc \ hb-blob.hh \ hb-buffer-serialize.cc \ diff --git a/src/hb-bit-page.hh b/src/hb-bit-page.hh new file mode 100644 index 000000000..80aeee0c9 --- /dev/null +++ b/src/hb-bit-page.hh @@ -0,0 +1,212 @@ +/* + * Copyright © 2012,2017 Google, Inc. + * Copyright © 2021 Behdad Esfahbod + * + * This is part of HarfBuzz, a text shaping library. + * + * Permission is hereby granted, without written agreement and without + * license or royalty fees, to use, copy, modify, and distribute this + * software and its documentation for any purpose, provided that the + * above copyright notice and the following two paragraphs appear in + * all copies of this software. + * + * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES + * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN + * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH + * DAMAGE. + * + * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, + * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS + * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + * Google Author(s): Behdad Esfahbod + */ + +#ifndef HB_BIT_PAGE_HH +#define HB_BIT_PAGE_HH + +#include "hb.hh" + +struct hb_bit_page_t +{ + void init0 () { v.clear (); } + void init1 () { v.clear (0xFF); } + + constexpr unsigned len () const + { return ARRAY_LENGTH_CONST (v); } + + bool is_empty (bool inverted = false) const + { + for (unsigned int i = 0; i < len (); i++) + if (elt_maybe_invert (v[i], inverted)) + return false; + return true; + } + + void add (hb_codepoint_t g) { elt (g) |= mask (g); } + void del (hb_codepoint_t g) { elt (g) &= ~mask (g); } + void set (hb_codepoint_t g, bool v) { if (v) add (g); else del (g); } + bool get (hb_codepoint_t g) const { return elt (g) & mask (g); } + + void add_range (hb_codepoint_t a, hb_codepoint_t b) + { + elt_t *la = &elt (a); + elt_t *lb = &elt (b); + if (la == lb) + *la |= (mask (b) << 1) - mask(a); + else + { + *la |= ~(mask (a) - 1); + la++; + + memset (la, 0xff, (char *) lb - (char *) la); + + *lb |= ((mask (b) << 1) - 1); + } + } + void del_range (hb_codepoint_t a, hb_codepoint_t b) + { + elt_t *la = &elt (a); + elt_t *lb = &elt (b); + if (la == lb) + *la &= ~((mask (b) << 1) - mask(a)); + else + { + *la &= mask (a) - 1; + la++; + + memset (la, 0, (char *) lb - (char *) la); + + *lb &= ~((mask (b) << 1) - 1); + } + } + void set_range (hb_codepoint_t a, hb_codepoint_t b, bool v) + { if (v) add_range (a, b); else del_range (a, b); } + + bool is_equal (const hb_bit_page_t &other) const + { + return 0 == hb_memcmp (&v, &other.v, sizeof (v)); + } + bool is_subset (const hb_bit_page_t &larger_page) const + { + for (unsigned i = 0; i < len (); i++) + if (~larger_page.v[i] & v[i]) + return false; + return true; + } + + unsigned int get_population () const + { + unsigned int pop = 0; + for (unsigned int i = 0; i < len (); i++) + pop += hb_popcount (v[i]); + return pop; + } + + bool next (hb_codepoint_t *codepoint, bool inverted = false) const + { + unsigned int m = (*codepoint + 1) & MASK; + if (!m) + { + *codepoint = INVALID; + return false; + } + unsigned int i = m / ELT_BITS; + unsigned int j = m & ELT_MASK; + + const elt_t vv = v[i] & ~((elt_t (1) << j) - 1); + for (elt_t p = elt_maybe_invert (vv, inverted); + i < len (); + p = elt_maybe_invert (v[++i], inverted)) + if (p) + { + *codepoint = i * ELT_BITS + elt_get_min (p); + return true; + } + + *codepoint = INVALID; + return false; + } + bool previous (hb_codepoint_t *codepoint, bool inverted = false) const + { + unsigned int m = (*codepoint - 1) & MASK; + if (m == MASK) + { + *codepoint = INVALID; + return false; + } + unsigned int i = m / ELT_BITS; + unsigned int j = m & ELT_MASK; + + /* Fancy mask to avoid shifting by elt_t bitsize, which is undefined. */ + const elt_t mask = j < 8 * sizeof (elt_t) - 1 ? + ((elt_t (1) << (j + 1)) - 1) : + (elt_t) -1; + const elt_t vv = v[i] & mask; + elt_t p = elt_maybe_invert (vv, inverted); + while (true) + { + if (p) + { + *codepoint = i * ELT_BITS + elt_get_max (p); + return true; + } + if ((int) i <= 0) break; + p = elt_maybe_invert (v[--i], inverted); + } + + *codepoint = INVALID; + return false; + } + hb_codepoint_t get_min (bool inverted = false) const + { + for (unsigned int i = 0; i < len (); i++) + { + elt_t e = elt_maybe_invert (v[i], inverted); + if (e) + return i * ELT_BITS + elt_get_min (e); + } + return INVALID; + } + hb_codepoint_t get_max (bool inverted = false) const + { + for (int i = len () - 1; i >= 0; i--) + { + elt_t e = elt_maybe_invert (v[i], inverted); + if (e) + return i * ELT_BITS + elt_get_max (e); + } + return 0; + } + + static constexpr hb_codepoint_t INVALID = HB_SET_VALUE_INVALID; + + typedef unsigned long long elt_t; + static constexpr unsigned PAGE_BITS = 512; + static_assert ((PAGE_BITS & ((PAGE_BITS) - 1)) == 0, ""); + + static unsigned int elt_get_min (const elt_t &elt) { return hb_ctz (elt); } + static unsigned int elt_get_max (const elt_t &elt) { return hb_bit_storage (elt) - 1; } + static elt_t elt_maybe_invert (elt_t elt, bool inverted) { return inverted ? ~elt : elt; } + + typedef hb_vector_size_t vector_t; + + static constexpr unsigned ELT_BITS = sizeof (elt_t) * 8; + static constexpr unsigned ELT_MASK = ELT_BITS - 1; + static constexpr unsigned BITS = sizeof (vector_t) * 8; + static constexpr unsigned MASK = BITS - 1; + static_assert ((unsigned) PAGE_BITS == (unsigned) BITS, ""); + + elt_t &elt (hb_codepoint_t g) { return v[(g & MASK) / ELT_BITS]; } + const elt_t& elt (hb_codepoint_t g) const { return v[(g & MASK) / ELT_BITS]; } + static constexpr elt_t mask (hb_codepoint_t g) { return elt_t (1) << (g & ELT_MASK); } + + vector_t v; +}; +static_assert (hb_bit_page_t::PAGE_BITS == sizeof (hb_bit_page_t) * 8, ""); + + +#endif /* HB_BIT_PAGE_HH */ diff --git a/src/hb-set.hh b/src/hb-set.hh index 92952e727..09940c654 100644 --- a/src/hb-set.hh +++ b/src/hb-set.hh @@ -1,5 +1,6 @@ /* * Copyright © 2012,2017 Google, Inc. + * Copyright © 2021 Behdad Esfahbod * * This is part of HarfBuzz, a text shaping library. * @@ -28,16 +29,10 @@ #define HB_SET_HH #include "hb.hh" +#include "hb-bit-page.hh" #include "hb-machinery.hh" -/* - * hb_set_t - */ - -/* TODO Keep a freelist so we can release pages that are completely zeroed. At that - * point maybe also use a sentinel value for "all-1" pages? */ - struct hb_set_t { hb_set_t () { init (); } @@ -48,6 +43,10 @@ struct hb_set_t // TODO Add move construtor/assign // TODO Add constructor for Iterator; with specialization for (sorted) vector / array? + /* TODO Keep a freelist so we can release pages that are completely zeroed. At that + * point maybe also use a sentinel value for "all-1" pages? */ + + using page_t = hb_bit_page_t; struct page_map_t { int cmp (const page_map_t &o) const { return cmp (o.major); } @@ -57,182 +56,6 @@ struct hb_set_t uint32_t index; }; - struct page_t - { - void init0 () { v.clear (); } - void init1 () { v.clear (0xFF); } - - constexpr unsigned len () const - { return ARRAY_LENGTH_CONST (v); } - - bool is_empty (bool inverted = false) const - { - for (unsigned int i = 0; i < len (); i++) - if (elt_maybe_invert (v[i], inverted)) - return false; - return true; - } - - void add (hb_codepoint_t g) { elt (g) |= mask (g); } - void del (hb_codepoint_t g) { elt (g) &= ~mask (g); } - void set (hb_codepoint_t g, bool v) { if (v) add (g); else del (g); } - bool get (hb_codepoint_t g) const { return elt (g) & mask (g); } - - void add_range (hb_codepoint_t a, hb_codepoint_t b) - { - elt_t *la = &elt (a); - elt_t *lb = &elt (b); - if (la == lb) - *la |= (mask (b) << 1) - mask(a); - else - { - *la |= ~(mask (a) - 1); - la++; - - memset (la, 0xff, (char *) lb - (char *) la); - - *lb |= ((mask (b) << 1) - 1); - } - } - void del_range (hb_codepoint_t a, hb_codepoint_t b) - { - elt_t *la = &elt (a); - elt_t *lb = &elt (b); - if (la == lb) - *la &= ~((mask (b) << 1) - mask(a)); - else - { - *la &= mask (a) - 1; - la++; - - memset (la, 0, (char *) lb - (char *) la); - - *lb &= ~((mask (b) << 1) - 1); - } - } - void set_range (hb_codepoint_t a, hb_codepoint_t b, bool v) - { if (v) add_range (a, b); else del_range (a, b); } - - bool is_equal (const page_t &other) const - { - return 0 == hb_memcmp (&v, &other.v, sizeof (v)); - } - bool is_subset (const page_t &larger_page) const - { - for (unsigned i = 0; i < len (); i++) - if (~larger_page.v[i] & v[i]) - return false; - return true; - } - - unsigned int get_population () const - { - unsigned int pop = 0; - for (unsigned int i = 0; i < len (); i++) - pop += hb_popcount (v[i]); - return pop; - } - - bool next (hb_codepoint_t *codepoint, bool inverted = false) const - { - unsigned int m = (*codepoint + 1) & MASK; - if (!m) - { - *codepoint = INVALID; - return false; - } - unsigned int i = m / ELT_BITS; - unsigned int j = m & ELT_MASK; - - const elt_t vv = v[i] & ~((elt_t (1) << j) - 1); - for (elt_t p = elt_maybe_invert (vv, inverted); - i < len (); - p = elt_maybe_invert (v[++i], inverted)) - if (p) - { - *codepoint = i * ELT_BITS + elt_get_min (p); - return true; - } - - *codepoint = INVALID; - return false; - } - bool previous (hb_codepoint_t *codepoint, bool inverted = false) const - { - unsigned int m = (*codepoint - 1) & MASK; - if (m == MASK) - { - *codepoint = INVALID; - return false; - } - unsigned int i = m / ELT_BITS; - unsigned int j = m & ELT_MASK; - - /* Fancy mask to avoid shifting by elt_t bitsize, which is undefined. */ - const elt_t mask = j < 8 * sizeof (elt_t) - 1 ? - ((elt_t (1) << (j + 1)) - 1) : - (elt_t) -1; - const elt_t vv = v[i] & mask; - elt_t p = elt_maybe_invert (vv, inverted); - while (true) - { - if (p) - { - *codepoint = i * ELT_BITS + elt_get_max (p); - return true; - } - if ((int) i <= 0) break; - p = elt_maybe_invert (v[--i], inverted); - } - - *codepoint = INVALID; - return false; - } - hb_codepoint_t get_min (bool inverted = false) const - { - for (unsigned int i = 0; i < len (); i++) - { - elt_t e = elt_maybe_invert (v[i], inverted); - if (e) - return i * ELT_BITS + elt_get_min (e); - } - return INVALID; - } - hb_codepoint_t get_max (bool inverted = false) const - { - for (int i = len () - 1; i >= 0; i--) - { - elt_t e = elt_maybe_invert (v[i], inverted); - if (e) - return i * ELT_BITS + elt_get_max (e); - } - return 0; - } - - typedef unsigned long long elt_t; - static constexpr unsigned PAGE_BITS = 512; - static_assert ((PAGE_BITS & ((PAGE_BITS) - 1)) == 0, ""); - - static unsigned int elt_get_min (const elt_t &elt) { return hb_ctz (elt); } - static unsigned int elt_get_max (const elt_t &elt) { return hb_bit_storage (elt) - 1; } - static elt_t elt_maybe_invert (elt_t elt, bool inverted) { return inverted ? ~elt : elt; } - - typedef hb_vector_size_t vector_t; - - static constexpr unsigned ELT_BITS = sizeof (elt_t) * 8; - static constexpr unsigned ELT_MASK = ELT_BITS - 1; - static constexpr unsigned BITS = sizeof (vector_t) * 8; - static constexpr unsigned MASK = BITS - 1; - static_assert ((unsigned) PAGE_BITS == (unsigned) BITS, ""); - - elt_t &elt (hb_codepoint_t g) { return v[(g & MASK) / ELT_BITS]; } - const elt_t& elt (hb_codepoint_t g) const { return v[(g & MASK) / ELT_BITS]; } - static constexpr elt_t mask (hb_codepoint_t g) { return elt_t (1) << (g & ELT_MASK); } - - vector_t v; - }; - static_assert (page_t::PAGE_BITS == sizeof (page_t) * 8, ""); - hb_object_header_t header; bool successful; /* Allocations successful */ mutable unsigned int population; @@ -904,6 +727,7 @@ struct hb_set_t } static constexpr hb_codepoint_t INVALID = HB_SET_VALUE_INVALID; + static_assert (INVALID == page_t::INVALID, ""); /* * Iterator implementation. diff --git a/src/meson.build b/src/meson.build index e7093cb29..cbe57e9eb 100644 --- a/src/meson.build +++ b/src/meson.build @@ -25,6 +25,7 @@ hb_base_sources = files( 'hb-array.hh', 'hb-atomic.hh', 'hb-bimap.hh', + 'hb-bit-page.hh', 'hb-blob.cc', 'hb-blob.hh', 'hb-buffer-serialize.cc', From f245dc4db86483be3ede773e0bc8ba68065e2380 Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Sun, 15 Aug 2021 12:40:36 -0600 Subject: [PATCH 10/55] [set] Whitespace --- src/hb-set.hh | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/hb-set.hh b/src/hb-set.hh index 09940c654..d47b3e8ca 100644 --- a/src/hb-set.hh +++ b/src/hb-set.hh @@ -387,9 +387,9 @@ struct hb_set_t return true; } - bool allocate_compact_workspace(hb_vector_t& workspace) + bool allocate_compact_workspace (hb_vector_t& workspace) { - if (unlikely(!workspace.resize (pages.length))) + if (unlikely (!workspace.resize (pages.length))) { successful = false; return false; From f6d6eff6a2f996df3144b9c03326c8efdcbf10bf Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Mon, 16 Aug 2021 19:41:44 -0600 Subject: [PATCH 11/55] [object] Remove unused HB_REFERENCE_COUNT_INIT --- src/hb-object.hh | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/hb-object.hh b/src/hb-object.hh index 64abb0ce1..c2870270d 100644 --- a/src/hb-object.hh +++ b/src/hb-object.hh @@ -140,8 +140,6 @@ struct hb_lockable_set_t * Reference-count. */ -#define HB_REFERENCE_COUNT_INIT {0} - struct hb_reference_count_t { mutable hb_atomic_int_t ref_count; From 2d5ef05d67d9a352d620e9d9e781e25717ab3a31 Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Mon, 16 Aug 2021 20:13:58 -0600 Subject: [PATCH 12/55] Use !g_object_is_valid() instead of g_object_is_inert() --- src/hb-shape-plan.cc | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/hb-shape-plan.cc b/src/hb-shape-plan.cc index aa7da2db3..66332165c 100644 --- a/src/hb-shape-plan.cc +++ b/src/hb-shape-plan.cc @@ -404,7 +404,7 @@ _hb_shape_plan_execute_internal (hb_shape_plan_t *shape_plan, buffer->assert_unicode (); - if (unlikely (hb_object_is_inert (shape_plan))) + if (unlikely (!hb_object_is_valid (shape_plan))) return false; assert (shape_plan->face_unsafe == font->face); @@ -529,7 +529,7 @@ hb_shape_plan_create_cached2 (hb_face_t *face, retry: hb_face_t::plan_node_t *cached_plan_nodes = face->shape_plans; - bool dont_cache = hb_object_is_inert (face); + bool dont_cache = !hb_object_is_valid (face); if (likely (!dont_cache)) { From 9cc4da962f53c2a9883742a0d9e9fd24222bd7b4 Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Mon, 16 Aug 2021 20:17:53 -0600 Subject: [PATCH 13/55] [object] Remove hb_object_is_inert() --- src/hb-object.hh | 15 ++++++--------- 1 file changed, 6 insertions(+), 9 deletions(-) diff --git a/src/hb-object.hh b/src/hb-object.hh index c2870270d..0e15cb12c 100644 --- a/src/hb-object.hh +++ b/src/hb-object.hh @@ -195,6 +195,8 @@ struct hb_object_header_t hb_reference_count_t ref_count; mutable hb_atomic_int_t writable = 0; hb_atomic_ptr_t user_data; + + bool is_inert () const { return !ref_count.get_relaxed (); } }; #define HB_OBJECT_HEADER_STATIC {} @@ -232,11 +234,6 @@ static inline void hb_object_init (Type *obj) obj->header.user_data.init (); } template -static inline bool hb_object_is_inert (const Type *obj) -{ - return unlikely (obj->header.ref_count.is_inert ()); -} -template static inline bool hb_object_is_valid (const Type *obj) { return likely (obj->header.ref_count.is_valid ()); @@ -255,7 +252,7 @@ template static inline Type *hb_object_reference (Type *obj) { hb_object_trace (obj, HB_FUNC); - if (unlikely (!obj || hb_object_is_inert (obj))) + if (unlikely (!obj || obj->header.is_inert ())) return obj; assert (hb_object_is_valid (obj)); obj->header.ref_count.inc (); @@ -265,7 +262,7 @@ template static inline bool hb_object_destroy (Type *obj) { hb_object_trace (obj, HB_FUNC); - if (unlikely (!obj || hb_object_is_inert (obj))) + if (unlikely (!obj || obj->header.is_inert ())) return false; assert (hb_object_is_valid (obj)); if (obj->header.ref_count.dec () != 1) @@ -293,7 +290,7 @@ static inline bool hb_object_set_user_data (Type *obj, hb_destroy_func_t destroy, hb_bool_t replace) { - if (unlikely (!obj || hb_object_is_inert (obj))) + if (unlikely (!obj || obj->header.is_inert ())) return false; assert (hb_object_is_valid (obj)); @@ -320,7 +317,7 @@ template static inline void *hb_object_get_user_data (Type *obj, hb_user_data_key_t *key) { - if (unlikely (!obj || hb_object_is_inert (obj))) + if (unlikely (!obj || obj->header.is_inert ())) return nullptr; assert (hb_object_is_valid (obj)); hb_user_data_array_t *user_data = obj->header.user_data.get (); From fad452bffb4047b84aad3e2684244ce0385742ff Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Mon, 16 Aug 2021 20:48:24 -0600 Subject: [PATCH 14/55] [set] Move main functionality into hb_bit_set_t To add inversion on top in hb_invertible_set_t and use that as hb_set_t. --- src/Makefile.sources | 1 + src/hb-bit-set.hh | 787 +++++++++++++++++++++++++++++++++++ src/hb-ot-layout-gsubgpos.hh | 5 +- src/hb-set.cc | 2 +- src/hb-set.hh | 737 ++------------------------------ 5 files changed, 828 insertions(+), 704 deletions(-) create mode 100644 src/hb-bit-set.hh diff --git a/src/Makefile.sources b/src/Makefile.sources index 64a6274dd..04b9cbe22 100644 --- a/src/Makefile.sources +++ b/src/Makefile.sources @@ -20,6 +20,7 @@ HB_BASE_sources = \ hb-atomic.hh \ hb-bimap.hh \ hb-bit-page.hh \ + hb-bit-set.hh \ hb-blob.cc \ hb-blob.hh \ hb-buffer-serialize.cc \ diff --git a/src/hb-bit-set.hh b/src/hb-bit-set.hh new file mode 100644 index 000000000..8e386b91e --- /dev/null +++ b/src/hb-bit-set.hh @@ -0,0 +1,787 @@ +/* + * Copyright © 2012,2017 Google, Inc. + * Copyright © 2021 Behdad Esfahbod + * + * This is part of HarfBuzz, a text shaping library. + * + * Permission is hereby granted, without written agreement and without + * license or royalty fees, to use, copy, modify, and distribute this + * software and its documentation for any purpose, provided that the + * above copyright notice and the following two paragraphs appear in + * all copies of this software. + * + * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES + * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN + * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH + * DAMAGE. + * + * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, + * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS + * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + * Google Author(s): Behdad Esfahbod + */ + +#ifndef HB_BIT_SET_HH +#define HB_BIT_SET_HH + +#include "hb.hh" +#include "hb-bit-page.hh" +#include "hb-machinery.hh" + + +struct hb_bit_set_t +{ + hb_bit_set_t () + { + init (); + } + ~hb_bit_set_t () + { + fini (); + } + + void init () + { + successful = true; + population = 0; + last_page_lookup = 0; + page_map.init (); + pages.init (); + } + void fini () + { + page_map.fini (); + pages.fini (); + } + + hb_bit_set_t (const hb_bit_set_t& other) : hb_bit_set_t () { set (other); } + void operator= (const hb_bit_set_t& other) { set (other); } + // TODO Add move construtor/assign + // TODO Add constructor for Iterator; with specialization for (sorted) vector / array? + + /* TODO Keep a freelist so we can release pages that are completely zeroed. At that + * point maybe also use a sentinel value for "all-1" pages? */ + + using page_t = hb_bit_page_t; + struct page_map_t + { + int cmp (const page_map_t &o) const { return cmp (o.major); } + int cmp (uint32_t o_major) const { return (int) o_major - (int) major; } + + uint32_t major; + uint32_t index; + }; + + bool successful; /* Allocations successful */ + mutable unsigned int population; + mutable unsigned int last_page_lookup; + hb_sorted_vector_t page_map; + hb_vector_t pages; + + void err () { if (successful) successful = false; } /* TODO Remove */ + bool in_error () const { return !successful; } + + bool resize (unsigned int count) + { + if (unlikely (count > pages.length && !successful)) return false; + if (!pages.resize (count) || !page_map.resize (count)) + { + pages.resize (page_map.length); + successful = false; + return false; + } + return true; + } + + void reset () + { + successful = true; + clear (); + } + + void clear () + { + if (resize (0)) + population = 0; + } + bool is_empty () const + { + unsigned int count = pages.length; + for (unsigned int i = 0; i < count; i++) + if (!pages[i].is_empty ()) + return false; + return true; + } + explicit operator bool () const { return !is_empty (); } + + private: + void dirty () { population = UINT_MAX; } + public: + + void add (hb_codepoint_t g) + { + if (unlikely (!successful)) return; + if (unlikely (g == INVALID)) return; + dirty (); + page_t *page = page_for_insert (g); if (unlikely (!page)) return; + page->add (g); + } + bool add_range (hb_codepoint_t a, hb_codepoint_t b) + { + if (unlikely (!successful)) return true; /* https://github.com/harfbuzz/harfbuzz/issues/657 */ + if (unlikely (a > b || a == INVALID || b == INVALID)) return false; + dirty (); + unsigned int ma = get_major (a); + unsigned int mb = get_major (b); + if (ma == mb) + { + page_t *page = page_for_insert (a); if (unlikely (!page)) return false; + page->add_range (a, b); + } + else + { + page_t *page = page_for_insert (a); if (unlikely (!page)) return false; + page->add_range (a, major_start (ma + 1) - 1); + + for (unsigned int m = ma + 1; m < mb; m++) + { + page = page_for_insert (major_start (m)); if (unlikely (!page)) return false; + page->init1 (); + } + + page = page_for_insert (b); if (unlikely (!page)) return false; + page->add_range (major_start (mb), b); + } + return true; + } + + template + void add_array (const T *array, unsigned int count, unsigned int stride=sizeof(T)) + { + if (unlikely (!successful)) return; + if (!count) return; + dirty (); + hb_codepoint_t g = *array; + while (count) + { + unsigned int m = get_major (g); + page_t *page = page_for_insert (g); if (unlikely (!page)) return; + unsigned int start = major_start (m); + unsigned int end = major_start (m + 1); + do + { + page->add (g); + + array = &StructAtOffsetUnaligned (array, stride); + count--; + } + while (count && (g = *array, start <= g && g < end)); + } + } + template + void add_array (const hb_array_t& arr) { add_array (&arr, arr.len ()); } + + /* Might return false if array looks unsorted. + * Used for faster rejection of corrupt data. */ + template + bool add_sorted_array (const T *array, unsigned int count, unsigned int stride=sizeof(T)) + { + if (unlikely (!successful)) return true; /* https://github.com/harfbuzz/harfbuzz/issues/657 */ + if (!count) return true; + dirty (); + hb_codepoint_t g = *array; + hb_codepoint_t last_g = g; + while (count) + { + unsigned int m = get_major (g); + page_t *page = page_for_insert (g); if (unlikely (!page)) return false; + unsigned int end = major_start (m + 1); + do + { + /* If we try harder we can change the following comparison to <=; + * Not sure if it's worth it. */ + if (g < last_g) return false; + last_g = g; + page->add (g); + + array = (const T *) ((const char *) array + stride); + count--; + } + while (count && (g = *array, g < end)); + } + return true; + } + template + bool add_sorted_array (const hb_sorted_array_t& arr) { return add_sorted_array (&arr, arr.len ()); } + + void del (hb_codepoint_t g) + { + /* TODO perform op even if !successful. */ + if (unlikely (!successful)) return; + page_t *page = page_for (g); + if (!page) + return; + dirty (); + page->del (g); + } + + private: + void del_pages (int ds, int de) + { + if (ds <= de) + { + // Pre-allocate the workspace that compact() will need so we can bail on allocation failure + // before attempting to rewrite the page map. + hb_vector_t compact_workspace; + if (unlikely (!allocate_compact_workspace (compact_workspace))) return; + + unsigned int write_index = 0; + for (unsigned int i = 0; i < page_map.length; i++) + { + int m = (int) page_map[i].major; + if (m < ds || de < m) + page_map[write_index++] = page_map[i]; + } + compact (compact_workspace, write_index); + resize (write_index); + } + } + + + public: + void del_range (hb_codepoint_t a, hb_codepoint_t b) + { + /* TODO perform op even if !successful. */ + if (unlikely (!successful)) return; + if (unlikely (a > b || a == INVALID)) return; + dirty (); + unsigned int ma = get_major (a); + unsigned int mb = get_major (b); + /* Delete pages from ds through de if ds <= de. */ + int ds = (a == major_start (ma))? (int) ma: (int) (ma + 1); + int de = (b + 1 == major_start (mb + 1))? (int) mb: ((int) mb - 1); + if (ds > de || (int) ma < ds) + { + page_t *page = page_for (a); + if (page) + { + if (ma == mb) + page->del_range (a, b); + else + page->del_range (a, major_start (ma + 1) - 1); + } + } + if (de < (int) mb && ma != mb) + { + page_t *page = page_for (b); + if (page) + page->del_range (major_start (mb), b); + } + del_pages (ds, de); + } + + bool get (hb_codepoint_t g) const + { + const page_t *page = page_for (g); + if (!page) + return false; + return page->get (g); + } + + /* Has interface. */ + static constexpr bool SENTINEL = false; + typedef bool value_t; + value_t operator [] (hb_codepoint_t k) const { return get (k); } + bool has (hb_codepoint_t k) const { return (*this)[k] != SENTINEL; } + /* Predicate. */ + bool operator () (hb_codepoint_t k) const { return has (k); } + + /* Sink interface. */ + hb_bit_set_t& operator << (hb_codepoint_t v) + { add (v); return *this; } + hb_bit_set_t& operator << (const hb_pair_t& range) + { add_range (range.first, range.second); return *this; } + + bool intersects (hb_codepoint_t first, hb_codepoint_t last) const + { + hb_codepoint_t c = first - 1; + return next (&c) && c <= last; + } + void set (const hb_bit_set_t &other) + { + if (unlikely (!successful)) return; + unsigned int count = other.pages.length; + if (!resize (count)) + return; + population = other.population; + + hb_memcpy ((void *) pages, (const void *) other.pages, count * pages.item_size); + hb_memcpy ((void *) page_map, (const void *) other.page_map, count * page_map.item_size); + } + + bool is_equal (const hb_bit_set_t &other) const + { + if (get_population () != other.get_population ()) + return false; + + unsigned int na = pages.length; + unsigned int nb = other.pages.length; + + unsigned int a = 0, b = 0; + for (; a < na && b < nb; ) + { + if (page_at (a).is_empty ()) { a++; continue; } + if (other.page_at (b).is_empty ()) { b++; continue; } + if (page_map[a].major != other.page_map[b].major || + !page_at (a).is_equal (other.page_at (b))) + return false; + a++; + b++; + } + for (; a < na; a++) + if (!page_at (a).is_empty ()) { return false; } + for (; b < nb; b++) + if (!other.page_at (b).is_empty ()) { return false; } + + return true; + } + + bool is_subset (const hb_bit_set_t &larger_set) const + { + /* TODO: Merge this and is_equal() into something like process(). */ + if (unlikely(larger_set.is_empty ())) + return is_empty (); + + uint32_t spi = 0; + for (uint32_t lpi = 0; spi < page_map.length && lpi < larger_set.page_map.length; lpi++) + { + uint32_t spm = page_map[spi].major; + uint32_t lpm = larger_set.page_map[lpi].major; + auto sp = page_at (spi); + auto lp = larger_set.page_at (lpi); + + if (spm < lpm && !sp.is_empty ()) + return false; + + if (lpm < spm) + continue; + + if (!sp.is_subset (lp)) + return false; + + spi++; + } + + while (spi < page_map.length) + if (!page_at (spi++).is_empty ()) + return false; + + return true; + } + + private: + bool allocate_compact_workspace (hb_vector_t& workspace) + { + if (unlikely (!workspace.resize (pages.length))) + { + successful = false; + return false; + } + + return true; + } + + /* + * workspace should be a pre-sized vector allocated to hold at exactly pages.length + * elements. + */ + void compact (hb_vector_t& workspace, + unsigned int length) + { + assert(workspace.length == pages.length); + hb_vector_t& old_index_to_page_map_index = workspace; + + hb_fill (old_index_to_page_map_index.writer(), 0xFFFFFFFF); + /* TODO(iter) Rewrite as dagger? */ + for (unsigned i = 0; i < length; i++) + old_index_to_page_map_index[page_map[i].index] = i; + + compact_pages (old_index_to_page_map_index); + } + void compact_pages (const hb_vector_t& old_index_to_page_map_index) + { + unsigned int write_index = 0; + for (unsigned int i = 0; i < pages.length; i++) + { + if (old_index_to_page_map_index[i] == 0xFFFFFFFF) continue; + + if (write_index < i) + pages[write_index] = pages[i]; + + page_map[old_index_to_page_map_index[i]].index = write_index; + write_index++; + } + } + public: + + template + void process (const Op& op, const hb_bit_set_t &other) + { + const bool passthru_left = op (1, 0); + const bool passthru_right = op (0, 1); + + if (unlikely (!successful)) return; + + dirty (); + + unsigned int na = pages.length; + unsigned int nb = other.pages.length; + unsigned int next_page = na; + + unsigned int count = 0, newCount = 0; + unsigned int a = 0, b = 0; + unsigned int write_index = 0; + + // Pre-allocate the workspace that compact() will need so we can bail on allocation failure + // before attempting to rewrite the page map. + hb_vector_t compact_workspace; + if (!passthru_left && unlikely (!allocate_compact_workspace (compact_workspace))) return; + + for (; a < na && b < nb; ) + { + if (page_map[a].major == other.page_map[b].major) + { + if (!passthru_left) + { + // Move page_map entries that we're keeping from the left side set + // to the front of the page_map vector. This isn't necessary if + // passthru_left is set since no left side pages will be removed + // in that case. + if (write_index < a) + page_map[write_index] = page_map[a]; + write_index++; + } + + count++; + a++; + b++; + } + else if (page_map[a].major < other.page_map[b].major) + { + if (passthru_left) + count++; + a++; + } + else + { + if (passthru_right) + count++; + b++; + } + } + if (passthru_left) + count += na - a; + if (passthru_right) + count += nb - b; + + if (!passthru_left) + { + na = write_index; + next_page = write_index; + compact (compact_workspace, write_index); + } + + if (!resize (count)) + return; + + newCount = count; + + /* Process in-place backward. */ + a = na; + b = nb; + for (; a && b; ) + { + if (page_map[a - 1].major == other.page_map[b - 1].major) + { + a--; + b--; + count--; + page_map[count] = page_map[a]; + page_at (count).v = op (page_at (a).v, other.page_at (b).v); + } + else if (page_map[a - 1].major > other.page_map[b - 1].major) + { + a--; + if (passthru_left) + { + count--; + page_map[count] = page_map[a]; + } + } + else + { + b--; + if (passthru_right) + { + count--; + page_map[count].major = other.page_map[b].major; + page_map[count].index = next_page++; + page_at (count).v = other.page_at (b).v; + } + } + } + if (passthru_left) + while (a) + { + a--; + count--; + page_map[count] = page_map [a]; + } + if (passthru_right) + while (b) + { + b--; + count--; + page_map[count].major = other.page_map[b].major; + page_map[count].index = next_page++; + page_at (count).v = other.page_at (b).v; + } + assert (!count); + if (pages.length > newCount) + // This resize() doesn't need to be checked because we can't get here + // if the set is currently in_error() and this only resizes downwards + // which will always succeed if the set is not in_error(). + resize (newCount); + } + + bool next (hb_codepoint_t *codepoint) const + { + // TODO: this should be merged with prev() as both implementations + // are very similar. + if (unlikely (*codepoint == INVALID)) { + *codepoint = get_min (); + return *codepoint != INVALID; + } + + const auto* page_map_array = page_map.arrayZ; + unsigned int major = get_major (*codepoint); + unsigned int i = last_page_lookup; + + if (unlikely (i >= page_map.length || page_map_array[i].major != major)) + { + page_map.bfind (major, &i, HB_NOT_FOUND_STORE_CLOSEST); + if (i >= page_map.length) { + *codepoint = INVALID; + return false; + } + } + + const auto* pages_array = pages.arrayZ; + const page_map_t ¤t = page_map_array[i]; + if (likely (current.major == major)) + { + if (pages_array[current.index].next (codepoint)) + { + *codepoint += current.major * page_t::PAGE_BITS; + last_page_lookup = i; + return true; + } + i++; + } + + for (; i < page_map.length; i++) + { + const page_map_t ¤t = page_map.arrayZ[i]; + hb_codepoint_t m = pages_array[current.index].get_min (); + if (m != INVALID) + { + *codepoint = current.major * page_t::PAGE_BITS + m; + last_page_lookup = i; + return true; + } + } + last_page_lookup = 0; + *codepoint = INVALID; + return false; + } + bool previous (hb_codepoint_t *codepoint) const + { + if (unlikely (*codepoint == INVALID)) { + *codepoint = get_max (); + return *codepoint != INVALID; + } + + page_map_t map = {get_major (*codepoint), 0}; + unsigned int i; + page_map.bfind (map, &i, HB_NOT_FOUND_STORE_CLOSEST); + if (i < page_map.length && page_map[i].major == map.major) + { + if (pages[page_map[i].index].previous (codepoint)) + { + *codepoint += page_map[i].major * page_t::PAGE_BITS; + return true; + } + } + i--; + for (; (int) i >= 0; i--) + { + hb_codepoint_t m = pages[page_map[i].index].get_max (); + if (m != INVALID) + { + *codepoint = page_map[i].major * page_t::PAGE_BITS + m; + return true; + } + } + *codepoint = INVALID; + return false; + } + bool next_range (hb_codepoint_t *first, hb_codepoint_t *last) const + { + hb_codepoint_t i; + + i = *last; + if (!next (&i)) + { + *last = *first = INVALID; + return false; + } + + /* TODO Speed up. */ + *last = *first = i; + while (next (&i) && i == *last + 1) + (*last)++; + + return true; + } + bool previous_range (hb_codepoint_t *first, hb_codepoint_t *last) const + { + hb_codepoint_t i; + + i = *first; + if (!previous (&i)) + { + *last = *first = INVALID; + return false; + } + + /* TODO Speed up. */ + *last = *first = i; + while (previous (&i) && i == *first - 1) + (*first)--; + + return true; + } + + unsigned int get_population () const + { + if (population != UINT_MAX) + return population; + + unsigned int pop = 0; + unsigned int count = pages.length; + for (unsigned int i = 0; i < count; i++) + pop += pages[i].get_population (); + + population = pop; + return pop; + } + hb_codepoint_t get_min () const + { + unsigned int count = pages.length; + for (unsigned int i = 0; i < count; i++) + if (!page_at (i).is_empty ()) + return page_map[i].major * page_t::PAGE_BITS + page_at (i).get_min (); + return INVALID; + } + hb_codepoint_t get_max () const + { + unsigned int count = pages.length; + for (int i = count - 1; i >= 0; i--) + if (!page_at (i).is_empty ()) + return page_map[(unsigned) i].major * page_t::PAGE_BITS + page_at (i).get_max (); + return INVALID; + } + + static constexpr hb_codepoint_t INVALID = page_t::INVALID; + + /* + * Iterator implementation. + */ + struct iter_t : hb_iter_with_fallback_t + { + static constexpr bool is_sorted_iterator = true; + iter_t (const hb_bit_set_t &s_ = Null (hb_bit_set_t), + bool init = true) : s (&s_), v (INVALID), l(0) + { + if (init) + { + l = s->get_population () + 1; + __next__ (); + } + } + + typedef hb_codepoint_t __item_t__; + hb_codepoint_t __item__ () const { return v; } + bool __more__ () const { return v != INVALID; } + void __next__ () { s->next (&v); if (l) l--; } + void __prev__ () { s->previous (&v); } + unsigned __len__ () const { return l; } + iter_t end () const { return iter_t (*s, false); } + bool operator != (const iter_t& o) const + { return s != o.s || v != o.v; } + + protected: + const hb_bit_set_t *s; + hb_codepoint_t v; + unsigned l; + }; + iter_t iter () const { return iter_t (*this); } + operator iter_t () const { return iter (); } + + protected: + + page_t *page_for_insert (hb_codepoint_t g) + { + page_map_t map = {get_major (g), pages.length}; + unsigned int i; + if (!page_map.bfind (map, &i, HB_NOT_FOUND_STORE_CLOSEST)) + { + if (!resize (pages.length + 1)) + return nullptr; + + pages[map.index].init0 (); + memmove (page_map + i + 1, + page_map + i, + (page_map.length - 1 - i) * page_map.item_size); + page_map[i] = map; + } + return &pages[page_map[i].index]; + } + page_t *page_for (hb_codepoint_t g) + { + page_map_t key = {get_major (g)}; + const page_map_t *found = page_map.bsearch (key); + if (found) + return &pages[found->index]; + return nullptr; + } + const page_t *page_for (hb_codepoint_t g) const + { + page_map_t key = {get_major (g)}; + const page_map_t *found = page_map.bsearch (key); + if (found) + return &pages[found->index]; + return nullptr; + } + page_t &page_at (unsigned int i) { return pages[page_map[i].index]; } + const page_t &page_at (unsigned int i) const { return pages[page_map[i].index]; } + unsigned int get_major (hb_codepoint_t g) const { return g / page_t::PAGE_BITS; } + hb_codepoint_t major_start (unsigned int major) const { return major * page_t::PAGE_BITS; } +}; + + +#endif /* HB_BIT_SET_HH */ diff --git a/src/hb-ot-layout-gsubgpos.hh b/src/hb-ot-layout-gsubgpos.hh index f1c111a4a..a68abb533 100644 --- a/src/hb-ot-layout-gsubgpos.hh +++ b/src/hb-ot-layout-gsubgpos.hh @@ -3719,8 +3719,9 @@ struct GSUBGPOS hb_set_t alternate_feature_indices; if (version.to_int () >= 0x00010001u) (this+featureVars).closure_features (lookup_indices, &alternate_feature_indices); - if (unlikely (alternate_feature_indices.in_error())) { - feature_indices->successful = false; + if (unlikely (alternate_feature_indices.in_error())) + { + feature_indices->err (); return; } #endif diff --git a/src/hb-set.cc b/src/hb-set.cc index 25f29c67b..17bbdc055 100644 --- a/src/hb-set.cc +++ b/src/hb-set.cc @@ -169,7 +169,7 @@ hb_set_get_user_data (hb_set_t *set, hb_bool_t hb_set_allocation_successful (const hb_set_t *set) { - return set->successful; + return !set->in_error (); } /** diff --git a/src/hb-set.hh b/src/hb-set.hh index d47b3e8ca..5c70eeedc 100644 --- a/src/hb-set.hh +++ b/src/hb-set.hh @@ -29,47 +29,17 @@ #define HB_SET_HH #include "hb.hh" -#include "hb-bit-page.hh" -#include "hb-machinery.hh" +#include "hb-bit-set.hh" struct hb_set_t { - hb_set_t () { init (); } - ~hb_set_t () { fini (); } - - hb_set_t (const hb_set_t& other) : hb_set_t () { set (other); } - void operator= (const hb_set_t& other) { set (other); } - // TODO Add move construtor/assign - // TODO Add constructor for Iterator; with specialization for (sorted) vector / array? - - /* TODO Keep a freelist so we can release pages that are completely zeroed. At that - * point maybe also use a sentinel value for "all-1" pages? */ - - using page_t = hb_bit_page_t; - struct page_map_t - { - int cmp (const page_map_t &o) const { return cmp (o.major); } - int cmp (uint32_t o_major) const { return (int) o_major - (int) major; } - - uint32_t major; - uint32_t index; - }; - hb_object_header_t header; - bool successful; /* Allocations successful */ - mutable unsigned int population; - mutable unsigned int last_page_lookup; - hb_sorted_vector_t page_map; - hb_vector_t pages; + hb_bit_set_t s; void init_shallow () { - successful = true; - population = 0; - last_page_lookup = 0; - page_map.init (); - pages.init (); + s.init (); } void init () { @@ -78,10 +48,7 @@ struct hb_set_t } void fini_shallow () { - population = 0; - last_page_lookup = 0; - page_map.fini (); - pages.fini (); + s.fini (); } void fini () { @@ -89,103 +56,23 @@ struct hb_set_t fini_shallow (); } - bool in_error () const { return !successful; } - - bool resize (unsigned int count) - { - if (unlikely (count > pages.length && !successful)) return false; - if (!pages.resize (count) || !page_map.resize (count)) - { - pages.resize (page_map.length); - successful = false; - return false; - } - return true; - } - - void reset () - { - successful = true; - clear (); - } - - void clear () - { - if (resize (0)) - population = 0; - } - bool is_empty () const - { - unsigned int count = pages.length; - for (unsigned int i = 0; i < count; i++) - if (!pages[i].is_empty ()) - return false; - return true; - } explicit operator bool () const { return !is_empty (); } - void dirty () { population = UINT_MAX; } + void err () { s.err (); } + bool in_error () const { return s.in_error (); } - void add (hb_codepoint_t g) - { - if (unlikely (!successful)) return; - if (unlikely (g == INVALID)) return; - dirty (); - page_t *page = page_for_insert (g); if (unlikely (!page)) return; - page->add (g); - } - bool add_range (hb_codepoint_t a, hb_codepoint_t b) - { - if (unlikely (!successful)) return true; /* https://github.com/harfbuzz/harfbuzz/issues/657 */ - if (unlikely (a > b || a == INVALID || b == INVALID)) return false; - dirty (); - unsigned int ma = get_major (a); - unsigned int mb = get_major (b); - if (ma == mb) - { - page_t *page = page_for_insert (a); if (unlikely (!page)) return false; - page->add_range (a, b); - } - else - { - page_t *page = page_for_insert (a); if (unlikely (!page)) return false; - page->add_range (a, major_start (ma + 1) - 1); + void reset () { s.reset (); } - for (unsigned int m = ma + 1; m < mb; m++) - { - page = page_for_insert (major_start (m)); if (unlikely (!page)) return false; - page->init1 (); - } + void clear () { s.clear (); } - page = page_for_insert (b); if (unlikely (!page)) return false; - page->add_range (major_start (mb), b); - } - return true; - } + bool is_empty () const { return s.is_empty (); } + + void add (hb_codepoint_t g) { s.add (g); } + bool add_range (hb_codepoint_t a, hb_codepoint_t b) { return s.add_range (a, b); } template void add_array (const T *array, unsigned int count, unsigned int stride=sizeof(T)) - { - if (unlikely (!successful)) return; - if (!count) return; - dirty (); - hb_codepoint_t g = *array; - while (count) - { - unsigned int m = get_major (g); - page_t *page = page_for_insert (g); if (unlikely (!page)) return; - unsigned int start = major_start (m); - unsigned int end = major_start (m + 1); - do - { - page->add (g); - - array = &StructAtOffsetUnaligned (array, stride); - count--; - } - while (count && (g = *array, start <= g && g < end)); - } - } + { s.add_array (array, count, stride); } template void add_array (const hb_array_t& arr) { add_array (&arr, arr.len ()); } @@ -193,108 +80,14 @@ struct hb_set_t * Used for faster rejection of corrupt data. */ template bool add_sorted_array (const T *array, unsigned int count, unsigned int stride=sizeof(T)) - { - if (unlikely (!successful)) return true; /* https://github.com/harfbuzz/harfbuzz/issues/657 */ - if (!count) return true; - dirty (); - hb_codepoint_t g = *array; - hb_codepoint_t last_g = g; - while (count) - { - unsigned int m = get_major (g); - page_t *page = page_for_insert (g); if (unlikely (!page)) return false; - unsigned int end = major_start (m + 1); - do - { - /* If we try harder we can change the following comparison to <=; - * Not sure if it's worth it. */ - if (g < last_g) return false; - last_g = g; - page->add (g); - - array = (const T *) ((const char *) array + stride); - count--; - } - while (count && (g = *array, g < end)); - } - return true; - } + { return s.add_sorted_array (array, count, stride); } template bool add_sorted_array (const hb_sorted_array_t& arr) { return add_sorted_array (&arr, arr.len ()); } - void del (hb_codepoint_t g) - { - /* TODO perform op even if !successful. */ - if (unlikely (!successful)) return; - page_t *page = page_for (g); - if (!page) - return; - dirty (); - page->del (g); - } + void del (hb_codepoint_t g) { s.del (g); } + void del_range (hb_codepoint_t a, hb_codepoint_t b) { s.del_range (a, b); } - private: - void del_pages (int ds, int de) - { - if (ds <= de) - { - // Pre-allocate the workspace that compact() will need so we can bail on allocation failure - // before attempting to rewrite the page map. - hb_vector_t compact_workspace; - if (unlikely (!allocate_compact_workspace (compact_workspace))) return; - - unsigned int write_index = 0; - for (unsigned int i = 0; i < page_map.length; i++) - { - int m = (int) page_map[i].major; - if (m < ds || de < m) - page_map[write_index++] = page_map[i]; - } - compact (compact_workspace, write_index); - resize (write_index); - } - } - - - public: - void del_range (hb_codepoint_t a, hb_codepoint_t b) - { - /* TODO perform op even if !successful. */ - if (unlikely (!successful)) return; - if (unlikely (a > b || a == INVALID)) return; - dirty (); - unsigned int ma = get_major (a); - unsigned int mb = get_major (b); - /* Delete pages from ds through de if ds <= de. */ - int ds = (a == major_start (ma))? (int) ma: (int) (ma + 1); - int de = (b + 1 == major_start (mb + 1))? (int) mb: ((int) mb - 1); - if (ds > de || (int) ma < ds) - { - page_t *page = page_for (a); - if (page) - { - if (ma == mb) - page->del_range (a, b); - else - page->del_range (a, major_start (ma + 1) - 1); - } - } - if (de < (int) mb && ma != mb) - { - page_t *page = page_for (b); - if (page) - page->del_range (major_start (mb), b); - } - del_pages (ds, de); - } - - bool get (hb_codepoint_t g) const - { - const page_t *page = page_for (g); - if (!page) - return false; - return page->get (g); - } + bool get (hb_codepoint_t g) const { return s.get (g); } /* Has interface. */ static constexpr bool SENTINEL = false; @@ -311,497 +104,39 @@ struct hb_set_t { add_range (range.first, range.second); return *this; } bool intersects (hb_codepoint_t first, hb_codepoint_t last) const - { - hb_codepoint_t c = first - 1; - return next (&c) && c <= last; - } - void set (const hb_set_t &other) - { - if (unlikely (!successful)) return; - unsigned int count = other.pages.length; - if (!resize (count)) - return; - population = other.population; + { return s.intersects (first, last); } - hb_memcpy ((void *) pages, (const void *) other.pages, count * pages.item_size); - hb_memcpy ((void *) page_map, (const void *) other.page_map, count * page_map.item_size); - } + void set (const hb_set_t &other) { s.set (other.s); } - bool is_equal (const hb_set_t &other) const - { - if (get_population () != other.get_population ()) - return false; + bool is_equal (const hb_set_t &other) const { return s.is_equal (other.s); } - unsigned int na = pages.length; - unsigned int nb = other.pages.length; + bool is_subset (const hb_set_t &larger_set) const { return s.is_subset (larger_set.s); } - unsigned int a = 0, b = 0; - for (; a < na && b < nb; ) - { - if (page_at (a).is_empty ()) { a++; continue; } - if (other.page_at (b).is_empty ()) { b++; continue; } - if (page_map[a].major != other.page_map[b].major || - !page_at (a).is_equal (other.page_at (b))) - return false; - a++; - b++; - } - for (; a < na; a++) - if (!page_at (a).is_empty ()) { return false; } - for (; b < nb; b++) - if (!other.page_at (b).is_empty ()) { return false; } + void union_ (const hb_set_t &other) { s.process (hb_bitwise_or, other.s); } + void intersect (const hb_set_t &other) { s.process (hb_bitwise_and, other.s); } + void subtract (const hb_set_t &other) { s.process (hb_bitwise_sub, other.s); } + void symmetric_difference (const hb_set_t &other) { s.process (hb_bitwise_xor, other.s); } - return true; - } - - bool is_subset (const hb_set_t &larger_set) const - { - /* TODO: Merge this and is_equal() into something like process(). */ - if (unlikely(larger_set.is_empty ())) - return is_empty (); - - uint32_t spi = 0; - for (uint32_t lpi = 0; spi < page_map.length && lpi < larger_set.page_map.length; lpi++) - { - uint32_t spm = page_map[spi].major; - uint32_t lpm = larger_set.page_map[lpi].major; - auto sp = page_at (spi); - auto lp = larger_set.page_at (lpi); - - if (spm < lpm && !sp.is_empty ()) - return false; - - if (lpm < spm) - continue; - - if (!sp.is_subset (lp)) - return false; - - spi++; - } - - while (spi < page_map.length) - if (!page_at (spi++).is_empty ()) - return false; - - return true; - } - - bool allocate_compact_workspace (hb_vector_t& workspace) - { - if (unlikely (!workspace.resize (pages.length))) - { - successful = false; - return false; - } - - return true; - } - - - /* - * workspace should be a pre-sized vector allocated to hold at exactly pages.length - * elements. - */ - void compact (hb_vector_t& workspace, - unsigned int length) - { - assert(workspace.length == pages.length); - hb_vector_t& old_index_to_page_map_index = workspace; - - hb_fill (old_index_to_page_map_index.writer(), 0xFFFFFFFF); - /* TODO(iter) Rewrite as dagger? */ - for (unsigned i = 0; i < length; i++) - old_index_to_page_map_index[page_map[i].index] = i; - - compact_pages (old_index_to_page_map_index); - } - - void compact_pages (const hb_vector_t& old_index_to_page_map_index) - { - unsigned int write_index = 0; - for (unsigned int i = 0; i < pages.length; i++) - { - if (old_index_to_page_map_index[i] == 0xFFFFFFFF) continue; - - if (write_index < i) - pages[write_index] = pages[i]; - - page_map[old_index_to_page_map_index[i]].index = write_index; - write_index++; - } - } - - template - void process (const Op& op, const hb_set_t &other) - { - const bool passthru_left = op (1, 0); - const bool passthru_right = op (0, 1); - - if (unlikely (!successful)) return; - - dirty (); - - unsigned int na = pages.length; - unsigned int nb = other.pages.length; - unsigned int next_page = na; - - unsigned int count = 0, newCount = 0; - unsigned int a = 0, b = 0; - unsigned int write_index = 0; - - // Pre-allocate the workspace that compact() will need so we can bail on allocation failure - // before attempting to rewrite the page map. - hb_vector_t compact_workspace; - if (!passthru_left && unlikely (!allocate_compact_workspace (compact_workspace))) return; - - for (; a < na && b < nb; ) - { - if (page_map[a].major == other.page_map[b].major) - { - if (!passthru_left) - { - // Move page_map entries that we're keeping from the left side set - // to the front of the page_map vector. This isn't necessary if - // passthru_left is set since no left side pages will be removed - // in that case. - if (write_index < a) - page_map[write_index] = page_map[a]; - write_index++; - } - - count++; - a++; - b++; - } - else if (page_map[a].major < other.page_map[b].major) - { - if (passthru_left) - count++; - a++; - } - else - { - if (passthru_right) - count++; - b++; - } - } - if (passthru_left) - count += na - a; - if (passthru_right) - count += nb - b; - - if (!passthru_left) - { - na = write_index; - next_page = write_index; - compact (compact_workspace, write_index); - } - - if (!resize (count)) - return; - - newCount = count; - - /* Process in-place backward. */ - a = na; - b = nb; - for (; a && b; ) - { - if (page_map[a - 1].major == other.page_map[b - 1].major) - { - a--; - b--; - count--; - page_map[count] = page_map[a]; - page_at (count).v = op (page_at (a).v, other.page_at (b).v); - } - else if (page_map[a - 1].major > other.page_map[b - 1].major) - { - a--; - if (passthru_left) - { - count--; - page_map[count] = page_map[a]; - } - } - else - { - b--; - if (passthru_right) - { - count--; - page_map[count].major = other.page_map[b].major; - page_map[count].index = next_page++; - page_at (count).v = other.page_at (b).v; - } - } - } - if (passthru_left) - while (a) - { - a--; - count--; - page_map[count] = page_map [a]; - } - if (passthru_right) - while (b) - { - b--; - count--; - page_map[count].major = other.page_map[b].major; - page_map[count].index = next_page++; - page_at (count).v = other.page_at (b).v; - } - assert (!count); - if (pages.length > newCount) - // This resize() doesn't need to be checked because we can't get here - // if the set is currently in_error() and this only resizes downwards - // which will always succeed if the set is not in_error(). - resize (newCount); - } - - void union_ (const hb_set_t &other) - { - process (hb_bitwise_or, other); - } - void intersect (const hb_set_t &other) - { - process (hb_bitwise_and, other); - } - void subtract (const hb_set_t &other) - { - process (hb_bitwise_sub, other); - } - void symmetric_difference (const hb_set_t &other) - { - process (hb_bitwise_xor, other); - } - bool next (hb_codepoint_t *codepoint) const - { - // TODO: this should be merged with prev() as both implementations - // are very similar. - if (unlikely (*codepoint == INVALID)) { - *codepoint = get_min (); - return *codepoint != INVALID; - } - - const auto* page_map_array = page_map.arrayZ; - unsigned int major = get_major (*codepoint); - unsigned int i = last_page_lookup; - - if (unlikely (i >= page_map.length || page_map_array[i].major != major)) - { - page_map.bfind (major, &i, HB_NOT_FOUND_STORE_CLOSEST); - if (i >= page_map.length) { - *codepoint = INVALID; - return false; - } - } - - const auto* pages_array = pages.arrayZ; - const page_map_t ¤t = page_map_array[i]; - if (likely (current.major == major)) - { - if (pages_array[current.index].next (codepoint)) - { - *codepoint += current.major * page_t::PAGE_BITS; - last_page_lookup = i; - return true; - } - i++; - } - - for (; i < page_map.length; i++) - { - const page_map_t ¤t = page_map.arrayZ[i]; - hb_codepoint_t m = pages_array[current.index].get_min (); - if (m != INVALID) - { - *codepoint = current.major * page_t::PAGE_BITS + m; - last_page_lookup = i; - return true; - } - } - last_page_lookup = 0; - *codepoint = INVALID; - return false; - } - bool previous (hb_codepoint_t *codepoint) const - { - if (unlikely (*codepoint == INVALID)) { - *codepoint = get_max (); - return *codepoint != INVALID; - } - - page_map_t map = {get_major (*codepoint), 0}; - unsigned int i; - page_map.bfind (map, &i, HB_NOT_FOUND_STORE_CLOSEST); - if (i < page_map.length && page_map[i].major == map.major) - { - if (pages[page_map[i].index].previous (codepoint)) - { - *codepoint += page_map[i].major * page_t::PAGE_BITS; - return true; - } - } - i--; - for (; (int) i >= 0; i--) - { - hb_codepoint_t m = pages[page_map[i].index].get_max (); - if (m != INVALID) - { - *codepoint = page_map[i].major * page_t::PAGE_BITS + m; - return true; - } - } - *codepoint = INVALID; - return false; - } + bool next (hb_codepoint_t *codepoint) const { return s.next (codepoint); } + bool previous (hb_codepoint_t *codepoint) const { return s.previous (codepoint); } bool next_range (hb_codepoint_t *first, hb_codepoint_t *last) const - { - hb_codepoint_t i; - - i = *last; - if (!next (&i)) - { - *last = *first = INVALID; - return false; - } - - /* TODO Speed up. */ - *last = *first = i; - while (next (&i) && i == *last + 1) - (*last)++; - - return true; - } + { return s.next_range (first, last); } bool previous_range (hb_codepoint_t *first, hb_codepoint_t *last) const - { - hb_codepoint_t i; + { return s.previous_range (first, last); } - i = *first; - if (!previous (&i)) - { - *last = *first = INVALID; - return false; - } + unsigned int get_population () const { return s.get_population (); } + hb_codepoint_t get_min () const { return s.get_min (); } + hb_codepoint_t get_max () const { return s.get_max (); } - /* TODO Speed up. */ - *last = *first = i; - while (previous (&i) && i == *first - 1) - (*first)--; - - return true; - } - - unsigned int get_population () const - { - if (population != UINT_MAX) - return population; - - unsigned int pop = 0; - unsigned int count = pages.length; - for (unsigned int i = 0; i < count; i++) - pop += pages[i].get_population (); - - population = pop; - return pop; - } - hb_codepoint_t get_min () const - { - unsigned int count = pages.length; - for (unsigned int i = 0; i < count; i++) - if (!page_at (i).is_empty ()) - return page_map[i].major * page_t::PAGE_BITS + page_at (i).get_min (); - return INVALID; - } - hb_codepoint_t get_max () const - { - unsigned int count = pages.length; - for (int i = count - 1; i >= 0; i--) - if (!page_at (i).is_empty ()) - return page_map[(unsigned) i].major * page_t::PAGE_BITS + page_at (i).get_max (); - return INVALID; - } - - static constexpr hb_codepoint_t INVALID = HB_SET_VALUE_INVALID; - static_assert (INVALID == page_t::INVALID, ""); + static constexpr hb_codepoint_t INVALID = hb_bit_set_t::INVALID; + static_assert (INVALID == HB_SET_VALUE_INVALID, ""); /* * Iterator implementation. */ - struct iter_t : hb_iter_with_fallback_t - { - static constexpr bool is_sorted_iterator = true; - iter_t (const hb_set_t &s_ = Null (hb_set_t), - bool init = true) : s (&s_), v (INVALID), l(0) - { - if (init) - { - l = s->get_population () + 1; - __next__ (); - } - } - - typedef hb_codepoint_t __item_t__; - hb_codepoint_t __item__ () const { return v; } - bool __more__ () const { return v != INVALID; } - void __next__ () { s->next (&v); if (l) l--; } - void __prev__ () { s->previous (&v); } - unsigned __len__ () const { return l; } - iter_t end () const { return iter_t (*s, false); } - bool operator != (const iter_t& o) const - { return s != o.s || v != o.v; } - - protected: - const hb_set_t *s; - hb_codepoint_t v; - unsigned l; - }; - iter_t iter () const { return iter_t (*this); } + using iter_t = hb_bit_set_t::iter_t; + iter_t iter () const { return iter_t (this->s); } operator iter_t () const { return iter (); } - - protected: - - page_t *page_for_insert (hb_codepoint_t g) - { - page_map_t map = {get_major (g), pages.length}; - unsigned int i; - if (!page_map.bfind (map, &i, HB_NOT_FOUND_STORE_CLOSEST)) - { - if (!resize (pages.length + 1)) - return nullptr; - - pages[map.index].init0 (); - memmove (page_map + i + 1, - page_map + i, - (page_map.length - 1 - i) * page_map.item_size); - page_map[i] = map; - } - return &pages[page_map[i].index]; - } - page_t *page_for (hb_codepoint_t g) - { - page_map_t key = {get_major (g)}; - const page_map_t *found = page_map.bsearch (key); - if (found) - return &pages[found->index]; - return nullptr; - } - const page_t *page_for (hb_codepoint_t g) const - { - page_map_t key = {get_major (g)}; - const page_map_t *found = page_map.bsearch (key); - if (found) - return &pages[found->index]; - return nullptr; - } - page_t &page_at (unsigned int i) { return pages[page_map[i].index]; } - const page_t &page_at (unsigned int i) const { return pages[page_map[i].index]; } - unsigned int get_major (hb_codepoint_t g) const { return g / page_t::PAGE_BITS; } - hb_codepoint_t major_start (unsigned int major) const { return major * page_t::PAGE_BITS; } }; From b5cdbdc030dc700134f41b67b5a42ab54806a9a3 Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Tue, 17 Aug 2021 10:53:08 -0600 Subject: [PATCH 15/55] [set] Turn hb_set_t into instance of template taking implementation t --- src/hb-set.hh | 32 ++++++++++++++++++-------------- 1 file changed, 18 insertions(+), 14 deletions(-) diff --git a/src/hb-set.hh b/src/hb-set.hh index 5c70eeedc..221a4b337 100644 --- a/src/hb-set.hh +++ b/src/hb-set.hh @@ -32,10 +32,11 @@ #include "hb-bit-set.hh" -struct hb_set_t +template +struct hb_intset_t { hb_object_header_t header; - hb_bit_set_t s; + impl_t s; void init_shallow () { @@ -98,24 +99,24 @@ struct hb_set_t bool operator () (hb_codepoint_t k) const { return has (k); } /* Sink interface. */ - hb_set_t& operator << (hb_codepoint_t v) + hb_intset_t& operator << (hb_codepoint_t v) { add (v); return *this; } - hb_set_t& operator << (const hb_pair_t& range) + hb_intset_t& operator << (const hb_pair_t& range) { add_range (range.first, range.second); return *this; } bool intersects (hb_codepoint_t first, hb_codepoint_t last) const { return s.intersects (first, last); } - void set (const hb_set_t &other) { s.set (other.s); } + void set (const hb_intset_t &other) { s.set (other.s); } - bool is_equal (const hb_set_t &other) const { return s.is_equal (other.s); } + bool is_equal (const hb_intset_t &other) const { return s.is_equal (other.s); } - bool is_subset (const hb_set_t &larger_set) const { return s.is_subset (larger_set.s); } + bool is_subset (const hb_intset_t &larger_set) const { return s.is_subset (larger_set.s); } - void union_ (const hb_set_t &other) { s.process (hb_bitwise_or, other.s); } - void intersect (const hb_set_t &other) { s.process (hb_bitwise_and, other.s); } - void subtract (const hb_set_t &other) { s.process (hb_bitwise_sub, other.s); } - void symmetric_difference (const hb_set_t &other) { s.process (hb_bitwise_xor, other.s); } + void union_ (const hb_intset_t &other) { s.process (hb_bitwise_or, other.s); } + void intersect (const hb_intset_t &other) { s.process (hb_bitwise_and, other.s); } + void subtract (const hb_intset_t &other) { s.process (hb_bitwise_sub, other.s); } + void symmetric_difference (const hb_intset_t &other) { s.process (hb_bitwise_xor, other.s); } bool next (hb_codepoint_t *codepoint) const { return s.next (codepoint); } bool previous (hb_codepoint_t *codepoint) const { return s.previous (codepoint); } @@ -128,16 +129,19 @@ struct hb_set_t hb_codepoint_t get_min () const { return s.get_min (); } hb_codepoint_t get_max () const { return s.get_max (); } - static constexpr hb_codepoint_t INVALID = hb_bit_set_t::INVALID; - static_assert (INVALID == HB_SET_VALUE_INVALID, ""); + static constexpr hb_codepoint_t INVALID = impl_t::INVALID; /* * Iterator implementation. */ - using iter_t = hb_bit_set_t::iter_t; + using iter_t = typename impl_t::iter_t; iter_t iter () const { return iter_t (this->s); } operator iter_t () const { return iter (); } }; +struct hb_set_t : hb_intset_t {}; + +static_assert (hb_set_t::INVALID == HB_SET_VALUE_INVALID, ""); + #endif /* HB_SET_HH */ From f0c3804fa292ef3be41cc8d1cdea8239f00e2295 Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Tue, 17 Aug 2021 15:37:19 -0600 Subject: [PATCH 16/55] [set] Add hb_bit_set_invertible_t and resurrect hb_set_invert() Implementation is NOT complete yet. --- docs/harfbuzz-sections.txt | 2 +- src/Makefile.sources | 1 + src/hb-bit-set-invertible.hh | 168 +++++++++++++++++++++++++++++++++++ src/hb-bit-set.hh | 15 ++-- src/hb-deprecated.h | 3 - src/hb-set.cc | 9 +- src/hb-set.h | 3 + src/hb-set.hh | 40 ++++----- 8 files changed, 201 insertions(+), 40 deletions(-) create mode 100644 src/hb-bit-set-invertible.hh diff --git a/docs/harfbuzz-sections.txt b/docs/harfbuzz-sections.txt index a56b8b43b..ac96c75ac 100644 --- a/docs/harfbuzz-sections.txt +++ b/docs/harfbuzz-sections.txt @@ -195,7 +195,6 @@ HB_OT_VAR_NO_AXIS_INDEX hb_ot_var_axis_t hb_ot_var_find_axis hb_ot_var_get_axes -hb_set_invert hb_unicode_eastasian_width_func_t hb_unicode_eastasian_width hb_unicode_funcs_set_eastasian_width_func @@ -614,6 +613,7 @@ hb_set_get_population hb_set_get_user_data hb_set_has hb_set_intersect +hb_set_invert hb_set_is_empty hb_set_is_equal hb_set_is_subset diff --git a/src/Makefile.sources b/src/Makefile.sources index 04b9cbe22..28fbf2c52 100644 --- a/src/Makefile.sources +++ b/src/Makefile.sources @@ -21,6 +21,7 @@ HB_BASE_sources = \ hb-bimap.hh \ hb-bit-page.hh \ hb-bit-set.hh \ + hb-bit-set-invertible.hh \ hb-blob.cc \ hb-blob.hh \ hb-buffer-serialize.cc \ diff --git a/src/hb-bit-set-invertible.hh b/src/hb-bit-set-invertible.hh new file mode 100644 index 000000000..a3212b4e2 --- /dev/null +++ b/src/hb-bit-set-invertible.hh @@ -0,0 +1,168 @@ +/* + * Copyright © 2012,2017 Google, Inc. + * Copyright © 2021 Behdad Esfahbod + * + * This is part of HarfBuzz, a text shaping library. + * + * Permission is hereby granted, without written agreement and without + * license or royalty fees, to use, copy, modify, and distribute this + * software and its documentation for any purpose, provided that the + * above copyright notice and the following two paragraphs appear in + * all copies of this software. + * + * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES + * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN + * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH + * DAMAGE. + * + * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, + * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS + * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + * Google Author(s): Behdad Esfahbod + */ + +#ifndef HB_BIT_SET_INVERTIBLE_HH +#define HB_BIT_SET_INVERTIBLE_HH + +#include "hb.hh" +#include "hb-bit-set.hh" + + +struct hb_bit_set_invertible_t +{ + hb_bit_set_t s; + bool inverted; + + hb_bit_set_invertible_t () { init (); } + ~hb_bit_set_invertible_t () { fini (); } + + void init () { s.init (); inverted = false; } + void fini () { s.fini (); } + void err () { s.err (); } + bool in_error () const { return s.in_error (); } + explicit operator bool () const { return !is_empty (); } + + void reset () { s.reset (); inverted = false; } + void clear () { s.clear (); inverted = false; } + void invert () { if (!s.in_error ()) inverted = !inverted; } + + bool is_empty () const { return inverted ? /*XXX*/false : s.is_empty (); } + + void add (hb_codepoint_t g) { inverted ? s.del (g) : s.add (g); } + bool add_range (hb_codepoint_t a, hb_codepoint_t b) { return inverted ? (s.del_range (a, b), true) : s.add_range (a, b); } + + template + void add_array (const T *array, unsigned int count, unsigned int stride=sizeof(T)) + { /*XXX(inverted)*/s.add_array (array, count, stride); } + template + void add_array (const hb_array_t& arr) { add_array (&arr, arr.len ()); } + + /* Might return false if array looks unsorted. + * Used for faster rejection of corrupt data. */ + template + bool add_sorted_array (const T *array, unsigned int count, unsigned int stride=sizeof(T)) + { return /*XXX(inverted)*/s.add_sorted_array (array, count, stride); } + template + bool add_sorted_array (const hb_sorted_array_t& arr) { return add_sorted_array (&arr, arr.len ()); } + + void del (hb_codepoint_t g) { inverted ? s.add (g) : s.del (g); } + void del_range (hb_codepoint_t a, hb_codepoint_t b) { inverted ? (void) s.add_range (a, b) : s.del_range (a, b); } + + bool get (hb_codepoint_t g) const { return s.get (g) ^ inverted; } + + /* Has interface. */ + static constexpr bool SENTINEL = false; + typedef bool value_t; + value_t operator [] (hb_codepoint_t k) const { return get (k); } + bool has (hb_codepoint_t k) const { return (*this)[k] != SENTINEL; } + /* Predicate. */ + bool operator () (hb_codepoint_t k) const { return has (k); } + + /* Sink interface. */ + hb_bit_set_invertible_t& operator << (hb_codepoint_t v) + { add (v); return *this; } + hb_bit_set_invertible_t& operator << (const hb_pair_t& range) + { add_range (range.first, range.second); return *this; } + + bool intersects (hb_codepoint_t first, hb_codepoint_t last) const + { return /*XXX(inverted)*/s.intersects (first, last); } + + void set (const hb_bit_set_invertible_t &other) { s.set (other.s); inverted = other.inverted; } + + bool is_equal (const hb_bit_set_invertible_t &other) const + { return inverted == other.inverted /*XXX*/ && s.is_equal (other.s); } + + bool is_subset (const hb_bit_set_invertible_t &larger_set) const + { + if (inverted && !larger_set.inverted) return false; /*XXX*/ + if (!inverted && larger_set.inverted) + { + /* TODO(iter) Write as hb_all dagger. */ + for (auto c: s) + if (larger_set.s.has (c)) + return false; + return true; + } + /* inverted == larger_set.inverted */ + return inverted ? larger_set.s.is_subset (s) : s.is_subset (larger_set.s); + } + + template + void process (const Op& op, const hb_bit_set_invertible_t &other) + { s.process (op, other.s); } + + /*XXX(inverted)*/ + void union_ (const hb_bit_set_invertible_t &other) { process (hb_bitwise_or, other); } + /*XXX(inverted)*/ + void intersect (const hb_bit_set_invertible_t &other) { process (hb_bitwise_and, other); } + /*XXX(inverted)*/ + void subtract (const hb_bit_set_invertible_t &other) { process (hb_bitwise_sub, other); } + /*XXX(inverted)*/ + void symmetric_difference (const hb_bit_set_invertible_t &other) { process (hb_bitwise_xor, other); } + + bool next (hb_codepoint_t *codepoint) const + { + /*XXX(inverted)*/ + return s.next (codepoint); + } + bool previous (hb_codepoint_t *codepoint) const + { + /*XXX(inverted)*/ + return s.previous (codepoint); + } + bool next_range (hb_codepoint_t *first, hb_codepoint_t *last) const + { + /*XXX(inverted)*/ + return s.next_range (first, last); + } + bool previous_range (hb_codepoint_t *first, hb_codepoint_t *last) const + { + /*XXX(inverted)*/ + return s.previous_range (first, last); + } + + unsigned int get_population () const + { return inverted ? INVALID - s.get_population () : s.get_population (); } + + hb_codepoint_t get_min () const + { return /*XXX(inverted)*/s.get_min (); } + hb_codepoint_t get_max () const + { return /*XXX(inverted)*/s.get_max (); } + + static constexpr hb_codepoint_t INVALID = hb_bit_set_t::INVALID; + + /* + * Iterator implementation. + */ + /*XXX(inverted)*/ + using iter_t = hb_bit_set_t::iter_t; + iter_t iter () const { return iter_t (this->s); } + operator iter_t () const { return iter (); } +}; + + +#endif /* HB_BIT_SET_INVERTIBLE_HH */ diff --git a/src/hb-bit-set.hh b/src/hb-bit-set.hh index 8e386b91e..3b5b473c6 100644 --- a/src/hb-bit-set.hh +++ b/src/hb-bit-set.hh @@ -35,14 +35,8 @@ struct hb_bit_set_t { - hb_bit_set_t () - { - init (); - } - ~hb_bit_set_t () - { - fini (); - } + hb_bit_set_t () { init (); } + ~hb_bit_set_t () { fini (); } void init () { @@ -558,6 +552,11 @@ struct hb_bit_set_t resize (newCount); } + void union_ (const hb_bit_set_t &other) { process (hb_bitwise_or, other); } + void intersect (const hb_bit_set_t &other) { process (hb_bitwise_and, other); } + void subtract (const hb_bit_set_t &other) { process (hb_bitwise_sub, other); } + void symmetric_difference (const hb_bit_set_t &other) { process (hb_bitwise_xor, other); } + bool next (hb_codepoint_t *codepoint) const { // TODO: this should be merged with prev() as both implementations diff --git a/src/hb-deprecated.h b/src/hb-deprecated.h index 5f1912578..a130d77f7 100644 --- a/src/hb-deprecated.h +++ b/src/hb-deprecated.h @@ -107,9 +107,6 @@ hb_font_funcs_set_glyph_func (hb_font_funcs_t *ffuncs, hb_font_get_glyph_func_t func, void *user_data, hb_destroy_func_t destroy); -HB_EXTERN HB_DEPRECATED void -hb_set_invert (hb_set_t *set); - /** * hb_unicode_eastasian_width_func_t: * @ufuncs: A Unicode-functions structure diff --git a/src/hb-set.cc b/src/hb-set.cc index 17bbdc055..eb6f41e11 100644 --- a/src/hb-set.cc +++ b/src/hb-set.cc @@ -432,22 +432,19 @@ hb_set_symmetric_difference (hb_set_t *set, set->symmetric_difference (*other); } -#ifndef HB_DISABLE_DEPRECATED /** * hb_set_invert: * @set: A set * * Inverts the contents of @set. * - * Since: 0.9.10 - * - * Deprecated: 1.6.1 + * Since: 3.0.0 **/ void -hb_set_invert (hb_set_t *set HB_UNUSED) +hb_set_invert (hb_set_t *set) { + set->invert (); } -#endif /** * hb_set_get_population: diff --git a/src/hb-set.h b/src/hb-set.h index 7f2112e69..423225bf9 100644 --- a/src/hb-set.h +++ b/src/hb-set.h @@ -94,6 +94,9 @@ hb_set_clear (hb_set_t *set); HB_EXTERN hb_bool_t hb_set_is_empty (const hb_set_t *set); +HB_EXTERN void +hb_set_invert (hb_set_t *set); + HB_EXTERN hb_bool_t hb_set_has (const hb_set_t *set, hb_codepoint_t codepoint); diff --git a/src/hb-set.hh b/src/hb-set.hh index 221a4b337..95132200a 100644 --- a/src/hb-set.hh +++ b/src/hb-set.hh @@ -29,28 +29,25 @@ #define HB_SET_HH #include "hb.hh" -#include "hb-bit-set.hh" +#include "hb-bit-set-invertible.hh" template -struct hb_intset_t +struct hb_sparseset_t { hb_object_header_t header; impl_t s; - void init_shallow () - { - s.init (); - } + hb_sparseset_t () { init (); } + ~hb_sparseset_t () { fini (); } + + void init_shallow () { s.init (); } void init () { hb_object_init (this); init_shallow (); } - void fini_shallow () - { - s.fini (); - } + void fini_shallow () { s.fini (); } void fini () { hb_object_fini (this); @@ -63,9 +60,8 @@ struct hb_intset_t bool in_error () const { return s.in_error (); } void reset () { s.reset (); } - void clear () { s.clear (); } - + void invert () { s.invert (); } bool is_empty () const { return s.is_empty (); } void add (hb_codepoint_t g) { s.add (g); } @@ -99,24 +95,24 @@ struct hb_intset_t bool operator () (hb_codepoint_t k) const { return has (k); } /* Sink interface. */ - hb_intset_t& operator << (hb_codepoint_t v) + hb_sparseset_t& operator << (hb_codepoint_t v) { add (v); return *this; } - hb_intset_t& operator << (const hb_pair_t& range) + hb_sparseset_t& operator << (const hb_pair_t& range) { add_range (range.first, range.second); return *this; } bool intersects (hb_codepoint_t first, hb_codepoint_t last) const { return s.intersects (first, last); } - void set (const hb_intset_t &other) { s.set (other.s); } + void set (const hb_sparseset_t &other) { s.set (other.s); } - bool is_equal (const hb_intset_t &other) const { return s.is_equal (other.s); } + bool is_equal (const hb_sparseset_t &other) const { return s.is_equal (other.s); } - bool is_subset (const hb_intset_t &larger_set) const { return s.is_subset (larger_set.s); } + bool is_subset (const hb_sparseset_t &larger_set) const { return s.is_subset (larger_set.s); } - void union_ (const hb_intset_t &other) { s.process (hb_bitwise_or, other.s); } - void intersect (const hb_intset_t &other) { s.process (hb_bitwise_and, other.s); } - void subtract (const hb_intset_t &other) { s.process (hb_bitwise_sub, other.s); } - void symmetric_difference (const hb_intset_t &other) { s.process (hb_bitwise_xor, other.s); } + void union_ (const hb_sparseset_t &other) { s.union_ (other.s); } + void intersect (const hb_sparseset_t &other) { s.intersect (other.s); } + void subtract (const hb_sparseset_t &other) { s.subtract (other.s); } + void symmetric_difference (const hb_sparseset_t &other) { s.symmetric_difference (other.s); } bool next (hb_codepoint_t *codepoint) const { return s.next (codepoint); } bool previous (hb_codepoint_t *codepoint) const { return s.previous (codepoint); } @@ -139,7 +135,7 @@ struct hb_intset_t operator iter_t () const { return iter (); } }; -struct hb_set_t : hb_intset_t {}; +struct hb_set_t : hb_sparseset_t {}; static_assert (hb_set_t::INVALID == HB_SET_VALUE_INVALID, ""); From 48ad9eef1eb5e5226fcfdb86f3cf5be925456a57 Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Wed, 18 Aug 2021 21:05:21 -0600 Subject: [PATCH 17/55] [bit-set] Merge page_for_insert() into page_for() --- src/hb-bit-set.hh | 27 +++++++++++---------------- 1 file changed, 11 insertions(+), 16 deletions(-) diff --git a/src/hb-bit-set.hh b/src/hb-bit-set.hh index 3b5b473c6..71e698e06 100644 --- a/src/hb-bit-set.hh +++ b/src/hb-bit-set.hh @@ -121,7 +121,7 @@ struct hb_bit_set_t if (unlikely (!successful)) return; if (unlikely (g == INVALID)) return; dirty (); - page_t *page = page_for_insert (g); if (unlikely (!page)) return; + page_t *page = page_for (g, true); if (unlikely (!page)) return; page->add (g); } bool add_range (hb_codepoint_t a, hb_codepoint_t b) @@ -133,21 +133,21 @@ struct hb_bit_set_t unsigned int mb = get_major (b); if (ma == mb) { - page_t *page = page_for_insert (a); if (unlikely (!page)) return false; + page_t *page = page_for (a, true); if (unlikely (!page)) return false; page->add_range (a, b); } else { - page_t *page = page_for_insert (a); if (unlikely (!page)) return false; + page_t *page = page_for (a, true); if (unlikely (!page)) return false; page->add_range (a, major_start (ma + 1) - 1); for (unsigned int m = ma + 1; m < mb; m++) { - page = page_for_insert (major_start (m)); if (unlikely (!page)) return false; + page = page_for (major_start (m), true); if (unlikely (!page)) return false; page->init1 (); } - page = page_for_insert (b); if (unlikely (!page)) return false; + page = page_for (b, true); if (unlikely (!page)) return false; page->add_range (major_start (mb), b); } return true; @@ -163,7 +163,7 @@ struct hb_bit_set_t while (count) { unsigned int m = get_major (g); - page_t *page = page_for_insert (g); if (unlikely (!page)) return; + page_t *page = page_for (g, true); if (unlikely (!page)) return; unsigned int start = major_start (m); unsigned int end = major_start (m + 1); do @@ -192,7 +192,7 @@ struct hb_bit_set_t while (count) { unsigned int m = get_major (g); - page_t *page = page_for_insert (g); if (unlikely (!page)) return false; + page_t *page = page_for (g, true); if (unlikely (!page)) return false; unsigned int end = major_start (m + 1); do { @@ -743,12 +743,15 @@ struct hb_bit_set_t protected: - page_t *page_for_insert (hb_codepoint_t g) + page_t *page_for (hb_codepoint_t g, bool insert = false) { page_map_t map = {get_major (g), pages.length}; unsigned int i; if (!page_map.bfind (map, &i, HB_NOT_FOUND_STORE_CLOSEST)) { + if (!insert) + return nullptr; + if (!resize (pages.length + 1)) return nullptr; @@ -760,14 +763,6 @@ struct hb_bit_set_t } return &pages[page_map[i].index]; } - page_t *page_for (hb_codepoint_t g) - { - page_map_t key = {get_major (g)}; - const page_map_t *found = page_map.bsearch (key); - if (found) - return &pages[found->index]; - return nullptr; - } const page_t *page_for (hb_codepoint_t g) const { page_map_t key = {get_major (g)}; From 0efa614c04a237722ca6a63a7b0c481fee11be97 Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Wed, 18 Aug 2021 21:16:05 -0600 Subject: [PATCH 18/55] [bit-set] Add del_array/del_sorted_array() --- src/hb-bit-set.hh | 35 +++++++++++++++++++++++++++++------ 1 file changed, 29 insertions(+), 6 deletions(-) diff --git a/src/hb-bit-set.hh b/src/hb-bit-set.hh index 71e698e06..493d3b26e 100644 --- a/src/hb-bit-set.hh +++ b/src/hb-bit-set.hh @@ -154,7 +154,7 @@ struct hb_bit_set_t } template - void add_array (const T *array, unsigned int count, unsigned int stride=sizeof(T)) + void set_array (bool v, const T *array, unsigned int count, unsigned int stride=sizeof(T)) { if (unlikely (!successful)) return; if (!count) return; @@ -163,12 +163,13 @@ struct hb_bit_set_t while (count) { unsigned int m = get_major (g); - page_t *page = page_for (g, true); if (unlikely (!page)) return; + page_t *page = page_for (g, v); if (unlikely (v && !page)) return; unsigned int start = major_start (m); unsigned int end = major_start (m + 1); do { - page->add (g); + if (v || page) /* The v check is to optimize out the page check if v is true. */ + page->set (g, v); array = &StructAtOffsetUnaligned (array, stride); count--; @@ -176,13 +177,23 @@ struct hb_bit_set_t while (count && (g = *array, start <= g && g < end)); } } + + template + void add_array (const T *array, unsigned int count, unsigned int stride=sizeof(T)) + { set_array (true, array, count, stride); } template void add_array (const hb_array_t& arr) { add_array (&arr, arr.len ()); } + template + void del_array (const T *array, unsigned int count, unsigned int stride=sizeof(T)) + { set_array (false, array, count, stride); } + template + void del_array (const hb_array_t& arr) { del_array (&arr, arr.len ()); } + /* Might return false if array looks unsorted. * Used for faster rejection of corrupt data. */ template - bool add_sorted_array (const T *array, unsigned int count, unsigned int stride=sizeof(T)) + bool set_sorted_array (bool v, const T *array, unsigned int count, unsigned int stride=sizeof(T)) { if (unlikely (!successful)) return true; /* https://github.com/harfbuzz/harfbuzz/issues/657 */ if (!count) return true; @@ -192,7 +203,7 @@ struct hb_bit_set_t while (count) { unsigned int m = get_major (g); - page_t *page = page_for (g, true); if (unlikely (!page)) return false; + page_t *page = page_for (g, v); if (unlikely (v && !page)) return false; unsigned int end = major_start (m + 1); do { @@ -200,7 +211,9 @@ struct hb_bit_set_t * Not sure if it's worth it. */ if (g < last_g) return false; last_g = g; - page->add (g); + + if (v || page) /* The v check is to optimize out the page check if v is true. */ + page->add (g); array = (const T *) ((const char *) array + stride); count--; @@ -209,9 +222,19 @@ struct hb_bit_set_t } return true; } + + template + bool add_sorted_array (const T *array, unsigned int count, unsigned int stride=sizeof(T)) + { return set_sorted_array (true, array, count, stride); } template bool add_sorted_array (const hb_sorted_array_t& arr) { return add_sorted_array (&arr, arr.len ()); } + template + bool del_sorted_array (const T *array, unsigned int count, unsigned int stride=sizeof(T)) + { return set_sorted_array (false, array, count, stride); } + template + bool del_sorted_array (const hb_sorted_array_t& arr) { return del_sorted_array (&arr, arr.len ()); } + void del (hb_codepoint_t g) { /* TODO perform op even if !successful. */ From c39d2f7a76807cfa8198eb931ff6c58e6bb7fc67 Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Wed, 18 Aug 2021 21:20:54 -0600 Subject: [PATCH 19/55] [bit-set-invertible] Implement add_array / add_sorted_array / intersects --- src/hb-bit-set-invertible.hh | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/src/hb-bit-set-invertible.hh b/src/hb-bit-set-invertible.hh index a3212b4e2..8ed5a1dc5 100644 --- a/src/hb-bit-set-invertible.hh +++ b/src/hb-bit-set-invertible.hh @@ -57,7 +57,7 @@ struct hb_bit_set_invertible_t template void add_array (const T *array, unsigned int count, unsigned int stride=sizeof(T)) - { /*XXX(inverted)*/s.add_array (array, count, stride); } + { inverted ? s.del_array (array, count, stride) : s.add_array (array, count, stride); } template void add_array (const hb_array_t& arr) { add_array (&arr, arr.len ()); } @@ -65,7 +65,7 @@ struct hb_bit_set_invertible_t * Used for faster rejection of corrupt data. */ template bool add_sorted_array (const T *array, unsigned int count, unsigned int stride=sizeof(T)) - { return /*XXX(inverted)*/s.add_sorted_array (array, count, stride); } + { return inverted ? s.del_sorted_array (array, count, stride) : s.add_sorted_array (array, count, stride); } template bool add_sorted_array (const hb_sorted_array_t& arr) { return add_sorted_array (&arr, arr.len ()); } @@ -89,7 +89,10 @@ struct hb_bit_set_invertible_t { add_range (range.first, range.second); return *this; } bool intersects (hb_codepoint_t first, hb_codepoint_t last) const - { return /*XXX(inverted)*/s.intersects (first, last); } + { + hb_codepoint_t c = first - 1; + return next (&c) && c <= last; + } void set (const hb_bit_set_invertible_t &other) { s.set (other.s); inverted = other.inverted; } From c66894d7c9f7883032fbe92aa33c49cb689b1230 Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Wed, 18 Aug 2021 21:24:29 -0600 Subject: [PATCH 20/55] [bit-set-invertible] Write a subset branch as dagger --- src/hb-bit-set-invertible.hh | 8 +------- 1 file changed, 1 insertion(+), 7 deletions(-) diff --git a/src/hb-bit-set-invertible.hh b/src/hb-bit-set-invertible.hh index 8ed5a1dc5..96dd468fd 100644 --- a/src/hb-bit-set-invertible.hh +++ b/src/hb-bit-set-invertible.hh @@ -103,13 +103,7 @@ struct hb_bit_set_invertible_t { if (inverted && !larger_set.inverted) return false; /*XXX*/ if (!inverted && larger_set.inverted) - { - /* TODO(iter) Write as hb_all dagger. */ - for (auto c: s) - if (larger_set.s.has (c)) - return false; - return true; - } + return hb_all (hb_iter (s) | hb_map (larger_set.s)); /* inverted == larger_set.inverted */ return inverted ? larger_set.s.is_subset (s) : s.is_subset (larger_set.s); } From 669b97d949173ceb691ece4c71c606f90c2f3e3f Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Wed, 18 Aug 2021 21:39:04 -0600 Subject: [PATCH 21/55] [bit-set-invertible] Implement iterator --- src/hb-bit-set-invertible.hh | 32 +++++++++++++++++++++++++++++--- 1 file changed, 29 insertions(+), 3 deletions(-) diff --git a/src/hb-bit-set-invertible.hh b/src/hb-bit-set-invertible.hh index 96dd468fd..5a4c3425c 100644 --- a/src/hb-bit-set-invertible.hh +++ b/src/hb-bit-set-invertible.hh @@ -155,9 +155,35 @@ struct hb_bit_set_invertible_t /* * Iterator implementation. */ - /*XXX(inverted)*/ - using iter_t = hb_bit_set_t::iter_t; - iter_t iter () const { return iter_t (this->s); } + struct iter_t : hb_iter_with_fallback_t + { + static constexpr bool is_sorted_iterator = true; + iter_t (const hb_bit_set_invertible_t &s_ = Null (hb_bit_set_invertible_t), + bool init = true) : s (&s_), v (INVALID), l(0) + { + if (init) + { + l = s->get_population () + 1; + __next__ (); + } + } + + typedef hb_codepoint_t __item_t__; + hb_codepoint_t __item__ () const { return v; } + bool __more__ () const { return v != INVALID; } + void __next__ () { s->next (&v); if (l) l--; } + void __prev__ () { s->previous (&v); } + unsigned __len__ () const { return l; } + iter_t end () const { return iter_t (*s, false); } + bool operator != (const iter_t& o) const + { return s != o.s || v != o.v; } + + protected: + const hb_bit_set_invertible_t *s; + hb_codepoint_t v; + unsigned l; + }; + iter_t iter () const { return iter_t (*this); } operator iter_t () const { return iter (); } }; From 18f50275ed2b66c9316d68138572b84ee713f0cc Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Wed, 18 Aug 2021 22:08:06 -0600 Subject: [PATCH 22/55] [bit-set] Restructure get_min/max() in prep for adding inverted --- src/hb-bit-set.hh | 26 ++++++++++++++++++-------- 1 file changed, 18 insertions(+), 8 deletions(-) diff --git a/src/hb-bit-set.hh b/src/hb-bit-set.hh index 493d3b26e..265a295c9 100644 --- a/src/hb-bit-set.hh +++ b/src/hb-bit-set.hh @@ -713,18 +713,28 @@ struct hb_bit_set_t } hb_codepoint_t get_min () const { - unsigned int count = pages.length; - for (unsigned int i = 0; i < count; i++) - if (!page_at (i).is_empty ()) - return page_map[i].major * page_t::PAGE_BITS + page_at (i).get_min (); + unsigned count = pages.length; + for (unsigned i = 0; i < count; i++) + { + const auto& map = page_map[i]; + const auto& page = pages[map.index]; + + if (!page.is_empty ()) + return map.major * page_t::PAGE_BITS + page.get_min (); + } return INVALID; } hb_codepoint_t get_max () const { - unsigned int count = pages.length; - for (int i = count - 1; i >= 0; i--) - if (!page_at (i).is_empty ()) - return page_map[(unsigned) i].major * page_t::PAGE_BITS + page_at (i).get_max (); + unsigned count = pages.length; + for (signed i = count - 1; i >= 0; i--) + { + const auto& map = page_map[(unsigned) i]; + const auto& page = pages[map.index]; + + if (!page.is_empty ()) + return map.major * page_t::PAGE_BITS + page.get_max (); + } return INVALID; } From 8aa92ff8f054a1b7b8d06618a6366a44cba8fe87 Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Wed, 18 Aug 2021 23:01:06 -0600 Subject: [PATCH 23/55] [bit-set-invertible] Implement get_min/max --- src/hb-bit-set-invertible.hh | 4 ++-- src/hb-bit-set.hh | 16 +++++++++++++--- 2 files changed, 15 insertions(+), 5 deletions(-) diff --git a/src/hb-bit-set-invertible.hh b/src/hb-bit-set-invertible.hh index 5a4c3425c..5d1c9f566 100644 --- a/src/hb-bit-set-invertible.hh +++ b/src/hb-bit-set-invertible.hh @@ -146,9 +146,9 @@ struct hb_bit_set_invertible_t { return inverted ? INVALID - s.get_population () : s.get_population (); } hb_codepoint_t get_min () const - { return /*XXX(inverted)*/s.get_min (); } + { return s.get_min (inverted); } hb_codepoint_t get_max () const - { return /*XXX(inverted)*/s.get_max (); } + { return inverted ? /*XXX*/ INVALID - 1 : s.get_max (); } static constexpr hb_codepoint_t INVALID = hb_bit_set_t::INVALID; diff --git a/src/hb-bit-set.hh b/src/hb-bit-set.hh index 265a295c9..5f38f4eaf 100644 --- a/src/hb-bit-set.hh +++ b/src/hb-bit-set.hh @@ -711,16 +711,26 @@ struct hb_bit_set_t population = pop; return pop; } - hb_codepoint_t get_min () const + hb_codepoint_t get_min (bool inverted = false) const { + unsigned last_major = (unsigned) -1; + unsigned count = pages.length; for (unsigned i = 0; i < count; i++) { const auto& map = page_map[i]; const auto& page = pages[map.index]; - if (!page.is_empty ()) - return map.major * page_t::PAGE_BITS + page.get_min (); + if (inverted) + { + if (last_major + 1 != map.major) + return (last_major + 1) * page_t::PAGE_BITS; + + last_major = map.major; + } + + if (!page.is_empty (inverted)) + return map.major * page_t::PAGE_BITS + page.get_min (inverted); } return INVALID; } From 6afefe1dc3f7aedc1f355bfa70bfee1a15829ec1 Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Thu, 19 Aug 2021 00:27:03 -0600 Subject: [PATCH 24/55] [algs] Remove unnecessary struct tag names --- src/hb-algs.hh | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/hb-algs.hh b/src/hb-algs.hh index 57b87b05c..716caf866 100644 --- a/src/hb-algs.hh +++ b/src/hb-algs.hh @@ -1159,25 +1159,25 @@ hb_codepoint_parse (const char *s, unsigned int len, int base, hb_codepoint_t *o /* Operators. */ -struct hb_bitwise_and +struct { HB_PARTIALIZE(2); template constexpr auto operator () (const T &a, const T &b) const HB_AUTO_RETURN (a & b) } HB_FUNCOBJ (hb_bitwise_and); -struct hb_bitwise_or +struct { HB_PARTIALIZE(2); template constexpr auto operator () (const T &a, const T &b) const HB_AUTO_RETURN (a | b) } HB_FUNCOBJ (hb_bitwise_or); -struct hb_bitwise_xor +struct { HB_PARTIALIZE(2); template constexpr auto operator () (const T &a, const T &b) const HB_AUTO_RETURN (a ^ b) } HB_FUNCOBJ (hb_bitwise_xor); -struct hb_bitwise_sub +struct { HB_PARTIALIZE(2); template constexpr auto operator () (const T &a, const T &b) const HB_AUTO_RETURN (a & ~b) From b94f24ec79877d57a17e8e8b9961127d590afa34 Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Thu, 19 Aug 2021 00:48:00 -0600 Subject: [PATCH 25/55] [bit-set-invertible] Implement set algebra --- src/hb-algs.hh | 32 +++++++++++++++- src/hb-bit-set-invertible.hh | 71 +++++++++++++++++++++++++++++++----- src/hb-bit-set.hh | 2 +- 3 files changed, 93 insertions(+), 12 deletions(-) diff --git a/src/hb-algs.hh b/src/hb-algs.hh index 716caf866..c2e99c1fc 100644 --- a/src/hb-algs.hh +++ b/src/hb-algs.hh @@ -1178,11 +1178,35 @@ struct } HB_FUNCOBJ (hb_bitwise_xor); struct +{ HB_PARTIALIZE(2); + template constexpr auto + operator () (const T &a, const T &b) const HB_AUTO_RETURN (~a & b) +} +HB_FUNCOBJ (hb_bitwise_lt); +struct { HB_PARTIALIZE(2); template constexpr auto operator () (const T &a, const T &b) const HB_AUTO_RETURN (a & ~b) } -HB_FUNCOBJ (hb_bitwise_sub); +HB_FUNCOBJ (hb_bitwise_gt); // aka sub +struct +{ HB_PARTIALIZE(2); + template constexpr auto + operator () (const T &a, const T &b) const HB_AUTO_RETURN (~a & ~b) +} +HB_FUNCOBJ (hb_bitwise_non); +struct +{ HB_PARTIALIZE(2); + template constexpr auto + operator () (const T &a, const T &b) const HB_AUTO_RETURN (~a | b) +} +HB_FUNCOBJ (hb_bitwise_le); +struct +{ HB_PARTIALIZE(2); + template constexpr auto + operator () (const T &a, const T &b) const HB_AUTO_RETURN (a | ~b) +} +HB_FUNCOBJ (hb_bitwise_ge); struct { template constexpr auto @@ -1203,6 +1227,12 @@ struct } HB_FUNCOBJ (hb_sub); struct +{ HB_PARTIALIZE(2); + template constexpr auto + operator () (const T &a, const T2 &b) const HB_AUTO_RETURN (b - a) +} +HB_FUNCOBJ (hb_rsub); +struct { HB_PARTIALIZE(2); template constexpr auto operator () (const T &a, const T2 &b) const HB_AUTO_RETURN (a * b) diff --git a/src/hb-bit-set-invertible.hh b/src/hb-bit-set-invertible.hh index 5d1c9f566..22a4c4f29 100644 --- a/src/hb-bit-set-invertible.hh +++ b/src/hb-bit-set-invertible.hh @@ -108,18 +108,69 @@ struct hb_bit_set_invertible_t return inverted ? larger_set.s.is_subset (s) : s.is_subset (larger_set.s); } + protected: template void process (const Op& op, const hb_bit_set_invertible_t &other) - { s.process (op, other.s); } - - /*XXX(inverted)*/ - void union_ (const hb_bit_set_invertible_t &other) { process (hb_bitwise_or, other); } - /*XXX(inverted)*/ - void intersect (const hb_bit_set_invertible_t &other) { process (hb_bitwise_and, other); } - /*XXX(inverted)*/ - void subtract (const hb_bit_set_invertible_t &other) { process (hb_bitwise_sub, other); } - /*XXX(inverted)*/ - void symmetric_difference (const hb_bit_set_invertible_t &other) { process (hb_bitwise_xor, other); } + { + s.process (op, other.s); + inverted = bool (op (int (inverted), int (other.inverted))); + } + public: + void union_ (const hb_bit_set_invertible_t &other) + { + if (inverted == other.inverted) + { + if (inverted) + process (hb_bitwise_and, other); + else + process (hb_bitwise_or, other); /* Main branch. */ + } + else + { + if (inverted) + process (hb_bitwise_gt, other); + else + process (hb_bitwise_lt, other); + } + } + void intersect (const hb_bit_set_invertible_t &other) + { + if (inverted == other.inverted) + { + if (inverted) + process (hb_bitwise_or, other); + else + process (hb_bitwise_and, other); /* Main branch. */ + } + else + { + if (inverted) + process (hb_bitwise_ge, other); + else + process (hb_bitwise_le, other); + } + } + void subtract (const hb_bit_set_invertible_t &other) + { + if (inverted == other.inverted) + { + if (inverted) + process (hb_bitwise_lt, other); + else + process (hb_bitwise_gt, other); /* Main branch. */ + } + else + { + if (inverted) + process (hb_bitwise_non, other); + else + process (hb_bitwise_and, other); + } + } + void symmetric_difference (const hb_bit_set_invertible_t &other) + { + process (hb_bitwise_xor, other); + } bool next (hb_codepoint_t *codepoint) const { diff --git a/src/hb-bit-set.hh b/src/hb-bit-set.hh index 5f38f4eaf..065b85f1b 100644 --- a/src/hb-bit-set.hh +++ b/src/hb-bit-set.hh @@ -577,7 +577,7 @@ struct hb_bit_set_t void union_ (const hb_bit_set_t &other) { process (hb_bitwise_or, other); } void intersect (const hb_bit_set_t &other) { process (hb_bitwise_and, other); } - void subtract (const hb_bit_set_t &other) { process (hb_bitwise_sub, other); } + void subtract (const hb_bit_set_t &other) { process (hb_bitwise_gt, other); } void symmetric_difference (const hb_bit_set_t &other) { process (hb_bitwise_xor, other); } bool next (hb_codepoint_t *codepoint) const From b119b48079ab4bece6bb0cf75c6606d25c49ee5e Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Thu, 19 Aug 2021 00:51:24 -0600 Subject: [PATCH 26/55] [bit-set-invertible] Add unlikely() around inverted checks --- src/hb-bit-set-invertible.hh | 36 +++++++++++++++++++----------------- 1 file changed, 19 insertions(+), 17 deletions(-) diff --git a/src/hb-bit-set-invertible.hh b/src/hb-bit-set-invertible.hh index 22a4c4f29..aadf8f4e1 100644 --- a/src/hb-bit-set-invertible.hh +++ b/src/hb-bit-set-invertible.hh @@ -52,8 +52,9 @@ struct hb_bit_set_invertible_t bool is_empty () const { return inverted ? /*XXX*/false : s.is_empty (); } - void add (hb_codepoint_t g) { inverted ? s.del (g) : s.add (g); } - bool add_range (hb_codepoint_t a, hb_codepoint_t b) { return inverted ? (s.del_range (a, b), true) : s.add_range (a, b); } + void add (hb_codepoint_t g) { unlikely (inverted) ? s.del (g) : s.add (g); } + bool add_range (hb_codepoint_t a, hb_codepoint_t b) + { return unlikely (inverted) ? (s.del_range (a, b), true) : s.add_range (a, b); } template void add_array (const T *array, unsigned int count, unsigned int stride=sizeof(T)) @@ -69,8 +70,9 @@ struct hb_bit_set_invertible_t template bool add_sorted_array (const hb_sorted_array_t& arr) { return add_sorted_array (&arr, arr.len ()); } - void del (hb_codepoint_t g) { inverted ? s.add (g) : s.del (g); } - void del_range (hb_codepoint_t a, hb_codepoint_t b) { inverted ? (void) s.add_range (a, b) : s.del_range (a, b); } + void del (hb_codepoint_t g) { unlikely (inverted) ? s.add (g) : s.del (g); } + void del_range (hb_codepoint_t a, hb_codepoint_t b) + { unlikely (inverted) ? (void) s.add_range (a, b) : s.del_range (a, b); } bool get (hb_codepoint_t g) const { return s.get (g) ^ inverted; } @@ -101,11 +103,11 @@ struct hb_bit_set_invertible_t bool is_subset (const hb_bit_set_invertible_t &larger_set) const { - if (inverted && !larger_set.inverted) return false; /*XXX*/ - if (!inverted && larger_set.inverted) + if (unlikely (inverted && !larger_set.inverted)) return false; /*XXX*/ + if (unlikely (!inverted && larger_set.inverted)) return hb_all (hb_iter (s) | hb_map (larger_set.s)); /* inverted == larger_set.inverted */ - return inverted ? larger_set.s.is_subset (s) : s.is_subset (larger_set.s); + return unlikely (inverted) ? larger_set.s.is_subset (s) : s.is_subset (larger_set.s); } protected: @@ -118,16 +120,16 @@ struct hb_bit_set_invertible_t public: void union_ (const hb_bit_set_invertible_t &other) { - if (inverted == other.inverted) + if (likely (inverted == other.inverted)) { - if (inverted) + if (unlikely (inverted)) process (hb_bitwise_and, other); else process (hb_bitwise_or, other); /* Main branch. */ } else { - if (inverted) + if (unlikely (inverted)) process (hb_bitwise_gt, other); else process (hb_bitwise_lt, other); @@ -135,16 +137,16 @@ struct hb_bit_set_invertible_t } void intersect (const hb_bit_set_invertible_t &other) { - if (inverted == other.inverted) + if (likely (inverted == other.inverted)) { - if (inverted) + if (unlikely (inverted)) process (hb_bitwise_or, other); else process (hb_bitwise_and, other); /* Main branch. */ } else { - if (inverted) + if (unlikely (inverted)) process (hb_bitwise_ge, other); else process (hb_bitwise_le, other); @@ -152,16 +154,16 @@ struct hb_bit_set_invertible_t } void subtract (const hb_bit_set_invertible_t &other) { - if (inverted == other.inverted) + if (likely (inverted == other.inverted)) { - if (inverted) + if (unlikely (inverted)) process (hb_bitwise_lt, other); else process (hb_bitwise_gt, other); /* Main branch. */ } else { - if (inverted) + if (unlikely (inverted)) process (hb_bitwise_non, other); else process (hb_bitwise_and, other); @@ -199,7 +201,7 @@ struct hb_bit_set_invertible_t hb_codepoint_t get_min () const { return s.get_min (inverted); } hb_codepoint_t get_max () const - { return inverted ? /*XXX*/ INVALID - 1 : s.get_max (); } + { return unlikely (inverted) ? /*XXX*/ INVALID - 1 : s.get_max (); } static constexpr hb_codepoint_t INVALID = hb_bit_set_t::INVALID; From 060de189ecdf2327c6583b97f02c33c21889ca15 Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Thu, 19 Aug 2021 00:58:34 -0600 Subject: [PATCH 27/55] [bit-page] Fix sanitizer error This essentially reverts 9449cfeefd7e3b761c8035c45330abd7a5201604 Problem was dereferencing pointer at end of array... --- src/hb-bit-page.hh | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/src/hb-bit-page.hh b/src/hb-bit-page.hh index 80aeee0c9..edacb5292 100644 --- a/src/hb-bit-page.hh +++ b/src/hb-bit-page.hh @@ -118,14 +118,17 @@ struct hb_bit_page_t unsigned int j = m & ELT_MASK; const elt_t vv = v[i] & ~((elt_t (1) << j) - 1); - for (elt_t p = elt_maybe_invert (vv, inverted); + for (const elt_t *pp = &vv; i < len (); - p = elt_maybe_invert (v[++i], inverted)) + pp = &v[++i]) + { + const elt_t p = elt_maybe_invert (*pp, inverted); if (p) { *codepoint = i * ELT_BITS + elt_get_min (p); return true; } + } *codepoint = INVALID; return false; @@ -146,16 +149,17 @@ struct hb_bit_page_t ((elt_t (1) << (j + 1)) - 1) : (elt_t) -1; const elt_t vv = v[i] & mask; - elt_t p = elt_maybe_invert (vv, inverted); + const elt_t *pp = &vv; while (true) { + const elt_t p = elt_maybe_invert (*pp, inverted); if (p) { *codepoint = i * ELT_BITS + elt_get_max (p); return true; } if ((int) i <= 0) break; - p = elt_maybe_invert (v[--i], inverted); + pp = &v[--i]; } *codepoint = INVALID; From f6aa37159bf1f4b3a2b83c7e263f4642959af73a Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Thu, 19 Aug 2021 01:12:25 -0600 Subject: [PATCH 28/55] [bit-set-invertible] Fix process logic for inverted [# On branch set-invert --- src/hb-bit-set-invertible.hh | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/hb-bit-set-invertible.hh b/src/hb-bit-set-invertible.hh index aadf8f4e1..ecfe3a186 100644 --- a/src/hb-bit-set-invertible.hh +++ b/src/hb-bit-set-invertible.hh @@ -113,10 +113,7 @@ struct hb_bit_set_invertible_t protected: template void process (const Op& op, const hb_bit_set_invertible_t &other) - { - s.process (op, other.s); - inverted = bool (op (int (inverted), int (other.inverted))); - } + { s.process (op, other.s); } public: void union_ (const hb_bit_set_invertible_t &other) { @@ -134,6 +131,7 @@ struct hb_bit_set_invertible_t else process (hb_bitwise_lt, other); } + inverted = inverted || other.inverted; } void intersect (const hb_bit_set_invertible_t &other) { @@ -151,6 +149,7 @@ struct hb_bit_set_invertible_t else process (hb_bitwise_le, other); } + inverted = inverted && other.inverted; } void subtract (const hb_bit_set_invertible_t &other) { @@ -168,10 +167,12 @@ struct hb_bit_set_invertible_t else process (hb_bitwise_and, other); } + inverted = inverted && !other.inverted; } void symmetric_difference (const hb_bit_set_invertible_t &other) { process (hb_bitwise_xor, other); + inverted = inverted ^ other.inverted; } bool next (hb_codepoint_t *codepoint) const From c27f5b1288e4786c27bd010a1f6b41c29ab37992 Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Thu, 19 Aug 2021 10:01:24 -0600 Subject: [PATCH 29/55] [bit-set-invertible] Plug in next_range()/previous_range() --- src/hb-bit-set-invertible.hh | 34 ++++++++++++++++++++++++++++++---- 1 file changed, 30 insertions(+), 4 deletions(-) diff --git a/src/hb-bit-set-invertible.hh b/src/hb-bit-set-invertible.hh index ecfe3a186..8f4b7f865 100644 --- a/src/hb-bit-set-invertible.hh +++ b/src/hb-bit-set-invertible.hh @@ -187,13 +187,39 @@ struct hb_bit_set_invertible_t } bool next_range (hb_codepoint_t *first, hb_codepoint_t *last) const { - /*XXX(inverted)*/ - return s.next_range (first, last); + hb_codepoint_t i; + + i = *last; + if (!next (&i)) + { + *last = *first = INVALID; + return false; + } + + /* TODO Speed up. */ + *last = *first = i; + while (next (&i) && i == *last + 1) + (*last)++; + + return true; } bool previous_range (hb_codepoint_t *first, hb_codepoint_t *last) const { - /*XXX(inverted)*/ - return s.previous_range (first, last); + hb_codepoint_t i; + + i = *first; + if (!previous (&i)) + { + *last = *first = INVALID; + return false; + } + + /* TODO Speed up. */ + *last = *first = i; + while (previous (&i) && i == *first - 1) + (*first)--; + + return true; } unsigned int get_population () const From 248ad3bce5b5e7190e174929bf1892f1a2bafb44 Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Thu, 19 Aug 2021 10:17:51 -0600 Subject: [PATCH 30/55] [bit-set-invertible] Implement next/previous This makes invertible set functionality complete. --- src/hb-bit-set-invertible.hh | 48 +++++++++++++++++++++++++++++++++--- 1 file changed, 44 insertions(+), 4 deletions(-) diff --git a/src/hb-bit-set-invertible.hh b/src/hb-bit-set-invertible.hh index 8f4b7f865..aaa1840f7 100644 --- a/src/hb-bit-set-invertible.hh +++ b/src/hb-bit-set-invertible.hh @@ -177,16 +177,53 @@ struct hb_bit_set_invertible_t bool next (hb_codepoint_t *codepoint) const { - /*XXX(inverted)*/ - return s.next (codepoint); + if (likely (!inverted)) + return s.next (codepoint); + + auto old = *codepoint; + do + { + auto v = old; + s.next (&v); + if (old + 1 < v) + { + *codepoint = old + 1; + return true; + } + old++; + } + while (old != INVALID); + + *codepoint = INVALID; + return false; } bool previous (hb_codepoint_t *codepoint) const { - /*XXX(inverted)*/ - return s.previous (codepoint); + if (likely (!inverted)) + return s.previous (codepoint); + + auto old = *codepoint; + do + { + auto v = old; + s.previous (&v); + if (old - 1 > v) + { + *codepoint = old - 1; + return true; + } + old--; + } + while (old != INVALID); + + *codepoint = INVALID; + return false; } bool next_range (hb_codepoint_t *first, hb_codepoint_t *last) const { + if (likely (!inverted)) + return s.next_range (first, last); + hb_codepoint_t i; i = *last; @@ -205,6 +242,9 @@ struct hb_bit_set_invertible_t } bool previous_range (hb_codepoint_t *first, hb_codepoint_t *last) const { + if (likely (!inverted)) + return s.previous_range (first, last); + hb_codepoint_t i; i = *first; From eb98bc1e322c0675de7f7b00e4e1932ec593277d Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Thu, 19 Aug 2021 11:19:24 -0600 Subject: [PATCH 31/55] [bit-set-invertible] Rewrite next/previous() using s.next/previous_range() --- src/hb-bit-set-invertible.hh | 54 ++++++++++++++++++++---------------- 1 file changed, 30 insertions(+), 24 deletions(-) diff --git a/src/hb-bit-set-invertible.hh b/src/hb-bit-set-invertible.hh index aaa1840f7..0b3712adc 100644 --- a/src/hb-bit-set-invertible.hh +++ b/src/hb-bit-set-invertible.hh @@ -181,21 +181,24 @@ struct hb_bit_set_invertible_t return s.next (codepoint); auto old = *codepoint; - do + auto v = old; + s.next (&v); + if (old + 1 < v) { - auto v = old; - s.next (&v); - if (old + 1 < v) - { - *codepoint = old + 1; - return true; - } - old++; + *codepoint = old + 1; + return true; } - while (old != INVALID); - *codepoint = INVALID; - return false; + if (unlikely (old + 1 == INVALID)) + { + *codepoint = INVALID; + return false; + } + + s.next_range (&old, &v); + + *codepoint = v + 1; + return *codepoint != INVALID; } bool previous (hb_codepoint_t *codepoint) const { @@ -203,21 +206,24 @@ struct hb_bit_set_invertible_t return s.previous (codepoint); auto old = *codepoint; - do + auto v = old; + s.previous (&v); + if (old - 1 > v) { - auto v = old; - s.previous (&v); - if (old - 1 > v) - { - *codepoint = old - 1; - return true; - } - old--; + *codepoint = old - 1; + return true; } - while (old != INVALID); - *codepoint = INVALID; - return false; + if (unlikely (old - 1 == INVALID)) + { + *codepoint = INVALID; + return false; + } + + s.previous_range (&v, &old); + + *codepoint = v - 1; + return *codepoint != INVALID; } bool next_range (hb_codepoint_t *first, hb_codepoint_t *last) const { From b21038d91de7f67bbfec549f618b0238c3ca7735 Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Thu, 19 Aug 2021 11:24:17 -0600 Subject: [PATCH 32/55] [bit-set-invertible] Rewrite next/previous_range() in terms of s.next/previous() --- src/hb-bit-set-invertible.hh | 26 ++++++++------------------ 1 file changed, 8 insertions(+), 18 deletions(-) diff --git a/src/hb-bit-set-invertible.hh b/src/hb-bit-set-invertible.hh index 0b3712adc..7c7bc372b 100644 --- a/src/hb-bit-set-invertible.hh +++ b/src/hb-bit-set-invertible.hh @@ -230,20 +230,15 @@ struct hb_bit_set_invertible_t if (likely (!inverted)) return s.next_range (first, last); - hb_codepoint_t i; - - i = *last; - if (!next (&i)) + if (!next (last)) { *last = *first = INVALID; return false; } - /* TODO Speed up. */ - *last = *first = i; - while (next (&i) && i == *last + 1) - (*last)++; - + *first = *last; + s.next (last); + --*last; return true; } bool previous_range (hb_codepoint_t *first, hb_codepoint_t *last) const @@ -251,20 +246,15 @@ struct hb_bit_set_invertible_t if (likely (!inverted)) return s.previous_range (first, last); - hb_codepoint_t i; - - i = *first; - if (!previous (&i)) + if (!previous (first)) { *last = *first = INVALID; return false; } - /* TODO Speed up. */ - *last = *first = i; - while (previous (&i) && i == *first - 1) - (*first)--; - + *last = *first; + s.previous (first); + ++*first; return true; } From f317d8e4261e6fef1a7d5682bd62a4562588b322 Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Thu, 19 Aug 2021 13:01:07 -0600 Subject: [PATCH 33/55] [bit-set-invertible] Fix intersect() logic --- src/hb-bit-set-invertible.hh | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/hb-bit-set-invertible.hh b/src/hb-bit-set-invertible.hh index 7c7bc372b..084e1d218 100644 --- a/src/hb-bit-set-invertible.hh +++ b/src/hb-bit-set-invertible.hh @@ -145,9 +145,9 @@ struct hb_bit_set_invertible_t else { if (unlikely (inverted)) - process (hb_bitwise_ge, other); + process (hb_bitwise_lt, other); else - process (hb_bitwise_le, other); + process (hb_bitwise_gt, other); } inverted = inverted && other.inverted; } From f4fd7baf7ec8ff5954e226f2e7ea2697e84a39dd Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Thu, 19 Aug 2021 13:05:12 -0600 Subject: [PATCH 34/55] [bit-set-invertible] Fix subtract() logic --- src/hb-bit-set-invertible.hh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/hb-bit-set-invertible.hh b/src/hb-bit-set-invertible.hh index 084e1d218..9cc6c1694 100644 --- a/src/hb-bit-set-invertible.hh +++ b/src/hb-bit-set-invertible.hh @@ -163,7 +163,7 @@ struct hb_bit_set_invertible_t else { if (unlikely (inverted)) - process (hb_bitwise_non, other); + process (hb_bitwise_or, other); else process (hb_bitwise_and, other); } From f09d5ed0f52987f4af39d0a577762d4dda99509c Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Thu, 19 Aug 2021 13:06:10 -0600 Subject: [PATCH 35/55] [algs] Remove hb_bitwise_non() --- src/hb-algs.hh | 6 ------ 1 file changed, 6 deletions(-) diff --git a/src/hb-algs.hh b/src/hb-algs.hh index c2e99c1fc..bbe097fe0 100644 --- a/src/hb-algs.hh +++ b/src/hb-algs.hh @@ -1190,12 +1190,6 @@ struct } HB_FUNCOBJ (hb_bitwise_gt); // aka sub struct -{ HB_PARTIALIZE(2); - template constexpr auto - operator () (const T &a, const T &b) const HB_AUTO_RETURN (~a & ~b) -} -HB_FUNCOBJ (hb_bitwise_non); -struct { HB_PARTIALIZE(2); template constexpr auto operator () (const T &a, const T &b) const HB_AUTO_RETURN (~a | b) From eec1a25e7169a2958a4f739d98cca4ae6e38605f Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Thu, 19 Aug 2021 13:22:36 -0600 Subject: [PATCH 36/55] [bit-set-invertible] Rewrite get_min/max() in terms of next/previous() --- src/hb-bit-set-invertible.hh | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/src/hb-bit-set-invertible.hh b/src/hb-bit-set-invertible.hh index 9cc6c1694..4bbda2524 100644 --- a/src/hb-bit-set-invertible.hh +++ b/src/hb-bit-set-invertible.hh @@ -262,9 +262,17 @@ struct hb_bit_set_invertible_t { return inverted ? INVALID - s.get_population () : s.get_population (); } hb_codepoint_t get_min () const - { return s.get_min (inverted); } + { + hb_codepoint_t v = INVALID; + next (&v); + return v; + } hb_codepoint_t get_max () const - { return unlikely (inverted) ? /*XXX*/ INVALID - 1 : s.get_max (); } + { + hb_codepoint_t v = INVALID; + previous (&v); + return v; + } static constexpr hb_codepoint_t INVALID = hb_bit_set_t::INVALID; From ee4e331a6e05ce5e99671a401e986c0fcdd2a691 Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Thu, 19 Aug 2021 13:23:22 -0600 Subject: [PATCH 37/55] [bit-set] Remove unused get_min(inverted) --- src/hb-bit-set.hh | 16 +++------------- 1 file changed, 3 insertions(+), 13 deletions(-) diff --git a/src/hb-bit-set.hh b/src/hb-bit-set.hh index 065b85f1b..a4a2aed2a 100644 --- a/src/hb-bit-set.hh +++ b/src/hb-bit-set.hh @@ -711,26 +711,16 @@ struct hb_bit_set_t population = pop; return pop; } - hb_codepoint_t get_min (bool inverted = false) const + hb_codepoint_t get_min () const { - unsigned last_major = (unsigned) -1; - unsigned count = pages.length; for (unsigned i = 0; i < count; i++) { const auto& map = page_map[i]; const auto& page = pages[map.index]; - if (inverted) - { - if (last_major + 1 != map.major) - return (last_major + 1) * page_t::PAGE_BITS; - - last_major = map.major; - } - - if (!page.is_empty (inverted)) - return map.major * page_t::PAGE_BITS + page.get_min (inverted); + if (!page.is_empty ()) + return map.major * page_t::PAGE_BITS + page.get_min (); } return INVALID; } From 87885e6f02fef1d8289050c1c939d5a5566b5ee2 Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Thu, 19 Aug 2021 13:26:25 -0600 Subject: [PATCH 38/55] [bit-set-invertible] Fix next/previous() logic --- src/hb-bit-set-invertible.hh | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/hb-bit-set-invertible.hh b/src/hb-bit-set-invertible.hh index 4bbda2524..030fc9867 100644 --- a/src/hb-bit-set-invertible.hh +++ b/src/hb-bit-set-invertible.hh @@ -195,6 +195,7 @@ struct hb_bit_set_invertible_t return false; } + v = old; s.next_range (&old, &v); *codepoint = v + 1; @@ -220,6 +221,7 @@ struct hb_bit_set_invertible_t return false; } + v = old; s.previous_range (&v, &old); *codepoint = v - 1; From ec4812a7d4031c2a579f0d49f526f0a9b418e063 Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Thu, 19 Aug 2021 13:32:44 -0600 Subject: [PATCH 39/55] [bit-page] Remove unused inverted code --- src/hb-bit-page.hh | 47 +++++++++++++++++----------------------------- 1 file changed, 17 insertions(+), 30 deletions(-) diff --git a/src/hb-bit-page.hh b/src/hb-bit-page.hh index edacb5292..263be3d04 100644 --- a/src/hb-bit-page.hh +++ b/src/hb-bit-page.hh @@ -38,10 +38,10 @@ struct hb_bit_page_t constexpr unsigned len () const { return ARRAY_LENGTH_CONST (v); } - bool is_empty (bool inverted = false) const + bool is_empty () const { for (unsigned int i = 0; i < len (); i++) - if (elt_maybe_invert (v[i], inverted)) + if (v[i]) return false; return true; } @@ -106,7 +106,7 @@ struct hb_bit_page_t return pop; } - bool next (hb_codepoint_t *codepoint, bool inverted = false) const + bool next (hb_codepoint_t *codepoint) const { unsigned int m = (*codepoint + 1) & MASK; if (!m) @@ -118,22 +118,17 @@ struct hb_bit_page_t unsigned int j = m & ELT_MASK; const elt_t vv = v[i] & ~((elt_t (1) << j) - 1); - for (const elt_t *pp = &vv; - i < len (); - pp = &v[++i]) - { - const elt_t p = elt_maybe_invert (*pp, inverted); - if (p) + for (const elt_t *p = &vv; i < len (); p = &v[++i]) + if (*p) { - *codepoint = i * ELT_BITS + elt_get_min (p); + *codepoint = i * ELT_BITS + elt_get_min (*p); return true; } - } *codepoint = INVALID; return false; } - bool previous (hb_codepoint_t *codepoint, bool inverted = false) const + bool previous (hb_codepoint_t *codepoint) const { unsigned int m = (*codepoint - 1) & MASK; if (m == MASK) @@ -149,40 +144,33 @@ struct hb_bit_page_t ((elt_t (1) << (j + 1)) - 1) : (elt_t) -1; const elt_t vv = v[i] & mask; - const elt_t *pp = &vv; + const elt_t *p = &vv; while (true) { - const elt_t p = elt_maybe_invert (*pp, inverted); - if (p) + if (*p) { - *codepoint = i * ELT_BITS + elt_get_max (p); + *codepoint = i * ELT_BITS + elt_get_max (*p); return true; } if ((int) i <= 0) break; - pp = &v[--i]; + p = &v[--i]; } *codepoint = INVALID; return false; } - hb_codepoint_t get_min (bool inverted = false) const + hb_codepoint_t get_min () const { for (unsigned int i = 0; i < len (); i++) - { - elt_t e = elt_maybe_invert (v[i], inverted); - if (e) - return i * ELT_BITS + elt_get_min (e); - } + if (v[i]) + return i * ELT_BITS + elt_get_min (v[i]); return INVALID; } - hb_codepoint_t get_max (bool inverted = false) const + hb_codepoint_t get_max () const { for (int i = len () - 1; i >= 0; i--) - { - elt_t e = elt_maybe_invert (v[i], inverted); - if (e) - return i * ELT_BITS + elt_get_max (e); - } + if (v[i]) + return i * ELT_BITS + elt_get_max (v[i]); return 0; } @@ -194,7 +182,6 @@ struct hb_bit_page_t static unsigned int elt_get_min (const elt_t &elt) { return hb_ctz (elt); } static unsigned int elt_get_max (const elt_t &elt) { return hb_bit_storage (elt) - 1; } - static elt_t elt_maybe_invert (elt_t elt, bool inverted) { return inverted ? ~elt : elt; } typedef hb_vector_size_t vector_t; From 2dfc104236395f224b6834ab52263fbafbe92651 Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Thu, 19 Aug 2021 14:47:33 -0600 Subject: [PATCH 40/55] [bit-set-invertible] Implement is_empty() for inverted case as well --- src/hb-bit-set-invertible.hh | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/src/hb-bit-set-invertible.hh b/src/hb-bit-set-invertible.hh index 030fc9867..fe3d9fa85 100644 --- a/src/hb-bit-set-invertible.hh +++ b/src/hb-bit-set-invertible.hh @@ -50,7 +50,12 @@ struct hb_bit_set_invertible_t void clear () { s.clear (); inverted = false; } void invert () { if (!s.in_error ()) inverted = !inverted; } - bool is_empty () const { return inverted ? /*XXX*/false : s.is_empty (); } + bool is_empty () const + { + hb_codepoint_t v = INVALID; + next (&v); + return v == INVALID; + } void add (hb_codepoint_t g) { unlikely (inverted) ? s.del (g) : s.add (g); } bool add_range (hb_codepoint_t a, hb_codepoint_t b) From 2579dc648f940c7c66ac0ef2cc75c7b6754c6892 Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Thu, 19 Aug 2021 14:48:27 -0600 Subject: [PATCH 41/55] [bit-set-invertible] Move code around --- src/hb-bit-set-invertible.hh | 31 +++++++++++++++---------------- 1 file changed, 15 insertions(+), 16 deletions(-) diff --git a/src/hb-bit-set-invertible.hh b/src/hb-bit-set-invertible.hh index fe3d9fa85..1b12e008e 100644 --- a/src/hb-bit-set-invertible.hh +++ b/src/hb-bit-set-invertible.hh @@ -56,6 +56,21 @@ struct hb_bit_set_invertible_t next (&v); return v == INVALID; } + hb_codepoint_t get_min () const + { + hb_codepoint_t v = INVALID; + next (&v); + return v; + } + hb_codepoint_t get_max () const + { + hb_codepoint_t v = INVALID; + previous (&v); + return v; + } + unsigned int get_population () const + { return inverted ? INVALID - s.get_population () : s.get_population (); } + void add (hb_codepoint_t g) { unlikely (inverted) ? s.del (g) : s.add (g); } bool add_range (hb_codepoint_t a, hb_codepoint_t b) @@ -265,22 +280,6 @@ struct hb_bit_set_invertible_t return true; } - unsigned int get_population () const - { return inverted ? INVALID - s.get_population () : s.get_population (); } - - hb_codepoint_t get_min () const - { - hb_codepoint_t v = INVALID; - next (&v); - return v; - } - hb_codepoint_t get_max () const - { - hb_codepoint_t v = INVALID; - previous (&v); - return v; - } - static constexpr hb_codepoint_t INVALID = hb_bit_set_t::INVALID; /* From e8911d137ca1e367a41143ece02149a62779cdf0 Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Thu, 19 Aug 2021 14:59:57 -0600 Subject: [PATCH 42/55] [bit-set-invertible] Implement a couple other missing corner cases Also, in bit-set, don't compute population in is_equal/is_subset() if we don't have it computed already. --- src/hb-bit-set-invertible.hh | 7 +++---- src/hb-bit-set.hh | 14 +++++++++----- 2 files changed, 12 insertions(+), 9 deletions(-) diff --git a/src/hb-bit-set-invertible.hh b/src/hb-bit-set-invertible.hh index 1b12e008e..e89712a8f 100644 --- a/src/hb-bit-set-invertible.hh +++ b/src/hb-bit-set-invertible.hh @@ -123,11 +123,10 @@ struct hb_bit_set_invertible_t bool is_subset (const hb_bit_set_invertible_t &larger_set) const { - if (unlikely (inverted && !larger_set.inverted)) return false; /*XXX*/ - if (unlikely (!inverted && larger_set.inverted)) + if (unlikely (inverted != larger_set.inverted)) return hb_all (hb_iter (s) | hb_map (larger_set.s)); - /* inverted == larger_set.inverted */ - return unlikely (inverted) ? larger_set.s.is_subset (s) : s.is_subset (larger_set.s); + else + return unlikely (inverted) ? larger_set.s.is_subset (s) : s.is_subset (larger_set.s); } protected: diff --git a/src/hb-bit-set.hh b/src/hb-bit-set.hh index a4a2aed2a..511c24fcb 100644 --- a/src/hb-bit-set.hh +++ b/src/hb-bit-set.hh @@ -342,7 +342,8 @@ struct hb_bit_set_t bool is_equal (const hb_bit_set_t &other) const { - if (get_population () != other.get_population ()) + if (has_population () && other.has_population () && + get_population () != other.get_population ()) return false; unsigned int na = pages.length; @@ -369,9 +370,11 @@ struct hb_bit_set_t bool is_subset (const hb_bit_set_t &larger_set) const { - /* TODO: Merge this and is_equal() into something like process(). */ - if (unlikely(larger_set.is_empty ())) - return is_empty (); +// /* TODO: Merge this and is_equal() into something like process(). */ + + if (has_population () && larger_set.has_population () && + get_population () != larger_set.get_population ()) + return false; uint32_t spi = 0; for (uint32_t lpi = 0; spi < page_map.length && lpi < larger_set.page_map.length; lpi++) @@ -698,9 +701,10 @@ struct hb_bit_set_t return true; } + bool has_population () const { return population != UINT_MAX; } unsigned int get_population () const { - if (population != UINT_MAX) + if (has_population ()) return population; unsigned int pop = 0; From 1babe80ed2506b36c22275b4c511296c8d9b4096 Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Thu, 19 Aug 2021 15:18:32 -0600 Subject: [PATCH 43/55] [bit-set-invertible] Fix last remaining corner-case --- src/hb-bit-set-invertible.hh | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/src/hb-bit-set-invertible.hh b/src/hb-bit-set-invertible.hh index e89712a8f..d2b40950b 100644 --- a/src/hb-bit-set-invertible.hh +++ b/src/hb-bit-set-invertible.hh @@ -119,7 +119,18 @@ struct hb_bit_set_invertible_t void set (const hb_bit_set_invertible_t &other) { s.set (other.s); inverted = other.inverted; } bool is_equal (const hb_bit_set_invertible_t &other) const - { return inverted == other.inverted /*XXX*/ && s.is_equal (other.s); } + { + if (likely (inverted == other.inverted)) + return s.is_equal (other.s); + else + { + /* TODO Add iter_ranges() and use here. */ + auto it1 = iter (); + auto it2 = other.iter (); + return hb_all (+ hb_zip (it1, it2) + | hb_map ([](hb_pair_t _) { return _.first == _.second; })); + } + } bool is_subset (const hb_bit_set_invertible_t &larger_set) const { From 92908c122bb578d502bdaa2fbf7a9a3b41540ae0 Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Thu, 19 Aug 2021 15:28:26 -0600 Subject: [PATCH 44/55] [bit-set-invertible] Remove extra check We don't expect immutable / null set in this code. --- src/hb-bit-set-invertible.hh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/hb-bit-set-invertible.hh b/src/hb-bit-set-invertible.hh index d2b40950b..3b1d9df3e 100644 --- a/src/hb-bit-set-invertible.hh +++ b/src/hb-bit-set-invertible.hh @@ -48,7 +48,7 @@ struct hb_bit_set_invertible_t void reset () { s.reset (); inverted = false; } void clear () { s.clear (); inverted = false; } - void invert () { if (!s.in_error ()) inverted = !inverted; } + void invert () { inverted = !inverted; } bool is_empty () const { From dc800ffd6c0b806b5b0db9d48cd57528d1fae3eb Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Thu, 19 Aug 2021 15:35:51 -0600 Subject: [PATCH 45/55] [bit-set] Remove TODO items we don't intend to finish --- src/hb-bit-set.hh | 8 -------- 1 file changed, 8 deletions(-) diff --git a/src/hb-bit-set.hh b/src/hb-bit-set.hh index 511c24fcb..6a305ff22 100644 --- a/src/hb-bit-set.hh +++ b/src/hb-bit-set.hh @@ -57,9 +57,6 @@ struct hb_bit_set_t // TODO Add move construtor/assign // TODO Add constructor for Iterator; with specialization for (sorted) vector / array? - /* TODO Keep a freelist so we can release pages that are completely zeroed. At that - * point maybe also use a sentinel value for "all-1" pages? */ - using page_t = hb_bit_page_t; struct page_map_t { @@ -237,7 +234,6 @@ struct hb_bit_set_t void del (hb_codepoint_t g) { - /* TODO perform op even if !successful. */ if (unlikely (!successful)) return; page_t *page = page_for (g); if (!page) @@ -272,7 +268,6 @@ struct hb_bit_set_t public: void del_range (hb_codepoint_t a, hb_codepoint_t b) { - /* TODO perform op even if !successful. */ if (unlikely (!successful)) return; if (unlikely (a > b || a == INVALID)) return; dirty (); @@ -370,8 +365,6 @@ struct hb_bit_set_t bool is_subset (const hb_bit_set_t &larger_set) const { -// /* TODO: Merge this and is_equal() into something like process(). */ - if (has_population () && larger_set.has_population () && get_population () != larger_set.get_population ()) return false; @@ -426,7 +419,6 @@ struct hb_bit_set_t hb_vector_t& old_index_to_page_map_index = workspace; hb_fill (old_index_to_page_map_index.writer(), 0xFFFFFFFF); - /* TODO(iter) Rewrite as dagger? */ for (unsigned i = 0; i < length; i++) old_index_to_page_map_index[page_map[i].index] = i; From 7115af23ebe4a896174d1a246fcfb3b4d0fe6806 Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Thu, 19 Aug 2021 15:55:21 -0600 Subject: [PATCH 46/55] [util] Fix glib deprecation warning re g_memdup() --- util/hb-subset.cc | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/util/hb-subset.cc b/util/hb-subset.cc index b30614179..be135d1ba 100644 --- a/util/hb-subset.cc +++ b/util/hb-subset.cc @@ -64,7 +64,13 @@ struct subset_main_t : option_parser_t, face_options_t, output_options_t g_option_context_set_ignore_unknown_options (parser.context, true); g_option_context_set_help_enabled (parser.context, false); - char **args = (char **) g_memdup (argv, argc * sizeof (*argv)); + char **args = (char **) +#if GLIB_CHECK_VERSION (2, 68, 0) + g_memdup2 +#else + g_memdup +#endif + (argv, argc * sizeof (*argv)); parser.parse (&argc, &args, true); g_free (args); From 1d832693e17935e025201905236b9fa34e1f310d Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Thu, 19 Aug 2021 16:02:30 -0600 Subject: [PATCH 47/55] [set] Protect against immutible null set with invertible addition --- src/hb-map.cc | 2 ++ src/hb-set.cc | 22 ++++++++++++++++++++++ 2 files changed, 24 insertions(+) diff --git a/src/hb-map.cc b/src/hb-map.cc index 6757535b7..388e67886 100644 --- a/src/hb-map.cc +++ b/src/hb-map.cc @@ -188,6 +188,7 @@ hb_map_set (hb_map_t *map, hb_codepoint_t key, hb_codepoint_t value) { + /* Immutable-safe. */ map->set (key, value); } @@ -220,6 +221,7 @@ void hb_map_del (hb_map_t *map, hb_codepoint_t key) { + /* Immutable-safe. */ map->del (key); } diff --git a/src/hb-set.cc b/src/hb-set.cc index eb6f41e11..f9bc85869 100644 --- a/src/hb-set.cc +++ b/src/hb-set.cc @@ -254,6 +254,7 @@ void hb_set_add (hb_set_t *set, hb_codepoint_t codepoint) { + /* Immutible-safe. */ set->add (codepoint); } @@ -273,6 +274,7 @@ hb_set_add_range (hb_set_t *set, hb_codepoint_t first, hb_codepoint_t last) { + /* Immutible-safe. */ set->add_range (first, last); } @@ -289,6 +291,7 @@ void hb_set_del (hb_set_t *set, hb_codepoint_t codepoint) { + /* Immutible-safe. */ set->del (codepoint); } @@ -311,6 +314,7 @@ hb_set_del_range (hb_set_t *set, hb_codepoint_t first, hb_codepoint_t last) { + /* Immutible-safe. */ set->del_range (first, last); } @@ -364,6 +368,9 @@ void hb_set_set (hb_set_t *set, const hb_set_t *other) { + if (unlikely (hb_object_is_immutable (set))) + return; + set->set (*other); } @@ -380,6 +387,9 @@ void hb_set_union (hb_set_t *set, const hb_set_t *other) { + if (unlikely (hb_object_is_immutable (set))) + return; + set->union_ (*other); } @@ -396,6 +406,9 @@ void hb_set_intersect (hb_set_t *set, const hb_set_t *other) { + if (unlikely (hb_object_is_immutable (set))) + return; + set->intersect (*other); } @@ -412,6 +425,9 @@ void hb_set_subtract (hb_set_t *set, const hb_set_t *other) { + if (unlikely (hb_object_is_immutable (set))) + return; + set->subtract (*other); } @@ -429,6 +445,9 @@ void hb_set_symmetric_difference (hb_set_t *set, const hb_set_t *other) { + if (unlikely (hb_object_is_immutable (set))) + return; + set->symmetric_difference (*other); } @@ -443,6 +462,9 @@ hb_set_symmetric_difference (hb_set_t *set, void hb_set_invert (hb_set_t *set) { + if (unlikely (hb_object_is_immutable (set))) + return; + set->invert (); } From 3f2cc582f283319a5f98469b993403c6f79f3ef9 Mon Sep 17 00:00:00 2001 From: Garret Rieger Date: Thu, 19 Aug 2021 15:00:07 -0700 Subject: [PATCH 48/55] [set] add basic and iteration set inverion tests. --- test/api/test-set.c | 220 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 220 insertions(+) diff --git a/test/api/test-set.c b/test/api/test-set.c index 21a48ffa6..611657ad6 100644 --- a/test/api/test-set.c +++ b/test/api/test-set.c @@ -574,6 +574,222 @@ test_set_delrange (void) hb_set_destroy (s); } +// Inverted tests: +// iteration: next/prev/next_range/prev_range +// is_empty() +// max/min +// has/get/[] +// add/del/add_range/del_range +// is_equal +// get_population +// +// Interesting cases: +// - empty inverted (ie. all numbers) +// - inverted with things removed at either extreme +// - inverted with things removed in the middle. +// +// Set operations: (for II, NN, IN, NI) +// - union +// - intersercts +// - sym diff +// - subtraction + +static const unsigned max_set_elements = -1; + +static void +test_set_inverted_basics (void) +{ + // Tests: + // add, del, has, get_population, is_empty, get_min, get_max + // for inverted sets. + hb_set_t *s = hb_set_create (); + hb_set_invert (s); + + g_assert_cmpint (hb_set_get_population (s), ==, max_set_elements); + g_assert (hb_set_has (s, 0)); + g_assert (hb_set_has (s, 13)); + g_assert (hb_set_has (s, max_set_elements - 1)); + g_assert (!hb_set_is_empty (s)); + g_assert_cmpint (hb_set_get_min (s), ==, 0); + g_assert_cmpint (hb_set_get_max (s), ==, max_set_elements - 1); + + hb_set_del (s, 13); + g_assert (!hb_set_has (s, 13)); + g_assert_cmpint (hb_set_get_population (s), ==, max_set_elements - 1); + g_assert_cmpint (hb_set_get_min (s), ==, 0); + g_assert_cmpint (hb_set_get_max (s), ==, max_set_elements - 1); + + hb_set_add (s, 13); + g_assert (hb_set_has (s, 13)); + g_assert_cmpint (hb_set_get_population (s), ==, max_set_elements); + + hb_set_del (s, 0); + hb_set_del (s, max_set_elements - 1); + g_assert (!hb_set_has (s, 0)); + g_assert (hb_set_has (s, 13)); + g_assert (!hb_set_has (s, max_set_elements - 1)); + g_assert (!hb_set_is_empty (s)); + g_assert_cmpint (hb_set_get_population (s), ==, max_set_elements - 2); + g_assert_cmpint (hb_set_get_min (s), ==, 1); + g_assert_cmpint (hb_set_get_max (s), ==, max_set_elements - 2); + + hb_set_destroy (s); +} + +static void +test_set_inverted_ranges (void) +{ + // Tests: + // add_range, del_range, has, get_population, is_empty, get_min, get_max + // for inverted sets. + hb_set_t *s = hb_set_create (); + hb_set_invert (s); + + hb_set_del_range (s, 41, 4000); + hb_set_add_range (s, 78, 601); + + g_assert (hb_set_has (s, 40)); + g_assert (!hb_set_has (s, 41)); + g_assert (!hb_set_has (s, 64)); + g_assert (!hb_set_has (s, 77)); + g_assert (hb_set_has (s, 78)); + g_assert (hb_set_has (s, 300)); + g_assert (hb_set_has (s, 601)); + g_assert (!hb_set_has (s, 602)); + g_assert (!hb_set_has (s, 3000)); + g_assert (!hb_set_has (s, 4000)); + g_assert (hb_set_has (s, 4001)); + + g_assert (!hb_set_is_empty (s)); + g_assert_cmpint (hb_set_get_population (s), ==, max_set_elements - 3436); + g_assert_cmpint (hb_set_get_min (s), ==, 0); + g_assert_cmpint (hb_set_get_max (s), ==, max_set_elements - 1); + + hb_set_del_range (s, 0, 37); + g_assert (!hb_set_has (s, 0)); + g_assert (!hb_set_has (s, 37)); + g_assert (hb_set_has (s, 38)); + g_assert (!hb_set_is_empty (s)); + g_assert_cmpint (hb_set_get_population (s), ==, + max_set_elements - 3436 - 38); + g_assert_cmpint (hb_set_get_min (s), ==, 38); + g_assert_cmpint (hb_set_get_max (s), ==, max_set_elements - 1); + + hb_set_del_range (s, max_set_elements - 13, max_set_elements - 1); + g_assert (!hb_set_has (s, max_set_elements - 1)); + g_assert (!hb_set_has (s, max_set_elements - 13)); + g_assert (hb_set_has (s, max_set_elements - 14)); + + g_assert (!hb_set_is_empty (s)); + g_assert_cmpint (hb_set_get_population (s), ==, + max_set_elements - 3436 - 38 - 13); + g_assert_cmpint (hb_set_get_min (s), ==, 38); + g_assert_cmpint (hb_set_get_max (s), ==, max_set_elements - 14); +} + +static void +test_set_inverted_iteration_next (void) +{ + // Tests: + // next, next_range + hb_set_t *s = hb_set_create (); + hb_set_invert (s); + + hb_set_del_range (s, 41, 4000); + hb_set_add_range (s, 78, 601); + + hb_codepoint_t cp = HB_SET_VALUE_INVALID; + hb_codepoint_t start = 0; + hb_codepoint_t end = 0; + g_assert (hb_set_next (s, &cp)); + g_assert_cmpint (cp, ==, 0); + g_assert (hb_set_next (s, &cp)); + g_assert_cmpint (cp, ==, 1); + + g_assert (hb_set_next_range (s, &start, &end)); + g_assert_cmpint (start, ==, 1); + g_assert_cmpint (end, ==, 40); + + start = 40; + end = 40; + g_assert (hb_set_next_range (s, &start, &end)); + g_assert_cmpint (start, ==, 78); + g_assert_cmpint (end, ==, 601); + + start = 40; + end = 57; + g_assert (hb_set_next_range (s, &start, &end)); + g_assert_cmpint (start, ==, 78); + g_assert_cmpint (end, ==, 601); + + cp = 39; + g_assert (hb_set_next (s, &cp)); + g_assert_cmpint (cp, ==, 40); + + g_assert (hb_set_next (s, &cp)); + g_assert_cmpint (cp, ==, 78); + + cp = 56; + g_assert (hb_set_next (s, &cp)); + g_assert_cmpint (cp, ==, 78); + + cp = 78; + g_assert (hb_set_next (s, &cp)); + g_assert_cmpint (cp, ==, 79); + + cp = 601; + g_assert (hb_set_next (s, &cp)); + g_assert_cmpint (cp, ==, 4001); + + cp = HB_SET_VALUE_INVALID; + hb_set_del (s, 0); + g_assert (hb_set_next (s, &cp)); + g_assert_cmpint (cp, ==, 1); + + start = 0; + end = 0; + g_assert (hb_set_next_range (s, &start, &end)); + g_assert_cmpint (start, ==, 1); + g_assert_cmpint (end, ==, 40); + + cp = max_set_elements - 1; + g_assert (!hb_set_next (s, &cp)); + g_assert_cmpint (cp, ==, HB_SET_VALUE_INVALID); + + start = 4000; + end = 4000; + g_assert (hb_set_next_range (s, &start, &end)); + g_assert_cmpint (start, ==, 4001); + g_assert_cmpint (end, ==, max_set_elements - 1); + + start = max_set_elements - 1; + end = max_set_elements - 1; + g_assert (!hb_set_next_range (s, &start, &end)); + g_assert_cmpint (start, ==, HB_SET_VALUE_INVALID); + g_assert_cmpint (end, ==, HB_SET_VALUE_INVALID); + + cp = max_set_elements - 3; + hb_set_del (s, max_set_elements - 1); + g_assert (hb_set_next (s, &cp)); + g_assert_cmpint (cp, ==, max_set_elements - 2); + g_assert (!hb_set_next (s, &cp)); + g_assert_cmpint (cp, ==, HB_SET_VALUE_INVALID); + + + start = max_set_elements - 2; + end = max_set_elements - 2; + g_assert (!hb_set_next_range (s, &start, &end)); + g_assert_cmpint (start, ==, HB_SET_VALUE_INVALID); + g_assert_cmpint (end, ==, HB_SET_VALUE_INVALID); + + start = max_set_elements - 3; + end = max_set_elements - 3; + g_assert (hb_set_next_range (s, &start, &end)); + g_assert_cmpint (start, ==, max_set_elements - 2); + g_assert_cmpint (end, ==, max_set_elements - 2); +} + + int main (int argc, char **argv) { @@ -590,5 +806,9 @@ main (int argc, char **argv) hb_test_add (test_set_intersect_page_reduction); hb_test_add (test_set_union); + hb_test_add (test_set_inverted_basics); + hb_test_add (test_set_inverted_ranges); + hb_test_add (test_set_inverted_iteration_next); + return hb_test_run(); } From 8f88747a5e100adc3f722baf573143cbb812ac48 Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Thu, 19 Aug 2021 16:30:48 -0600 Subject: [PATCH 49/55] [bit-set-invertible] Fix previous() iteration --- src/hb-bit-set-invertible.hh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/hb-bit-set-invertible.hh b/src/hb-bit-set-invertible.hh index 3b1d9df3e..5be6e451d 100644 --- a/src/hb-bit-set-invertible.hh +++ b/src/hb-bit-set-invertible.hh @@ -239,7 +239,7 @@ struct hb_bit_set_invertible_t auto old = *codepoint; auto v = old; s.previous (&v); - if (old - 1 > v) + if (old - 1 > v || v == INVALID) { *codepoint = old - 1; return true; From 84c2a30214eed8e9cabc1efa7460c74e0ca4f214 Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Thu, 19 Aug 2021 16:33:48 -0600 Subject: [PATCH 50/55] [bit-set-invertible] Second try fixing previous() --- src/hb-bit-set-invertible.hh | 29 +++++++++++++++-------------- 1 file changed, 15 insertions(+), 14 deletions(-) diff --git a/src/hb-bit-set-invertible.hh b/src/hb-bit-set-invertible.hh index 5be6e451d..ab48239bb 100644 --- a/src/hb-bit-set-invertible.hh +++ b/src/hb-bit-set-invertible.hh @@ -211,6 +211,12 @@ struct hb_bit_set_invertible_t return s.next (codepoint); auto old = *codepoint; + if (unlikely (old + 1 == INVALID)) + { + *codepoint = INVALID; + return false; + } + auto v = old; s.next (&v); if (old + 1 < v) @@ -219,12 +225,6 @@ struct hb_bit_set_invertible_t return true; } - if (unlikely (old + 1 == INVALID)) - { - *codepoint = INVALID; - return false; - } - v = old; s.next_range (&old, &v); @@ -237,20 +237,21 @@ struct hb_bit_set_invertible_t return s.previous (codepoint); auto old = *codepoint; - auto v = old; - s.previous (&v); - if (old - 1 > v || v == INVALID) - { - *codepoint = old - 1; - return true; - } - if (unlikely (old - 1 == INVALID)) { *codepoint = INVALID; return false; } + auto v = old; + s.previous (&v); + + if (old - 1 > v || v == INVALID) + { + *codepoint = old - 1; + return true; + } + v = old; s.previous_range (&v, &old); From 5c003d80a680ec619f0922318244e7d41ca709ba Mon Sep 17 00:00:00 2001 From: Garret Rieger Date: Thu, 19 Aug 2021 15:41:12 -0700 Subject: [PATCH 51/55] [set] add tests for inverted previous iteration. --- test/api/test-set.c | 108 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 108 insertions(+) diff --git a/test/api/test-set.c b/test/api/test-set.c index 611657ad6..e8767b335 100644 --- a/test/api/test-set.c +++ b/test/api/test-set.c @@ -789,6 +789,113 @@ test_set_inverted_iteration_next (void) g_assert_cmpint (end, ==, max_set_elements - 2); } +static void +test_set_inverted_iteration_prev (void) +{ + // Tests: + // previous, previous_range + hb_set_t *s = hb_set_create (); + hb_set_invert (s); + + hb_set_del_range (s, 41, 4000); + hb_set_add_range (s, 78, 601); + + hb_codepoint_t cp = HB_SET_VALUE_INVALID; + hb_codepoint_t start = max_set_elements - 1; + hb_codepoint_t end = max_set_elements - 1; + g_assert (hb_set_previous (s, &cp)); + g_assert_cmpint (cp, ==, max_set_elements - 1); + g_assert (hb_set_previous (s, &cp)); + g_assert_cmpint (cp, ==, max_set_elements - 2); + + g_assert (hb_set_previous_range (s, &start, &end)); + g_assert_cmpint (start, ==, 4001); + g_assert_cmpint (end, ==, max_set_elements - 2); + + start = 4001; + end = 4001; + g_assert (hb_set_previous_range (s, &start, &end)); + g_assert_cmpint (start, ==, 78); + g_assert_cmpint (end, ==, 601); + + start = 2500; + end = 3000; + g_assert (hb_set_previous_range (s, &start, &end)); + g_assert_cmpint (start, ==, 78); + g_assert_cmpint (end, ==, 601); + + cp = 4002; + g_assert (hb_set_previous (s, &cp)); + g_assert_cmpint (cp, ==, 4001); + + g_assert (hb_set_previous (s, &cp)); + g_assert_cmpint (cp, ==, 601); + + cp = 3500; + g_assert (hb_set_previous (s, &cp)); + g_assert_cmpint (cp, ==, 601); + + cp = 601; + g_assert (hb_set_previous (s, &cp)); + g_assert_cmpint (cp, ==, 600); + + cp = 78; + g_assert (hb_set_previous (s, &cp)); + g_assert_cmpint (cp, ==, 40); + + cp = HB_SET_VALUE_INVALID; + hb_set_del (s, max_set_elements - 1); + g_assert (hb_set_previous (s, &cp)); + g_assert_cmpint (cp, ==, max_set_elements - 2); + + start = max_set_elements - 1; + end = max_set_elements - 1; + g_assert (hb_set_previous_range (s, &start, &end)); + g_assert_cmpint (start, ==, 4001); + g_assert_cmpint (end, ==, max_set_elements - 2); + + cp = 0; + g_assert (!hb_set_previous (s, &cp)); + g_assert_cmpint (cp, ==, HB_SET_VALUE_INVALID); + + cp = 40; + g_assert (hb_set_previous (s, &cp)); + g_assert_cmpint (cp, ==, 39); + + start = 40; + end = 40; + g_assert (hb_set_previous_range (s, &start, &end)); + g_assert_cmpint (start, ==, 0); + g_assert_cmpint (end, ==, 39); + + start = 0; + end = 0; + g_assert (!hb_set_previous_range (s, &start, &end)); + g_assert_cmpint (start, ==, HB_SET_VALUE_INVALID); + g_assert_cmpint (end, ==, HB_SET_VALUE_INVALID); + + + cp = 2; + hb_set_del (s, 0); + g_assert (hb_set_previous (s, &cp)); + g_assert_cmpint (cp, ==, 1); + g_assert (!hb_set_previous (s, &cp)); + g_assert_cmpint (cp, ==, HB_SET_VALUE_INVALID); + + start = 1; + end = 1; + g_assert (!hb_set_previous_range (s, &start, &end)); + g_assert_cmpint (start, ==, HB_SET_VALUE_INVALID); + g_assert_cmpint (end, ==, HB_SET_VALUE_INVALID); + + start = 2; + end = 2; + g_assert (hb_set_previous_range (s, &start, &end)); + g_assert_cmpint (start, ==, 1); + g_assert_cmpint (end, ==, 1); + return; // TODO +} + int main (int argc, char **argv) @@ -809,6 +916,7 @@ main (int argc, char **argv) hb_test_add (test_set_inverted_basics); hb_test_add (test_set_inverted_ranges); hb_test_add (test_set_inverted_iteration_next); + hb_test_add (test_set_inverted_iteration_prev); return hb_test_run(); } From 287032af6cf3609bb9ca88cf622d478fc77698e3 Mon Sep 17 00:00:00 2001 From: Garret Rieger Date: Thu, 19 Aug 2021 15:45:28 -0700 Subject: [PATCH 52/55] [set] update set test TODO list. --- test/api/test-set.c | 9 +-------- 1 file changed, 1 insertion(+), 8 deletions(-) diff --git a/test/api/test-set.c b/test/api/test-set.c index e8767b335..94d374e31 100644 --- a/test/api/test-set.c +++ b/test/api/test-set.c @@ -574,14 +574,8 @@ test_set_delrange (void) hb_set_destroy (s); } -// Inverted tests: -// iteration: next/prev/next_range/prev_range -// is_empty() -// max/min -// has/get/[] -// add/del/add_range/del_range +// TODO(garretrieger): Inverted tests: // is_equal -// get_population // // Interesting cases: // - empty inverted (ie. all numbers) @@ -893,7 +887,6 @@ test_set_inverted_iteration_prev (void) g_assert (hb_set_previous_range (s, &start, &end)); g_assert_cmpint (start, ==, 1); g_assert_cmpint (end, ==, 1); - return; // TODO } From 325fd6ddb85a141507f752f37ab650bb56299247 Mon Sep 17 00:00:00 2001 From: Garret Rieger Date: Thu, 19 Aug 2021 15:54:31 -0700 Subject: [PATCH 53/55] [set] add tests for inverted set equality. --- test/api/test-set.c | 56 ++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 55 insertions(+), 1 deletion(-) diff --git a/test/api/test-set.c b/test/api/test-set.c index 94d374e31..54a31c2e2 100644 --- a/test/api/test-set.c +++ b/test/api/test-set.c @@ -575,7 +575,6 @@ test_set_delrange (void) } // TODO(garretrieger): Inverted tests: -// is_equal // // Interesting cases: // - empty inverted (ie. all numbers) @@ -890,6 +889,60 @@ test_set_inverted_iteration_prev (void) } +static void +test_set_inverted_equality (void) +{ + hb_set_t *a = hb_set_create (); + hb_set_t *b = hb_set_create (); + hb_set_invert (a); + hb_set_invert (b); + + g_assert (hb_set_is_equal (a, b)); + g_assert (hb_set_is_equal (b, a)); + + hb_set_add (a, 10); + g_assert (hb_set_is_equal (a, b)); + g_assert (hb_set_is_equal (b, a)); + + hb_set_del (a, 42); + g_assert (!hb_set_is_equal (a, b)); + g_assert (!hb_set_is_equal (b, a)); + + hb_set_del (b, 42); + g_assert (hb_set_is_equal (a, b)); + g_assert (hb_set_is_equal (b, a)); + + hb_set_del_range (a, 43, 50); + hb_set_del_range (a, 51, 76); + hb_set_del_range (b, 43, 76); + g_assert (hb_set_is_equal (a, b)); + g_assert (hb_set_is_equal (b, a)); + + hb_set_del (a, 0); + g_assert (!hb_set_is_equal (a, b)); + g_assert (!hb_set_is_equal (b, a)); + + hb_set_del (b, 0); + g_assert (hb_set_is_equal (a, b)); + g_assert (hb_set_is_equal (b, a)); + + hb_set_del (a, max_set_elements - 1); + g_assert (!hb_set_is_equal (a, b)); + g_assert (!hb_set_is_equal (b, a)); + + hb_set_del (b, max_set_elements - 1); + g_assert (hb_set_is_equal (a, b)); + g_assert (hb_set_is_equal (b, a)); + + hb_set_invert (a); + g_assert (!hb_set_is_equal (a, b)); + g_assert (!hb_set_is_equal (b, a)); + + hb_set_invert (b); + g_assert (hb_set_is_equal (a, b)); + g_assert (hb_set_is_equal (b, a)); +} + int main (int argc, char **argv) { @@ -910,6 +963,7 @@ main (int argc, char **argv) hb_test_add (test_set_inverted_ranges); hb_test_add (test_set_inverted_iteration_next); hb_test_add (test_set_inverted_iteration_prev); + hb_test_add (test_set_inverted_equality); return hb_test_run(); } From c4ed58299761ac2e5452bec890e44fcb7c9f1cc7 Mon Sep 17 00:00:00 2001 From: Garret Rieger Date: Thu, 19 Aug 2021 17:47:41 -0700 Subject: [PATCH 54/55] [set] add test for inverted set operations. This test checks all possible set configurations against each operation type. --- test/api/test-set.c | 125 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 125 insertions(+) diff --git a/test/api/test-set.c b/test/api/test-set.c index 54a31c2e2..f6aba8670 100644 --- a/test/api/test-set.c +++ b/test/api/test-set.c @@ -678,6 +678,8 @@ test_set_inverted_ranges (void) max_set_elements - 3436 - 38 - 13); g_assert_cmpint (hb_set_get_min (s), ==, 38); g_assert_cmpint (hb_set_get_max (s), ==, max_set_elements - 14); + + hb_set_destroy (s); } static void @@ -780,6 +782,8 @@ test_set_inverted_iteration_next (void) g_assert (hb_set_next_range (s, &start, &end)); g_assert_cmpint (start, ==, max_set_elements - 2); g_assert_cmpint (end, ==, max_set_elements - 2); + + hb_set_destroy (s); } static void @@ -886,6 +890,8 @@ test_set_inverted_iteration_prev (void) g_assert (hb_set_previous_range (s, &start, &end)); g_assert_cmpint (start, ==, 1); g_assert_cmpint (end, ==, 1); + + hb_set_destroy (s); } @@ -941,6 +947,124 @@ test_set_inverted_equality (void) hb_set_invert (b); g_assert (hb_set_is_equal (a, b)); g_assert (hb_set_is_equal (b, a)); + + hb_set_destroy (a); + hb_set_destroy (b); +} + +typedef enum { + UNION = 0, + INTERSECT, + SUBTRACT, + SYM_DIFF, + LAST, +} set_operation; + +static hb_set_t* prepare_set(hb_bool_t has_x, + hb_bool_t inverted, + hb_bool_t has_page) +{ + static const hb_codepoint_t x = 13; + hb_set_t* s = hb_set_create (); + if (inverted) hb_set_invert (s); + if (has_page) + { + // Ensure a page exists for x. + inverted ? hb_set_del (s, x) : hb_set_add (s, x); + } + if (has_x) + hb_set_add (s, x); + else + hb_set_del (s, x); + + return s; +} + +static hb_bool_t +check_set_operations(hb_bool_t a_has_x, + hb_bool_t a_inverted, + hb_bool_t a_has_page, + hb_bool_t b_has_x, + hb_bool_t b_inverted, + hb_bool_t b_has_page, + set_operation op) +{ + hb_codepoint_t x = 13; + hb_set_t* a = prepare_set (a_has_x, a_inverted, a_has_page); + hb_set_t* b = prepare_set (b_has_x, b_inverted, b_has_page); + + char* op_name; + hb_bool_t has_expected; + hb_bool_t should_have_x; + switch (op) { + case UNION: + default: + op_name = "union"; + should_have_x = (a_has_x || b_has_x); + hb_set_union (a, b); + has_expected = (hb_set_has (a, x) == should_have_x); + break; + case INTERSECT: + op_name = "intersect"; + should_have_x = (a_has_x && b_has_x); + hb_set_intersect (a, b); + has_expected = (hb_set_has (a, x) == should_have_x); + break; + case SUBTRACT: + op_name = "subtract"; + should_have_x = (a_has_x && !b_has_x); + hb_set_subtract (a, b); + has_expected = (hb_set_has (a, x) == should_have_x); + break; + case SYM_DIFF: + op_name = "sym_diff"; + should_have_x = (a_has_x ^ b_has_x); + hb_set_symmetric_difference (a, b); + has_expected = (hb_set_has (a, x) == should_have_x); + break; + } + + printf ("%s%s%s %-9s %s%s%s == %s [%s]\n", + a_inverted ? "i" : " ", + a_has_page ? "p" : " ", + a_has_x ? "{13}" : "{} ", + op_name, + b_inverted ? "i" : " ", + b_has_page ? "p" : " ", + b_has_x ? "{13}" : "{} ", + should_have_x ? "{13}" : "{} ", + has_expected ? "succeeded" : "failed"); + + hb_set_destroy (a); + hb_set_destroy (b); + + return has_expected; +} + +static void +test_set_inverted_operations (void) +{ + hb_bool_t all_succeeded = 1; + for (hb_bool_t a_has_x = 0; a_has_x <= 1; a_has_x++) { + for (hb_bool_t a_inverted = 0; a_inverted <= 1; a_inverted++) { + for (hb_bool_t b_has_x = 0; b_has_x <= 1; b_has_x++) { + for (hb_bool_t b_inverted = 0; b_inverted <= 1; b_inverted++) { + for (hb_bool_t a_has_page = 0; a_has_page <= !(a_has_x ^ a_inverted); a_has_page++) { + for (hb_bool_t b_has_page = 0; b_has_page <= !(b_has_x ^ b_inverted); b_has_page++) { + for (set_operation op = UNION; op < LAST; op++) { + all_succeeded = check_set_operations (a_has_x, a_inverted, a_has_page, + b_has_x, b_inverted, b_has_page, + op) + && all_succeeded; + } + } + } + } + } + } + } + + g_assert (all_succeeded); } int @@ -964,6 +1088,7 @@ main (int argc, char **argv) hb_test_add (test_set_inverted_iteration_next); hb_test_add (test_set_inverted_iteration_prev); hb_test_add (test_set_inverted_equality); + hb_test_add (test_set_inverted_operations); return hb_test_run(); } From 915550ab19659107acea9e70a7bc699a19fe2f44 Mon Sep 17 00:00:00 2001 From: Garret Rieger Date: Thu, 19 Aug 2021 17:48:38 -0700 Subject: [PATCH 55/55] [set] remove inverted test TODO. --- test/api/test-set.c | 13 ------------- 1 file changed, 13 deletions(-) diff --git a/test/api/test-set.c b/test/api/test-set.c index f6aba8670..eb32472b5 100644 --- a/test/api/test-set.c +++ b/test/api/test-set.c @@ -574,19 +574,6 @@ test_set_delrange (void) hb_set_destroy (s); } -// TODO(garretrieger): Inverted tests: -// -// Interesting cases: -// - empty inverted (ie. all numbers) -// - inverted with things removed at either extreme -// - inverted with things removed in the middle. -// -// Set operations: (for II, NN, IN, NI) -// - union -// - intersercts -// - sym diff -// - subtraction - static const unsigned max_set_elements = -1; static void