mozilla
/
gecko-dev
зеркало из https://github.com/mozilla/gecko-dev.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

Bug 1411005 - Update Harfbuzz to version 1.6.3. r=jfkthame

This commit is contained in:
Ryan VanderMeulen 2017-10-27 10:56:24 -04:00
Родитель 97ddc2ae3b
Коммит 42a983ba76
80 изменённых файлов: 1490 добавлений и 935 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

1
gfx/harfbuzz/Makefile.am
Просмотреть файл

@ -13,6 +13,7 @@ EXTRA_DIST = \
BUILD.md \
RELEASING.md \
CMakeLists.txt \
replace-enum-strings.cmake \
$(NULL)
MAINTAINERCLEANFILES = \

32
gfx/harfbuzz/NEWS
Просмотреть файл

@ -1,3 +1,35 @@
Overview of changes leading to 1.6.3
Thursday, October 26th, 2017
====================================
- Fix hb_set_t some more. Should be solid now.
- Implement get_glyph_name() for hb-ot-font.
- Misc fixes.
Overview of changes leading to 1.6.2
Monday, October 23nd, 2017
====================================
- Yesterday's release had a bad crasher; don't use it. That's what
happens when one works on Sunday...
https://github.com/behdad/harfbuzz/issues/578
- Build fixes for FreeBSD and Chrome Android.
Overview of changes leading to 1.6.1
Sunday, October 22nd, 2017
====================================
- Don't skip over COMBINING GRAPHEME JOINER when ligating, etc.
To be refined: https://github.com/behdad/harfbuzz/issues/554
- Faster hb_set_t implementation.
- Don't use deprecated ICU API.
- Fix undefined-behavior in Myanmar shaper, introduced in 1.6.0
- Deprecated API:
hb_set_invert()
Overview of changes leading to 1.6.0
Friday, October the 13th, 2017
====================================

4
gfx/harfbuzz/README-mozilla
Просмотреть файл

@ -1,9 +1,9 @@
gfx/harfbuzz status as of 2017-10-13:
gfx/harfbuzz status as of 2017-10-26:
This directory contains the harfbuzz source from the 'master' branch of
https://github.com/behdad/harfbuzz.
Current version: 1.6.0
Current version: 1.6.3
UPDATING:

5
gfx/harfbuzz/configure.ac
Просмотреть файл

@ -1,6 +1,6 @@
AC_PREREQ([2.64])
AC_INIT([HarfBuzz],
[1.6.0],
[1.6.3],
[https://github.com/behdad/harfbuzz/issues/new],
[harfbuzz],
[http://harfbuzz.org/])
@ -80,6 +80,9 @@ if test "x$GCC" = "xyes"; then
# Make symbols link locally
LDFLAGS="$LDFLAGS -Bsymbolic-functions"
# Choose C++ version
CXXFLAGS="$CXXFLAGS -std=c++11"
# Make sure we don't link to libstdc++
CXXFLAGS="$CXXFLAGS -fno-rtti -fno-exceptions"

2
gfx/harfbuzz/harfbuzz.doap
Просмотреть файл

@ -13,7 +13,7 @@
<!--download-page
rdf:resource=""/-->
<bug-database
rdf:resource="http://bugs.freedesktop.org/enter_bug.cgi?product=harfbuzz"/>
rdf:resource="https://github.com/behdad/harfbuzz/issues" />
<maintainer>
<foaf:Person>

4
gfx/harfbuzz/src/check-c-linkage-decls.sh
Просмотреть файл

@ -11,14 +11,14 @@ test "x$HBSOURCES" = x && HBSOURCES=`cd "$srcdir"; find . -maxdepth 1 -name 'hb*
for x in $HBHEADERS; do
test -f $srcdir/$x && x=$srcdir/$x
test -f "$srcdir/$x" -a ! -f "$x" && x="$srcdir/$x"
if ! grep -q HB_BEGIN_DECLS "$x" || ! grep -q HB_END_DECLS "$x"; then
echo "Ouch, file $x does not have HB_BEGIN_DECLS / HB_END_DECLS, but it should"
stat=1
fi
done
for x in $HBSOURCES; do
test -f $srcdir/$x && x=$srcdir/$x
test -f "$srcdir/$x" -a ! -f "$x" && x="$srcdir/$x"
if grep -q HB_BEGIN_DECLS "$x" || grep -q HB_END_DECLS "$x"; then
echo "Ouch, file $x has HB_BEGIN_DECLS / HB_END_DECLS, but it shouldn't"
stat=1

5
gfx/harfbuzz/src/check-externs.sh
Просмотреть файл

@ -13,8 +13,9 @@ test "x$EGREP" = x && EGREP='grep -E'
echo 'Checking that all public symbols are exported with HB_EXTERN'
for x in $HBHEADERS; do
test -f "$srcdir/$x" && x="$srcdir/$x"
$EGREP -B1 '^hb_' "$x" | $EGREP -E -v '^(--|hb_|HB_EXTERN )' -A1
test -f "$srcdir/$x" -a ! -f "$x" && x="$srcdir/$x"
$EGREP -B1 -n '^hb_' /dev/null "$x" |
$EGREP -v '(^--|:hb_|-HB_EXTERN )' -A1
done |
grep . >&2 && stat=1

2
gfx/harfbuzz/src/check-header-guards.sh
Просмотреть файл

@ -10,7 +10,7 @@ test "x$HBHEADERS" = x && HBHEADERS=`cd "$srcdir"; find . -maxdepth 1 -name 'hb*
test "x$HBSOURCES" = x && HBSOURCES=`cd "$srcdir"; find . -maxdepth 1 -name 'hb-*.cc' -or -name 'hb-*.hh'`
for x in $HBHEADERS $HBSOURCES; do
test -f "$srcdir/$x" && x="$srcdir/$x"
test -f "$srcdir/$x" -a ! -f "$x" && x="$srcdir/$x"
echo "$x" | grep -q '[^h]$' && continue;
xx=`echo "$x" | sed 's@.*/@@'`
tag=`echo "$xx" | tr 'a-z.-' 'A-Z_'`

4
gfx/harfbuzz/src/check-includes.sh
Просмотреть файл

@ -13,7 +13,7 @@ test "x$HBSOURCES" = x && HBSOURCES=`cd "$srcdir"; find . -maxdepth 1 -name 'hb-
echo 'Checking that public header files #include "hb-common.h" or "hb.h" first (or none)'
for x in $HBHEADERS; do
test -f "$srcdir/$x" && x="$srcdir/$x"
test -f "$srcdir/$x" -a ! -f "$x" && x="$srcdir/$x"
grep '#.*\<include\>' "$x" /dev/null | head -n 1
done |
grep -v '"hb-common[.]h"' |
@ -26,7 +26,7 @@ grep . >&2 && stat=1
echo 'Checking that source files #include "hb-*private.hh" first (or none)'
for x in $HBSOURCES; do
test -f "$srcdir/$x" && x="$srcdir/$x"
test -f "$srcdir/$x" -a ! -f "$x" && x="$srcdir/$x"
grep '#.*\<include\>' "$x" /dev/null | grep -v 'include _' | head -n 1
done |
grep -v '"hb-.*private[.]hh"' |

2
gfx/harfbuzz/src/harfbuzz-icu.pc
Просмотреть файл

@ -5,7 +5,7 @@ includedir=/usr/local/include
Name: harfbuzz
Description: HarfBuzz text shaping library ICU integration
Version: 1.6.0
Version: 1.6.3
Requires: harfbuzz
Requires.private: icu-uc

2
gfx/harfbuzz/src/harfbuzz.pc
Просмотреть файл

@ -5,7 +5,7 @@ includedir=/usr/local/include
Name: harfbuzz
Description: HarfBuzz text shaping library
Version: 1.6.0
Version: 1.6.3
Libs: -L${libdir} -lharfbuzz
Libs.private: -lm

12
gfx/harfbuzz/src/hb-blob.cc
Просмотреть файл

@ -72,8 +72,8 @@ _hb_blob_destroy_user_data (hb_blob_t *blob)
{
if (blob->destroy) {
blob->destroy (blob->user_data);
blob->user_data = NULL;
blob->destroy = NULL;
blob->user_data = nullptr;
blob->destroy = nullptr;
}
}
@ -194,12 +194,12 @@ hb_blob_get_empty (void)
true, /* immutable */
NULL, /* data */
nullptr, /* data */
0, /* length */
HB_MEMORY_MODE_READONLY, /* mode */
NULL, /* user_data */
NULL /* destroy */
nullptr, /* user_data */
nullptr /* destroy */
};
return const_cast<hb_blob_t *> (&_hb_blob_nil);
@ -379,7 +379,7 @@ hb_blob_get_data_writable (hb_blob_t *blob, unsigned int *length)
if (length)
*length = 0;
return NULL;
return nullptr;
}
if (length)

4
gfx/harfbuzz/src/hb-buffer-private.hh
Просмотреть файл

@ -45,8 +45,8 @@
#define HB_BUFFER_MAX_LEN_DEFAULT 0x3FFFFFFF /* Shaping more than a billion chars? Let us know! */
#endif
ASSERT_STATIC (sizeof (hb_glyph_info_t) == 20);
ASSERT_STATIC (sizeof (hb_glyph_info_t) == sizeof (hb_glyph_position_t));
static_assert ((sizeof (hb_glyph_info_t) == 20), "");
static_assert ((sizeof (hb_glyph_info_t) == sizeof (hb_glyph_position_t)), "");
HB_MARK_AS_FLAG_T (hb_buffer_flags_t);
HB_MARK_AS_FLAG_T (hb_buffer_serialize_flags_t);

16
gfx/harfbuzz/src/hb-buffer-serialize.cc
Просмотреть файл

@ -30,7 +30,7 @@
static const char *serialize_formats[] = {
"text",
"json",
NULL
nullptr
};
/**
@ -90,7 +90,7 @@ hb_buffer_serialize_format_to_string (hb_buffer_serialize_format_t format)
case HB_BUFFER_SERIALIZE_FORMAT_TEXT: return serialize_formats[0];
case HB_BUFFER_SERIALIZE_FORMAT_JSON: return serialize_formats[1];
default:
case HB_BUFFER_SERIALIZE_FORMAT_INVALID: return NULL;
case HB_BUFFER_SERIALIZE_FORMAT_INVALID: return nullptr;
}
}
@ -104,9 +104,9 @@ _hb_buffer_serialize_glyphs_json (hb_buffer_t *buffer,
hb_font_t *font,
hb_buffer_serialize_flags_t flags)
{
hb_glyph_info_t *info = hb_buffer_get_glyph_infos (buffer, NULL);
hb_glyph_info_t *info = hb_buffer_get_glyph_infos (buffer, nullptr);
hb_glyph_position_t *pos = (flags & HB_BUFFER_SERIALIZE_FLAG_NO_POSITIONS) ?
NULL : hb_buffer_get_glyph_positions (buffer, NULL);
nullptr : hb_buffer_get_glyph_positions (buffer, nullptr);
*buf_consumed = 0;
for (unsigned int i = start; i < end; i++)
@ -194,9 +194,9 @@ _hb_buffer_serialize_glyphs_text (hb_buffer_t *buffer,
hb_font_t *font,
hb_buffer_serialize_flags_t flags)
{
hb_glyph_info_t *info = hb_buffer_get_glyph_infos (buffer, NULL);
hb_glyph_info_t *info = hb_buffer_get_glyph_infos (buffer, nullptr);
hb_glyph_position_t *pos = (flags & HB_BUFFER_SERIALIZE_FLAG_NO_POSITIONS) ?
NULL : hb_buffer_get_glyph_positions (buffer, NULL);
nullptr : hb_buffer_get_glyph_positions (buffer, nullptr);
*buf_consumed = 0;
for (unsigned int i = start; i < end; i++)
@ -422,8 +422,8 @@ hb_bool_t
hb_buffer_deserialize_glyphs (hb_buffer_t *buffer,
const char *buf,
int buf_len, /* -1 means nul-terminated */
const char **end_ptr, /* May be NULL */
hb_font_t *font, /* May be NULL */
const char **end_ptr, /* May be nullptr */
hb_font_t *font, /* May be nullptr */
hb_buffer_serialize_format_t format)
{
const char *end;

12
gfx/harfbuzz/src/hb-buffer.cc
Просмотреть файл

@ -120,8 +120,8 @@ hb_buffer_t::enlarge (unsigned int size)
}
unsigned int new_allocated = allocated;
hb_glyph_position_t *new_pos = NULL;
hb_glyph_info_t *new_info = NULL;
hb_glyph_position_t *new_pos = nullptr;
hb_glyph_info_t *new_info = nullptr;
bool separate_out = out_info != info;
if (unlikely (_hb_unsigned_int_mul_overflows (size, sizeof (info[0]))))
@ -130,7 +130,7 @@ hb_buffer_t::enlarge (unsigned int size)
while (size >= new_allocated)
new_allocated += (new_allocated >> 1) + 32;
ASSERT_STATIC (sizeof (info[0]) == sizeof (pos[0]));
static_assert ((sizeof (info[0]) == sizeof (pos[0])), "");
if (unlikely (_hb_unsigned_int_mul_overflows (new_allocated, sizeof (info[0]))))
goto done;
@ -1993,9 +1993,9 @@ hb_buffer_set_message_func (hb_buffer_t *buffer,
buffer->message_data = user_data;
buffer->message_destroy = destroy;
} else {
buffer->message_func = NULL;
buffer->message_data = NULL;
buffer->message_destroy = NULL;
buffer->message_func = nullptr;
buffer->message_data = nullptr;
buffer->message_destroy = nullptr;
}
}

4
gfx/harfbuzz/src/hb-buffer.h
Просмотреть файл

@ -132,8 +132,8 @@ typedef struct hb_segment_properties_t {
#define HB_SEGMENT_PROPERTIES_DEFAULT {HB_DIRECTION_INVALID, \
HB_SCRIPT_INVALID, \
HB_LANGUAGE_INVALID, \
NULL, \
NULL}
(void *) 0, \
(void *) 0}
HB_EXTERN hb_bool_t
hb_segment_properties_equal (const hb_segment_properties_t *a,

74
gfx/harfbuzz/src/hb-cache-private.hh
Просмотреть файл

@ -1,74 +0,0 @@
/*
* Copyright © 2012 Google, 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.
*
* Google Author(s): Behdad Esfahbod
*/
#ifndef HB_CACHE_PRIVATE_HH
#define HB_CACHE_PRIVATE_HH
#include "hb-private.hh"
/* Implements a lock-free cache for int->int functions. */
template <unsigned int key_bits, unsigned int value_bits, unsigned int cache_bits>
struct hb_cache_t
{
ASSERT_STATIC (key_bits >= cache_bits);
ASSERT_STATIC (key_bits + value_bits - cache_bits < 8 * sizeof (unsigned int));
inline void clear (void)
{
memset (values, 255, sizeof (values));
}
inline bool get (unsigned int key, unsigned int *value)
{
unsigned int k = key & ((1u<<cache_bits)-1);
unsigned int v = values[k];
if ((v >> value_bits) != (key >> cache_bits))
return false;
*value = v & ((1u<<value_bits)-1);
return true;
}
inline bool set (unsigned int key, unsigned int value)
{
if (unlikely ((key >> key_bits) || (value >> value_bits)))
return false; /* Overflows */
unsigned int k = key & ((1u<<cache_bits)-1);
unsigned int v = ((key>>cache_bits)<<value_bits) | value;
values[k] = v;
return true;
}
private:
unsigned int values[1u<<cache_bits];
};
typedef hb_cache_t<21, 16, 8> hb_cmap_cache_t;
typedef hb_cache_t<16, 24, 8> hb_advance_cache_t;
#endif /* HB_CACHE_PRIVATE_HH */

18
gfx/harfbuzz/src/hb-common.cc
Просмотреть файл

@ -274,13 +274,13 @@ retry:
/* Not found; allocate one. */
hb_language_item_t *lang = (hb_language_item_t *) calloc (1, sizeof (hb_language_item_t));
if (unlikely (!lang))
return NULL;
return nullptr;
lang->next = first_lang;
*lang = key;
if (unlikely (!lang->lang))
{
free (lang);
return NULL;
return nullptr;
}
if (!hb_atomic_ptr_cmpexch (&langs, first_lang, lang)) {
@ -318,7 +318,7 @@ hb_language_from_string (const char *str, int len)
if (!str || !len || !*str)
return HB_LANGUAGE_INVALID;
hb_language_item_t *item = NULL;
hb_language_item_t *item = nullptr;
if (len >= 0)
{
/* NUL-terminate it. */
@ -349,7 +349,7 @@ hb_language_from_string (const char *str, int len)
const char *
hb_language_to_string (hb_language_t language)
{
/* This is actually NULL-safe! */
/* This is actually nullptr-safe! */
return language->s;
}
@ -369,7 +369,7 @@ hb_language_get_default (void)
hb_language_t language = (hb_language_t) hb_atomic_ptr_get (&default_language);
if (unlikely (language == HB_LANGUAGE_INVALID)) {
language = hb_language_from_string (setlocale (LC_CTYPE, NULL), -1);
language = hb_language_from_string (setlocale (LC_CTYPE, nullptr), -1);
(void) hb_atomic_ptr_cmpexch (&default_language, HB_LANGUAGE_INVALID, language);
}
@ -562,9 +562,9 @@ hb_user_data_array_t::set (hb_user_data_key_t *key,
void *
hb_user_data_array_t::get (hb_user_data_key_t *key)
{
hb_user_data_item_t item = {NULL, NULL, NULL};
hb_user_data_item_t item = {nullptr, nullptr, nullptr};
return items.find (key, &item, lock) ? item.data : NULL;
return items.find (key, &item, lock) ? item.data : nullptr;
}
@ -722,9 +722,9 @@ retry:
if (unlikely (!C))
{
C = newlocale (LC_ALL_MASK, "C", NULL);
C = newlocale (LC_ALL_MASK, "C", nullptr);
if (!hb_atomic_ptr_cmpexch (&C_locale, NULL, C))
if (!hb_atomic_ptr_cmpexch (&C_locale, nullptr, C))
{
freelocale (C_locale);
goto retry;

2
gfx/harfbuzz/src/hb-common.h
Просмотреть файл

@ -134,7 +134,7 @@ hb_language_from_string (const char *str, int len);
HB_EXTERN const char *
hb_language_to_string (hb_language_t language);
#define HB_LANGUAGE_INVALID ((hb_language_t) NULL)
#define HB_LANGUAGE_INVALID ((hb_language_t) 0)
HB_EXTERN hb_language_t
hb_language_get_default (void);

68
gfx/harfbuzz/src/hb-coretext.cc
Просмотреть файл

@ -65,12 +65,12 @@ reference_table (hb_face_t *face HB_UNUSED, hb_tag_t tag, void *user_data)
CGFontRef cg_font = reinterpret_cast<CGFontRef> (user_data);
CFDataRef cf_data = CGFontCopyTableForTag (cg_font, tag);
if (unlikely (!cf_data))
return NULL;
return nullptr;
const char *data = reinterpret_cast<const char*> (CFDataGetBytePtr (cf_data));
const size_t length = CFDataGetLength (cf_data);
if (!data || !length)
return NULL;
return nullptr;
return hb_blob_create (data, length, HB_MEMORY_MODE_READONLY,
reinterpret_cast<void *> (const_cast<__CFData *> (cf_data)),
@ -125,7 +125,7 @@ static void
release_data (void *info, const void *data, size_t size)
{
assert (hb_blob_get_length ((hb_blob_t *) info) == size &&
hb_blob_get_data ((hb_blob_t *) info, NULL) == data);
hb_blob_get_data ((hb_blob_t *) info, nullptr) == data);
hb_blob_destroy ((hb_blob_t *) info);
}
@ -133,7 +133,7 @@ release_data (void *info, const void *data, size_t size)
static CGFontRef
create_cg_font (hb_face_t *face)
{
CGFontRef cg_font = NULL;
CGFontRef cg_font = nullptr;
if (face->destroy == _hb_cg_font_release)
{
cg_font = CGFontRetain ((CGFontRef) face->user_data);
@ -161,7 +161,7 @@ create_cg_font (hb_face_t *face)
static CTFontRef
create_ct_font (CGFontRef cg_font, CGFloat font_size)
{
CTFontRef ct_font = NULL;
CTFontRef ct_font = nullptr;
/* CoreText does not enable trak table usage / tracking when creating a CTFont
* using CTFontCreateWithGraphicsFont. The only way of enabling tracking seems
@ -174,23 +174,23 @@ create_ct_font (CGFontRef cg_font, CGFloat font_size)
if (CFStringHasSuffix (cg_postscript_name, CFSTR ("-Bold")))
font_type = kCTFontUIFontEmphasizedSystem;
ct_font = CTFontCreateUIFontForLanguage (font_type, font_size, NULL);
ct_font = CTFontCreateUIFontForLanguage (font_type, font_size, nullptr);
CFStringRef ct_result_name = CTFontCopyPostScriptName(ct_font);
if (CFStringCompare (ct_result_name, cg_postscript_name, 0) != kCFCompareEqualTo)
{
CFRelease(ct_font);
ct_font = NULL;
ct_font = nullptr;
}
CFRelease (ct_result_name);
}
CFRelease (cg_postscript_name);
if (!ct_font)
ct_font = CTFontCreateWithGraphicsFont (cg_font, font_size, NULL, NULL);
ct_font = CTFontCreateWithGraphicsFont (cg_font, font_size, nullptr, nullptr);
if (unlikely (!ct_font)) {
DEBUG_MSG (CORETEXT, cg_font, "Font CTFontCreateWithGraphicsFont() failed");
return NULL;
return nullptr;
}
/* crbug.com/576941 and crbug.com/625902 and the investigation in the latter
@ -200,7 +200,7 @@ create_ct_font (CGFontRef cg_font, CGFloat font_size)
* reconfiguring the cascade list causes CoreText crashes. For details, see
* crbug.com/549610 */
// 0x00070000 stands for "kCTVersionNumber10_10", see CoreText.h
if (&CTGetCoreTextVersion != NULL && CTGetCoreTextVersion() < 0x00070000) {
if (&CTGetCoreTextVersion != nullptr && CTGetCoreTextVersion() < 0x00070000) {
CFStringRef fontName = CTFontCopyPostScriptName (ct_font);
bool isEmojiFont = CFStringCompare (fontName, CFSTR("AppleColorEmoji"), 0) == kCFCompareEqualTo;
CFRelease (fontName);
@ -214,7 +214,7 @@ create_ct_font (CGFontRef cg_font, CGFloat font_size)
* font fallback which we don't need anyway. */
{
CTFontDescriptorRef last_resort_font_desc = get_last_resort_font_desc ();
CTFontRef new_ct_font = CTFontCreateCopyWithAttributes (ct_font, 0.0, NULL, last_resort_font_desc);
CTFontRef new_ct_font = CTFontCreateCopyWithAttributes (ct_font, 0.0, nullptr, last_resort_font_desc);
CFRelease (last_resort_font_desc);
if (new_ct_font)
{
@ -257,7 +257,7 @@ _hb_coretext_shaper_face_data_create (hb_face_t *face)
if (unlikely (!cg_font))
{
DEBUG_MSG (CORETEXT, face, "CGFont creation failed..");
return NULL;
return nullptr;
}
return (hb_coretext_shaper_face_data_t *) cg_font;
@ -275,7 +275,7 @@ _hb_coretext_shaper_face_data_destroy (hb_coretext_shaper_face_data_t *data)
CGFontRef
hb_coretext_face_get_cg_font (hb_face_t *face)
{
if (unlikely (!hb_coretext_shaper_face_data_ensure (face))) return NULL;
if (unlikely (!hb_coretext_shaper_face_data_ensure (face))) return nullptr;
return (CGFontRef) HB_SHAPER_DATA_GET (face);
}
@ -288,7 +288,7 @@ hb_coretext_shaper_font_data_t *
_hb_coretext_shaper_font_data_create (hb_font_t *font)
{
hb_face_t *face = font->face;
if (unlikely (!hb_coretext_shaper_face_data_ensure (face))) return NULL;
if (unlikely (!hb_coretext_shaper_face_data_ensure (face))) return nullptr;
CGFontRef cg_font = (CGFontRef) HB_SHAPER_DATA_GET (face);
CTFontRef ct_font = create_ct_font (cg_font, coretext_font_size (font->ptem));
@ -296,7 +296,7 @@ _hb_coretext_shaper_font_data_create (hb_font_t *font)
if (unlikely (!ct_font))
{
DEBUG_MSG (CORETEXT, font, "CGFont creation failed..");
return NULL;
return nullptr;
}
return (hb_coretext_shaper_font_data_t *) ct_font;
@ -333,7 +333,7 @@ _hb_coretext_shaper_shape_plan_data_destroy (hb_coretext_shaper_shape_plan_data_
CTFontRef
hb_coretext_font_get_ct_font (hb_font_t *font)
{
if (unlikely (!hb_coretext_shaper_font_data_ensure (font))) return NULL;
if (unlikely (!hb_coretext_shaper_font_data_ensure (font))) return nullptr;
return (CTFontRef)HB_SHAPER_DATA_GET (font);
}
@ -678,7 +678,7 @@ _hb_coretext_shape (hb_shape_plan_t *shape_plan,
CFNumberCreate (kCFAllocatorDefault, kCFNumberIntType, &active_features[j].rec.feature),
CFNumberCreate (kCFAllocatorDefault, kCFNumberIntType, &active_features[j].rec.setting)
};
ASSERT_STATIC (ARRAY_LENGTH (keys) == ARRAY_LENGTH (values));
static_assert ((ARRAY_LENGTH_CONST (keys) == ARRAY_LENGTH_CONST (values)), "");
CFDictionaryRef dict = CFDictionaryCreate (kCFAllocatorDefault,
(const void **) keys,
(const void **) values,
@ -704,12 +704,12 @@ _hb_coretext_shape (hb_shape_plan_t *shape_plan,
CTFontDescriptorRef font_desc = CTFontDescriptorCreateWithAttributes (attributes);
CFRelease (attributes);
range->font = CTFontCreateCopyWithAttributes (ct_font, 0.0, NULL, font_desc);
range->font = CTFontCreateCopyWithAttributes (ct_font, 0.0, nullptr, font_desc);
CFRelease (font_desc);
}
else
{
range->font = NULL;
range->font = nullptr;
}
range->index_first = last_index;
@ -779,14 +779,14 @@ _hb_coretext_shape (hb_shape_plan_t *shape_plan,
#define FAIL(...) \
HB_STMT_START { \
DEBUG_MSG (CORETEXT, NULL, __VA_ARGS__); \
DEBUG_MSG (CORETEXT, nullptr, __VA_ARGS__); \
ret = false; \
goto fail; \
} HB_STMT_END;
bool ret = true;
CFStringRef string_ref = NULL;
CTLineRef line = NULL;
CFStringRef string_ref = nullptr;
CTLineRef line = nullptr;
if (0)
{
@ -798,8 +798,8 @@ resize_and_retry:
assert (line);
CFRelease (string_ref);
CFRelease (line);
string_ref = NULL;
line = NULL;
string_ref = nullptr;
line = nullptr;
/* Get previous start-of-scratch-area, that we use later for readjusting
* our existing scratch arrays. */
@ -820,7 +820,7 @@ resize_and_retry:
scratch_size -= old_scratch_used;
}
{
string_ref = CFStringCreateWithCharactersNoCopy (NULL,
string_ref = CFStringCreateWithCharactersNoCopy (nullptr,
pchars, chars_len,
kCFAllocatorNull);
if (unlikely (!string_ref))
@ -937,7 +937,7 @@ resize_and_retry:
CFArrayRef glyph_runs = CTLineGetGlyphRuns (line);
unsigned int num_runs = CFArrayGetCount (glyph_runs);
DEBUG_MSG (CORETEXT, NULL, "Num runs: %d", num_runs);
DEBUG_MSG (CORETEXT, nullptr, "Num runs: %d", num_runs);
buffer->len = 0;
uint32_t status_and = ~0, status_or = 0;
@ -963,7 +963,7 @@ resize_and_retry:
status_or |= run_status;
status_and &= run_status;
DEBUG_MSG (CORETEXT, run, "CTRunStatus: %x", run_status);
double run_advance = CTRunGetTypographicBounds (run, range_all, NULL, NULL, NULL);
double run_advance = CTRunGetTypographicBounds (run, range_all, nullptr, nullptr, nullptr);
if (HB_DIRECTION_IS_VERTICAL (buffer->props.direction))
run_advance = -run_advance;
DEBUG_MSG (CORETEXT, run, "Run advance: %g", run_advance);
@ -1089,7 +1089,7 @@ resize_and_retry:
/* Testing used to indicate that CTRunGetGlyphsPtr, etc (almost?) always
* succeed, and so copying data to our own buffer will be rare. Reports
* have it that this changed in OS X 10.10 Yosemite, and NULL is returned
* have it that this changed in OS X 10.10 Yosemite, and nullptr is returned
* frequently. At any rate, we can test that codepath by setting USE_PTR
* to false. */
@ -1105,13 +1105,13 @@ resize_and_retry:
{ /* Setup glyphs */
SCRATCH_SAVE();
const CGGlyph* glyphs = USE_PTR ? CTRunGetGlyphsPtr (run) : NULL;
const CGGlyph* glyphs = USE_PTR ? CTRunGetGlyphsPtr (run) : nullptr;
if (!glyphs) {
ALLOCATE_ARRAY (CGGlyph, glyph_buf, num_glyphs, goto resize_and_retry);
CTRunGetGlyphs (run, range_all, glyph_buf);
glyphs = glyph_buf;
}
const CFIndex* string_indices = USE_PTR ? CTRunGetStringIndicesPtr (run) : NULL;
const CFIndex* string_indices = USE_PTR ? CTRunGetStringIndicesPtr (run) : nullptr;
if (!string_indices) {
ALLOCATE_ARRAY (CFIndex, index_buf, num_glyphs, goto resize_and_retry);
CTRunGetStringIndices (run, range_all, index_buf);
@ -1133,7 +1133,7 @@ resize_and_retry:
* advance (in the advance direction only), and for last glyph we set
* whatever is needed to make the whole run's advance add up. */
SCRATCH_SAVE();
const CGPoint* positions = USE_PTR ? CTRunGetPositionsPtr (run) : NULL;
const CGPoint* positions = USE_PTR ? CTRunGetPositionsPtr (run) : nullptr;
if (!positions) {
ALLOCATE_ARRAY (CGPoint, position_buf, num_glyphs, goto resize_and_retry);
CTRunGetPositions (run, range_all, position_buf);
@ -1300,12 +1300,12 @@ _hb_coretext_aat_shaper_face_data_create (hb_face_t *face)
if (hb_blob_get_length (blob))
{
hb_blob_destroy (blob);
return hb_coretext_shaper_face_data_ensure (face) ? (hb_coretext_aat_shaper_face_data_t *) HB_SHAPER_DATA_SUCCEEDED : NULL;
return hb_coretext_shaper_face_data_ensure (face) ? (hb_coretext_aat_shaper_face_data_t *) HB_SHAPER_DATA_SUCCEEDED : nullptr;
}
hb_blob_destroy (blob);
}
return NULL;
return nullptr;
}
void
@ -1323,7 +1323,7 @@ struct hb_coretext_aat_shaper_font_data_t {};
hb_coretext_aat_shaper_font_data_t *
_hb_coretext_aat_shaper_font_data_create (hb_font_t *font)
{
return hb_coretext_shaper_font_data_ensure (font) ? (hb_coretext_aat_shaper_font_data_t *) HB_SHAPER_DATA_SUCCEEDED : NULL;
return hb_coretext_shaper_font_data_ensure (font) ? (hb_coretext_aat_shaper_font_data_t *) HB_SHAPER_DATA_SUCCEEDED : nullptr;
}
void

4
gfx/harfbuzz/src/hb-deprecated.h
Просмотреть файл

@ -34,6 +34,7 @@
#include "hb-common.h"
#include "hb-unicode.h"
#include "hb-font.h"
#include "hb-set.h"
HB_BEGIN_DECLS
@ -54,6 +55,9 @@ 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 void
hb_set_invert (hb_set_t *set);
#endif
HB_END_DECLS

28
gfx/harfbuzz/src/hb-directwrite.cc
Просмотреть файл

@ -140,7 +140,7 @@ _hb_directwrite_shaper_face_data_create(hb_face_t *face)
hb_directwrite_shaper_face_data_t *data =
(hb_directwrite_shaper_face_data_t *) malloc (sizeof (hb_directwrite_shaper_face_data_t));
if (unlikely (!data))
return NULL;
return nullptr;
// TODO: factory and fontFileLoader should be cached separately
IDWriteFactory* dwriteFactory;
@ -153,7 +153,7 @@ _hb_directwrite_shaper_face_data_create(hb_face_t *face)
HRESULT hr;
hb_blob_t *blob = hb_face_reference_blob (face);
IDWriteFontFileStream *fontFileStream = new DWriteFontFileStream (
(uint8_t*) hb_blob_get_data (blob, NULL), hb_blob_get_length (blob));
(uint8_t*) hb_blob_get_data (blob, nullptr), hb_blob_get_length (blob));
IDWriteFontFileLoader *fontFileLoader = new DWriteFontFileLoader (fontFileStream);
dwriteFactory->RegisterFontFileLoader (fontFileLoader);
@ -165,7 +165,7 @@ _hb_directwrite_shaper_face_data_create(hb_face_t *face)
#define FAIL(...) \
HB_STMT_START { \
DEBUG_MSG (DIRECTWRITE, NULL, __VA_ARGS__); \
DEBUG_MSG (DIRECTWRITE, nullptr, __VA_ARGS__); \
return false; \
} HB_STMT_END;
@ -233,12 +233,12 @@ struct hb_directwrite_shaper_font_data_t {
hb_directwrite_shaper_font_data_t *
_hb_directwrite_shaper_font_data_create (hb_font_t *font)
{
if (unlikely (!hb_directwrite_shaper_face_data_ensure (font->face))) return NULL;
if (unlikely (!hb_directwrite_shaper_face_data_ensure (font->face))) return nullptr;
hb_directwrite_shaper_font_data_t *data =
(hb_directwrite_shaper_font_data_t *) malloc (sizeof (hb_directwrite_shaper_font_data_t));
if (unlikely (!data))
return NULL;
return nullptr;
return data;
}
@ -313,7 +313,7 @@ public:
, mTextLength(textLength)
, mLocaleName(localeName)
, mReadingDirection(readingDirection)
, mCurrentRun(NULL) { };
, mCurrentRun(nullptr) { };
~TextAnalysis() {
// delete runs, except mRunHead which is part of the TextAnalysis object
@ -337,7 +337,7 @@ public:
mRunHead.mTextLength = mTextLength;
mRunHead.mBidiLevel =
(mReadingDirection == DWRITE_READING_DIRECTION_RIGHT_TO_LEFT);
mRunHead.nextRun = NULL;
mRunHead.nextRun = nullptr;
mCurrentRun = &mRunHead;
// Call each of the analyzers in sequence, recording their results.
@ -356,7 +356,7 @@ public:
{
if (textPosition >= mTextLength) {
// No text at this position, valid query though.
*textString = NULL;
*textString = nullptr;
*textLength = 0;
}
else {
@ -373,7 +373,7 @@ public:
if (textPosition == 0 || textPosition > mTextLength) {
// Either there is no text before here (== 0), or this
// is an invalid position. The query is considered valid thouh.
*textString = NULL;
*textString = nullptr;
*textLength = 0;
}
else {
@ -399,7 +399,7 @@ public:
OUT IDWriteNumberSubstitution** numberSubstitution)
{
// We do not support number substitution.
*numberSubstitution = NULL;
*numberSubstitution = nullptr;
*textLength = mTextLength - textPosition;
return S_OK;
@ -617,14 +617,14 @@ _hb_directwrite_shape_full(hb_shape_plan_t *shape_plan,
*/
uint32_t textLength = buffer->len;
TextAnalysis analysis(textString, textLength, NULL, readingDirection);
TextAnalysis analysis(textString, textLength, nullptr, readingDirection);
TextAnalysis::Run *runHead;
HRESULT hr;
hr = analysis.GenerateResults(analyzer, &runHead);
#define FAIL(...) \
HB_STMT_START { \
DEBUG_MSG (DIRECTWRITE, NULL, __VA_ARGS__); \
DEBUG_MSG (DIRECTWRITE, nullptr, __VA_ARGS__); \
return false; \
} HB_STMT_END;
@ -639,7 +639,7 @@ _hb_directwrite_shape_full(hb_shape_plan_t *shape_plan,
bool isRightToLeft = HB_DIRECTION_IS_BACKWARD (buffer->props.direction);
const wchar_t localeName[20] = {0};
if (buffer->props.language != NULL)
if (buffer->props.language != nullptr)
{
mbstowcs ((wchar_t*) localeName,
hb_language_to_string (buffer->props.language), 20);
@ -672,7 +672,7 @@ retry_getglyphs:
malloc (maxGlyphCount * sizeof (DWRITE_SHAPING_GLYPH_PROPERTIES));
hr = analyzer->GetGlyphs (textString, textLength, fontFace, false,
isRightToLeft, &runHead->mScript, localeName, NULL, &dwFeatures,
isRightToLeft, &runHead->mScript, localeName, nullptr, &dwFeatures,
featureRangeLengths, 1, maxGlyphCount, clusterMap, textProperties, glyphIndices,
glyphProperties, &glyphCount);

10
gfx/harfbuzz/src/hb-face.cc
Просмотреть файл

@ -43,9 +43,9 @@ const hb_face_t _hb_face_nil = {
true, /* immutable */
NULL, /* reference_table_func */
NULL, /* user_data */
NULL, /* destroy */
nullptr, /* reference_table_func */
nullptr, /* user_data */
nullptr, /* destroy */
0, /* index */
1000, /* upem */
@ -57,7 +57,7 @@ const hb_face_t _hb_face_nil = {
#undef HB_SHAPER_IMPLEMENT
},
NULL, /* shape_plans */
nullptr, /* shape_plans */
};
@ -109,7 +109,7 @@ _hb_face_for_data_closure_create (hb_blob_t *blob, unsigned int index)
closure = (hb_face_for_data_closure_t *) calloc (1, sizeof (hb_face_for_data_closure_t));
if (unlikely (!closure))
return NULL;
return nullptr;
closure->blob = blob;
closure->index = index;

36
gfx/harfbuzz/src/hb-font.cc
Просмотреть файл

@ -36,7 +36,7 @@
*/
static hb_bool_t
hb_font_get_font_h_extents_nil (hb_font_t *font,
hb_font_get_font_h_extents_nil (hb_font_t *font HB_UNUSED,
void *font_data HB_UNUSED,
hb_font_extents_t *metrics,
void *user_data HB_UNUSED)
@ -60,7 +60,7 @@ hb_font_get_font_h_extents_parent (hb_font_t *font,
}
static hb_bool_t
hb_font_get_font_v_extents_nil (hb_font_t *font,
hb_font_get_font_v_extents_nil (hb_font_t *font HB_UNUSED,
void *font_data HB_UNUSED,
hb_font_extents_t *metrics,
void *user_data HB_UNUSED)
@ -347,12 +347,12 @@ static const hb_font_funcs_t _hb_font_funcs_nil = {
true, /* immutable */
{
#define HB_FONT_FUNC_IMPLEMENT(name) NULL,
#define HB_FONT_FUNC_IMPLEMENT(name) nullptr,
HB_FONT_FUNCS_IMPLEMENT_CALLBACKS
#undef HB_FONT_FUNC_IMPLEMENT
},
{
#define HB_FONT_FUNC_IMPLEMENT(name) NULL,
#define HB_FONT_FUNC_IMPLEMENT(name) nullptr,
HB_FONT_FUNCS_IMPLEMENT_CALLBACKS
#undef HB_FONT_FUNC_IMPLEMENT
},
@ -370,12 +370,12 @@ static const hb_font_funcs_t _hb_font_funcs_parent = {
true, /* immutable */
{
#define HB_FONT_FUNC_IMPLEMENT(name) NULL,
#define HB_FONT_FUNC_IMPLEMENT(name) nullptr,
HB_FONT_FUNCS_IMPLEMENT_CALLBACKS
#undef HB_FONT_FUNC_IMPLEMENT
},
{
#define HB_FONT_FUNC_IMPLEMENT(name) NULL,
#define HB_FONT_FUNC_IMPLEMENT(name) nullptr,
HB_FONT_FUNCS_IMPLEMENT_CALLBACKS
#undef HB_FONT_FUNC_IMPLEMENT
},
@ -563,8 +563,8 @@ hb_font_funcs_set_##name##_func (hb_font_funcs_t *ffuncs, \
ffuncs->destroy.name = destroy; \
} else { \
ffuncs->get.f.name = hb_font_get_##name##_parent; \
ffuncs->user_data.name = NULL; \
ffuncs->destroy.name = NULL; \
ffuncs->user_data.name = nullptr; \
ffuncs->destroy.name = nullptr; \
} \
}
@ -1161,7 +1161,7 @@ hb_font_create_sub_font (hb_font_t *parent)
font->num_coords = parent->num_coords;
if (!font->num_coords)
font->coords = NULL;
font->coords = nullptr;
else
{
unsigned int size = parent->num_coords * sizeof (parent->coords[0]);
@ -1192,7 +1192,7 @@ hb_font_get_empty (void)
true, /* immutable */
NULL, /* parent */
nullptr, /* parent */
const_cast<hb_face_t *> (&_hb_face_nil),
1000, /* x_scale */
@ -1203,11 +1203,11 @@ hb_font_get_empty (void)
0, /* ptem */
0, /* num_coords */
NULL, /* coords */
nullptr, /* coords */
const_cast<hb_font_funcs_t *> (&_hb_font_funcs_nil), /* klass */
NULL, /* user_data */
NULL, /* destroy */
nullptr, /* user_data */
nullptr, /* destroy */
{
#define HB_SHAPER_IMPLEMENT(shaper) HB_SHAPER_DATA_INVALID,
@ -1639,13 +1639,13 @@ hb_font_set_variations (hb_font_t *font,
if (!variations_length)
{
hb_font_set_var_coords_normalized (font, NULL, 0);
hb_font_set_var_coords_normalized (font, nullptr, 0);
return;
}
unsigned int coords_length = hb_ot_var_get_axis_count (font->face);
int *normalized = coords_length ? (int *) calloc (coords_length, sizeof (int)) : NULL;
int *normalized = coords_length ? (int *) calloc (coords_length, sizeof (int)) : nullptr;
if (unlikely (coords_length && !normalized))
return;
@ -1668,7 +1668,7 @@ hb_font_set_var_coords_design (hb_font_t *font,
if (font->immutable)
return;
int *normalized = coords_length ? (int *) calloc (coords_length, sizeof (int)) : NULL;
int *normalized = coords_length ? (int *) calloc (coords_length, sizeof (int)) : nullptr;
if (unlikely (coords_length && !normalized))
return;
@ -1689,7 +1689,7 @@ hb_font_set_var_coords_normalized (hb_font_t *font,
if (font->immutable)
return;
int *copy = coords_length ? (int *) calloc (coords_length, sizeof (coords[0])) : NULL;
int *copy = coords_length ? (int *) calloc (coords_length, sizeof (coords[0])) : nullptr;
if (unlikely (coords_length && !copy))
return;
@ -1749,7 +1749,7 @@ trampoline_create (FuncType func,
trampoline_t *trampoline = (trampoline_t *) calloc (1, sizeof (trampoline_t));
if (unlikely (!trampoline))
return NULL;
return nullptr;
trampoline->closure.user_data = user_data;
trampoline->closure.destroy = destroy;

58
gfx/harfbuzz/src/hb-ft.cc
Просмотреть файл

@ -33,8 +33,6 @@
#include "hb-font-private.hh"
#include "hb-cache-private.hh" // Maybe use in the future?
#include FT_ADVANCES_H
#include FT_MULTIPLE_MASTERS_H
#include FT_TRUETYPE_TABLES_H
@ -83,7 +81,7 @@ _hb_ft_font_create (FT_Face ft_face, bool symbol, bool unref)
hb_ft_font_t *ft_font = (hb_ft_font_t *) calloc (1, sizeof (hb_ft_font_t));
if (unlikely (!ft_font))
return NULL;
return nullptr;
ft_font->ft_face = ft_face;
ft_font->symbol = symbol;
@ -158,7 +156,7 @@ FT_Face
hb_ft_font_get_face (hb_font_t *font)
{
if (font->destroy != _hb_ft_font_destroy)
return NULL;
return nullptr;
const hb_ft_font_t *ft_font = (const hb_ft_font_t *) font->user_data;
@ -424,7 +422,7 @@ hb_ft_get_font_h_extents (hb_font_t *font HB_UNUSED,
return true;
}
static hb_font_funcs_t *static_ft_funcs = NULL;
static hb_font_funcs_t *static_ft_funcs = nullptr;
#ifdef HB_USE_ATEXIT
static
@ -444,24 +442,24 @@ retry:
{
funcs = hb_font_funcs_create ();
hb_font_funcs_set_font_h_extents_func (funcs, hb_ft_get_font_h_extents, NULL, NULL);
//hb_font_funcs_set_font_v_extents_func (funcs, hb_ft_get_font_v_extents, NULL, NULL);
hb_font_funcs_set_nominal_glyph_func (funcs, hb_ft_get_nominal_glyph, NULL, NULL);
hb_font_funcs_set_variation_glyph_func (funcs, hb_ft_get_variation_glyph, NULL, NULL);
hb_font_funcs_set_glyph_h_advance_func (funcs, hb_ft_get_glyph_h_advance, NULL, NULL);
hb_font_funcs_set_glyph_v_advance_func (funcs, hb_ft_get_glyph_v_advance, NULL, NULL);
//hb_font_funcs_set_glyph_h_origin_func (funcs, hb_ft_get_glyph_h_origin, NULL, NULL);
hb_font_funcs_set_glyph_v_origin_func (funcs, hb_ft_get_glyph_v_origin, NULL, NULL);
hb_font_funcs_set_glyph_h_kerning_func (funcs, hb_ft_get_glyph_h_kerning, NULL, NULL);
//hb_font_funcs_set_glyph_v_kerning_func (funcs, hb_ft_get_glyph_v_kerning, NULL, NULL);
hb_font_funcs_set_glyph_extents_func (funcs, hb_ft_get_glyph_extents, NULL, NULL);
hb_font_funcs_set_glyph_contour_point_func (funcs, hb_ft_get_glyph_contour_point, NULL, NULL);
hb_font_funcs_set_glyph_name_func (funcs, hb_ft_get_glyph_name, NULL, NULL);
hb_font_funcs_set_glyph_from_name_func (funcs, hb_ft_get_glyph_from_name, NULL, NULL);
hb_font_funcs_set_font_h_extents_func (funcs, hb_ft_get_font_h_extents, nullptr, nullptr);
//hb_font_funcs_set_font_v_extents_func (funcs, hb_ft_get_font_v_extents, nullptr, nullptr);
hb_font_funcs_set_nominal_glyph_func (funcs, hb_ft_get_nominal_glyph, nullptr, nullptr);
hb_font_funcs_set_variation_glyph_func (funcs, hb_ft_get_variation_glyph, nullptr, nullptr);
hb_font_funcs_set_glyph_h_advance_func (funcs, hb_ft_get_glyph_h_advance, nullptr, nullptr);
hb_font_funcs_set_glyph_v_advance_func (funcs, hb_ft_get_glyph_v_advance, nullptr, nullptr);
//hb_font_funcs_set_glyph_h_origin_func (funcs, hb_ft_get_glyph_h_origin, nullptr, nullptr);
hb_font_funcs_set_glyph_v_origin_func (funcs, hb_ft_get_glyph_v_origin, nullptr, nullptr);
hb_font_funcs_set_glyph_h_kerning_func (funcs, hb_ft_get_glyph_h_kerning, nullptr, nullptr);
//hb_font_funcs_set_glyph_v_kerning_func (funcs, hb_ft_get_glyph_v_kerning, nullptr, nullptr);
hb_font_funcs_set_glyph_extents_func (funcs, hb_ft_get_glyph_extents, nullptr, nullptr);
hb_font_funcs_set_glyph_contour_point_func (funcs, hb_ft_get_glyph_contour_point, nullptr, nullptr);
hb_font_funcs_set_glyph_name_func (funcs, hb_ft_get_glyph_name, nullptr, nullptr);
hb_font_funcs_set_glyph_from_name_func (funcs, hb_ft_get_glyph_from_name, nullptr, nullptr);
hb_font_funcs_make_immutable (funcs);
if (!hb_atomic_ptr_cmpexch (&static_ft_funcs, NULL, funcs)) {
if (!hb_atomic_ptr_cmpexch (&static_ft_funcs, nullptr, funcs)) {
hb_font_funcs_destroy (funcs);
goto retry;
}
@ -490,17 +488,17 @@ reference_table (hb_face_t *face HB_UNUSED, hb_tag_t tag, void *user_data)
/* Note: FreeType like HarfBuzz uses the NONE tag for fetching the entire blob */
error = FT_Load_Sfnt_Table (ft_face, tag, 0, NULL, &length);
error = FT_Load_Sfnt_Table (ft_face, tag, 0, nullptr, &length);
if (error)
return NULL;
return nullptr;
buffer = (FT_Byte *) malloc (length);
if (!buffer)
return NULL;
return nullptr;
error = FT_Load_Sfnt_Table (ft_face, tag, 0, buffer, &length);
if (error)
return NULL;
return nullptr;
return hb_blob_create ((const char *) buffer, length,
HB_MEMORY_MODE_WRITABLE,
@ -581,7 +579,7 @@ hb_ft_face_create_cached (FT_Face ft_face)
if (ft_face->generic.finalizer)
ft_face->generic.finalizer (ft_face);
ft_face->generic.data = hb_ft_face_create (ft_face, NULL);
ft_face->generic.data = hb_ft_face_create (ft_face, nullptr);
ft_face->generic.finalizer = (FT_Generic_Finalizer) hb_ft_face_finalize;
}
@ -633,7 +631,7 @@ hb_ft_font_changed (hb_font_t *font)
#endif
#ifdef HAVE_FT_GET_VAR_BLEND_COORDINATES
FT_MM_Var *mm_var = NULL;
FT_MM_Var *mm_var = nullptr;
if (!FT_Get_MM_Var (ft_face, &mm_var))
{
FT_Fixed *ft_coords = (FT_Fixed *) calloc (mm_var->num_axis, sizeof (FT_Fixed));
@ -694,9 +692,9 @@ retry:
{
/* Not found; allocate one. */
if (FT_Init_FreeType (&library))
return NULL;
return nullptr;
if (!hb_atomic_ptr_cmpexch (&ft_library, NULL, library)) {
if (!hb_atomic_ptr_cmpexch (&ft_library, nullptr, library)) {
FT_Done_FreeType (library);
goto retry;
}
@ -724,7 +722,7 @@ hb_ft_font_set_funcs (hb_font_t *font)
if (unlikely (!blob_length))
DEBUG_MSG (FT, font, "Font face has empty blob");
FT_Face ft_face = NULL;
FT_Face ft_face = nullptr;
FT_Error err = FT_New_Memory_Face (get_ft_library (),
(const FT_Byte *) blob_data,
blob_length,
@ -751,7 +749,7 @@ hb_ft_font_set_funcs (hb_font_t *font)
{
FT_Matrix matrix = { font->x_scale < 0 ? -1 : +1, 0,
0, font->y_scale < 0 ? -1 : +1};
FT_Set_Transform (ft_face, &matrix, NULL);
FT_Set_Transform (ft_face, &matrix, nullptr);
}
unsigned int num_coords;

2
gfx/harfbuzz/src/hb-glib.cc
Просмотреть файл

@ -370,7 +370,7 @@ hb_glib_get_unicode_funcs (void)
static const hb_unicode_funcs_t _hb_glib_unicode_funcs = {
HB_OBJECT_HEADER_STATIC,
NULL, /* parent */
nullptr, /* parent */
true, /* immutable */
{
#define HB_UNICODE_FUNC_IMPLEMENT(name) hb_glib_unicode_##name,

2
gfx/harfbuzz/src/hb-gobject-structs.cc
Просмотреть файл

@ -58,7 +58,7 @@ hb_gobject_##name##_get_type (void) \
static hb_##name##_t *_hb_##name##_reference (const hb_##name##_t *l) \
{ \
hb_##name##_t *c = (hb_##name##_t *) calloc (1, sizeof (hb_##name##_t)); \
if (unlikely (!c)) return NULL; \
if (unlikely (!c)) return nullptr; \
*c = *l; \
return c; \
} \

26
gfx/harfbuzz/src/hb-graphite2.cc
Просмотреть файл

@ -59,7 +59,7 @@ static const void *hb_graphite2_get_table (const void *data, unsigned int tag, s
hb_graphite2_shaper_face_data_t *face_data = (hb_graphite2_shaper_face_data_t *) data;
hb_graphite2_tablelist_t *tlist = face_data->tlist;
hb_blob_t *blob = NULL;
hb_blob_t *blob = nullptr;
for (hb_graphite2_tablelist_t *p = tlist; p; p = p->next)
if (p->tag == tag) {
@ -74,7 +74,7 @@ static const void *hb_graphite2_get_table (const void *data, unsigned int tag, s
hb_graphite2_tablelist_t *p = (hb_graphite2_tablelist_t *) calloc (1, sizeof (hb_graphite2_tablelist_t));
if (unlikely (!p)) {
hb_blob_destroy (blob);
return NULL;
return nullptr;
}
p->blob = blob;
p->tag = tag;
@ -100,20 +100,20 @@ _hb_graphite2_shaper_face_data_create (hb_face_t *face)
if (!hb_blob_get_length (silf_blob))
{
hb_blob_destroy (silf_blob);
return NULL;
return nullptr;
}
hb_blob_destroy (silf_blob);
hb_graphite2_shaper_face_data_t *data = (hb_graphite2_shaper_face_data_t *) calloc (1, sizeof (hb_graphite2_shaper_face_data_t));
if (unlikely (!data))
return NULL;
return nullptr;
data->face = face;
data->grface = gr_make_face (data, &hb_graphite2_get_table, gr_face_preloadAll);
if (unlikely (!data->grface)) {
free (data);
return NULL;
return nullptr;
}
return data;
@ -143,7 +143,7 @@ _hb_graphite2_shaper_face_data_destroy (hb_graphite2_shaper_face_data_t *data)
gr_face *
hb_graphite2_face_get_gr_face (hb_face_t *face)
{
if (unlikely (!hb_graphite2_shaper_face_data_ensure (face))) return NULL;
if (unlikely (!hb_graphite2_shaper_face_data_ensure (face))) return nullptr;
return HB_SHAPER_DATA_GET (face)->grface;
}
@ -171,7 +171,7 @@ _hb_graphite2_shaper_font_data_destroy (hb_graphite2_shaper_font_data_t *data HB
gr_font *
hb_graphite2_font_get_gr_font (hb_font_t *font)
{
return NULL;
return nullptr;
}
@ -221,7 +221,7 @@ _hb_graphite2_shape (hb_shape_plan_t *shape_plan,
gr_face *grface = HB_SHAPER_DATA_GET (face)->grface;
const char *lang = hb_language_to_string (hb_buffer_get_language (buffer));
const char *lang_end = lang ? strchr (lang, '-') : NULL;
const char *lang_end = lang ? strchr (lang, '-') : nullptr;
int lang_len = lang_end ? lang_end - lang : -1;
gr_feature_val *feats = gr_face_featureval_for_lang (grface, lang ? hb_tag_from_string (lang, lang_len) : 0);
@ -232,7 +232,7 @@ _hb_graphite2_shape (hb_shape_plan_t *shape_plan,
gr_fref_set_feature_value (fref, features[i].value, feats);
}
gr_segment *seg = NULL;
gr_segment *seg = nullptr;
const gr_slot *is;
unsigned int ci = 0, ic = 0;
float curradvx = 0., curradvy = 0.;
@ -250,7 +250,7 @@ _hb_graphite2_shape (hb_shape_plan_t *shape_plan,
hb_tag_t script_tag[2];
hb_ot_tags_from_script (hb_buffer_get_script (buffer), &script_tag[0], &script_tag[1]);
seg = gr_make_seg (NULL, grface,
seg = gr_make_seg (nullptr, grface,
script_tag[1] == HB_TAG_NONE ? script_tag[0] : script_tag[1],
feats,
gr_utf32, chars, buffer->len,
@ -368,7 +368,7 @@ _hb_graphite2_shape (hb_shape_plan_t *shape_plan,
/* Positioning. */
unsigned int currclus = (unsigned int) -1;
const hb_glyph_info_t *info = buffer->info;
hb_glyph_position_t *pPos = hb_buffer_get_glyph_positions (buffer, NULL);
hb_glyph_position_t *pPos = hb_buffer_get_glyph_positions (buffer, nullptr);
if (!HB_DIRECTION_IS_BACKWARD(buffer->props.direction))
{
curradvx = 0;
@ -383,7 +383,7 @@ _hb_graphite2_shape (hb_shape_plan_t *shape_plan,
} else
pPos->x_advance = 0.;
pPos->y_advance = gr_slot_advance_Y (is, grface, NULL) * yscale;
pPos->y_advance = gr_slot_advance_Y (is, grface, nullptr) * yscale;
curradvy += pPos->y_advance;
}
}
@ -400,7 +400,7 @@ _hb_graphite2_shape (hb_shape_plan_t *shape_plan,
} else
pPos->x_advance = 0.;
pPos->y_advance = gr_slot_advance_Y (is, grface, NULL) * yscale;
pPos->y_advance = gr_slot_advance_Y (is, grface, nullptr) * yscale;
curradvy -= pPos->y_advance;
pPos->x_offset = (gr_slot_origin_X (is) - info->var1.i32) * xscale - curradvx + pPos->x_advance;
pPos->y_offset = gr_slot_origin_Y (is) * yscale - curradvy;

20
gfx/harfbuzz/src/hb-icu.cc
Просмотреть файл

@ -34,7 +34,7 @@
#include "hb-unicode-private.hh"
#include <unicode/uchar.h>
#include <unicode/unorm.h>
#include <unicode/unorm2.h>
#include <unicode/ustring.h>
#include <unicode/utf16.h>
#include <unicode/uversion.h>
@ -200,7 +200,7 @@ hb_icu_unicode_compose (hb_unicode_funcs_t *ufuncs HB_UNUSED,
if (err) return false;
icu_err = U_ZERO_ERROR;
len = unorm_normalize (utf16, len, UNORM_NFC, 0, normalized, ARRAY_LENGTH (normalized), &icu_err);
len = unorm2_normalize (unorm2_getNFCInstance (&icu_err), utf16, len, normalized, ARRAY_LENGTH (normalized), &icu_err);
if (U_FAILURE (icu_err))
return false;
if (u_countChar32 (normalized, len) == 1) {
@ -261,7 +261,7 @@ hb_icu_unicode_decompose (hb_unicode_funcs_t *ufuncs HB_UNUSED,
if (err) return false;
icu_err = U_ZERO_ERROR;
len = unorm_normalize (utf16, len, UNORM_NFD, 0, normalized, ARRAY_LENGTH (normalized), &icu_err);
len = unorm2_normalize (unorm2_getNFDInstance (&icu_err), utf16, len, normalized, ARRAY_LENGTH (normalized), &icu_err);
if (U_FAILURE (icu_err))
return false;
@ -281,7 +281,7 @@ hb_icu_unicode_decompose (hb_unicode_funcs_t *ufuncs HB_UNUSED,
* the second part :-(. */
UChar recomposed[20];
icu_err = U_ZERO_ERROR;
unorm_normalize (normalized, len, UNORM_NFC, 0, recomposed, ARRAY_LENGTH (recomposed), &icu_err);
unorm2_normalize (unorm2_getNFCInstance (&icu_err), normalized, len, recomposed, ARRAY_LENGTH (recomposed), &icu_err);
if (U_FAILURE (icu_err))
return false;
hb_codepoint_t c;
@ -297,7 +297,7 @@ hb_icu_unicode_decompose (hb_unicode_funcs_t *ufuncs HB_UNUSED,
U16_PREV_UNSAFE (normalized, len, *b); /* Changes len in-place. */
UChar recomposed[18 * 2];
icu_err = U_ZERO_ERROR;
len = unorm_normalize (normalized, len, UNORM_NFC, 0, recomposed, ARRAY_LENGTH (recomposed), &icu_err);
len = unorm2_normalize (unorm2_getNFCInstance (&icu_err), normalized, len, recomposed, ARRAY_LENGTH (recomposed), &icu_err);
if (U_FAILURE (icu_err))
return false;
/* We expect that recomposed has exactly one character now. */
@ -331,14 +331,14 @@ hb_icu_unicode_decompose_compatibility (hb_unicode_funcs_t *ufuncs HB_UNUSED,
/* Normalise the codepoint using NFKD mode. */
icu_err = U_ZERO_ERROR;
len = unorm_normalize (utf16, len, UNORM_NFKD, 0, normalized, ARRAY_LENGTH (normalized), &icu_err);
if (icu_err)
len = unorm2_normalize (unorm2_getNFKDInstance (&icu_err), utf16, len, normalized, ARRAY_LENGTH (normalized), &icu_err);
if (U_FAILURE (icu_err))
return 0;
/* Convert the decomposed form from UTF-16 to UTF-32. */
icu_err = U_ZERO_ERROR;
u_strToUTF32 ((UChar32*) decomposed, HB_UNICODE_MAX_DECOMPOSITION_LEN, &utf32_len, normalized, len, &icu_err);
if (icu_err)
if (U_FAILURE (icu_err))
return 0;
return utf32_len;
@ -351,7 +351,7 @@ hb_icu_get_unicode_funcs (void)
static const hb_unicode_funcs_t _hb_icu_unicode_funcs = {
HB_OBJECT_HEADER_STATIC,
NULL, /* parent */
nullptr, /* parent */
true, /* immutable */
{
#define HB_UNICODE_FUNC_IMPLEMENT(name) hb_icu_unicode_##name,
@ -364,7 +364,7 @@ hb_icu_get_unicode_funcs (void)
if (!hb_atomic_ptr_get (&normalizer)) {
UErrorCode icu_err = U_ZERO_ERROR;
/* We ignore failure in getNFCInstace(). */
(void) hb_atomic_ptr_cmpexch (&normalizer, NULL, unorm2_getNFCInstance (&icu_err));
(void) hb_atomic_ptr_cmpexch (&normalizer, nullptr, unorm2_getNFCInstance (&icu_err));
}
#endif
return const_cast<hb_unicode_funcs_t *> (&_hb_icu_unicode_funcs);

2
gfx/harfbuzz/src/hb-mutex-private.hh
Просмотреть файл

@ -68,7 +68,7 @@ typedef CRITICAL_SECTION hb_mutex_impl_t;
#include <pthread.h>
typedef pthread_mutex_t hb_mutex_impl_t;
#define HB_MUTEX_IMPL_INIT PTHREAD_MUTEX_INITIALIZER
#define hb_mutex_impl_init(M) pthread_mutex_init (M, NULL)
#define hb_mutex_impl_init(M) pthread_mutex_init (M, nullptr)
#define hb_mutex_impl_lock(M) pthread_mutex_lock (M)
#define hb_mutex_impl_unlock(M) pthread_mutex_unlock (M)
#define hb_mutex_impl_finish(M) pthread_mutex_destroy (M)

2
gfx/harfbuzz/src/hb-object-private.hh
Просмотреть файл

@ -193,7 +193,7 @@ static inline void *hb_object_get_user_data (Type *obj,
hb_user_data_key_t *key)
{
if (unlikely (!obj || hb_object_is_inert (obj)))
return NULL;
return nullptr;
assert (hb_object_is_valid (obj));
return obj->header.user_data.get (key);
}

41
gfx/harfbuzz/src/hb-open-type-private.hh
Просмотреть файл

@ -85,7 +85,7 @@ static inline Type& StructAfter(TObject &X)
#define _DEFINE_INSTANCE_ASSERTION1(_line, _assertion) \
inline void _instance_assertion_on_line_##_line (void) const \
{ \
ASSERT_STATIC (_assertion); \
static_assert ((_assertion), ""); \
ASSERT_INSTANCE_POD (*this); /* Make sure it's POD. */ \
}
# define _DEFINE_INSTANCE_ASSERTION0(_line, _assertion) _DEFINE_INSTANCE_ASSERTION1 (_line, _assertion)
@ -136,7 +136,7 @@ static const void *_NullPool[(256+8) / sizeof (void *)];
/* Generic nul-content Null objects. */
template <typename Type>
static inline const Type& Null (void) {
ASSERT_STATIC (sizeof (Type) <= sizeof (_NullPool));
static_assert ((sizeof (Type) <= sizeof (_NullPool)), "");
return *CastP<Type> (_NullPool);
}
@ -147,7 +147,7 @@ template <> \
/*static*/ inline const Type& Null<Type> (void) { \
return *CastP<Type> (_Null##Type); \
} /* The following line really exists such that we end in a place needing semicolon */ \
ASSERT_STATIC (Type::min_size + 1 <= sizeof (_Null##Type))
static_assert (Type::min_size + 1 <= sizeof (_Null##Type), "Null pool too small. Enlarge.")
/* Accessor macro. */
#define Null(Type) Null<Type>()
@ -192,9 +192,9 @@ struct hb_sanitize_context_t :
{
inline hb_sanitize_context_t (void) :
debug_depth (0),
start (NULL), end (NULL),
start (nullptr), end (nullptr),
writable (false), edit_count (0),
blob (NULL) {}
blob (nullptr) {}
inline const char *get_name (void) { return "SANITIZE"; }
template <typename T, typename F>
@ -214,7 +214,7 @@ struct hb_sanitize_context_t :
inline void start_processing (void)
{
this->start = hb_blob_get_data (this->blob, NULL);
this->start = hb_blob_get_data (this->blob, nullptr);
this->end = this->start + hb_blob_get_length (this->blob);
assert (this->start <= this->end); /* Must not overflow. */
this->edit_count = 0;
@ -233,8 +233,8 @@ struct hb_sanitize_context_t :
this->start, this->end, this->edit_count);
hb_blob_destroy (this->blob);
this->blob = NULL;
this->start = this->end = NULL;
this->blob = nullptr;
this->start = this->end = nullptr;
}
inline bool check_range (const void *base, unsigned int len) const
@ -349,7 +349,7 @@ struct Sanitizer
} else {
unsigned int edit_count = c->edit_count;
if (edit_count && !c->writable) {
c->start = hb_blob_get_data_writable (blob, NULL);
c->start = hb_blob_get_data_writable (blob, nullptr);
c->end = c->start + hb_blob_get_length (blob);
if (c->start) {
@ -374,7 +374,7 @@ struct Sanitizer
static const Type* lock_instance (hb_blob_t *blob) {
hb_blob_make_immutable (blob);
const char *base = hb_blob_get_data (blob, NULL);
const char *base = hb_blob_get_data (blob, nullptr);
return unlikely (!base) ? &Null(Type) : CastP<Type> (base);
}
};
@ -445,7 +445,7 @@ struct hb_serialize_context_t
{
if (unlikely (this->ran_out_of_room || this->end - this->head < ptrdiff_t (size))) {
this->ran_out_of_room = true;
return NULL;
return nullptr;
}
memset (this->head, 0, size);
char *ret = this->head;
@ -471,7 +471,7 @@ struct hb_serialize_context_t
{
unsigned int size = obj.get_size ();
Type *ret = this->allocate_size<Type> (size);
if (unlikely (!ret)) return NULL;
if (unlikely (!ret)) return nullptr;
memcpy (ret, obj, size);
return ret;
}
@ -481,7 +481,7 @@ struct hb_serialize_context_t
{
unsigned int size = obj.min_size;
assert (this->start <= (char *) &obj && (char *) &obj <= this->head && (char *) &obj + size >= this->head);
if (unlikely (!this->allocate_size<Type> (((char *) &obj) + size - this->head))) return NULL;
if (unlikely (!this->allocate_size<Type> (((char *) &obj) + size - this->head))) return nullptr;
return reinterpret_cast<Type *> (&obj);
}
@ -490,7 +490,7 @@ struct hb_serialize_context_t
{
unsigned int size = obj.get_size ();
assert (this->start < (char *) &obj && (char *) &obj <= this->head && (char *) &obj + size >= this->head);
if (unlikely (!this->allocate_size<Type> (((char *) &obj) + size - this->head))) return NULL;
if (unlikely (!this->allocate_size<Type> (((char *) &obj) + size - this->head))) return nullptr;
return reinterpret_cast<Type *> (&obj);
}
@ -1047,11 +1047,12 @@ struct SortedArrayOf : ArrayOf<Type, LenType>
inline int bsearch (const SearchType &x) const
{
/* Hand-coded bsearch here since this is in the hot inner loop. */
const Type *array = this->array;
int min = 0, max = (int) this->len - 1;
while (min <= max)
{
int mid = (min + max) / 2;
int c = this->array[mid].cmp (x);
int c = array[mid].cmp (x);
if (c < 0)
max = mid - 1;
else if (c > 0)
@ -1073,7 +1074,7 @@ struct hb_lazy_loader_t
inline void init (hb_face_t *face_)
{
face = face_;
instance = NULL;
instance = nullptr;
}
inline void fini (void)
@ -1096,7 +1097,7 @@ struct hb_lazy_loader_t
p = const_cast<T *> (&OT::Null(T));
else
p->init (face);
if (unlikely (!hb_atomic_ptr_cmpexch (const_cast<T **>(&instance), NULL, p)))
if (unlikely (!hb_atomic_ptr_cmpexch (const_cast<T **>(&instance), nullptr, p)))
{
if (p != &OT::Null(T))
p->fini ();
@ -1123,8 +1124,8 @@ struct hb_lazy_table_loader_t
inline void init (hb_face_t *face_)
{
face = face_;
instance = NULL;
blob = NULL;
instance = nullptr;
blob = nullptr;
}
inline void fini (void)
@ -1140,7 +1141,7 @@ struct hb_lazy_table_loader_t
{
hb_blob_t *blob_ = OT::Sanitizer<T>::sanitize (face->reference_table (T::tableTag));
p = const_cast<T *>(OT::Sanitizer<T>::lock_instance (blob_));
if (!hb_atomic_ptr_cmpexch (const_cast<T **>(&instance), NULL, p))
if (!hb_atomic_ptr_cmpexch (const_cast<T **>(&instance), nullptr, p))
{
hb_blob_destroy (blob_);
goto retry;

4
gfx/harfbuzz/src/hb-ot-cbdt-table.hh
Просмотреть файл

@ -245,7 +245,7 @@ struct IndexSubtableArray
return &indexSubtablesZ[i];
}
}
return NULL;
return nullptr;
}
protected:
@ -344,7 +344,7 @@ struct CBLC
}
}
return NULL;
return nullptr;
}
protected:

2
gfx/harfbuzz/src/hb-ot-cmap-table.hh
Просмотреть файл

@ -508,7 +508,7 @@ struct cmap
* unsorted subtable list. */
int result = encodingRecord./*bsearch*/lsearch (key);
if (result == -1 || !encodingRecord[result].subtable)
return NULL;
return nullptr;
return &(this+encodingRecord[result].subtable);
}

103
gfx/harfbuzz/src/hb-ot-font.cc
Просмотреть файл

@ -38,7 +38,7 @@
#include "hb-ot-hmtx-table.hh"
#include "hb-ot-os2-table.hh"
#include "hb-ot-var-hvar-table.hh"
//#include "hb-ot-post-table.hh"
#include "hb-ot-post-table.hh"
struct hb_ot_face_metrics_accelerator_t
@ -235,8 +235,8 @@ struct hb_ot_face_cbdt_accelerator_t
cbdt_len = hb_blob_get_length (cbdt_blob);
if (hb_blob_get_length (cblc_blob) == 0) {
cblc = NULL;
cbdt = NULL;
cblc = nullptr;
cbdt = nullptr;
return; /* Not a bitmap font. */
}
cblc = OT::Sanitizer<OT::CBLC>::lock_instance (cblc_blob);
@ -301,6 +301,40 @@ struct hb_ot_face_cbdt_accelerator_t
}
};
struct hb_ot_face_post_accelerator_t
{
hb_blob_t *post_blob;
unsigned int post_len;
const OT::post *post;
inline void init (hb_face_t *face)
{
this->post_blob = OT::Sanitizer<OT::post>::sanitize (face->reference_table (HB_OT_TAG_post));
this->post = OT::Sanitizer<OT::post>::lock_instance (this->post_blob);
this->post_len = hb_blob_get_length (this->post_blob);
}
inline void fini (void)
{
hb_blob_destroy (this->post_blob);
}
inline bool get_glyph_name (hb_codepoint_t glyph,
char *name, unsigned int size) const
{
return this->post->get_glyph_name (glyph, name, size, this->post_len);
}
inline bool get_glyph_from_name (const char *name, int len,
hb_codepoint_t *glyph) const
{
if (unlikely (!len))
return false;
return this->post->get_glyph_from_name (name, len, glyph, this->post_len);
}
};
typedef bool (*hb_cmap_get_glyph_func_t) (const void *obj,
hb_codepoint_t codepoint,
hb_codepoint_t *glyph);
@ -349,8 +383,8 @@ struct hb_ot_face_cmap_accelerator_t
{
this->blob = OT::Sanitizer<OT::cmap>::sanitize (face->reference_table (HB_OT_TAG_cmap));
const OT::cmap *cmap = OT::Sanitizer<OT::cmap>::lock_instance (this->blob);
const OT::CmapSubtable *subtable = NULL;
const OT::CmapSubtableFormat14 *subtable_uvs = NULL;
const OT::CmapSubtable *subtable = nullptr;
const OT::CmapSubtableFormat14 *subtable_uvs = nullptr;
bool symbol = false;
/* 32-bit subtables. */
@ -436,6 +470,7 @@ struct hb_ot_font_t
hb_ot_face_metrics_accelerator_t v_metrics;
OT::hb_lazy_loader_t<hb_ot_face_glyf_accelerator_t> glyf;
OT::hb_lazy_loader_t<hb_ot_face_cbdt_accelerator_t> cbdt;
OT::hb_lazy_loader_t<hb_ot_face_post_accelerator_t> post;
};
@ -445,7 +480,7 @@ _hb_ot_font_create (hb_face_t *face)
hb_ot_font_t *ot_font = (hb_ot_font_t *) calloc (1, sizeof (hb_ot_font_t));
if (unlikely (!ot_font))
return NULL;
return nullptr;
ot_font->cmap.init (face);
ot_font->h_metrics.init (face, HB_OT_TAG_hhea, HB_OT_TAG_hmtx, HB_OT_TAG_HVAR, HB_OT_TAG_os2);
@ -453,6 +488,7 @@ _hb_ot_font_create (hb_face_t *face)
ot_font->h_metrics.ascender - ot_font->h_metrics.descender); /* TODO Can we do this lazily? */
ot_font->glyf.init (face);
ot_font->cbdt.init (face);
ot_font->post.init (face);
return ot_font;
}
@ -467,6 +503,7 @@ _hb_ot_font_destroy (void *data)
ot_font->v_metrics.fini ();
ot_font->glyf.fini ();
ot_font->cbdt.fini ();
ot_font->post.fini ();
free (ot_font);
}
@ -535,6 +572,28 @@ hb_ot_get_glyph_extents (hb_font_t *font HB_UNUSED,
return ret;
}
static hb_bool_t
hb_ot_get_glyph_name (hb_font_t *font HB_UNUSED,
void *font_data,
hb_codepoint_t glyph,
char *name, unsigned int size,
void *user_data HB_UNUSED)
{
const hb_ot_font_t *ot_font = (const hb_ot_font_t *) font_data;
return ot_font->post->get_glyph_name (glyph, name, size);
}
static hb_bool_t
hb_ot_get_glyph_from_name (hb_font_t *font HB_UNUSED,
void *font_data,
const char *name, int len,
hb_codepoint_t *glyph,
void *user_data HB_UNUSED)
{
const hb_ot_font_t *ot_font = (const hb_ot_font_t *) font_data;
return ot_font->post->get_glyph_from_name (name, len, glyph);
}
static hb_bool_t
hb_ot_get_font_h_extents (hb_font_t *font HB_UNUSED,
void *font_data,
@ -563,7 +622,7 @@ hb_ot_get_font_v_extents (hb_font_t *font HB_UNUSED,
return ot_font->v_metrics.has_font_extents;
}
static hb_font_funcs_t *static_ot_funcs = NULL;
static hb_font_funcs_t *static_ot_funcs = nullptr;
#ifdef HB_USE_ATEXIT
static
@ -583,24 +642,24 @@ retry:
{
funcs = hb_font_funcs_create ();
hb_font_funcs_set_font_h_extents_func (funcs, hb_ot_get_font_h_extents, NULL, NULL);
hb_font_funcs_set_font_v_extents_func (funcs, hb_ot_get_font_v_extents, NULL, NULL);
hb_font_funcs_set_nominal_glyph_func (funcs, hb_ot_get_nominal_glyph, NULL, NULL);
hb_font_funcs_set_variation_glyph_func (funcs, hb_ot_get_variation_glyph, NULL, NULL);
hb_font_funcs_set_glyph_h_advance_func (funcs, hb_ot_get_glyph_h_advance, NULL, NULL);
hb_font_funcs_set_glyph_v_advance_func (funcs, hb_ot_get_glyph_v_advance, NULL, NULL);
//hb_font_funcs_set_glyph_h_origin_func (funcs, hb_ot_get_glyph_h_origin, NULL, NULL);
//hb_font_funcs_set_glyph_v_origin_func (funcs, hb_ot_get_glyph_v_origin, NULL, NULL);
//hb_font_funcs_set_glyph_h_kerning_func (funcs, hb_ot_get_glyph_h_kerning, NULL, NULL); TODO
//hb_font_funcs_set_glyph_v_kerning_func (funcs, hb_ot_get_glyph_v_kerning, NULL, NULL);
hb_font_funcs_set_glyph_extents_func (funcs, hb_ot_get_glyph_extents, NULL, NULL);
//hb_font_funcs_set_glyph_contour_point_func (funcs, hb_ot_get_glyph_contour_point, NULL, NULL); TODO
//hb_font_funcs_set_glyph_name_func (funcs, hb_ot_get_glyph_name, NULL, NULL); TODO
//hb_font_funcs_set_glyph_from_name_func (funcs, hb_ot_get_glyph_from_name, NULL, NULL); TODO
hb_font_funcs_set_font_h_extents_func (funcs, hb_ot_get_font_h_extents, nullptr, nullptr);
hb_font_funcs_set_font_v_extents_func (funcs, hb_ot_get_font_v_extents, nullptr, nullptr);
hb_font_funcs_set_nominal_glyph_func (funcs, hb_ot_get_nominal_glyph, nullptr, nullptr);
hb_font_funcs_set_variation_glyph_func (funcs, hb_ot_get_variation_glyph, nullptr, nullptr);
hb_font_funcs_set_glyph_h_advance_func (funcs, hb_ot_get_glyph_h_advance, nullptr, nullptr);
hb_font_funcs_set_glyph_v_advance_func (funcs, hb_ot_get_glyph_v_advance, nullptr, nullptr);
//hb_font_funcs_set_glyph_h_origin_func (funcs, hb_ot_get_glyph_h_origin, nullptr, nullptr);
//hb_font_funcs_set_glyph_v_origin_func (funcs, hb_ot_get_glyph_v_origin, nullptr, nullptr);
//hb_font_funcs_set_glyph_h_kerning_func (funcs, hb_ot_get_glyph_h_kerning, nullptr, nullptr); TODO
//hb_font_funcs_set_glyph_v_kerning_func (funcs, hb_ot_get_glyph_v_kerning, nullptr, nullptr);
hb_font_funcs_set_glyph_extents_func (funcs, hb_ot_get_glyph_extents, nullptr, nullptr);
//hb_font_funcs_set_glyph_contour_point_func (funcs, hb_ot_get_glyph_contour_point, nullptr, nullptr); TODO
hb_font_funcs_set_glyph_name_func (funcs, hb_ot_get_glyph_name, nullptr, nullptr);
hb_font_funcs_set_glyph_from_name_func (funcs, hb_ot_get_glyph_from_name, nullptr, nullptr);
hb_font_funcs_make_immutable (funcs);
if (!hb_atomic_ptr_cmpexch (&static_ot_funcs, NULL, funcs)) {
if (!hb_atomic_ptr_cmpexch (&static_ot_funcs, nullptr, funcs)) {
hb_font_funcs_destroy (funcs);
goto retry;
}

16
gfx/harfbuzz/src/hb-ot-layout-common-private.hh
Просмотреть файл

@ -214,7 +214,7 @@ struct LangSys
}
inline bool sanitize (hb_sanitize_context_t *c,
const Record<LangSys>::sanitize_closure_t * = NULL) const
const Record<LangSys>::sanitize_closure_t * = nullptr) const
{
TRACE_SANITIZE (this);
return_trace (c->check_struct (this) && featureIndex.sanitize (c));
@ -254,7 +254,7 @@ struct Script
inline const LangSys& get_default_lang_sys (void) const { return this+defaultLangSys; }
inline bool sanitize (hb_sanitize_context_t *c,
const Record<Script>::sanitize_closure_t * = NULL) const
const Record<Script>::sanitize_closure_t * = nullptr) const
{
TRACE_SANITIZE (this);
return_trace (defaultLangSys.sanitize (c, this) && langSys.sanitize (c, this));
@ -435,17 +435,17 @@ struct FeatureParamsCharacterVariants
* specifies a string (or strings,
* for multiple languages) for a
* user-interface label for this
* feature. (May be NULL.) */
* feature. (May be nullptr.) */
USHORT featUITooltipTextNameID;/* The ‘name’ table name ID that
* specifies a string (or strings,
* for multiple languages) that an
* application can use for tooltip
* text for this feature. (May be
* NULL.) */
* nullptr.) */
USHORT sampleTextNameID; /* The ‘name’ table name ID that
* specifies sample text that
* illustrates the effect of this
* feature. (May be NULL.) */
* feature. (May be nullptr.) */
USHORT numNamedParameters; /* Number of named parameters. (May
* be zero.) */
USHORT firstParamUILabelNameID;/* The first ‘name’ table name ID
@ -507,7 +507,7 @@ struct Feature
{ return this+featureParams; }
inline bool sanitize (hb_sanitize_context_t *c,
const Record<Feature>::sanitize_closure_t *closure = NULL) const
const Record<Feature>::sanitize_closure_t *closure = nullptr) const
{
TRACE_SANITIZE (this);
if (unlikely (!(c->check_struct (this) && lookupIndex.sanitize (c))))
@ -690,7 +690,7 @@ struct CoverageFormat1
inline unsigned int get_coverage (hb_codepoint_t glyph_id) const
{
int i = glyphArray.bsearch (glyph_id);
ASSERT_STATIC (((unsigned int) -1) == NOT_COVERED);
static_assert ((((unsigned int) -1) == NOT_COVERED), "");
return i;
}
@ -1458,7 +1458,7 @@ struct FeatureTableSubstitution
if (record.featureIndex == feature_index)
return &(this+record.feature);
}
return NULL;
return nullptr;
}
inline bool sanitize (hb_sanitize_context_t *c) const

6
gfx/harfbuzz/src/hb-ot-layout-gdef-table.hh
Просмотреть файл

@ -404,9 +404,9 @@ struct GDEF
{
unsigned int klass = get_glyph_class (glyph);
ASSERT_STATIC ((unsigned int) HB_OT_LAYOUT_GLYPH_PROPS_BASE_GLYPH == (unsigned int) LookupFlag::IgnoreBaseGlyphs);
ASSERT_STATIC ((unsigned int) HB_OT_LAYOUT_GLYPH_PROPS_LIGATURE == (unsigned int) LookupFlag::IgnoreLigatures);
ASSERT_STATIC ((unsigned int) HB_OT_LAYOUT_GLYPH_PROPS_MARK == (unsigned int) LookupFlag::IgnoreMarks);
static_assert (((unsigned int) HB_OT_LAYOUT_GLYPH_PROPS_BASE_GLYPH == (unsigned int) LookupFlag::IgnoreBaseGlyphs), "");
static_assert (((unsigned int) HB_OT_LAYOUT_GLYPH_PROPS_LIGATURE == (unsigned int) LookupFlag::IgnoreLigatures), "");
static_assert (((unsigned int) HB_OT_LAYOUT_GLYPH_PROPS_MARK == (unsigned int) LookupFlag::IgnoreMarks), "");
switch (klass) {
default: return 0;

2
gfx/harfbuzz/src/hb-ot-layout-gsub-table.hh
Просмотреть файл

@ -658,7 +658,7 @@ struct Ligature
if (likely (!match_input (c, count,
&component[1],
match_glyph,
NULL,
nullptr,
&match_length,
match_positions,
&is_mark_ligature,

66
gfx/harfbuzz/src/hb-ot-layout-gsubgpos-private.hh
Просмотреть файл

@ -77,7 +77,7 @@ struct hb_closure_context_t :
unsigned int nesting_level_left_ = HB_MAX_NESTING_LEVEL) :
face (face_),
glyphs (glyphs_),
recurse_func (NULL),
recurse_func (nullptr),
nesting_level_left (nesting_level_left_),
debug_depth (0) {}
@ -146,7 +146,7 @@ struct hb_collect_glyphs_context_t :
if (unlikely (nesting_level_left == 0 || !recurse_func))
return default_return_value ();
/* Note that GPOS sets recurse_func to NULL already, so it doesn't get
/* Note that GPOS sets recurse_func to nullptr already, so it doesn't get
* past the previous check. For GSUB, we only want to collect the output
* glyphs in the recursion. If output is not requested, we can go home now.
*
@ -160,7 +160,7 @@ struct hb_collect_glyphs_context_t :
return HB_VOID;
/* Return if new lookup was recursed to before. */
if (recursed_lookups.has (lookup_index))
if (recursed_lookups->has (lookup_index))
return HB_VOID;
hb_set_t *old_before = before;
@ -176,7 +176,7 @@ struct hb_collect_glyphs_context_t :
input = old_input;
after = old_after;
recursed_lookups.add (lookup_index);
recursed_lookups->add (lookup_index);
return HB_VOID;
}
@ -187,31 +187,31 @@ struct hb_collect_glyphs_context_t :
hb_set_t *after;
hb_set_t *output;
recurse_func_t recurse_func;
hb_set_t recursed_lookups;
hb_set_t *recursed_lookups;
unsigned int nesting_level_left;
unsigned int debug_depth;
hb_collect_glyphs_context_t (hb_face_t *face_,
hb_set_t *glyphs_before, /* OUT. May be NULL */
hb_set_t *glyphs_input, /* OUT. May be NULL */
hb_set_t *glyphs_after, /* OUT. May be NULL */
hb_set_t *glyphs_output, /* OUT. May be NULL */
hb_set_t *glyphs_before, /* OUT. May be nullptr */
hb_set_t *glyphs_input, /* OUT. May be nullptr */
hb_set_t *glyphs_after, /* OUT. May be nullptr */
hb_set_t *glyphs_output, /* OUT. May be nullptr */
unsigned int nesting_level_left_ = HB_MAX_NESTING_LEVEL) :
face (face_),
before (glyphs_before ? glyphs_before : hb_set_get_empty ()),
input (glyphs_input ? glyphs_input : hb_set_get_empty ()),
after (glyphs_after ? glyphs_after : hb_set_get_empty ()),
output (glyphs_output ? glyphs_output : hb_set_get_empty ()),
recurse_func (NULL),
recursed_lookups (),
recurse_func (nullptr),
recursed_lookups (nullptr),
nesting_level_left (nesting_level_left_),
debug_depth (0)
{
recursed_lookups.init ();
recursed_lookups = hb_set_create ();
}
~hb_collect_glyphs_context_t (void)
{
recursed_lookups.fini ();
hb_set_destroy (recursed_lookups);
}
void set_recurse_func (recurse_func_t func) { recurse_func = func; }
@ -273,8 +273,8 @@ struct hb_apply_context_t :
#define arg1(arg) (arg) /* Remove the macro to see why it's needed! */
syllable arg1(0),
#undef arg1
match_func (NULL),
match_data (NULL) {};
match_func (nullptr),
match_data (nullptr) {};
typedef bool (*match_func_t) (hb_codepoint_t glyph_id, const USHORT &value, const void *data);
@ -342,8 +342,8 @@ struct hb_apply_context_t :
inline void init (hb_apply_context_t *c_, bool context_match = false)
{
c = c_;
match_glyph_data = NULL;
matcher.set_match_func (NULL, NULL);
match_glyph_data = nullptr;
matcher.set_match_func (nullptr, nullptr);
matcher.set_lookup_props (c->lookup_props);
/* Ignore ZWNJ if we are matching GSUB context, or matching GPOS. */
matcher.set_ignore_zwnj (c->table_index == 1 || (context_match && c->auto_zwnj));
@ -491,7 +491,7 @@ struct hb_apply_context_t :
hb_buffer_t *buffer_) :
iter_input (), iter_context (),
font (font_), face (font->face), buffer (buffer_),
recurse_func (NULL),
recurse_func (nullptr),
gdef (*hb_ot_layout_from_face (face)->gdef),
var_store (gdef.get_var_store ()),
direction (buffer_->props.direction),
@ -719,10 +719,10 @@ static inline bool match_input (hb_apply_context_t *c,
const void *match_data,
unsigned int *end_offset,
unsigned int match_positions[HB_MAX_CONTEXT_LENGTH],
bool *p_is_mark_ligature = NULL,
unsigned int *p_total_component_count = NULL)
bool *p_is_mark_ligature = nullptr,
unsigned int *p_total_component_count = nullptr)
{
TRACE_APPLY (NULL);
TRACE_APPLY (nullptr);
if (unlikely (count > HB_MAX_CONTEXT_LENGTH)) return_trace (false);
@ -846,7 +846,7 @@ static inline bool ligate_input (hb_apply_context_t *c,
bool is_mark_ligature,
unsigned int total_component_count)
{
TRACE_APPLY (NULL);
TRACE_APPLY (nullptr);
hb_buffer_t *buffer = c->buffer;
@ -943,7 +943,7 @@ static inline bool match_backtrack (hb_apply_context_t *c,
const void *match_data,
unsigned int *match_start)
{
TRACE_APPLY (NULL);
TRACE_APPLY (nullptr);
hb_apply_context_t::skipping_iterator_t &skippy_iter = c->iter_context;
skippy_iter.reset (c->buffer->backtrack_len (), count);
@ -966,7 +966,7 @@ static inline bool match_lookahead (hb_apply_context_t *c,
unsigned int offset,
unsigned int *end_index)
{
TRACE_APPLY (NULL);
TRACE_APPLY (nullptr);
hb_apply_context_t::skipping_iterator_t &skippy_iter = c->iter_context;
skippy_iter.reset (c->buffer->idx + offset - 1, count);
@ -1016,7 +1016,7 @@ static inline bool apply_lookup (hb_apply_context_t *c,
const LookupRecord lookupRecord[], /* Array of LookupRecords--in design order */
unsigned int match_length)
{
TRACE_APPLY (NULL);
TRACE_APPLY (nullptr);
hb_buffer_t *buffer = c->buffer;
int end;
@ -1334,7 +1334,7 @@ struct ContextFormat1
struct ContextClosureLookupContext lookup_context = {
{intersects_glyph},
NULL
nullptr
};
unsigned int count = ruleSet.len;
@ -1352,7 +1352,7 @@ struct ContextFormat1
struct ContextCollectGlyphsLookupContext lookup_context = {
{collect_glyph},
NULL
nullptr
};
unsigned int count = ruleSet.len;
@ -1367,7 +1367,7 @@ struct ContextFormat1
const RuleSet &rule_set = this+ruleSet[(this+coverage).get_coverage (c->glyphs[0])];
struct ContextApplyLookupContext lookup_context = {
{match_glyph},
NULL
nullptr
};
return_trace (rule_set.would_apply (c, lookup_context));
}
@ -1387,7 +1387,7 @@ struct ContextFormat1
const RuleSet &rule_set = this+ruleSet[index];
struct ContextApplyLookupContext lookup_context = {
{match_glyph},
NULL
nullptr
};
return_trace (rule_set.apply (c, lookup_context));
}
@ -1892,7 +1892,7 @@ struct ChainContextFormat1
struct ChainContextClosureLookupContext lookup_context = {
{intersects_glyph},
{NULL, NULL, NULL}
{nullptr, nullptr, nullptr}
};
unsigned int count = ruleSet.len;
@ -1910,7 +1910,7 @@ struct ChainContextFormat1
struct ChainContextCollectGlyphsLookupContext lookup_context = {
{collect_glyph},
{NULL, NULL, NULL}
{nullptr, nullptr, nullptr}
};
unsigned int count = ruleSet.len;
@ -1925,7 +1925,7 @@ struct ChainContextFormat1
const ChainRuleSet &rule_set = this+ruleSet[(this+coverage).get_coverage (c->glyphs[0])];
struct ChainContextApplyLookupContext lookup_context = {
{match_glyph},
{NULL, NULL, NULL}
{nullptr, nullptr, nullptr}
};
return_trace (rule_set.would_apply (c, lookup_context));
}
@ -1944,7 +1944,7 @@ struct ChainContextFormat1
const ChainRuleSet &rule_set = this+ruleSet[index];
struct ChainContextApplyLookupContext lookup_context = {
{match_glyph},
{NULL, NULL, NULL}
{nullptr, nullptr, nullptr}
};
return_trace (rule_set.apply (c, lookup_context));
}

4
gfx/harfbuzz/src/hb-ot-layout-jstf-table.hh
Просмотреть файл

@ -124,7 +124,7 @@ struct JstfPriority
struct JstfLangSys : OffsetListOf<JstfPriority>
{
inline bool sanitize (hb_sanitize_context_t *c,
const Record<JstfLangSys>::sanitize_closure_t * = NULL) const
const Record<JstfLangSys>::sanitize_closure_t * = nullptr) const
{
TRACE_SANITIZE (this);
return_trace (OffsetListOf<JstfPriority>::sanitize (c));
@ -165,7 +165,7 @@ struct JstfScript
inline const JstfLangSys& get_default_lang_sys (void) const { return this+defaultLangSys; }
inline bool sanitize (hb_sanitize_context_t *c,
const Record<JstfScript>::sanitize_closure_t * = NULL) const
const Record<JstfScript>::sanitize_closure_t * = nullptr) const
{
TRACE_SANITIZE (this);
return_trace (extenderGlyphs.sanitize (c, this) &&

21
gfx/harfbuzz/src/hb-ot-layout-private.hh
Просмотреть файл

@ -33,7 +33,7 @@
#include "hb-font-private.hh"
#include "hb-buffer-private.hh"
#include "hb-set-private.hh"
#include "hb-set-digest-private.hh"
#include "hb-open-type-private.hh"
@ -226,7 +226,9 @@ _next_syllable (hb_buffer_t *buffer, unsigned int start)
* - General_Category: 5 bits.
* - A bit each for:
* * Is it Default_Ignorable(); we have a modified Default_Ignorable().
* * Whether it's one of the three Mongolian Free Variation Selectors.
* * Whether it's one of the three Mongolian Free Variation Selectors,
* CGJ, or other characters that are hidden but should not be ignored
* like most other Default_Ignorable()s do during matching.
* * One free bit right now.
*
* The high-byte has different meanings, switched by the Gen-Cat:
@ -264,20 +266,21 @@ _hb_glyph_info_set_unicode_props (hb_glyph_info_t *info, hb_buffer_t *buffer)
buffer->scratch_flags |= HB_BUFFER_SCRATCH_FLAG_HAS_DEFAULT_IGNORABLES;
props |= UPROPS_MASK_IGNORABLE;
if (u == 0x200Cu) props |= UPROPS_MASK_Cf_ZWNJ;
if (u == 0x200Du) props |= UPROPS_MASK_Cf_ZWJ;
else if (u == 0x200Du) props |= UPROPS_MASK_Cf_ZWJ;
/* Mongolian Free Variation Selectors need to be remembered
* because although we need to hide them like default-ignorables,
* they need to non-ignorable during shaping. This is similar to
* what we do for joiners in Indic-like shapers, but since the
* FVSes are GC=Mn, we have use a separate bit to remember them.
* Fixes:
* https://github.com/behdad/harfbuzz/issues/234
*/
if (unlikely (hb_in_range (u, 0x180Bu, 0x180Du))) props |= UPROPS_MASK_HIDDEN;
* https://github.com/behdad/harfbuzz/issues/234 */
else if (unlikely (hb_in_range (u, 0x180Bu, 0x180Du))) props |= UPROPS_MASK_HIDDEN;
/* TAG characters need similar treatment. Fixes:
* https://github.com/behdad/harfbuzz/issues/463
*/
if (unlikely (hb_in_range (u, 0xE0020u, 0xE007Fu))) props |= UPROPS_MASK_HIDDEN;
* https://github.com/behdad/harfbuzz/issues/463 */
else if (unlikely (hb_in_range (u, 0xE0020u, 0xE007Fu))) props |= UPROPS_MASK_HIDDEN;
/* COMBINING GRAPHEME JOINER should not be skipped; at least some times.
* https://github.com/behdad/harfbuzz/issues/554 */
else if (unlikely (u == 0x034Fu)) props |= UPROPS_MASK_HIDDEN;
}
else if (unlikely (HB_UNICODE_GENERAL_CATEGORY_IS_NON_ENCLOSING_MARK_OR_MODIFIER_SYMBOL (gen_cat)))
{

44
gfx/harfbuzz/src/hb-ot-layout.cc
Просмотреть файл

@ -44,7 +44,7 @@ _hb_ot_layout_create (hb_face_t *face)
{
hb_ot_layout_t *layout = (hb_ot_layout_t *) calloc (1, sizeof (hb_ot_layout_t));
if (unlikely (!layout))
return NULL;
return nullptr;
layout->gdef_blob = OT::Sanitizer<OT::GDEF>::sanitize (face->reference_table (HB_OT_TAG_GDEF));
layout->gdef = OT::Sanitizer<OT::GDEF>::lock_instance (layout->gdef_blob);
@ -176,7 +176,7 @@ _hb_ot_layout_create (hb_face_t *face)
(layout->gpos_lookup_count && !layout->gpos_accels)))
{
_hb_ot_layout_destroy (layout);
return NULL;
return nullptr;
}
for (unsigned int i = 0; i < layout->gsub_lookup_count; i++)
@ -321,7 +321,7 @@ hb_ot_layout_table_find_script (hb_face_t *face,
hb_tag_t script_tag,
unsigned int *script_index)
{
ASSERT_STATIC (OT::Index::NOT_FOUND_INDEX == HB_OT_LAYOUT_NO_SCRIPT_INDEX);
static_assert ((OT::Index::NOT_FOUND_INDEX == HB_OT_LAYOUT_NO_SCRIPT_INDEX), "");
const OT::GSUBGPOS &g = get_gsubgpos_table (face, table_tag);
if (g.find_script_index (script_tag, script_index))
@ -352,7 +352,7 @@ hb_ot_layout_table_choose_script (hb_face_t *face,
unsigned int *script_index,
hb_tag_t *chosen_script)
{
ASSERT_STATIC (OT::Index::NOT_FOUND_INDEX == HB_OT_LAYOUT_NO_SCRIPT_INDEX);
static_assert ((OT::Index::NOT_FOUND_INDEX == HB_OT_LAYOUT_NO_SCRIPT_INDEX), "");
const OT::GSUBGPOS &g = get_gsubgpos_table (face, table_tag);
while (*script_tags)
@ -411,7 +411,7 @@ hb_ot_layout_table_find_feature (hb_face_t *face,
hb_tag_t feature_tag,
unsigned int *feature_index)
{
ASSERT_STATIC (OT::Index::NOT_FOUND_INDEX == HB_OT_LAYOUT_NO_FEATURE_INDEX);
static_assert ((OT::Index::NOT_FOUND_INDEX == HB_OT_LAYOUT_NO_FEATURE_INDEX), "");
const OT::GSUBGPOS &g = get_gsubgpos_table (face, table_tag);
unsigned int num_features = g.get_feature_count ();
@ -448,7 +448,7 @@ hb_ot_layout_script_find_language (hb_face_t *face,
hb_tag_t language_tag,
unsigned int *language_index)
{
ASSERT_STATIC (OT::Index::NOT_FOUND_INDEX == HB_OT_LAYOUT_DEFAULT_LANGUAGE_INDEX);
static_assert ((OT::Index::NOT_FOUND_INDEX == HB_OT_LAYOUT_DEFAULT_LANGUAGE_INDEX), "");
const OT::Script &s = get_gsubgpos_table (face, table_tag).get_script (script_index);
if (s.find_lang_sys_index (language_tag, language_index))
@ -474,7 +474,7 @@ hb_ot_layout_language_get_required_feature_index (hb_face_t *face,
script_index,
language_index,
feature_index,
NULL);
nullptr);
}
/**
@ -527,7 +527,7 @@ hb_ot_layout_language_get_feature_tags (hb_face_t *face,
const OT::GSUBGPOS &g = get_gsubgpos_table (face, table_tag);
const OT::LangSys &l = g.get_script (script_index).get_lang_sys (language_index);
ASSERT_STATIC (sizeof (unsigned int) == sizeof (hb_tag_t));
static_assert ((sizeof (unsigned int) == sizeof (hb_tag_t)), "");
unsigned int ret = l.get_feature_indexes (start_offset, feature_count, (unsigned int *) feature_tags);
if (feature_tags) {
@ -548,7 +548,7 @@ hb_ot_layout_language_find_feature (hb_face_t *face,
hb_tag_t feature_tag,
unsigned int *feature_index)
{
ASSERT_STATIC (OT::Index::NOT_FOUND_INDEX == HB_OT_LAYOUT_NO_FEATURE_INDEX);
static_assert ((OT::Index::NOT_FOUND_INDEX == HB_OT_LAYOUT_NO_FEATURE_INDEX), "");
const OT::GSUBGPOS &g = get_gsubgpos_table (face, table_tag);
const OT::LangSys &l = g.get_script (script_index).get_lang_sys (language_index);
@ -652,7 +652,7 @@ _hb_ot_layout_collect_lookups_features (hb_face_t *face,
script_index,
language_index,
&required_feature_index,
NULL))
nullptr))
_hb_ot_layout_collect_lookups_lookups (face,
table_tag,
required_feature_index,
@ -721,7 +721,7 @@ _hb_ot_layout_collect_lookups_languages (hb_face_t *face,
unsigned int count = hb_ot_layout_script_get_language_tags (face,
table_tag,
script_index,
0, NULL, NULL);
0, nullptr, nullptr);
for (unsigned int language_index = 0; language_index < count; language_index++)
_hb_ot_layout_collect_lookups_features (face,
table_tag,
@ -768,7 +768,7 @@ hb_ot_layout_collect_lookups (hb_face_t *face,
/* All scripts */
unsigned int count = hb_ot_layout_table_get_script_tags (face,
table_tag,
0, NULL, NULL);
0, nullptr, nullptr);
for (unsigned int script_index = 0; script_index < count; script_index++)
_hb_ot_layout_collect_lookups_languages (face,
table_tag,
@ -805,10 +805,10 @@ void
hb_ot_layout_lookup_collect_glyphs (hb_face_t *face,
hb_tag_t table_tag,
unsigned int lookup_index,
hb_set_t *glyphs_before, /* OUT. May be NULL */
hb_set_t *glyphs_input, /* OUT. May be NULL */
hb_set_t *glyphs_after, /* OUT. May be NULL */
hb_set_t *glyphs_output /* OUT. May be NULL */)
hb_set_t *glyphs_before, /* OUT. May be nullptr */
hb_set_t *glyphs_input, /* OUT. May be nullptr */
hb_set_t *glyphs_after, /* OUT. May be nullptr */
hb_set_t *glyphs_output /* OUT. May be nullptr */)
{
if (unlikely (!hb_ot_shaper_face_data_ensure (face))) return;
@ -859,7 +859,7 @@ hb_ot_layout_feature_with_variations_get_lookups (hb_face_t *face,
unsigned int *lookup_count /* IN/OUT */,
unsigned int *lookup_indexes /* OUT */)
{
ASSERT_STATIC (OT::FeatureVariations::NOT_FOUND_INDEX == HB_OT_LAYOUT_NO_VARIATIONS_INDEX);
static_assert ((OT::FeatureVariations::NOT_FOUND_INDEX == HB_OT_LAYOUT_NO_VARIATIONS_INDEX), "");
const OT::GSUBGPOS &g = get_gsubgpos_table (face, table_tag);
const OT::Feature &f = g.get_feature_variation (feature_index, variations_index);
@ -967,11 +967,11 @@ hb_ot_layout_position_finish_offsets (hb_font_t *font, hb_buffer_t *buffer)
**/
hb_bool_t
hb_ot_layout_get_size_params (hb_face_t *face,
unsigned int *design_size, /* OUT. May be NULL */
unsigned int *subfamily_id, /* OUT. May be NULL */
unsigned int *subfamily_name_id, /* OUT. May be NULL */
unsigned int *range_start, /* OUT. May be NULL */
unsigned int *range_end /* OUT. May be NULL */)
unsigned int *design_size, /* OUT. May be nullptr */
unsigned int *subfamily_id, /* OUT. May be nullptr */
unsigned int *subfamily_name_id, /* OUT. May be nullptr */
unsigned int *range_start, /* OUT. May be nullptr */
unsigned int *range_end /* OUT. May be nullptr */)
{
const OT::GPOS &gpos = _get_gpos (face);
const hb_tag_t tag = HB_TAG ('s','i','z','e');

10
gfx/harfbuzz/src/hb-ot-map-private.hh
Просмотреть файл

@ -53,8 +53,8 @@ struct hb_ot_map_t
unsigned int auto_zwnj : 1;
unsigned int auto_zwj : 1;
static int cmp (const feature_map_t *a, const feature_map_t *b)
{ return a->tag < b->tag ? -1 : a->tag > b->tag ? 1 : 0; }
inline int cmp (const hb_tag_t *tag_) const
{ return *tag_ < tag ? -1 : *tag_ > tag ? 1 : 0; }
};
struct lookup_map_t {
@ -79,7 +79,7 @@ struct hb_ot_map_t
inline hb_mask_t get_global_mask (void) const { return global_mask; }
inline hb_mask_t get_mask (hb_tag_t feature_tag, unsigned int *shift = NULL) const {
inline hb_mask_t get_mask (hb_tag_t feature_tag, unsigned int *shift = nullptr) const {
const feature_map_t *map = features.bsearch (&feature_tag);
if (shift) *shift = map ? map->shift : 0;
return map ? map->mask : 0;
@ -108,14 +108,14 @@ struct hb_ot_map_t
inline void get_stage_lookups (unsigned int table_index, unsigned int stage,
const struct lookup_map_t **plookups, unsigned int *lookup_count) const {
if (unlikely (stage == (unsigned int) -1)) {
*plookups = NULL;
*plookups = nullptr;
*lookup_count = 0;
return;
}
assert (stage <= stages[table_index].len);
unsigned int start = stage ? stages[table_index][stage - 1].last_lookup : 0;
unsigned int end = stage < stages[table_index].len ? stages[table_index][stage].last_lookup : lookups[table_index].len;
*plookups = end == start ? NULL : &lookups[table_index][start];
*plookups = end == start ? nullptr : &lookups[table_index][start];
*lookup_count = end - start;
}

6
gfx/harfbuzz/src/hb-ot-map.cc
Просмотреть файл

@ -138,7 +138,7 @@ hb_ot_map_builder_t::compile (hb_ot_map_t &m,
const int *coords,
unsigned int num_coords)
{
ASSERT_STATIC (!(HB_GLYPH_FLAG_DEFINED & (HB_GLYPH_FLAG_DEFINED + 1)));
static_assert ((!(HB_GLYPH_FLAG_DEFINED & (HB_GLYPH_FLAG_DEFINED + 1))), "");
unsigned int global_bit_mask = HB_GLYPH_FLAG_DEFINED + 1;
unsigned int global_bit_shift = _hb_popcount32 (HB_GLYPH_FLAG_DEFINED);
@ -269,8 +269,8 @@ hb_ot_map_builder_t::compile (hb_ot_map_t &m,
feature_infos.shrink (0); /* Done with these */
add_gsub_pause (NULL);
add_gpos_pause (NULL);
add_gsub_pause (nullptr);
add_gpos_pause (nullptr);
for (unsigned int table_index = 0; table_index < 2; table_index++)
{

12
gfx/harfbuzz/src/hb-ot-math-table.hh
Просмотреть файл

@ -50,7 +50,7 @@ struct MathValueRecord
protected:
SHORT value; /* The X or Y value in design units */
OffsetTo<Device> deviceTable; /* Offset to the device table - from the
* beginning of parent table. May be NULL.
* beginning of parent table. May be nullptr.
* Suggested format for device table is 1. */
public:
@ -319,7 +319,7 @@ struct MathKernInfoRecord
protected:
/* Offset to MathKern table for each corner -
* from the beginning of MathKernInfo table. May be NULL. */
* from the beginning of MathKernInfo table. May be nullptr. */
OffsetTo<MathKern> mathKern[4];
public:
@ -402,7 +402,7 @@ struct MathGlyphInfo
* from the beginning of MathGlyphInfo table. When the left or right glyph of
* a box is an extended shape variant, the (ink) box (and not the default
* position defined by values in MathConstants table) should be used for
* vertical positioning purposes. May be NULL.. */
* vertical positioning purposes. May be nullptr.. */
OffsetTo<Coverage> extendedShapeCoverage;
/* Offset to MathKernInfo table -
@ -463,8 +463,8 @@ struct MathGlyphPartRecord
out.end_connector_length = font->em_scale (endConnectorLength, scale);
out.full_advance = font->em_scale (fullAdvance, scale);
ASSERT_STATIC ((unsigned int) HB_MATH_GLYPH_PART_FLAG_EXTENDER ==
(unsigned int) PartFlags::Extender);
static_assert ((unsigned int) HB_MATH_GLYPH_PART_FLAG_EXTENDER ==
(unsigned int) PartFlags::Extender, "");
out.flags = (hb_ot_math_glyph_part_flags_t)
(unsigned int)
@ -571,7 +571,7 @@ struct MathGlyphConstruction
protected:
/* Offset to MathGlyphAssembly table for this shape - from the beginning of
MathGlyphConstruction table. May be NULL. */
MathGlyphConstruction table. May be nullptr. */
OffsetTo<MathGlyphAssembly> glyphAssembly;
/* MathGlyphVariantRecords for alternative variants of the glyphs. */

173
gfx/harfbuzz/src/hb-ot-post-table.hh
Просмотреть файл

@ -29,6 +29,48 @@
#include "hb-open-type-private.hh"
#define NUM_FORMAT1_NAMES 258
static const char* const format1_names[NUM_FORMAT1_NAMES] =
{
".notdef", ".null", "nonmarkingreturn", "space", "exclam", "quotedbl",
"numbersign", "dollar", "percent", "ampersand", "quotesingle", "parenleft",
"parenright", "asterisk", "plus", "comma", "hyphen", "period", "slash",
"zero", "one", "two", "three", "four", "five", "six", "seven", "eight",
"nine", "colon", "semicolon", "less", "equal", "greater", "question", "at",
"A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O",
"P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "bracketleft",
"backslash", "bracketright", "asciicircum", "underscore", "grave", "a", "b",
"c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q",
"r", "s", "t", "u", "v", "w", "x", "y", "z", "braceleft", "bar",
"braceright", "asciitilde", "Adieresis", "Aring", "Ccedilla", "Eacute",
"Ntilde", "Odieresis", "Udieresis", "aacute", "agrave", "acircumflex",
"adieresis", "atilde", "aring", "ccedilla", "eacute", "egrave",
"ecircumflex", "edieresis", "iacute", "igrave", "icircumflex", "idieresis",
"ntilde", "oacute", "ograve", "ocircumflex", "odieresis", "otilde", "uacute",
"ugrave", "ucircumflex", "udieresis", "dagger", "degree", "cent", "sterling",
"section", "bullet", "paragraph", "germandbls", "registered", "copyright",
"trademark", "acute", "dieresis", "notequal", "AE", "Oslash", "infinity",
"plusminus", "lessequal", "greaterequal", "yen", "mu", "partialdiff",
"summation", "product", "pi", "integral", "ordfeminine", "ordmasculine",
"Omega", "ae", "oslash", "questiondown", "exclamdown", "logicalnot",
"radical", "florin", "approxequal", "Delta", "guillemotleft",
"guillemotright", "ellipsis", "nonbreakingspace", "Agrave", "Atilde",
"Otilde", "OE", "oe", "endash", "emdash", "quotedblleft", "quotedblright",
"quoteleft", "quoteright", "divide", "lozenge", "ydieresis", "Ydieresis",
"fraction", "currency", "guilsinglleft", "guilsinglright", "fi", "fl",
"daggerdbl", "periodcentered", "quotesinglbase", "quotedblbase",
"perthousand", "Acircumflex", "Ecircumflex", "Aacute", "Edieresis", "Egrave",
"Iacute", "Icircumflex", "Idieresis", "Igrave", "Oacute", "Ocircumflex",
"apple", "Ograve", "Uacute", "Ucircumflex", "Ugrave", "dotlessi",
"circumflex", "tilde", "macron", "breve", "dotaccent", "ring", "cedilla",
"hungarumlaut", "ogonek", "caron", "Lslash", "lslash", "Scaron", "scaron",
"Zcaron", "zcaron", "brokenbar", "Eth", "eth", "Yacute", "yacute", "Thorn",
"thorn", "minus", "multiply", "onesuperior", "twosuperior", "threesuperior",
"onehalf", "onequarter", "threequarters", "franc", "Gbreve", "gbreve",
"Idotaccent", "Scedilla", "scedilla", "Cacute", "cacute", "Ccaron", "ccaron",
"dcroat",
};
namespace OT {
@ -71,12 +113,141 @@ struct post
return_trace (false);
if (version.to_int () == 0x00020000)
{
const postV2Tail &v2 = StructAfter<postV2Tail>(*this);
const postV2Tail &v2 = StructAfter<postV2Tail> (*this);
return_trace (v2.sanitize (c));
}
return_trace (true);
}
inline bool get_glyph_name (hb_codepoint_t glyph,
char *buffer, unsigned int buffer_length,
unsigned int blob_len) const
{
if (version.to_int () == 0x00010000)
{
if (glyph >= NUM_FORMAT1_NAMES)
return false;
if (!buffer_length)
return true;
strncpy (buffer, format1_names[glyph], buffer_length);
buffer[buffer_length - 1] = '\0';
return true;
}
if (version.to_int () == 0x00020000)
{
const postV2Tail &v2 = StructAfter<postV2Tail> (*this);
if (glyph >= v2.numberOfGlyphs)
return false;
if (!buffer_length)
return true;
unsigned int index = v2.glyphNameIndex[glyph];
if (index < NUM_FORMAT1_NAMES)
{
if (!buffer_length)
return true;
strncpy (buffer, format1_names[index], buffer_length);
buffer[buffer_length - 1] = '\0';
return true;
}
index -= NUM_FORMAT1_NAMES;
unsigned int offset = min_size + v2.min_size + 2 * v2.numberOfGlyphs;
unsigned char *data = (unsigned char *) this + offset;
unsigned char *end = (unsigned char *) this + blob_len;
for (unsigned int i = 0; data < end; i++)
{
unsigned int name_length = data[0];
data++;
if (i == index)
{
if (unlikely (!name_length))
return false;
unsigned int remaining = end - data;
name_length = MIN (name_length, buffer_length - 1);
name_length = MIN (name_length, remaining);
memcpy (buffer, data, name_length);
buffer[name_length] = '\0';
return true;
}
data += name_length;
}
return false;
}
return false;
}
inline bool get_glyph_from_name (const char *name, int len,
hb_codepoint_t *glyph,
unsigned int blob_len) const
{
if (len < 0)
len = strlen (name);
if (version.to_int () == 0x00010000)
{
for (int i = 0; i < NUM_FORMAT1_NAMES; i++)
{
if (strncmp (name, format1_names[i], len) == 0 && format1_names[i][len] == '\0')
{
*glyph = i;
return true;
}
}
return false;
}
if (version.to_int () == 0x00020000)
{
const postV2Tail &v2 = StructAfter<postV2Tail> (*this);
unsigned int offset = min_size + v2.min_size + 2 * v2.numberOfGlyphs;
char* data = (char*) this + offset;
/* XXX The following code is wrong. */
return false;
for (hb_codepoint_t gid = 0; gid < v2.numberOfGlyphs; gid++)
{
unsigned int index = v2.glyphNameIndex[gid];
if (index < NUM_FORMAT1_NAMES)
{
if (strncmp (name, format1_names[index], len) == 0 && format1_names[index][len] == '\0')
{
*glyph = gid;
return true;
}
continue;
}
index -= NUM_FORMAT1_NAMES;
for (unsigned int i = 0; data < (char*) this + blob_len; i++)
{
unsigned int name_length = data[0];
unsigned int remaining = (char*) this + blob_len - data - 1;
name_length = MIN (name_length, remaining);
if (name_length == (unsigned int) len && strncmp (name, data + 1, len) == 0)
{
*glyph = gid;
return true;
}
data += name_length + 1;
}
return false;
}
return false;
}
return false;
}
public:
FixedVersion<>version; /* 0x00010000 for version 1.0
* 0x00020000 for version 2.0

14
gfx/harfbuzz/src/hb-ot-shape-complex-arabic-fallback.hh
Просмотреть файл

@ -73,7 +73,7 @@ arabic_fallback_synthesize_lookup_single (const hb_ot_shape_plan_t *plan HB_UNUS
}
if (!num_glyphs)
return NULL;
return nullptr;
/* Bubble-sort or something equally good!
* May not be good-enough for presidential candidate interviews, but good-enough for us... */
@ -94,7 +94,7 @@ arabic_fallback_synthesize_lookup_single (const hb_ot_shape_plan_t *plan HB_UNUS
c.end_serialize ();
/* TODO sanitize the results? */
return ret ? c.copy<OT::SubstLookup> () : NULL;
return ret ? c.copy<OT::SubstLookup> () : nullptr;
}
static OT::SubstLookup *
@ -153,7 +153,7 @@ arabic_fallback_synthesize_lookup_ligature (const hb_ot_shape_plan_t *plan HB_UN
}
if (!num_ligatures)
return NULL;
return nullptr;
OT::Supplier<OT::GlyphID> first_glyphs_supplier (first_glyphs, num_first_glyphs);
OT::Supplier<unsigned int > ligature_per_first_glyph_count_supplier (ligature_per_first_glyph_count_list, num_first_glyphs);
@ -177,7 +177,7 @@ arabic_fallback_synthesize_lookup_ligature (const hb_ot_shape_plan_t *plan HB_UN
c.end_serialize ();
/* TODO sanitize the results? */
return ret ? c.copy<OT::SubstLookup> () : NULL;
return ret ? c.copy<OT::SubstLookup> () : nullptr;
}
static OT::SubstLookup *
@ -237,8 +237,8 @@ arabic_fallback_plan_init_win1256 (arabic_fallback_plan_t *fallback_plan,
return false;
const Manifest &manifest = reinterpret_cast<const Manifest&> (arabic_win1256_gsub_lookups.manifest);
ASSERT_STATIC (sizeof (arabic_win1256_gsub_lookups.manifestData) / sizeof (ManifestLookup)
<= ARABIC_FALLBACK_MAX_LOOKUPS);
static_assert (sizeof (arabic_win1256_gsub_lookups.manifestData) / sizeof (ManifestLookup)
<= ARABIC_FALLBACK_MAX_LOOKUPS, "");
/* TODO sanitize the table? */
unsigned j = 0;
@ -271,7 +271,7 @@ arabic_fallback_plan_init_unicode (arabic_fallback_plan_t *fallback_plan,
const hb_ot_shape_plan_t *plan,
hb_font_t *font)
{
ASSERT_STATIC (ARRAY_LENGTH_CONST(arabic_fallback_features) <= ARABIC_FALLBACK_MAX_LOOKUPS);
static_assert ((ARRAY_LENGTH_CONST(arabic_fallback_features) <= ARABIC_FALLBACK_MAX_LOOKUPS), "");
unsigned int j = 0;
for (unsigned int i = 0; i < ARRAY_LENGTH(arabic_fallback_features) ; i++)
{

36
gfx/harfbuzz/src/hb-ot-shape-complex-arabic.cc
Просмотреть файл

@ -41,7 +41,7 @@
/* See:
* https://github.com/behdad/harfbuzz/commit/6e6f82b6f3dde0fc6c3c7d991d9ec6cfff57823d#commitcomment-14248516 */
#define HB_ARABIC_GENERAL_CATEGORY_IS_WORD(gen_cat) \
(FLAG_SAFE (gen_cat) & \
(FLAG_UNSAFE (gen_cat) & \
(FLAG (HB_UNICODE_GENERAL_CATEGORY_UNASSIGNED) | \
FLAG (HB_UNICODE_GENERAL_CATEGORY_PRIVATE_USE) | \
/*FLAG (HB_UNICODE_GENERAL_CATEGORY_LOWERCASE_LETTER) |*/ \
@ -90,7 +90,7 @@ static unsigned int get_joining_type (hb_codepoint_t u, hb_unicode_general_categ
if (likely (j_type != JOINING_TYPE_X))
return j_type;
return (FLAG_SAFE(gen_cat) &
return (FLAG_UNSAFE(gen_cat) &
(FLAG(HB_UNICODE_GENERAL_CATEGORY_NON_SPACING_MARK) |
FLAG(HB_UNICODE_GENERAL_CATEGORY_ENCLOSING_MARK) |
FLAG(HB_UNICODE_GENERAL_CATEGORY_FORMAT))
@ -212,13 +212,13 @@ collect_features_arabic (hb_ot_shape_planner_t *plan)
map->add_global_bool_feature (HB_TAG('c','c','m','p'));
map->add_global_bool_feature (HB_TAG('l','o','c','l'));
map->add_gsub_pause (NULL);
map->add_gsub_pause (nullptr);
for (unsigned int i = 0; i < ARABIC_NUM_FEATURES; i++)
{
bool has_fallback = plan->props.script == HB_SCRIPT_ARABIC && !FEATURE_IS_SYRIAC (arabic_features[i]);
map->add_feature (arabic_features[i], 1, has_fallback ? F_HAS_FALLBACK : F_NONE);
map->add_gsub_pause (NULL);
map->add_gsub_pause (nullptr);
}
map->add_feature (HB_TAG('r','l','i','g'), 1, F_GLOBAL|F_HAS_FALLBACK);
@ -228,7 +228,7 @@ collect_features_arabic (hb_ot_shape_planner_t *plan)
/* No pause after rclt. See 98460779bae19e4d64d29461ff154b3527bf8420. */
map->add_global_bool_feature (HB_TAG('r','c','l','t'));
map->add_global_bool_feature (HB_TAG('c','a','l','t'));
map->add_gsub_pause (NULL);
map->add_gsub_pause (nullptr);
/* The spec includes 'cswh'. Earlier versions of Windows
* used to enable this by default, but testing suggests
@ -265,7 +265,7 @@ data_create_arabic (const hb_ot_shape_plan_t *plan)
{
arabic_shape_plan_t *arabic_plan = (arabic_shape_plan_t *) calloc (1, sizeof (arabic_shape_plan_t));
if (unlikely (!arabic_plan))
return NULL;
return nullptr;
arabic_plan->do_fallback = plan->props.script == HB_SCRIPT_ARABIC;
arabic_plan->has_stch = !!plan->map.get_1_mask (HB_TAG ('s','t','c','h'));
@ -412,7 +412,7 @@ retry:
{
/* This sucks. We need a font to build the fallback plan... */
fallback_plan = arabic_fallback_plan_create (plan, font);
if (unlikely (!hb_atomic_ptr_cmpexch (&(const_cast<arabic_shape_plan_t *> (arabic_plan))->fallback_plan, NULL, fallback_plan))) {
if (unlikely (!hb_atomic_ptr_cmpexch (&(const_cast<arabic_shape_plan_t *> (arabic_plan))->fallback_plan, nullptr, fallback_plan))) {
arabic_fallback_plan_destroy (fallback_plan);
goto retry;
}
@ -532,11 +532,11 @@ apply_stch (const hb_ot_shape_plan_t *plan,
}
i++; // Don't touch i again.
DEBUG_MSG (ARABIC, NULL, "%s stretch at (%d,%d,%d)",
DEBUG_MSG (ARABIC, nullptr, "%s stretch at (%d,%d,%d)",
step == MEASURE ? "measuring" : "cutting", context, start, end);
DEBUG_MSG (ARABIC, NULL, "rest of word: count=%d width %d", start - context, w_total);
DEBUG_MSG (ARABIC, NULL, "fixed tiles: count=%d width=%d", n_fixed, w_fixed);
DEBUG_MSG (ARABIC, NULL, "repeating tiles: count=%d width=%d", n_repeating, w_repeating);
DEBUG_MSG (ARABIC, nullptr, "rest of word: count=%d width %d", start - context, w_total);
DEBUG_MSG (ARABIC, nullptr, "fixed tiles: count=%d width=%d", n_fixed, w_fixed);
DEBUG_MSG (ARABIC, nullptr, "repeating tiles: count=%d width=%d", n_repeating, w_repeating);
/* Number of additional times to repeat each repeating tile. */
int n_copies = 0;
@ -559,7 +559,7 @@ apply_stch (const hb_ot_shape_plan_t *plan,
if (step == MEASURE)
{
extra_glyphs_needed += n_copies * n_repeating;
DEBUG_MSG (ARABIC, NULL, "will add extra %d copies of repeating tiles", n_copies);
DEBUG_MSG (ARABIC, nullptr, "will add extra %d copies of repeating tiles", n_copies);
}
else
{
@ -572,7 +572,7 @@ apply_stch (const hb_ot_shape_plan_t *plan,
if (info[k - 1].arabic_shaping_action() == STCH_REPEATING)
repeat += n_copies;
DEBUG_MSG (ARABIC, NULL, "appending %d copies of glyph %d; j=%d",
DEBUG_MSG (ARABIC, nullptr, "appending %d copies of glyph %d; j=%d",
repeat, info[k - 1].codepoint, j);
for (unsigned int n = 0; n < repeat; n++)
{
@ -691,16 +691,16 @@ const hb_ot_complex_shaper_t _hb_ot_complex_shaper_arabic =
{
"arabic",
collect_features_arabic,
NULL, /* override_features */
nullptr, /* override_features */
data_create_arabic,
data_destroy_arabic,
NULL, /* preprocess_text */
nullptr, /* preprocess_text */
postprocess_glyphs_arabic,
HB_OT_SHAPE_NORMALIZATION_MODE_DEFAULT,
NULL, /* decompose */
NULL, /* compose */
nullptr, /* decompose */
nullptr, /* compose */
setup_masks_arabic,
NULL, /* disable_otl */
nullptr, /* disable_otl */
reorder_marks_arabic,
HB_OT_SHAPE_ZERO_WIDTH_MARKS_BY_GDEF_LATE,
true, /* fallback_position */

22
gfx/harfbuzz/src/hb-ot-shape-complex-default.cc
Просмотреть файл

@ -30,18 +30,18 @@
const hb_ot_complex_shaper_t _hb_ot_complex_shaper_default =
{
"default",
NULL, /* collect_features */
NULL, /* override_features */
NULL, /* data_create */
NULL, /* data_destroy */
NULL, /* preprocess_text */
NULL, /* postprocess_glyphs */
nullptr, /* collect_features */
nullptr, /* override_features */
nullptr, /* data_create */
nullptr, /* data_destroy */
nullptr, /* preprocess_text */
nullptr, /* postprocess_glyphs */
HB_OT_SHAPE_NORMALIZATION_MODE_DEFAULT,
NULL, /* decompose */
NULL, /* compose */
NULL, /* setup_masks */
NULL, /* disable_otl */
NULL, /* reorder_marks */
nullptr, /* decompose */
nullptr, /* compose */
nullptr, /* setup_masks */
nullptr, /* disable_otl */
nullptr, /* reorder_marks */
HB_OT_SHAPE_ZERO_WIDTH_MARKS_BY_GDEF_LATE,
true, /* fallback_position */
};

12
gfx/harfbuzz/src/hb-ot-shape-complex-hangul.cc
Просмотреть файл

@ -80,7 +80,7 @@ data_create_hangul (const hb_ot_shape_plan_t *plan)
{
hangul_shape_plan_t *hangul_plan = (hangul_shape_plan_t *) calloc (1, sizeof (hangul_shape_plan_t));
if (unlikely (!hangul_plan))
return NULL;
return nullptr;
for (unsigned int i = 0; i < HANGUL_FEATURE_COUNT; i++)
hangul_plan->mask_array[i] = plan->map.get_1_mask (hangul_features[i]);
@ -420,13 +420,13 @@ const hb_ot_complex_shaper_t _hb_ot_complex_shaper_hangul =
data_create_hangul,
data_destroy_hangul,
preprocess_text_hangul,
NULL, /* postprocess_glyphs */
nullptr, /* postprocess_glyphs */
HB_OT_SHAPE_NORMALIZATION_MODE_NONE,
NULL, /* decompose */
NULL, /* compose */
nullptr, /* decompose */
nullptr, /* compose */
setup_masks_hangul,
NULL, /* disable_otl */
NULL, /* reorder_marks */
nullptr, /* disable_otl */
nullptr, /* reorder_marks */
HB_OT_SHAPE_ZERO_WIDTH_MARKS_NONE,
false, /* fallback_position */
};

18
gfx/harfbuzz/src/hb-ot-shape-complex-hebrew.cc
Просмотреть файл

@ -170,18 +170,18 @@ disable_otl_hebrew (const hb_ot_shape_plan_t *plan)
const hb_ot_complex_shaper_t _hb_ot_complex_shaper_hebrew =
{
"hebrew",
NULL, /* collect_features */
NULL, /* override_features */
NULL, /* data_create */
NULL, /* data_destroy */
NULL, /* preprocess_text */
NULL, /* postprocess_glyphs */
nullptr, /* collect_features */
nullptr, /* override_features */
nullptr, /* data_create */
nullptr, /* data_destroy */
nullptr, /* preprocess_text */
nullptr, /* postprocess_glyphs */
HB_OT_SHAPE_NORMALIZATION_MODE_DEFAULT,
NULL, /* decompose */
nullptr, /* decompose */
compose_hebrew,
NULL, /* setup_masks */
nullptr, /* setup_masks */
disable_otl_hebrew,
NULL, /* reorder_marks */
nullptr, /* reorder_marks */
HB_OT_SHAPE_ZERO_WIDTH_MARKS_BY_GDEF_LATE,
true, /* fallback_position */
};

26
gfx/harfbuzz/src/hb-ot-shape-complex-indic.cc
Просмотреть файл

@ -142,7 +142,7 @@ is_one_of (const hb_glyph_info_t &info, unsigned int flags)
{
/* If it ligated, all bets are off. */
if (_hb_glyph_info_ligated (&info)) return false;
return !!(FLAG_SAFE (info.indic_category()) & flags);
return !!(FLAG_UNSAFE (info.indic_category()) & flags);
}
static inline bool
@ -198,7 +198,7 @@ set_indic_properties (hb_glyph_info_t &info)
0x1CEEu, 0x1CF1u)))
{
cat = OT_Symbol;
ASSERT_STATIC ((int) INDIC_SYLLABIC_CATEGORY_AVAGRAHA == OT_Symbol);
static_assert (((int) INDIC_SYLLABIC_CATEGORY_AVAGRAHA == OT_Symbol), "");
}
else if (unlikely (hb_in_range<hb_codepoint_t> (u, 0x17CDu, 0x17D1u) ||
u == 0x17CBu || u == 0x17D3u || u == 0x17DDu)) /* Khmer Various signs */
@ -233,7 +233,7 @@ set_indic_properties (hb_glyph_info_t &info)
* Re-assign position.
*/
if ((FLAG_SAFE (cat) & CONSONANT_FLAGS))
if ((FLAG_UNSAFE (cat) & CONSONANT_FLAGS))
{
pos = POS_BASE_C;
if (is_ra (u))
@ -243,7 +243,7 @@ set_indic_properties (hb_glyph_info_t &info)
{
pos = matra_position (u, pos);
}
else if ((FLAG_SAFE (cat) & (FLAG (OT_SM) | FLAG (OT_VD) | FLAG (OT_A) | FLAG (OT_Symbol))))
else if ((FLAG_UNSAFE (cat) & (FLAG (OT_SM) | FLAG (OT_VD) | FLAG (OT_A) | FLAG (OT_Symbol))))
{
pos = POS_SMVD;
}
@ -435,7 +435,7 @@ collect_features_indic (hb_ot_shape_planner_t *plan)
map->add_gsub_pause (initial_reordering);
for (; i < INDIC_BASIC_FEATURES; i++) {
map->add_feature (indic_features[i].tag, 1, indic_features[i].flags | F_MANUAL_ZWJ | F_MANUAL_ZWNJ);
map->add_gsub_pause (NULL);
map->add_gsub_pause (nullptr);
}
map->add_gsub_pause (final_reordering);
for (; i < INDIC_NUM_FEATURES; i++) {
@ -533,7 +533,7 @@ data_create_indic (const hb_ot_shape_plan_t *plan)
{
indic_shape_plan_t *indic_plan = (indic_shape_plan_t *) calloc (1, sizeof (indic_shape_plan_t));
if (unlikely (!indic_plan))
return NULL;
return nullptr;
indic_plan->config = &indic_configs[0];
for (unsigned int i = 1; i < ARRAY_LENGTH (indic_configs); i++)
@ -968,7 +968,7 @@ initial_reordering_consonant_syllable (const hb_ot_shape_plan_t *plan,
indic_position_t last_pos = POS_START;
for (unsigned int i = start; i < end; i++)
{
if ((FLAG_SAFE (info[i].indic_category()) & (JOINER_FLAGS | FLAG (OT_N) | FLAG (OT_RS) | MEDIAL_FLAGS | HALANT_OR_COENG_FLAGS)))
if ((FLAG_UNSAFE (info[i].indic_category()) & (JOINER_FLAGS | FLAG (OT_N) | FLAG (OT_RS) | MEDIAL_FLAGS | HALANT_OR_COENG_FLAGS)))
{
info[i].indic_position() = last_pos;
if (unlikely (info[i].indic_category() == OT_H &&
@ -1538,7 +1538,7 @@ final_reordering_syllable (const hb_ot_shape_plan_t *plan,
{
new_reph_pos = base;
while (new_reph_pos + 1 < end &&
!( FLAG_SAFE (info[new_reph_pos + 1].indic_position()) & (FLAG (POS_POST_C) | FLAG (POS_AFTER_POST) | FLAG (POS_SMVD))))
!( FLAG_UNSAFE (info[new_reph_pos + 1].indic_position()) & (FLAG (POS_POST_C) | FLAG (POS_AFTER_POST) | FLAG (POS_SMVD))))
new_reph_pos++;
if (new_reph_pos < end)
goto reph_move;
@ -1688,7 +1688,7 @@ final_reordering_syllable (const hb_ot_shape_plan_t *plan,
/* Apply 'init' to the Left Matra if it's a word start. */
if (info[start].indic_position () == POS_PRE_M &&
(!start ||
!(FLAG_SAFE (_hb_glyph_info_get_general_category (&info[start - 1])) &
!(FLAG_UNSAFE (_hb_glyph_info_get_general_category (&info[start - 1])) &
FLAG_RANGE (HB_UNICODE_GENERAL_CATEGORY_FORMAT, HB_UNICODE_GENERAL_CATEGORY_NON_SPACING_MARK))))
info[start].mask |= indic_plan->mask_array[INIT];
@ -1848,14 +1848,14 @@ const hb_ot_complex_shaper_t _hb_ot_complex_shaper_indic =
override_features_indic,
data_create_indic,
data_destroy_indic,
NULL, /* preprocess_text */
NULL, /* postprocess_glyphs */
nullptr, /* preprocess_text */
nullptr, /* postprocess_glyphs */
HB_OT_SHAPE_NORMALIZATION_MODE_COMPOSED_DIACRITICS_NO_SHORT_CIRCUIT,
decompose_indic,
compose_indic,
setup_masks_indic,
NULL, /* disable_otl */
NULL, /* reorder_marks */
nullptr, /* disable_otl */
nullptr, /* reorder_marks */
HB_OT_SHAPE_ZERO_WIDTH_MARKS_NONE,
false, /* fallback_position */
};

42
gfx/harfbuzz/src/hb-ot-shape-complex-myanmar.cc
Просмотреть файл

@ -103,7 +103,7 @@ collect_features_myanmar (hb_ot_shape_planner_t *plan)
for (unsigned int i = 0; i < ARRAY_LENGTH (basic_features); i++)
{
map->add_feature (basic_features[i], 1, F_GLOBAL | F_MANUAL_ZWJ);
map->add_gsub_pause (NULL);
map->add_gsub_pause (nullptr);
}
map->add_gsub_pause (final_reordering);
for (unsigned int i = 0; i < ARRAY_LENGTH (other_features); i++)
@ -154,7 +154,7 @@ is_one_of (const hb_glyph_info_t &info, unsigned int flags)
{
/* If it ligated, all bets are off. */
if (_hb_glyph_info_ligated (&info)) return false;
return !!(FLAG_SAFE (info.myanmar_category()) & flags);
return !!(FLAG_UNSAFE (info.myanmar_category()) & flags);
}
static inline bool
@ -513,18 +513,18 @@ final_reordering (const hb_ot_shape_plan_t *plan,
const hb_ot_complex_shaper_t _hb_ot_complex_shaper_myanmar_old =
{
"default",
NULL, /* collect_features */
NULL, /* override_features */
NULL, /* data_create */
NULL, /* data_destroy */
NULL, /* preprocess_text */
NULL, /* postprocess_glyphs */
nullptr, /* collect_features */
nullptr, /* override_features */
nullptr, /* data_create */
nullptr, /* data_destroy */
nullptr, /* preprocess_text */
nullptr, /* postprocess_glyphs */
HB_OT_SHAPE_NORMALIZATION_MODE_DEFAULT,
NULL, /* decompose */
NULL, /* compose */
NULL, /* setup_masks */
NULL, /* disable_otl */
NULL, /* reorder_marks */
nullptr, /* decompose */
nullptr, /* compose */
nullptr, /* setup_masks */
nullptr, /* disable_otl */
nullptr, /* reorder_marks */
HB_OT_SHAPE_ZERO_WIDTH_MARKS_BY_GDEF_LATE,
true, /* fallback_position */
};
@ -534,16 +534,16 @@ const hb_ot_complex_shaper_t _hb_ot_complex_shaper_myanmar =
"myanmar",
collect_features_myanmar,
override_features_myanmar,
NULL, /* data_create */
NULL, /* data_destroy */
NULL, /* preprocess_text */
NULL, /* postprocess_glyphs */
nullptr, /* data_create */
nullptr, /* data_destroy */
nullptr, /* preprocess_text */
nullptr, /* postprocess_glyphs */
HB_OT_SHAPE_NORMALIZATION_MODE_COMPOSED_DIACRITICS_NO_SHORT_CIRCUIT,
NULL, /* decompose */
NULL, /* compose */
nullptr, /* decompose */
nullptr, /* compose */
setup_masks_myanmar,
NULL, /* disable_otl */
NULL, /* reorder_marks */
nullptr, /* disable_otl */
nullptr, /* reorder_marks */
HB_OT_SHAPE_ZERO_WIDTH_MARKS_BY_GDEF_EARLY,
false, /* fallback_position */
};

26
gfx/harfbuzz/src/hb-ot-shape-complex-private.hh
Просмотреть файл

@ -70,7 +70,7 @@ struct hb_ot_complex_shaper_t
/* collect_features()
* Called during shape_plan().
* Shapers should use plan->map to add their features and callbacks.
* May be NULL.
* May be nullptr.
*/
void (*collect_features) (hb_ot_shape_planner_t *plan);
@ -78,7 +78,7 @@ struct hb_ot_complex_shaper_t
* Called during shape_plan().
* Shapers should use plan->map to override features and add callbacks after
* common features are added.
* May be NULL.
* May be nullptr.
*/
void (*override_features) (hb_ot_shape_planner_t *plan);
@ -86,15 +86,15 @@ struct hb_ot_complex_shaper_t
/* data_create()
* Called at the end of shape_plan().
* Whatever shapers return will be accessible through plan->data later.
* If NULL is returned, means a plan failure.
* If nullptr is returned, means a plan failure.
*/
void *(*data_create) (const hb_ot_shape_plan_t *plan);
/* data_destroy()
* Called when the shape_plan is being destroyed.
* plan->data is passed here for destruction.
* If NULL is returned, means a plan failure.
* May be NULL.
* If nullptr is returned, means a plan failure.
* May be nullptr.
*/
void (*data_destroy) (void *data);
@ -102,7 +102,7 @@ struct hb_ot_complex_shaper_t
/* preprocess_text()
* Called during shape().
* Shapers can use to modify text before shaping starts.
* May be NULL.
* May be nullptr.
*/
void (*preprocess_text) (const hb_ot_shape_plan_t *plan,
hb_buffer_t *buffer,
@ -111,7 +111,7 @@ struct hb_ot_complex_shaper_t
/* postprocess_glyphs()
* Called during shape().
* Shapers can use to modify glyphs after shaping ends.
* May be NULL.
* May be nullptr.
*/
void (*postprocess_glyphs) (const hb_ot_shape_plan_t *plan,
hb_buffer_t *buffer,
@ -122,7 +122,7 @@ struct hb_ot_complex_shaper_t
/* decompose()
* Called during shape()'s normalization.
* May be NULL.
* May be nullptr.
*/
bool (*decompose) (const hb_ot_shape_normalize_context_t *c,
hb_codepoint_t ab,
@ -131,7 +131,7 @@ struct hb_ot_complex_shaper_t
/* compose()
* Called during shape()'s normalization.
* May be NULL.
* May be nullptr.
*/
bool (*compose) (const hb_ot_shape_normalize_context_t *c,
hb_codepoint_t a,
@ -142,7 +142,7 @@ struct hb_ot_complex_shaper_t
* Called during shape().
* Shapers should use map to get feature masks and set on buffer.
* Shapers may NOT modify characters.
* May be NULL.
* May be nullptr.
*/
void (*setup_masks) (const hb_ot_shape_plan_t *plan,
hb_buffer_t *buffer,
@ -152,14 +152,14 @@ struct hb_ot_complex_shaper_t
* Called during shape().
* If set and returns true, GDEF/GSUB/GPOS of the font are ignored
* and fallback operations used.
* May be NULL.
* May be nullptr.
*/
bool (*disable_otl) (const hb_ot_shape_plan_t *plan);
/* reorder_marks()
* Called during shape().
* Shapers can use to modify ordering of combining marks.
* May be NULL.
* May be nullptr.
*/
void (*reorder_marks) (const hb_ot_shape_plan_t *plan,
hb_buffer_t *buffer,
@ -286,7 +286,7 @@ hb_ot_shape_complex_categorize (const hb_ot_shape_planner_t *planner)
planner->map.script_index[0],
planner->map.language_index[0],
HB_TAG ('p','r','e','f'),
NULL))
nullptr))
return &_hb_ot_complex_shaper_indic;
else
return &_hb_ot_complex_shaper_default;

22
gfx/harfbuzz/src/hb-ot-shape-complex-thai.cc
Просмотреть файл

@ -97,7 +97,7 @@ thai_pua_shape (hb_codepoint_t u, thai_action_t action, hb_font_t *font)
hb_codepoint_t u;
hb_codepoint_t win_pua;
hb_codepoint_t mac_pua;
} const *pua_mappings = NULL;
} const *pua_mappings = nullptr;
static const thai_pua_mapping_t SD_mappings[] = {
{0x0E48u, 0xF70Au, 0xF88Bu}, /* MAI EK */
{0x0E49u, 0xF70Bu, 0xF88Eu}, /* MAI THO */
@ -367,18 +367,18 @@ preprocess_text_thai (const hb_ot_shape_plan_t *plan,
const hb_ot_complex_shaper_t _hb_ot_complex_shaper_thai =
{
"thai",
NULL, /* collect_features */
NULL, /* override_features */
NULL, /* data_create */
NULL, /* data_destroy */
nullptr, /* collect_features */
nullptr, /* override_features */
nullptr, /* data_create */
nullptr, /* data_destroy */
preprocess_text_thai,
NULL, /* postprocess_glyphs */
nullptr, /* postprocess_glyphs */
HB_OT_SHAPE_NORMALIZATION_MODE_DEFAULT,
NULL, /* decompose */
NULL, /* compose */
NULL, /* setup_masks */
NULL, /* disable_otl */
NULL, /* reorder_marks */
nullptr, /* decompose */
nullptr, /* compose */
nullptr, /* setup_masks */
nullptr, /* disable_otl */
nullptr, /* reorder_marks */
HB_OT_SHAPE_ZERO_WIDTH_MARKS_BY_GDEF_LATE,
false,/* fallback_position */
};

20
gfx/harfbuzz/src/hb-ot-shape-complex-tibetan.cc
Просмотреть файл

@ -48,17 +48,17 @@ const hb_ot_complex_shaper_t _hb_ot_complex_shaper_tibetan =
{
"default",
collect_features_tibetan,
NULL, /* override_features */
NULL, /* data_create */
NULL, /* data_destroy */
NULL, /* preprocess_text */
NULL, /* postprocess_glyphs */
nullptr, /* override_features */
nullptr, /* data_create */
nullptr, /* data_destroy */
nullptr, /* preprocess_text */
nullptr, /* postprocess_glyphs */
HB_OT_SHAPE_NORMALIZATION_MODE_DEFAULT,
NULL, /* decompose */
NULL, /* compose */
NULL, /* setup_masks */
NULL, /* disable_otl */
NULL, /* reorder_marks */
nullptr, /* decompose */
nullptr, /* compose */
nullptr, /* setup_masks */
nullptr, /* disable_otl */
nullptr, /* reorder_marks */
HB_OT_SHAPE_ZERO_WIDTH_MARKS_BY_GDEF_LATE,
true, /* fallback_position */
};

20
gfx/harfbuzz/src/hb-ot-shape-complex-use.cc
Просмотреть файл

@ -144,7 +144,7 @@ collect_features_use (hb_ot_shape_planner_t *plan)
/* "Topographical features" */
for (unsigned int i = 0; i < ARRAY_LENGTH (arabic_features); i++)
map->add_feature (arabic_features[i], 1, F_NONE);
map->add_gsub_pause (NULL);
map->add_gsub_pause (nullptr);
/* "Standard typographic presentation" and "Positional feature application" */
for (unsigned int i = 0; i < ARRAY_LENGTH (other_features); i++)
@ -199,7 +199,7 @@ data_create_use (const hb_ot_shape_plan_t *plan)
{
use_shape_plan_t *use_plan = (use_shape_plan_t *) calloc (1, sizeof (use_shape_plan_t));
if (unlikely (!use_plan))
return NULL;
return nullptr;
use_plan->rphf_mask = plan->map.get_1_mask (HB_TAG('r','p','h','f'));
@ -209,7 +209,7 @@ data_create_use (const hb_ot_shape_plan_t *plan)
if (unlikely (!use_plan->arabic_plan))
{
free (use_plan);
return NULL;
return nullptr;
}
}
@ -292,7 +292,7 @@ setup_topographical_masks (const hb_ot_shape_plan_t *plan,
if (use_plan->arabic_plan)
return;
ASSERT_STATIC (INIT < 4 && ISOL < 4 && MEDI < 4 && FINA < 4);
static_assert ((INIT < 4 && ISOL < 4 && MEDI < 4 && FINA < 4), "");
hb_mask_t masks[4], all_masks = 0;
for (unsigned int i = 0; i < 4; i++)
{
@ -424,7 +424,7 @@ reorder_syllable (hb_buffer_t *buffer, unsigned int start, unsigned int end)
{
syllable_type_t syllable_type = (syllable_type_t) (buffer->info[start].syllable() & 0x0F);
/* Only a few syllable types need reordering. */
if (unlikely (!(FLAG_SAFE (syllable_type) &
if (unlikely (!(FLAG_UNSAFE (syllable_type) &
(FLAG (virama_terminated_cluster) |
FLAG (standard_cluster) |
FLAG (broken_cluster) |
@ -597,17 +597,17 @@ const hb_ot_complex_shaper_t _hb_ot_complex_shaper_use =
{
"use",
collect_features_use,
NULL, /* override_features */
nullptr, /* override_features */
data_create_use,
data_destroy_use,
NULL, /* preprocess_text */
NULL, /* postprocess_glyphs */
nullptr, /* preprocess_text */
nullptr, /* postprocess_glyphs */
HB_OT_SHAPE_NORMALIZATION_MODE_COMPOSED_DIACRITICS_NO_SHORT_CIRCUIT,
decompose_use,
compose_use,
setup_masks_use,
NULL, /* disable_otl */
NULL, /* reorder_marks */
nullptr, /* disable_otl */
nullptr, /* reorder_marks */
HB_OT_SHAPE_ZERO_WIDTH_MARKS_BY_GDEF_EARLY,
false, /* fallback_position */
};

2
gfx/harfbuzz/src/hb-ot-shape-private.hh
Просмотреть файл

@ -73,7 +73,7 @@ struct hb_ot_shape_planner_t
hb_ot_shape_planner_t (const hb_shape_plan_t *master_plan) :
face (master_plan->face_unsafe),
props (master_plan->props),
shaper (NULL),
shaper (nullptr),
map (face, &props) {}
~hb_ot_shape_planner_t (void) { map.finish (); }

25
gfx/harfbuzz/src/hb-ot-shape.cc
Просмотреть файл

@ -70,7 +70,7 @@ hb_ot_shape_collect_features (hb_ot_shape_planner_t *planner,
hb_ot_map_builder_t *map = &planner->map;
map->add_global_bool_feature (HB_TAG('r','v','r','n'));
map->add_gsub_pause (NULL);
map->add_gsub_pause (nullptr);
switch (props->direction) {
case HB_DIRECTION_LTR:
@ -176,7 +176,7 @@ _hb_ot_shaper_shape_plan_data_create (hb_shape_plan_t *shape_plan,
{
hb_ot_shape_plan_t *plan = (hb_ot_shape_plan_t *) calloc (1, sizeof (hb_ot_shape_plan_t));
if (unlikely (!plan))
return NULL;
return nullptr;
hb_ot_shape_planner_t planner (shape_plan);
@ -190,7 +190,7 @@ _hb_ot_shaper_shape_plan_data_create (hb_shape_plan_t *shape_plan,
if (plan->shaper->data_create) {
plan->data = plan->shaper->data_create (plan);
if (unlikely (!plan->data))
return NULL;
return nullptr;
}
return plan;
@ -928,7 +928,7 @@ hb_ot_shape_glyphs_closure (hb_font_t *font,
{
hb_ot_shape_plan_t plan;
const char *shapers[] = {"ot", NULL};
const char *shapers[] = {"ot", nullptr};
hb_shape_plan_t *shape_plan = hb_shape_plan_create_cached (font->face, &buffer->props,
features, num_features, shapers);
@ -939,18 +939,19 @@ hb_ot_shape_glyphs_closure (hb_font_t *font,
for (unsigned int i = 0; i < count; i++)
add_char (font, buffer->unicode, mirror, info[i].codepoint, glyphs);
hb_set_t lookups;
lookups.init ();
hb_ot_shape_plan_collect_lookups (shape_plan, HB_OT_TAG_GSUB, &lookups);
hb_set_t *lookups = hb_set_create ();
hb_ot_shape_plan_collect_lookups (shape_plan, HB_OT_TAG_GSUB, lookups);
/* And find transitive closure. */
hb_set_t copy;
copy.init ();
hb_set_t *copy = hb_set_create ();
do {
copy.set (glyphs);
for (hb_codepoint_t lookup_index = -1; hb_set_next (&lookups, &lookup_index);)
copy->set (glyphs);
for (hb_codepoint_t lookup_index = -1; hb_set_next (lookups, &lookup_index);)
hb_ot_layout_lookup_substitute_closure (font->face, lookup_index, glyphs);
} while (!copy.is_equal (glyphs));
} while (!copy->is_equal (glyphs));
hb_set_destroy (copy);
hb_set_destroy (lookups);
hb_shape_plan_destroy (shape_plan);
}

2
gfx/harfbuzz/src/hb-ot-tag.cc
Просмотреть файл

@ -1020,7 +1020,7 @@ hb_ot_tag_to_language (hb_tag_t tag)
unsigned int i;
if (tag == HB_OT_TAG_DEFAULT_LANGUAGE)
return NULL;
return nullptr;
/* struct LangTag has only room for 3-letter language tags. */
switch (tag) {

2
gfx/harfbuzz/src/hb-ot-var.cc
Просмотреть файл

@ -130,7 +130,7 @@ hb_ot_var_normalize_variations (hb_face_t *face,
for (unsigned int i = 0; i < variations_length; i++)
{
unsigned int axis_index;
if (hb_ot_var_find_axis (face, variations[i].tag, &axis_index, NULL) &&
if (hb_ot_var_find_axis (face, variations[i].tag, &axis_index, nullptr) &&
axis_index < coords_length)
coords[axis_index] = fvar.normalize_axis_value (axis_index, variations[i].value);
}

286
gfx/harfbuzz/src/hb-private.hh
Просмотреть файл

@ -74,6 +74,39 @@ extern "C" void hb_free_impl(void *ptr);
/* Compiler attributes */
#if __cplusplus < 201103L
// Null pointer literal
// Source: SC22/WG21/N2431 = J16/07-0301
// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2431.pdf
const // this is a const object...
class {
public:
template<class T> // convertible to any type
operator T*() const { // of null non-member
return 0; // pointer...
}
template<class C, class T> // or any type of null
operator T C::*() const { // member pointer...
return 0;
}
private:
void operator&() const; // whose address can't be taken
} _hb_nullptr = {}; // and whose name is nullptr
#define nullptr _hb_nullptr
// Static assertions
#ifndef static_assert
#define _PASTE1(a,b) a##b
#define _PASTE(a,b) _PASTE1(a,b)
#define static_assert(e, msg) \
HB_UNUSED typedef int _PASTE(static_assertion_failed_at_line_, __LINE__) [(e) ? 1 : -1]
#endif // static_assert
#endif // __cplusplus < 201103L
#if (defined(__GNUC__) || defined(__clang__)) && defined(__OPTIMIZE__)
#define likely(expr) (__builtin_expect (!!(expr), 1))
#define unlikely(expr) (__builtin_expect (!!(expr), 0))
@ -168,13 +201,13 @@ extern "C" void hb_free_impl(void *ptr);
# if defined(_WIN32_WCE)
/* Some things not defined on Windows CE. */
# define vsnprintf _vsnprintf
# define getenv(Name) NULL
# define getenv(Name) nullptr
# if _WIN32_WCE < 0x800
# define setlocale(Category, Locale) "C"
static int errno = 0; /* Use something better? */
# endif
# elif defined(WINAPI_FAMILY) && (WINAPI_FAMILY==WINAPI_FAMILY_PC_APP || WINAPI_FAMILY==WINAPI_FAMILY_PHONE_APP)
# define getenv(Name) NULL
# define getenv(Name) nullptr
# endif
# if defined(_MSC_VER) && _MSC_VER < 1900
# define snprintf _snprintf
@ -209,11 +242,6 @@ static int errno = 0; /* Use something better? */
/* Basics */
#ifndef NULL
# define NULL ((void *) 0)
#endif
#undef MIN
template <typename Type>
static inline Type MIN (const Type &a, const Type &b) { return a < b ? a : b; }
@ -235,32 +263,26 @@ static inline unsigned int ARRAY_LENGTH (const Type (&)[n]) { return n; }
#define HB_STMT_START do
#define HB_STMT_END while (0)
#define _ASSERT_STATIC1(_line, _cond) HB_UNUSED typedef int _static_assert_on_line_##_line##_failed[(_cond)?1:-1]
#define _ASSERT_STATIC0(_line, _cond) _ASSERT_STATIC1 (_line, (_cond))
#define ASSERT_STATIC(_cond) _ASSERT_STATIC0 (__LINE__, (_cond))
template <unsigned int cond> class hb_assert_constant_t {};
template <unsigned int cond> class hb_assert_constant_t;
template <> class hb_assert_constant_t<1> {};
#define ASSERT_STATIC_EXPR_ZERO(_cond) (0 * (unsigned int) sizeof (hb_assert_constant_t<_cond>))
#define _PASTE1(a,b) a##b
#define PASTE(a,b) _PASTE1(a,b)
/* Lets assert int types. Saves trouble down the road. */
ASSERT_STATIC (sizeof (int8_t) == 1);
ASSERT_STATIC (sizeof (uint8_t) == 1);
ASSERT_STATIC (sizeof (int16_t) == 2);
ASSERT_STATIC (sizeof (uint16_t) == 2);
ASSERT_STATIC (sizeof (int32_t) == 4);
ASSERT_STATIC (sizeof (uint32_t) == 4);
ASSERT_STATIC (sizeof (int64_t) == 8);
ASSERT_STATIC (sizeof (uint64_t) == 8);
static_assert ((sizeof (int8_t) == 1), "");
static_assert ((sizeof (uint8_t) == 1), "");
static_assert ((sizeof (int16_t) == 2), "");
static_assert ((sizeof (uint16_t) == 2), "");
static_assert ((sizeof (int32_t) == 4), "");
static_assert ((sizeof (uint32_t) == 4), "");
static_assert ((sizeof (int64_t) == 8), "");
static_assert ((sizeof (uint64_t) == 8), "");
ASSERT_STATIC (sizeof (hb_codepoint_t) == 4);
ASSERT_STATIC (sizeof (hb_position_t) == 4);
ASSERT_STATIC (sizeof (hb_mask_t) == 4);
ASSERT_STATIC (sizeof (hb_var_int_t) == 4);
static_assert ((sizeof (hb_codepoint_t) == 4), "");
static_assert ((sizeof (hb_position_t) == 4), "");
static_assert ((sizeof (hb_mask_t) == 4), "");
static_assert ((sizeof (hb_var_int_t) == 4), "");
/* We like our types POD */
@ -295,7 +317,7 @@ ASSERT_STATIC (sizeof (hb_var_int_t) == 4);
/* Void! */
struct _hb_void_t {};
typedef const _hb_void_t *hb_void_t;
#define HB_VOID ((const _hb_void_t *) NULL)
#define HB_VOID ((const _hb_void_t *) nullptr)
/* Return the number of 1 bits in mask. */
static inline HB_CONST_FUNC unsigned int
@ -311,6 +333,18 @@ _hb_popcount32 (uint32_t mask)
return (((y + (y >> 3)) & 030707070707) % 077);
#endif
}
static inline HB_CONST_FUNC unsigned int
_hb_popcount64 (uint64_t mask)
{
#if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
if (sizeof (long) >= sizeof (mask))
return __builtin_popcountl (mask);
#endif
return _hb_popcount32 (mask & 0xFFFFFFFF) + _hb_popcount32 (mask >> 32);
}
template <typename T> static inline unsigned int _hb_popcount (T mask);
template <> inline unsigned int _hb_popcount<uint32_t> (uint32_t mask) { return _hb_popcount32 (mask); }
template <> inline unsigned int _hb_popcount<uint64_t> (uint64_t mask) { return _hb_popcount64 (mask); }
/* Returns the number of bits needed to store number */
static inline HB_CONST_FUNC unsigned int
@ -361,7 +395,7 @@ typedef int (*hb_compare_func_t) (const void *, const void *);
/* arrays and maps */
#define HB_PREALLOCED_ARRAY_INIT {0, 0, NULL}
#define HB_PREALLOCED_ARRAY_INIT {0, 0, nullptr}
template <typename Type, unsigned int StaticSize=16>
struct hb_prealloced_array_t
{
@ -370,41 +404,56 @@ struct hb_prealloced_array_t
Type *array;
Type static_array[StaticSize];
void init (void) { memset (this, 0, sizeof (*this)); }
void init (void)
{
len = 0;
allocated = ARRAY_LENGTH (static_array);
array = static_array;
}
inline Type& operator [] (unsigned int i) { return array[i]; }
inline const Type& operator [] (unsigned int i) const { return array[i]; }
inline Type *push (void)
{
if (!array) {
array = static_array;
allocated = ARRAY_LENGTH (static_array);
}
if (likely (len < allocated))
return &array[len++];
if (unlikely (!resize (len + 1)))
return nullptr;
/* Need to reallocate */
unsigned int new_allocated = allocated + (allocated >> 1) + 8;
Type *new_array = NULL;
return &array[len - 1];
}
if (array == static_array) {
new_array = (Type *) calloc (new_allocated, sizeof (Type));
if (new_array)
memcpy (new_array, array, len * sizeof (Type));
} else {
bool overflows = (new_allocated < allocated) || _hb_unsigned_int_mul_overflows (new_allocated, sizeof (Type));
if (likely (!overflows)) {
new_array = (Type *) realloc (array, new_allocated * sizeof (Type));
inline bool resize (unsigned int size)
{
if (unlikely (size > allocated))
{
/* Need to reallocate */
unsigned int new_allocated = allocated;
while (size >= new_allocated)
new_allocated += (new_allocated >> 1) + 8;
Type *new_array = nullptr;
if (array == static_array) {
new_array = (Type *) calloc (new_allocated, sizeof (Type));
if (new_array)
memcpy (new_array, array, len * sizeof (Type));
} else {
bool overflows = (new_allocated < allocated) || _hb_unsigned_int_mul_overflows (new_allocated, sizeof (Type));
if (likely (!overflows)) {
new_array = (Type *) realloc (array, new_allocated * sizeof (Type));
}
}
if (unlikely (!new_array))
return false;
array = new_array;
allocated = new_allocated;
}
if (unlikely (!new_array))
return NULL;
array = new_array;
allocated = new_allocated;
return &array[len++];
len = size;
return true;
}
inline void pop (void)
@ -433,14 +482,14 @@ struct hb_prealloced_array_t
for (unsigned int i = 0; i < len; i++)
if (array[i] == v)
return &array[i];
return NULL;
return nullptr;
}
template <typename T>
inline const Type *find (T v) const {
for (unsigned int i = 0; i < len; i++)
if (array[i] == v)
return &array[i];
return NULL;
return nullptr;
}
inline void qsort (void)
@ -454,21 +503,46 @@ struct hb_prealloced_array_t
}
template <typename T>
inline Type *bsearch (T *key)
inline Type *bsearch (T *x)
{
return (Type *) ::bsearch (key, array, len, sizeof (Type), (hb_compare_func_t) Type::cmp);
unsigned int i;
return bfind (x, &i) ? &array[i] : nullptr;
}
template <typename T>
inline const Type *bsearch (T *key) const
inline const Type *bsearch (T *x) const
{
return (const Type *) ::bsearch (key, array, len, sizeof (Type), (hb_compare_func_t) Type::cmp);
unsigned int i;
return bfind (x, &i) ? &array[i] : nullptr;
}
template <typename T>
inline bool bfind (T *x, unsigned int *i) const
{
int min = 0, max = (int) this->len - 1;
while (min <= max)
{
int mid = (min + max) / 2;
int c = this->array[mid].cmp (x);
if (c < 0)
max = mid - 1;
else if (c > 0)
min = mid + 1;
else
{
*i = mid;
return true;
}
}
if (max < 0 || (max < (int) this->len && this->array[max].cmp (x) > 0))
max++;
*i = max;
return false;
}
inline void finish (void)
{
if (array != static_array)
free (array);
array = NULL;
array = nullptr;
allocated = len = 0;
}
};
@ -502,7 +576,7 @@ struct hb_lockable_set_t
old.finish ();
}
else {
item = NULL;
item = nullptr;
l.unlock ();
}
} else {
@ -765,8 +839,8 @@ _hb_debug_msg<0> (const char *what HB_UNUSED,
const char *message HB_UNUSED,
...) {}
#define DEBUG_MSG_LEVEL(WHAT, OBJ, LEVEL, LEVEL_DIR, ...) _hb_debug_msg<HB_DEBUG_##WHAT> (#WHAT, (OBJ), NULL, true, (LEVEL), (LEVEL_DIR), __VA_ARGS__)
#define DEBUG_MSG(WHAT, OBJ, ...) _hb_debug_msg<HB_DEBUG_##WHAT> (#WHAT, (OBJ), NULL, false, 0, 0, __VA_ARGS__)
#define DEBUG_MSG_LEVEL(WHAT, OBJ, LEVEL, LEVEL_DIR, ...) _hb_debug_msg<HB_DEBUG_##WHAT> (#WHAT, (OBJ), nullptr, true, (LEVEL), (LEVEL_DIR), __VA_ARGS__)
#define DEBUG_MSG(WHAT, OBJ, ...) _hb_debug_msg<HB_DEBUG_##WHAT> (#WHAT, (OBJ), nullptr, false, 0, 0, __VA_ARGS__)
#define DEBUG_MSG_FUNC(WHAT, OBJ, ...) _hb_debug_msg<HB_DEBUG_##WHAT> (#WHAT, (OBJ), HB_FUNC, false, 0, 0, __VA_ARGS__)
@ -825,7 +899,7 @@ struct hb_auto_trace_t {
{
_hb_warn_no_return<ret_t> (returned);
if (!returned) {
_hb_debug_msg<max_level> (what, obj, NULL, true, plevel ? *plevel : 1, -1, " ");
_hb_debug_msg<max_level> (what, obj, nullptr, true, plevel ? *plevel : 1, -1, " ");
}
if (plevel) --*plevel;
}
@ -837,11 +911,11 @@ struct hb_auto_trace_t {
return v;
}
_hb_debug_msg<max_level> (what, obj, NULL, true, plevel ? *plevel : 1, -1,
_hb_debug_msg<max_level> (what, obj, nullptr, true, plevel ? *plevel : 1, -1,
"return %s (line %d)",
hb_printer_t<ret_t>().print (v), line);
if (plevel) --*plevel;
plevel = NULL;
plevel = nullptr;
returned = true;
return v;
}
@ -882,7 +956,7 @@ hb_in_range (T u, T lo, T hi)
* one right now. Declaring a variable won't work as HB_UNUSED
* is unusable on some platforms and unused types are less likely
* to generate a warning than unused variables. */
ASSERT_STATIC (sizeof (hb_assert_unsigned_t<T>) >= 0);
static_assert ((sizeof (hb_assert_unsigned_t<T>) >= 0), "");
/* The casts below are important as if T is smaller than int,
* the subtract results will become a signed int! */
@ -927,11 +1001,10 @@ hb_in_ranges (T u, T lo1, T hi1, T lo2, T hi2, T lo3, T hi3)
/* Useful for set-operations on small enums.
* For example, for testing "x ∈ {x1, x2, x3}" use:
* (FLAG_SAFE(x) & (FLAG(x1) | FLAG(x2) | FLAG(x3)))
* (FLAG_UNSAFE(x) & (FLAG(x1) | FLAG(x2) | FLAG(x3)))
*/
#define FLAG(x) (ASSERT_STATIC_EXPR_ZERO ((x) < 32) + (1U << (x)))
#define FLAG_SAFE(x) (1U << (x))
#define FLAG_UNSAFE(x) ((x) < 32 ? FLAG_SAFE(x) : 0)
#define FLAG(x) (ASSERT_STATIC_EXPR_ZERO ((unsigned int)(x) < 32) + (1U << (unsigned int)(x)))
#define FLAG_UNSAFE(x) ((unsigned int)(x) < 32 ? (1U << (unsigned int)(x)) : 0)
#define FLAG_RANGE(x,y) (ASSERT_STATIC_EXPR_ZERO ((x) < (y)) + FLAG(y+1) - FLAG(x))
@ -963,7 +1036,7 @@ hb_stable_sort (T *array, unsigned int len, int(*compar)(const T *, const T *),
template <typename T> static inline void
hb_stable_sort (T *array, unsigned int len, int(*compar)(const T *, const T *))
{
hb_stable_sort (array, len, compar, (int *) NULL);
hb_stable_sort (array, len, compar, (int *) nullptr);
}
static inline hb_bool_t
@ -985,6 +1058,73 @@ hb_codepoint_parse (const char *s, unsigned int len, int base, hb_codepoint_t *o
}
/* Vectorization */
struct HbOpOr
{
static const bool passthru_left = true;
static const bool passthru_right = true;
template <typename T> static void process (T &o, const T &a, const T &b) { o = a | b; }
};
struct HbOpAnd
{
static const bool passthru_left = false;
static const bool passthru_right = false;
template <typename T> static void process (T &o, const T &a, const T &b) { o = a & b; }
};
struct HbOpMinus
{
static const bool passthru_left = true;
static const bool passthru_right = false;
template <typename T> static void process (T &o, const T &a, const T &b) { o = a & ~b; }
};
struct HbOpXor
{
static const bool passthru_left = true;
static const bool passthru_right = true;
template <typename T> static void process (T &o, const T &a, const T &b) { o = a ^ b; }
};
/* Type behaving similar to vectorized vars defined using __attribute__((vector_size(...))). */
template <typename elt_t, unsigned int byte_size>
struct hb_vector_size_t
{
elt_t& operator [] (unsigned int i) { return v[i]; }
const elt_t& operator [] (unsigned int i) const { return v[i]; }
template <class Op>
inline hb_vector_size_t process (const hb_vector_size_t &o) const
{
hb_vector_size_t r;
for (unsigned int i = 0; i < ARRAY_LENGTH (v); i++)
Op::process (r.v[i], v[i], o.v[i]);
return r;
}
inline hb_vector_size_t operator | (const hb_vector_size_t &o) const
{ return process<HbOpOr> (o); }
inline hb_vector_size_t operator & (const hb_vector_size_t &o) const
{ return process<HbOpAnd> (o); }
inline hb_vector_size_t operator ^ (const hb_vector_size_t &o) const
{ return process<HbOpXor> (o); }
inline hb_vector_size_t operator ~ () const
{
hb_vector_size_t r;
for (unsigned int i = 0; i < ARRAY_LENGTH (v); i++)
r.v[i] = ~v[i];
return r;
}
private:
static_assert (byte_size / sizeof (elt_t) * sizeof (elt_t) == byte_size, "");
elt_t v[byte_size / sizeof (elt_t)];
};
/* The `vector_size' attribute was introduced in gcc 3.1. */
#if defined( __GNUC__ ) && ( __GNUC__ >= 4 )
#define HAVE_VECTOR_SIZE 1
#endif
/* Global runtime options. */
struct hb_options_t
@ -997,7 +1137,7 @@ union hb_options_union_t {
unsigned int i;
hb_options_t opts;
};
ASSERT_STATIC (sizeof (int) == sizeof (hb_options_union_t));
static_assert ((sizeof (int) == sizeof (hb_options_union_t)), "");
HB_INTERNAL void
_hb_options_init (void);

144
gfx/harfbuzz/src/hb-set-digest-private.hh Normal file
Просмотреть файл

@ -0,0 +1,144 @@
/*
* Copyright © 2012 Google, 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.
*
* Google Author(s): Behdad Esfahbod
*/
#ifndef HB_SET_DIGEST_PRIVATE_HH
#define HB_SET_DIGEST_PRIVATE_HH
#include "hb-private.hh"
/*
* The set digests here implement various "filters" that support
* "approximate member query". Conceptually these are like Bloom
* Filter and Quotient Filter, however, much smaller, faster, and
* designed to fit the requirements of our uses for glyph coverage
* queries.
*
* Our filters are highly accurate if the lookup covers fairly local
* set of glyphs, but fully flooded and ineffective if coverage is
* all over the place.
*
* The frozen-set can be used instead of a digest, to trade more
* memory for 100% accuracy, but in practice, that doesn't look like
* an attractive trade-off.
*/
template <typename mask_t, unsigned int shift>
struct hb_set_digest_lowest_bits_t
{
ASSERT_POD ();
static const unsigned int mask_bytes = sizeof (mask_t);
static const unsigned int mask_bits = sizeof (mask_t) * 8;
static const unsigned int num_bits = 0
+ (mask_bytes >= 1 ? 3 : 0)
+ (mask_bytes >= 2 ? 1 : 0)
+ (mask_bytes >= 4 ? 1 : 0)
+ (mask_bytes >= 8 ? 1 : 0)
+ (mask_bytes >= 16? 1 : 0)
+ 0;
static_assert ((shift < sizeof (hb_codepoint_t) * 8), "");
static_assert ((shift + num_bits <= sizeof (hb_codepoint_t) * 8), "");
inline void init (void) {
mask = 0;
}
inline void add (hb_codepoint_t g) {
mask |= mask_for (g);
}
inline void add_range (hb_codepoint_t a, hb_codepoint_t b) {
if ((b >> shift) - (a >> shift) >= mask_bits - 1)
mask = (mask_t) -1;
else {
mask_t ma = mask_for (a);
mask_t mb = mask_for (b);
mask |= mb + (mb - ma) - (mb < ma);
}
}
inline bool may_have (hb_codepoint_t g) const {
return !!(mask & mask_for (g));
}
private:
static inline mask_t mask_for (hb_codepoint_t g) {
return ((mask_t) 1) << ((g >> shift) & (mask_bits - 1));
}
mask_t mask;
};
template <typename head_t, typename tail_t>
struct hb_set_digest_combiner_t
{
ASSERT_POD ();
inline void init (void) {
head.init ();
tail.init ();
}
inline void add (hb_codepoint_t g) {
head.add (g);
tail.add (g);
}
inline void add_range (hb_codepoint_t a, hb_codepoint_t b) {
head.add_range (a, b);
tail.add_range (a, b);
}
inline bool may_have (hb_codepoint_t g) const {
return head.may_have (g) && tail.may_have (g);
}
private:
head_t head;
tail_t tail;
};
/*
* hb_set_digest_t
*
* This is a combination of digests that performs "best".
* There is not much science to this: it's a result of intuition
* and testing.
*/
typedef hb_set_digest_combiner_t
<
hb_set_digest_lowest_bits_t<unsigned long, 4>,
hb_set_digest_combiner_t
<
hb_set_digest_lowest_bits_t<unsigned long, 0>,
hb_set_digest_lowest_bits_t<unsigned long, 9>
>
> hb_set_digest_t;
#endif /* HB_SET_DIGEST_PRIVATE_HH */

573
gfx/harfbuzz/src/hb-set-private.hh
Просмотреть файл

@ -1,5 +1,5 @@
/*
* Copyright © 2012 Google, Inc.
* Copyright © 2012,2017 Google, Inc.
*
* This is part of HarfBuzz, a text shaping library.
*
@ -31,158 +31,174 @@
#include "hb-object-private.hh"
/*
* The set digests here implement various "filters" that support
* "approximate member query". Conceptually these are like Bloom
* Filter and Quotient Filter, however, much smaller, faster, and
* designed to fit the requirements of our uses for glyph coverage
* queries.
*
* Our filters are highly accurate if the lookup covers fairly local
* set of glyphs, but fully flooded and ineffective if coverage is
* all over the place.
*
* The frozen-set can be used instead of a digest, to trade more
* memory for 100% accuracy, but in practice, that doesn't look like
* an attractive trade-off.
*/
template <typename mask_t, unsigned int shift>
struct hb_set_digest_lowest_bits_t
{
ASSERT_POD ();
static const unsigned int mask_bytes = sizeof (mask_t);
static const unsigned int mask_bits = sizeof (mask_t) * 8;
static const unsigned int num_bits = 0
+ (mask_bytes >= 1 ? 3 : 0)
+ (mask_bytes >= 2 ? 1 : 0)
+ (mask_bytes >= 4 ? 1 : 0)
+ (mask_bytes >= 8 ? 1 : 0)
+ (mask_bytes >= 16? 1 : 0)
+ 0;
ASSERT_STATIC (shift < sizeof (hb_codepoint_t) * 8);
ASSERT_STATIC (shift + num_bits <= sizeof (hb_codepoint_t) * 8);
inline void init (void) {
mask = 0;
}
inline void add (hb_codepoint_t g) {
mask |= mask_for (g);
}
inline void add_range (hb_codepoint_t a, hb_codepoint_t b) {
if ((b >> shift) - (a >> shift) >= mask_bits - 1)
mask = (mask_t) -1;
else {
mask_t ma = mask_for (a);
mask_t mb = mask_for (b);
mask |= mb + (mb - ma) - (mb < ma);
}
}
inline bool may_have (hb_codepoint_t g) const {
return !!(mask & mask_for (g));
}
private:
static inline mask_t mask_for (hb_codepoint_t g) {
return ((mask_t) 1) << ((g >> shift) & (mask_bits - 1));
}
mask_t mask;
};
template <typename head_t, typename tail_t>
struct hb_set_digest_combiner_t
{
ASSERT_POD ();
inline void init (void) {
head.init ();
tail.init ();
}
inline void add (hb_codepoint_t g) {
head.add (g);
tail.add (g);
}
inline void add_range (hb_codepoint_t a, hb_codepoint_t b) {
head.add_range (a, b);
tail.add_range (a, b);
}
inline bool may_have (hb_codepoint_t g) const {
return head.may_have (g) && tail.may_have (g);
}
private:
head_t head;
tail_t tail;
};
/*
* hb_set_digest_t
*
* This is a combination of digests that performs "best".
* There is not much science to this: it's a result of intuition
* and testing.
*/
typedef hb_set_digest_combiner_t
<
hb_set_digest_lowest_bits_t<unsigned long, 4>,
hb_set_digest_combiner_t
<
hb_set_digest_lowest_bits_t<unsigned long, 0>,
hb_set_digest_lowest_bits_t<unsigned long, 9>
>
> hb_set_digest_t;
/*
* hb_set_t
*/
/* TODO Make this faster and memmory efficient. */
struct hb_set_t
{
friend struct hb_frozen_set_t;
struct page_map_t
{
inline int cmp (const page_map_t *o) const { return (int) o->major - (int) major; }
uint32_t major;
uint32_t index;
};
struct page_t
{
inline void init (void) {
memset (&v, 0, sizeof (v));
}
inline unsigned int len (void) const
{ return ARRAY_LENGTH_CONST (v); }
inline bool is_empty (void) const
{
for (unsigned int i = 0; i < len (); i++)
if (v[i])
return false;
return true;
}
inline void add (hb_codepoint_t g) { elt (g) |= mask (g); }
inline void del (hb_codepoint_t g) { elt (g) &= ~mask (g); }
inline bool has (hb_codepoint_t g) const { return !!(elt (g) & mask (g)); }
inline bool is_equal (const page_t *other) const
{
return 0 == memcmp (&v, &other->v, sizeof (v));
}
inline unsigned int get_population (void) const
{
unsigned int pop = 0;
for (unsigned int i = 0; i < len (); i++)
pop += _hb_popcount (v[i]);
return pop;
}
inline bool next (hb_codepoint_t *codepoint) 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;
for (; j < ELT_BITS; j++)
if (v[i] & (elt_t (1) << j))
goto found;
for (i++; i < len (); i++)
if (v[i])
for (j = 0; j < ELT_BITS; j++)
if (v[i] & (elt_t (1) << j))
goto found;
*codepoint = INVALID;
return false;
found:
*codepoint = i * ELT_BITS + j;
return true;
}
inline hb_codepoint_t get_min (void) const
{
for (unsigned int i = 0; i < len (); i++)
if (v[i])
{
elt_t e = v[i];
for (unsigned int j = 0; j < ELT_BITS; j++)
if (e & (elt_t (1) << j))
return i * ELT_BITS + j;
}
return INVALID;
}
inline hb_codepoint_t get_max (void) const
{
for (int i = len () - 1; i >= 0; i--)
if (v[i])
{
elt_t e = v[i];
for (int j = ELT_BITS - 1; j >= 0; j--)
if (e & (elt_t (1) << j))
return i * ELT_BITS + j;
}
return 0;
}
static const unsigned int PAGE_BITS = 512; /* Use to tune. */
static_assert ((PAGE_BITS & ((PAGE_BITS) - 1)) == 0, "");
typedef uint64_t elt_t;
#if 0 && HAVE_VECTOR_SIZE
/* The vectorized version does not work with clang as non-const
* elt() errs "non-const reference cannot bind to vector element". */
typedef elt_t vector_t __attribute__((vector_size (PAGE_BITS / 8)));
#else
typedef hb_vector_size_t<elt_t, PAGE_BITS / 8> vector_t;
#endif
vector_t v;
static const unsigned int ELT_BITS = sizeof (elt_t) * 8;
static const unsigned int ELT_MASK = ELT_BITS - 1;
static const unsigned int BITS = sizeof (vector_t) * 8;
static const unsigned int MASK = BITS - 1;
static_assert (PAGE_BITS == BITS, "");
elt_t &elt (hb_codepoint_t g) { return v[(g & MASK) / ELT_BITS]; }
elt_t const &elt (hb_codepoint_t g) const { return v[(g & MASK) / ELT_BITS]; }
elt_t mask (hb_codepoint_t g) const { return elt_t (1) << (g & ELT_MASK); }
};
static_assert (page_t::PAGE_BITS == sizeof (page_t) * 8, "");
hb_object_header_t header;
ASSERT_POD ();
bool in_error;
hb_prealloced_array_t<page_map_t, 8> page_map;
hb_prealloced_array_t<page_t, 8> pages;
inline void init (void) {
hb_object_init (this);
clear ();
}
inline void fini (void) {
inline bool resize (unsigned int count)
{
if (unlikely (in_error)) return false;
if (!pages.resize (count) || !page_map.resize (count))
{
pages.resize (page_map.len);
in_error = true;
return false;
}
return true;
}
inline void clear (void) {
if (unlikely (hb_object_is_inert (this)))
return;
in_error = false;
memset (elts, 0, sizeof elts);
page_map.resize (0);
pages.resize (0);
}
inline bool is_empty (void) const {
for (unsigned int i = 0; i < ARRAY_LENGTH (elts); i++)
if (elts[i])
unsigned int count = pages.len;
for (unsigned int i = 0; i < count; i++)
if (!pages[i].is_empty ())
return false;
return true;
}
inline void add (hb_codepoint_t g)
{
if (unlikely (in_error)) return;
if (unlikely (g == INVALID)) return;
if (unlikely (g > MAX_G)) return;
elt (g) |= mask (g);
page_t *page = page_for_insert (g);
if (!page)
return;
page->add (g);
}
inline void add_range (hb_codepoint_t a, hb_codepoint_t b)
{
@ -194,92 +210,181 @@ struct hb_set_t
inline void del (hb_codepoint_t g)
{
if (unlikely (in_error)) return;
if (unlikely (g > MAX_G)) return;
elt (g) &= ~mask (g);
page_t *p = page_for (g);
if (!p)
return;
p->del (g);
}
inline void del_range (hb_codepoint_t a, hb_codepoint_t b)
{
if (unlikely (in_error)) return;
/* TODO Speedup */
for (unsigned int i = a; i < b + 1; i++)
del (i);
}
inline bool has (hb_codepoint_t g) const
{
if (unlikely (g > MAX_G)) return false;
return !!(elt (g) & mask (g));
const page_t *p = page_for (g);
if (!p)
return false;
return p->has (g);
}
inline bool intersects (hb_codepoint_t first,
hb_codepoint_t last) const
{
if (unlikely (first > MAX_G)) return false;
if (unlikely (last > MAX_G)) last = MAX_G;
unsigned int end = last + 1;
for (hb_codepoint_t i = first; i < end; i++)
if (has (i))
return true;
return false;
}
inline bool is_equal (const hb_set_t *other) const
{
for (unsigned int i = 0; i < ELTS; i++)
if (elts[i] != other->elts[i])
return false;
return true;
hb_codepoint_t c = first - 1;
return next (&c) && c <= last;
}
inline void set (const hb_set_t *other)
{
if (unlikely (in_error)) return;
for (unsigned int i = 0; i < ELTS; i++)
elts[i] = other->elts[i];
unsigned int count = other->pages.len;
if (!resize (count))
return;
memcpy (pages.array, other->pages.array, count * sizeof (pages.array[0]));
memcpy (page_map.array, other->page_map.array, count * sizeof (page_map.array[0]));
}
inline void union_ (const hb_set_t *other)
inline bool is_equal (const hb_set_t *other) const
{
unsigned int na = pages.len;
unsigned int nb = other->pages.len;
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;
}
template <class Op>
inline void process (const hb_set_t *other)
{
if (unlikely (in_error)) return;
for (unsigned int i = 0; i < ELTS; i++)
elts[i] |= other->elts[i];
unsigned int na = pages.len;
unsigned int nb = other->pages.len;
unsigned int count = 0;
unsigned int a = 0, b = 0;
for (; a < na && b < nb; )
{
if (page_map[a].major == other->page_map[b].major)
{
count++;
a++;
b++;
}
else if (page_map[a].major < other->page_map[b].major)
{
if (Op::passthru_left)
count++;
a++;
}
else
{
if (Op::passthru_right)
count++;
b++;
}
}
if (Op::passthru_left)
count += na - a;
if (Op::passthru_right)
count += nb - b;
if (!resize (count))
return;
/* 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--;
Op::process (page_at (--count).v, page_at (a).v, other->page_at (b).v);
}
else if (page_map[a - 1].major > other->page_map[b - 1].major)
{
a--;
if (Op::passthru_left)
page_at (--count).v = page_at (a).v;
}
else
{
b--;
if (Op::passthru_right)
page_at (--count).v = other->page_at (b).v;
}
}
if (Op::passthru_left)
while (a)
page_at (--count).v = page_at (--a).v;
if (Op::passthru_right)
while (b)
page_at (--count).v = other->page_at (--b).v;
assert (!count);
}
inline void union_ (const hb_set_t *other)
{
process<HbOpOr> (other);
}
inline void intersect (const hb_set_t *other)
{
if (unlikely (in_error)) return;
for (unsigned int i = 0; i < ELTS; i++)
elts[i] &= other->elts[i];
process<HbOpAnd> (other);
}
inline void subtract (const hb_set_t *other)
{
if (unlikely (in_error)) return;
for (unsigned int i = 0; i < ELTS; i++)
elts[i] &= ~other->elts[i];
process<HbOpMinus> (other);
}
inline void symmetric_difference (const hb_set_t *other)
{
if (unlikely (in_error)) return;
for (unsigned int i = 0; i < ELTS; i++)
elts[i] ^= other->elts[i];
}
inline void invert (void)
{
if (unlikely (in_error)) return;
for (unsigned int i = 0; i < ELTS; i++)
elts[i] = ~elts[i];
process<HbOpXor> (other);
}
inline bool next (hb_codepoint_t *codepoint) const
{
if (unlikely (*codepoint == INVALID)) {
hb_codepoint_t i = get_min ();
if (i != INVALID) {
*codepoint = i;
*codepoint = get_min ();
return *codepoint != INVALID;
}
page_map_t map = {get_major (*codepoint), 0};
unsigned int i;
page_map.bfind (&map, &i);
if (i < page_map.len)
{
if (pages[page_map[i].index].next (codepoint))
{
*codepoint += page_map[i].major * page_t::PAGE_BITS;
return true;
}
i++;
}
for (; i < page_map.len; i++)
{
hb_codepoint_t m = pages[page_map[i].index].get_min ();
if (m != INVALID)
{
*codepoint = page_map[i].major * page_t::PAGE_BITS + m;
return true;
} else {
*codepoint = INVALID;
return false;
}
}
for (hb_codepoint_t i = *codepoint + 1; i < MAX_G + 1; i++)
if (has (i)) {
*codepoint = i;
return true;
}
*codepoint = INVALID;
return false;
}
@ -303,99 +408,65 @@ struct hb_set_t
inline unsigned int get_population (void) const
{
unsigned int count = 0;
for (unsigned int i = 0; i < ELTS; i++)
count += _hb_popcount32 (elts[i]);
return count;
unsigned int pop = 0;
unsigned int count = pages.len;
for (unsigned int i = 0; i < count; i++)
pop += pages[i].get_population ();
return pop;
}
inline hb_codepoint_t get_min (void) const
{
for (unsigned int i = 0; i < ELTS; i++)
if (elts[i])
for (unsigned int j = 0; j < BITS; j++)
if (elts[i] & (1u << j))
return i * BITS + j;
unsigned int count = pages.len;
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;
}
inline hb_codepoint_t get_max (void) const
{
for (unsigned int i = ELTS; i; i--)
if (elts[i - 1])
for (unsigned int j = BITS; j; j--)
if (elts[i - 1] & (1u << (j - 1)))
return (i - 1) * BITS + (j - 1);
unsigned int count = pages.len;
for (int i = count - 1; i >= 0; i++)
if (!page_at (i).is_empty ())
return page_map[i].major * page_t::PAGE_BITS + page_at (i).get_max ();
return INVALID;
}
typedef uint32_t elt_t;
static const unsigned int MAX_G = 65536 - 1; /* XXX Fix this... */
static const unsigned int SHIFT = 5;
static const unsigned int BITS = (1 << SHIFT);
static const unsigned int MASK = BITS - 1;
static const unsigned int ELTS = (MAX_G + 1 + (BITS - 1)) / BITS;
static const hb_codepoint_t INVALID = HB_SET_VALUE_INVALID;
elt_t &elt (hb_codepoint_t g) { return elts[g >> SHIFT]; }
elt_t const &elt (hb_codepoint_t g) const { return elts[g >> SHIFT]; }
elt_t mask (hb_codepoint_t g) const { return elt_t (1) << (g & MASK); }
elt_t elts[ELTS]; /* XXX 8kb */
ASSERT_STATIC (sizeof (elt_t) * 8 == BITS);
ASSERT_STATIC (sizeof (elt_t) * 8 * ELTS > MAX_G);
};
struct hb_frozen_set_t
{
static const unsigned int SHIFT = hb_set_t::SHIFT;
static const unsigned int BITS = hb_set_t::BITS;
static const unsigned int MASK = hb_set_t::MASK;
typedef hb_set_t::elt_t elt_t;
inline void init (const hb_set_t &set)
page_t *page_for_insert (hb_codepoint_t g)
{
start = count = 0;
elts = NULL;
unsigned int max = set.get_max ();
if (max == set.INVALID)
return;
unsigned int min = set.get_min ();
const elt_t &min_elt = set.elt (min);
start = min & ~MASK;
count = max - start + 1;
unsigned int num_elts = (count + BITS - 1) / BITS;
unsigned int elts_size = num_elts * sizeof (elt_t);
elts = (elt_t *) malloc (elts_size);
if (unlikely (!elts))
page_map_t map = {get_major (g), pages.len};
unsigned int i;
if (!page_map.bfind (&map, &i))
{
start = count = 0;
return;
if (!resize (pages.len + 1))
return nullptr;
pages[map.index].init ();
memmove (&page_map[i + 1], &page_map[i], (page_map.len - 1 - i) * sizeof (page_map[0]));
page_map[i] = map;
}
memcpy (elts, &min_elt, elts_size);
return &pages[page_map[i].index];
}
inline void fini (void)
page_t *page_for (hb_codepoint_t g)
{
if (elts)
free (elts);
page_map_t key = {get_major (g)};
const page_map_t *found = page_map.bsearch (&key);
if (found)
return &pages[found->index];
return nullptr;
}
inline bool has (hb_codepoint_t g) const
const page_t *page_for (hb_codepoint_t g) const
{
/* hb_codepoint_t is unsigned. */
g -= start;
if (unlikely (g > count)) return false;
return !!(elt (g) & mask (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;
}
elt_t const &elt (hb_codepoint_t g) const { return elts[g >> SHIFT]; }
elt_t mask (hb_codepoint_t g) const { return elt_t (1) << (g & MASK); }
private:
hb_codepoint_t start, count;
elt_t *elts;
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; }
};

9
gfx/harfbuzz/src/hb-set.cc
Просмотреть файл

@ -45,7 +45,8 @@ hb_set_create (void)
if (!(set = hb_object_create<hb_set_t> ()))
return hb_set_get_empty ();
set->clear ();
set->page_map.init ();
set->pages.init ();
return set;
}
@ -95,7 +96,8 @@ hb_set_destroy (hb_set_t *set)
{
if (!hb_object_destroy (set)) return;
set->fini ();
set->page_map.finish ();
set->pages.finish ();
free (set);
}
@ -376,11 +378,12 @@ hb_set_symmetric_difference (hb_set_t *set,
*
*
* Since: 0.9.10
*
* Deprecated: 1.6.1
**/
void
hb_set_invert (hb_set_t *set)
{
set->invert ();
}
/**

3
gfx/harfbuzz/src/hb-set.h
Просмотреть файл

@ -126,9 +126,6 @@ HB_EXTERN void
hb_set_symmetric_difference (hb_set_t *set,
const hb_set_t *other);
HB_EXTERN void
hb_set_invert (hb_set_t *set);
HB_EXTERN unsigned int
hb_set_get_population (const hb_set_t *set);

24
gfx/harfbuzz/src/hb-shape-plan.cc
Просмотреть файл

@ -115,7 +115,7 @@ hb_shape_plan_create (hb_face_t *face,
{
return hb_shape_plan_create2 (face, props,
user_features, num_user_features,
NULL, 0,
nullptr, 0,
shaper_list);
}
@ -128,7 +128,7 @@ hb_shape_plan_create2 (hb_face_t *face,
unsigned int num_coords,
const char * const *shaper_list)
{
DEBUG_MSG_FUNC (SHAPE_PLAN, NULL,
DEBUG_MSG_FUNC (SHAPE_PLAN, nullptr,
"face=%p num_features=%d num_coords=%d shaper_list=%p",
face,
num_user_features,
@ -136,8 +136,8 @@ hb_shape_plan_create2 (hb_face_t *face,
shaper_list);
hb_shape_plan_t *shape_plan;
hb_feature_t *features = NULL;
int *coords = NULL;
hb_feature_t *features = nullptr;
int *coords = nullptr;
if (unlikely (!face))
face = hb_face_get_empty ();
@ -196,16 +196,16 @@ hb_shape_plan_get_empty (void)
HB_OBJECT_HEADER_STATIC,
true, /* default_shaper_list */
NULL, /* face */
nullptr, /* face */
HB_SEGMENT_PROPERTIES_DEFAULT, /* props */
NULL, /* shaper_func */
NULL, /* shaper_name */
nullptr, /* shaper_func */
nullptr, /* shaper_name */
NULL, /* user_features */
nullptr, /* user_features */
0, /* num_user_featurs */
NULL, /* coords */
nullptr, /* coords */
0, /* num_coords */
{
@ -470,7 +470,7 @@ hb_shape_plan_create_cached (hb_face_t *face,
{
return hb_shape_plan_create_cached2 (face, props,
user_features, num_user_features,
NULL, 0,
nullptr, 0,
shaper_list);
}
@ -483,7 +483,7 @@ hb_shape_plan_create_cached2 (hb_face_t *face,
unsigned int num_coords,
const char * const *shaper_list)
{
DEBUG_MSG_FUNC (SHAPE_PLAN, NULL,
DEBUG_MSG_FUNC (SHAPE_PLAN, nullptr,
"face=%p num_features=%d shaper_list=%p",
face,
num_user_features,
@ -494,7 +494,7 @@ hb_shape_plan_create_cached2 (hb_face_t *face,
shaper_list,
user_features,
num_user_features,
NULL
nullptr
};
if (shaper_list) {

8
gfx/harfbuzz/src/hb-shape.cc
Просмотреть файл

@ -76,7 +76,7 @@ retry:
/* Not found; allocate one. */
shaper_list = (const char **) calloc (1 + HB_SHAPERS_COUNT, sizeof (const char *));
if (unlikely (!shaper_list)) {
static const char *nil_shaper_list[] = {NULL};
static const char *nil_shaper_list[] = {nullptr};
return nil_shaper_list;
}
@ -84,9 +84,9 @@ retry:
unsigned int i;
for (i = 0; i < HB_SHAPERS_COUNT; i++)
shaper_list[i] = shapers[i].name;
shaper_list[i] = NULL;
shaper_list[i] = nullptr;
if (!hb_atomic_ptr_cmpexch (&static_shaper_list, NULL, shaper_list)) {
if (!hb_atomic_ptr_cmpexch (&static_shaper_list, nullptr, shaper_list)) {
free (shaper_list);
goto retry;
}
@ -157,5 +157,5 @@ hb_shape (hb_font_t *font,
const hb_feature_t *features,
unsigned int num_features)
{
hb_shape_full (font, buffer, features, num_features, NULL);
hb_shape_full (font, buffer, features, num_features, nullptr);
}

6
gfx/harfbuzz/src/hb-shaper-private.hh
Просмотреть файл

@ -100,7 +100,7 @@ HB_SHAPER_DATA_ENSURE_FUNC(shaper, object) (hb_##object##_t *object) \
/* Drop and recreate. */ \
/* If someone dropped it in the mean time, throw it away and don't touch it. \
* Otherwise, destruct it. */ \
if (hb_atomic_ptr_cmpexch (&HB_SHAPER_DATA (shaper, object), data, NULL)) { \
if (hb_atomic_ptr_cmpexch (&HB_SHAPER_DATA (shaper, object), data, nullptr)) { \
HB_SHAPER_DATA_DESTROY_FUNC (shaper, object) (data); \
} \
goto retry; \
@ -109,7 +109,7 @@ HB_SHAPER_DATA_ENSURE_FUNC(shaper, object) (hb_##object##_t *object) \
data = HB_SHAPER_DATA_CREATE_FUNC (shaper, object) (object); \
if (unlikely (!data)) \
data = (HB_SHAPER_DATA_TYPE (shaper, object) *) HB_SHAPER_DATA_INVALID; \
if (!hb_atomic_ptr_cmpexch (&HB_SHAPER_DATA (shaper, object), NULL, data)) { \
if (!hb_atomic_ptr_cmpexch (&HB_SHAPER_DATA (shaper, object), nullptr, data)) { \
if (data && \
data != HB_SHAPER_DATA_INVALID && \
data != HB_SHAPER_DATA_SUCCEEDED) \
@ -117,7 +117,7 @@ HB_SHAPER_DATA_ENSURE_FUNC(shaper, object) (hb_##object##_t *object) \
goto retry; \
} \
} \
return data != NULL && !HB_SHAPER_DATA_IS_INVALID (data); \
return data != nullptr && !HB_SHAPER_DATA_IS_INVALID (data); \
}

6
gfx/harfbuzz/src/hb-shaper.cc
Просмотреть файл

@ -59,14 +59,14 @@ retry:
{
char *env = getenv ("HB_SHAPER_LIST");
if (!env || !*env) {
(void) hb_atomic_ptr_cmpexch (&static_shapers, NULL, &all_shapers[0]);
(void) hb_atomic_ptr_cmpexch (&static_shapers, nullptr, &all_shapers[0]);
return (const hb_shaper_pair_t *) all_shapers;
}
/* Not found; allocate one. */
shapers = (hb_shaper_pair_t *) calloc (1, sizeof (all_shapers));
if (unlikely (!shapers)) {
(void) hb_atomic_ptr_cmpexch (&static_shapers, NULL, &all_shapers[0]);
(void) hb_atomic_ptr_cmpexch (&static_shapers, nullptr, &all_shapers[0]);
return (const hb_shaper_pair_t *) all_shapers;
}
@ -97,7 +97,7 @@ retry:
p = end + 1;
}
if (!hb_atomic_ptr_cmpexch (&static_shapers, NULL, shapers)) {
if (!hb_atomic_ptr_cmpexch (&static_shapers, nullptr, shapers)) {
free (shapers);
goto retry;
}

2
gfx/harfbuzz/src/hb-ucdn.cc
Просмотреть файл

@ -238,7 +238,7 @@ hb_ucdn_get_unicode_funcs (void)
static const hb_unicode_funcs_t _hb_ucdn_unicode_funcs = {
HB_OBJECT_HEADER_STATIC,
NULL, /* parent */
nullptr, /* parent */
true, /* immutable */
{
#define HB_UNICODE_FUNC_IMPLEMENT(name) hb_ucdn_##name,

4
gfx/harfbuzz/src/hb-unicode-private.hh
Просмотреть файл

@ -357,13 +357,13 @@ extern HB_INTERNAL const hb_unicode_funcs_t _hb_unicode_funcs_nil;
/* Misc */
#define HB_UNICODE_GENERAL_CATEGORY_IS_MARK(gen_cat) \
(FLAG_SAFE (gen_cat) & \
(FLAG_UNSAFE (gen_cat) & \
(FLAG (HB_UNICODE_GENERAL_CATEGORY_SPACING_MARK) | \
FLAG (HB_UNICODE_GENERAL_CATEGORY_ENCLOSING_MARK) | \
FLAG (HB_UNICODE_GENERAL_CATEGORY_NON_SPACING_MARK)))
#define HB_UNICODE_GENERAL_CATEGORY_IS_NON_ENCLOSING_MARK_OR_MODIFIER_SYMBOL(gen_cat) \
(FLAG_SAFE (gen_cat) & \
(FLAG_UNSAFE (gen_cat) & \
(FLAG (HB_UNICODE_GENERAL_CATEGORY_SPACING_MARK) | \
FLAG (HB_UNICODE_GENERAL_CATEGORY_NON_SPACING_MARK) | \
FLAG (HB_UNICODE_GENERAL_CATEGORY_MODIFIER_SYMBOL)))

4
gfx/harfbuzz/src/hb-unicode.cc
Просмотреть файл

@ -188,7 +188,7 @@ hb_unicode_funcs_create (hb_unicode_funcs_t *parent)
const hb_unicode_funcs_t _hb_unicode_funcs_nil = {
HB_OBJECT_HEADER_STATIC,
NULL, /* parent */
nullptr, /* parent */
true, /* immutable */
{
#define HB_UNICODE_FUNC_IMPLEMENT(name) hb_unicode_##name##_nil,
@ -365,7 +365,7 @@ hb_unicode_funcs_set_##name##_func (hb_unicode_funcs_t *ufuncs, \
} else { \
ufuncs->func.name = ufuncs->parent->func.name; \
ufuncs->user_data.name = ufuncs->parent->user_data.name; \
ufuncs->destroy.name = NULL; \
ufuncs->destroy.name = nullptr; \
} \
}

52
gfx/harfbuzz/src/hb-uniscribe.cc
Просмотреть файл

@ -202,9 +202,9 @@ struct hb_uniscribe_shaper_funcs_t {
inline void init (void)
{
HMODULE hinstLib;
this->ScriptItemizeOpenType = NULL;
this->ScriptShapeOpenType = NULL;
this->ScriptPlaceOpenType = NULL;
this->ScriptItemizeOpenType = nullptr;
this->ScriptShapeOpenType = nullptr;
this->ScriptPlaceOpenType = nullptr;
hinstLib = GetModuleHandle (TEXT ("usp10.dll"));
if (hinstLib)
@ -217,7 +217,7 @@ struct hb_uniscribe_shaper_funcs_t {
!this->ScriptShapeOpenType ||
!this->ScriptPlaceOpenType)
{
DEBUG_MSG (UNISCRIBE, NULL, "OpenType versions of functions not found; falling back.");
DEBUG_MSG (UNISCRIBE, nullptr, "OpenType versions of functions not found; falling back.");
this->ScriptItemizeOpenType = hb_ScriptItemizeOpenType;
this->ScriptShapeOpenType = hb_ScriptShapeOpenType;
this->ScriptPlaceOpenType = hb_ScriptPlaceOpenType;
@ -242,11 +242,11 @@ retry:
{
funcs = (hb_uniscribe_shaper_funcs_t *) calloc (1, sizeof (hb_uniscribe_shaper_funcs_t));
if (unlikely (!funcs))
return NULL;
return nullptr;
funcs->init ();
if (!hb_atomic_ptr_cmpexch (&uniscribe_funcs, NULL, funcs)) {
if (!hb_atomic_ptr_cmpexch (&uniscribe_funcs, nullptr, funcs)) {
free (funcs);
goto retry;
}
@ -316,7 +316,7 @@ _hb_generate_unique_face_name (wchar_t *face_name, unsigned int *plen)
const char *enc = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-";
UUID id;
UuidCreate ((UUID*) &id);
ASSERT_STATIC (2 + 3 * (16/2) < LF_FACESIZE);
static_assert ((2 + 3 * (16/2) < LF_FACESIZE), "");
unsigned int name_str_len = 0;
face_name[name_str_len++] = 'F';
face_name[name_str_len++] = '_';
@ -369,7 +369,7 @@ _hb_rename_font (hb_blob_t *blob, wchar_t *new_name)
if (!new_sfnt_data)
{
hb_blob_destroy (blob);
return NULL;
return nullptr;
}
memcpy(new_sfnt_data, orig_sfnt_data, length);
@ -417,7 +417,7 @@ _hb_rename_font (hb_blob_t *blob, wchar_t *new_name)
{
free (new_sfnt_data);
hb_blob_destroy (blob);
return NULL;
return nullptr;
}
}
@ -427,7 +427,7 @@ _hb_rename_font (hb_blob_t *blob, wchar_t *new_name)
hb_blob_destroy (blob);
return hb_blob_create ((const char *) new_sfnt_data, new_length,
HB_MEMORY_MODE_WRITABLE, NULL, free);
HB_MEMORY_MODE_WRITABLE, nullptr, free);
}
hb_uniscribe_shaper_face_data_t *
@ -435,13 +435,13 @@ _hb_uniscribe_shaper_face_data_create (hb_face_t *face)
{
hb_uniscribe_shaper_face_data_t *data = (hb_uniscribe_shaper_face_data_t *) calloc (1, sizeof (hb_uniscribe_shaper_face_data_t));
if (unlikely (!data))
return NULL;
return nullptr;
data->funcs = hb_uniscribe_shaper_get_funcs ();
if (unlikely (!data->funcs))
{
free (data);
return NULL;
return nullptr;
}
hb_blob_t *blob = hb_face_reference_blob (face);
@ -452,18 +452,18 @@ _hb_uniscribe_shaper_face_data_create (hb_face_t *face)
if (unlikely (!blob))
{
free (data);
return NULL;
return nullptr;
}
DWORD num_fonts_installed;
data->fh = AddFontMemResourceEx ((void *) hb_blob_get_data (blob, NULL),
data->fh = AddFontMemResourceEx ((void *) hb_blob_get_data (blob, nullptr),
hb_blob_get_length (blob),
0, &num_fonts_installed);
if (unlikely (!data->fh))
{
DEBUG_MSG (UNISCRIBE, face, "Face AddFontMemResourceEx() failed");
free (data);
return NULL;
return nullptr;
}
return data;
@ -509,11 +509,11 @@ populate_log_font (LOGFONTW *lf,
hb_uniscribe_shaper_font_data_t *
_hb_uniscribe_shaper_font_data_create (hb_font_t *font)
{
if (unlikely (!hb_uniscribe_shaper_face_data_ensure (font->face))) return NULL;
if (unlikely (!hb_uniscribe_shaper_face_data_ensure (font->face))) return nullptr;
hb_uniscribe_shaper_font_data_t *data = (hb_uniscribe_shaper_font_data_t *) calloc (1, sizeof (hb_uniscribe_shaper_font_data_t));
if (unlikely (!data))
return NULL;
return nullptr;
int font_size = font->face->get_upem (); /* Default... */
/* No idea if the following is even a good idea. */
@ -525,25 +525,25 @@ _hb_uniscribe_shaper_font_data_create (hb_font_t *font)
data->x_mult = (double) font->x_scale / font_size;
data->y_mult = (double) font->y_scale / font_size;
data->hdc = GetDC (NULL);
data->hdc = GetDC (nullptr);
if (unlikely (!populate_log_font (&data->log_font, font, font_size))) {
DEBUG_MSG (UNISCRIBE, font, "Font populate_log_font() failed");
_hb_uniscribe_shaper_font_data_destroy (data);
return NULL;
return nullptr;
}
data->hfont = CreateFontIndirectW (&data->log_font);
if (unlikely (!data->hfont)) {
DEBUG_MSG (UNISCRIBE, font, "Font CreateFontIndirectW() failed");
_hb_uniscribe_shaper_font_data_destroy (data);
return NULL;
return nullptr;
}
if (!SelectObject (data->hdc, data->hfont)) {
DEBUG_MSG (UNISCRIBE, font, "Font SelectObject() failed");
_hb_uniscribe_shaper_font_data_destroy (data);
return NULL;
return nullptr;
}
return data;
@ -553,7 +553,7 @@ void
_hb_uniscribe_shaper_font_data_destroy (hb_uniscribe_shaper_font_data_t *data)
{
if (data->hdc)
ReleaseDC (NULL, data->hdc);
ReleaseDC (nullptr, data->hdc);
if (data->hfont)
DeleteObject (data->hfont);
if (data->script_cache)
@ -564,7 +564,7 @@ _hb_uniscribe_shaper_font_data_destroy (hb_uniscribe_shaper_font_data_t *data)
LOGFONTW *
hb_uniscribe_font_get_logfontw (hb_font_t *font)
{
if (unlikely (!hb_uniscribe_shaper_font_data_ensure (font))) return NULL;
if (unlikely (!hb_uniscribe_shaper_font_data_ensure (font))) return nullptr;
hb_uniscribe_shaper_font_data_t *font_data = HB_SHAPER_DATA_GET (font);
return &font_data->log_font;
}
@ -572,7 +572,7 @@ hb_uniscribe_font_get_logfontw (hb_font_t *font)
HFONT
hb_uniscribe_font_get_hfont (hb_font_t *font)
{
if (unlikely (!hb_uniscribe_shaper_font_data_ensure (font))) return NULL;
if (unlikely (!hb_uniscribe_shaper_font_data_ensure (font))) return nullptr;
hb_uniscribe_shaper_font_data_t *font_data = HB_SHAPER_DATA_GET (font);
return font_data->hfont;
}
@ -738,7 +738,7 @@ _hb_uniscribe_shape (hb_shape_plan_t *shape_plan,
#define FAIL(...) \
HB_STMT_START { \
DEBUG_MSG (UNISCRIBE, NULL, __VA_ARGS__); \
DEBUG_MSG (UNISCRIBE, nullptr, __VA_ARGS__); \
return false; \
} HB_STMT_END;
@ -960,7 +960,7 @@ retry:
/* out */
advances + glyphs_offset,
offsets + glyphs_offset,
NULL);
nullptr);
if (unlikely (FAILED (hr)))
FAIL ("ScriptPlaceOpenType() failed: 0x%08xL", hr);

4
gfx/harfbuzz/src/hb-version.h
Просмотреть файл

@ -38,9 +38,9 @@ HB_BEGIN_DECLS
#define HB_VERSION_MAJOR 1
#define HB_VERSION_MINOR 6
#define HB_VERSION_MICRO 0
#define HB_VERSION_MICRO 3
#define HB_VERSION_STRING "1.6.0"
#define HB_VERSION_STRING "1.6.3"
#define HB_VERSION_ATLEAST(major,minor,micro) \
((major)*10000+(minor)*100+(micro) <= \

4
gfx/harfbuzz/src/main.cc
Просмотреть файл

@ -47,11 +47,11 @@ main (int argc, char **argv)
exit (1);
}
const char *font_data = NULL;
const char *font_data = nullptr;
int len = 0;
#ifdef HAVE_GLIB
GMappedFile *mf = g_mapped_file_new (argv[1], false, NULL);
GMappedFile *mf = g_mapped_file_new (argv[1], false, nullptr);
font_data = g_mapped_file_get_contents (mf);
len = g_mapped_file_get_length (mf);
#else

8
gfx/harfbuzz/src/test-buffer-serialize.cc
Просмотреть файл

@ -45,7 +45,7 @@
int
main (int argc, char **argv)
{
hb_blob_t *blob = NULL;
hb_blob_t *blob = nullptr;
if (argc != 2) {
fprintf (stderr, "usage: %s font-file\n", argv[0]);
@ -61,7 +61,7 @@ main (int argc, char **argv)
hb_memory_mode_t mm;
#ifdef HAVE_GLIB
GMappedFile *mf = g_mapped_file_new (argv[1], false, NULL);
GMappedFile *mf = g_mapped_file_new (argv[1], false, nullptr);
font_data = g_mapped_file_get_contents (mf);
len = g_mapped_file_get_length (mf);
destroy = (hb_destroy_func_t) g_mapped_file_unref;
@ -86,7 +86,7 @@ main (int argc, char **argv)
hb_face_t *face = hb_face_create (blob, 0 /* first face */);
hb_blob_destroy (blob);
blob = NULL;
blob = nullptr;
unsigned int upem = hb_face_get_upem (face);
hb_font_t *font = hb_font_create (face);
@ -115,7 +115,7 @@ main (int argc, char **argv)
ret = false;
hb_buffer_serialize_glyphs (buf, 0, hb_buffer_get_length (buf),
out, sizeof (out), NULL,
out, sizeof (out), nullptr,
font, HB_BUFFER_SERIALIZE_FORMAT_JSON,
HB_BUFFER_SERIALIZE_FLAG_DEFAULT);
puts (out);

6
gfx/harfbuzz/src/test-size-params.cc
Просмотреть файл

@ -43,7 +43,7 @@
int
main (int argc, char **argv)
{
hb_blob_t *blob = NULL;
hb_blob_t *blob = nullptr;
if (argc != 2) {
fprintf (stderr, "usage: %s font-file\n", argv[0]);
@ -59,7 +59,7 @@ main (int argc, char **argv)
hb_memory_mode_t mm;
#ifdef HAVE_GLIB
GMappedFile *mf = g_mapped_file_new (argv[1], false, NULL);
GMappedFile *mf = g_mapped_file_new (argv[1], false, nullptr);
font_data = g_mapped_file_get_contents (mf);
len = g_mapped_file_get_length (mf);
destroy = (hb_destroy_func_t) g_mapped_file_unref;
@ -85,7 +85,7 @@ main (int argc, char **argv)
/* Create the face */
hb_face_t *face = hb_face_create (blob, 0 /* first face */);
hb_blob_destroy (blob);
blob = NULL;
blob = nullptr;
unsigned int p[5];
bool ret = hb_ot_layout_get_size_params (face, p, p+1, p+2, p+3, p+4);

8
gfx/harfbuzz/src/test-would-substitute.cc
Просмотреть файл

@ -47,7 +47,7 @@
int
main (int argc, char **argv)
{
hb_blob_t *blob = NULL;
hb_blob_t *blob = nullptr;
if (argc != 4 && argc != 5) {
fprintf (stderr, "usage: %s font-file lookup-index first-glyph [second-glyph]\n", argv[0]);
@ -63,7 +63,7 @@ main (int argc, char **argv)
hb_memory_mode_t mm;
#ifdef HAVE_GLIB
GMappedFile *mf = g_mapped_file_new (argv[1], false, NULL);
GMappedFile *mf = g_mapped_file_new (argv[1], false, nullptr);
font_data = g_mapped_file_get_contents (mf);
len = g_mapped_file_get_length (mf);
destroy = (hb_destroy_func_t) g_mapped_file_unref;
@ -89,7 +89,7 @@ main (int argc, char **argv)
/* Create the face */
hb_face_t *face = hb_face_create (blob, 0 /* first face */);
hb_blob_destroy (blob);
blob = NULL;
blob = nullptr;
hb_font_t *font = hb_font_create (face);
#ifdef HAVE_FREETYPE
@ -102,5 +102,5 @@ main (int argc, char **argv)
(argc > 4 &&
!hb_font_glyph_from_string (font, argv[4], -1, &glyphs[1])))
return 2;
return !hb_ot_layout_lookup_would_substitute (face, strtol (argv[2], NULL, 0), glyphs, len, false);
return !hb_ot_layout_lookup_would_substitute (face, strtol (argv[2], nullptr, 0), glyphs, len, false);
}

12
gfx/harfbuzz/src/test.cc
Просмотреть файл

@ -46,7 +46,7 @@
int
main (int argc, char **argv)
{
hb_blob_t *blob = NULL;
hb_blob_t *blob = nullptr;
if (argc != 2) {
fprintf (stderr, "usage: %s font-file.ttf\n", argv[0]);
@ -62,7 +62,7 @@ main (int argc, char **argv)
hb_memory_mode_t mm;
#ifdef HAVE_GLIB
GMappedFile *mf = g_mapped_file_new (argv[1], false, NULL);
GMappedFile *mf = g_mapped_file_new (argv[1], false, nullptr);
font_data = g_mapped_file_get_contents (mf);
len = g_mapped_file_get_length (mf);
destroy = (hb_destroy_func_t) g_mapped_file_unref;
@ -90,7 +90,7 @@ main (int argc, char **argv)
/* Create the face */
hb_face_t *face = hb_face_create (blob, 0 /* first face */);
hb_blob_destroy (blob);
blob = NULL;
blob = nullptr;
unsigned int upem = hb_face_get_upem (face);
hb_font_t *font = hb_font_create (face);
@ -105,11 +105,11 @@ main (int argc, char **argv)
hb_buffer_add_utf8 (buffer, "\xe0\xa4\x95\xe0\xa5\x8d\xe0\xa4\xb0\xe0\xa5\x8d\xe0\xa4\x95", -1, 0, -1);
hb_buffer_guess_segment_properties (buffer);
hb_shape (font, buffer, NULL, 0);
hb_shape (font, buffer, nullptr, 0);
unsigned int count = hb_buffer_get_length (buffer);
hb_glyph_info_t *infos = hb_buffer_get_glyph_infos (buffer, NULL);
hb_glyph_position_t *positions = hb_buffer_get_glyph_positions (buffer, NULL);
hb_glyph_info_t *infos = hb_buffer_get_glyph_infos (buffer, nullptr);
hb_glyph_position_t *positions = hb_buffer_get_glyph_positions (buffer, nullptr);
for (unsigned int i = 0; i < count; i++)
{