mirror of
https://github.com/storytold/harfbuzz.git
synced 2026-11-20 06:21:16 +01:00
Keep the hot spend primitive always-inline and branch-free. Budget costs and multipliers are unsigned and structurally bounded by their callers, so the primitive only needs to debit the live counter and report exhaustion. Move hb-limits.hh alongside the shared internal headers, after the paired inline/noinline attribute definitions it now depends on. Tests: meson test -C build (272/272 passed) Assisted-by: OpenAI Codex <codex@openai.com>
146 lines
4.6 KiB
C++
146 lines
4.6 KiB
C++
/*
|
|
* Copyright © 2019 Facebook, Inc.
|
|
*
|
|
* 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.
|
|
*
|
|
* Facebook Author(s): Behdad Esfahbod
|
|
*/
|
|
|
|
#include "hb.hh"
|
|
#include "hb-algs.hh"
|
|
#include "hb-set.hh"
|
|
|
|
|
|
static char *
|
|
test_func (int a, char **b)
|
|
{
|
|
return b ? b[a] : nullptr;
|
|
}
|
|
|
|
struct A
|
|
{
|
|
void a () {}
|
|
};
|
|
|
|
int
|
|
main (int argc, char **argv)
|
|
{
|
|
int i = 1;
|
|
auto p = hb_pair (1, i);
|
|
|
|
p.second = 2;
|
|
hb_always_assert (i == 2);
|
|
|
|
const int c = 3;
|
|
auto pc = hb_pair (1, c);
|
|
hb_always_assert (pc.second == 3);
|
|
|
|
auto q = p;
|
|
hb_always_assert (&q != &p);
|
|
q.second = 4;
|
|
hb_always_assert (i == 4);
|
|
|
|
hb_invoke (test_func, 0, nullptr);
|
|
|
|
A a;
|
|
hb_invoke (&A::a, a);
|
|
|
|
hb_always_assert (1 == hb_min (8, 1));
|
|
hb_always_assert (8 == hb_max (8, 1));
|
|
|
|
int x = 1, y = 2;
|
|
hb_min (x, 3);
|
|
hb_min (3, x);
|
|
hb_min (x, 4 + 3);
|
|
int &z = hb_min (x, y);
|
|
z = 3;
|
|
hb_always_assert (x == 3);
|
|
|
|
hb_pair_t<const int*, int> xp = hb_pair_t<int *, long> (nullptr, 0);
|
|
xp = hb_pair_t<int *, double> (nullptr, 1);
|
|
xp = hb_pair_t<const int*, int> (nullptr, 1);
|
|
|
|
hb_always_assert (3 == hb_partial (hb_min, 3) (4));
|
|
hb_always_assert (3 == hb_partial<1> (hb_min, 4) (3));
|
|
|
|
auto M0 = hb_partial<2> (hb_max, 0);
|
|
hb_always_assert (M0 (-2) == 0);
|
|
hb_always_assert (M0 (+2) == 2);
|
|
|
|
hb_always_assert (hb_add (2) (5) == 7);
|
|
hb_always_assert (hb_add (5) (2) == 7);
|
|
|
|
hb_always_assert (hb_saturate_add (1, 2) == 3);
|
|
hb_always_assert (hb_saturate_add (INT_MAX, 1) == INT_MAX);
|
|
hb_always_assert (hb_saturate_add (INT_MIN, -1) == INT_MIN);
|
|
hb_always_assert (hb_saturate_add (INT_MAX, INT_MIN) == -1);
|
|
hb_always_assert (hb_saturate_sub (3, 2) == 1);
|
|
hb_always_assert (hb_saturate_sub (INT_MAX, -1) == INT_MAX);
|
|
hb_always_assert (hb_saturate_sub (INT_MIN, 1) == INT_MIN);
|
|
hb_always_assert (hb_saturate_sub (INT_MIN, INT_MIN) == 0);
|
|
hb_always_assert (hb_saturate_neg (2) == -2);
|
|
hb_always_assert (hb_saturate_neg (-2) == 2);
|
|
hb_always_assert (hb_saturate_neg (INT_MIN) == INT_MAX);
|
|
hb_always_assert (hb_clamp_to<int> (1.) == 1);
|
|
hb_always_assert (hb_clamp_to<int> ((double) INT_MAX + 1.) == INT_MAX);
|
|
hb_always_assert (hb_clamp_to<int> ((double) INT_MIN - 1.) == INT_MIN);
|
|
hb_always_assert (hb_clamp_to<int> ((int64_t) 1) == 1);
|
|
hb_always_assert (hb_clamp_to<int> ((int64_t) INT_MAX + 1) == INT_MAX);
|
|
hb_always_assert (hb_clamp_to<int> ((int64_t) INT_MIN - 1) == INT_MIN);
|
|
|
|
int64_t budget = 10;
|
|
hb_always_assert (hb_budget_spend (budget, 4, 2));
|
|
hb_always_assert (budget == 2);
|
|
hb_always_assert (!hb_budget_spend (budget, 3));
|
|
hb_always_assert (budget == -1);
|
|
hb_always_assert (!hb_budget_spend (budget, 1));
|
|
hb_always_assert (budget == -2);
|
|
|
|
budget = 0;
|
|
hb_always_assert (hb_budget_spend (budget, 0));
|
|
hb_always_assert (!hb_budget_spend (budget, 1));
|
|
hb_always_assert (budget == -1);
|
|
|
|
budget = INT64_MAX;
|
|
hb_always_assert (hb_budget_spend (budget, 1024));
|
|
hb_always_assert (budget == INT64_MAX - 1024);
|
|
|
|
x = 1;
|
|
hb_always_assert (++hb_inc (x) == 3);
|
|
hb_always_assert (x == 3);
|
|
|
|
hb_set_t set1 {1};
|
|
hb_set_t set2 {2};
|
|
|
|
hb_always_assert (hb_hash (set1) != hb_hash (set2));
|
|
hb_always_assert (hb_hash (set1) == hb_hash (hb_set_t {1}));
|
|
hb_always_assert (hb_hash (set1) != hb_hash (hb_set_t {}));
|
|
hb_always_assert (hb_hash (set1) != hb_hash (hb_set_t {2}));
|
|
hb_always_assert (hb_hash (set2) == hb_hash (hb_set_t {2}));
|
|
|
|
/* hb_hash, unlike std::hash, dereferences pointers. */
|
|
hb_always_assert (hb_hash (set1) == hb_hash (&set1));
|
|
hb_always_assert (hb_hash (set1) == hb_hash (hb::shared_ptr<hb_set_t> {hb_set_reference (&set1)}));
|
|
hb_always_assert (hb_hash (set1) == hb_hash (hb::unique_ptr<hb_set_t> {hb_set_reference (&set1)}));
|
|
|
|
return 0;
|
|
}
|