#429: update Harfbuzz to 1.5.1
This commit is contained in:
parent
f4bf5ad976
commit
083639c711
|
@ -2,32 +2,27 @@
|
|||
|
||||
NULL =
|
||||
|
||||
SUBDIRS = src util test
|
||||
ACLOCAL_AMFLAGS = -I m4
|
||||
|
||||
pkgconfigdir = $(libdir)/pkgconfig
|
||||
pkgconfig_DATA = harfbuzz.pc
|
||||
SUBDIRS = src util test docs win32
|
||||
|
||||
EXTRA_DIST = \
|
||||
autogen.sh \
|
||||
harfbuzz.doap \
|
||||
README.python \
|
||||
BUILD.md \
|
||||
CMakeLists.txt \
|
||||
$(NULL)
|
||||
|
||||
MAINTAINERCLEANFILES = \
|
||||
$(GITIGNORE_MAINTAINERCLEANFILES_TOPLEVEL) \
|
||||
$(GITIGNORE_MAINTAINERCLEANFILES_M4_LIBTOOL) \
|
||||
$(GITIGNORE_MAINTAINERCLEANFILES_MAKEFILE_IN) \
|
||||
$(srcdir)/INSTALL \
|
||||
$(srcdir)/aclocal.m4 \
|
||||
$(srcdir)/autoscan.log \
|
||||
$(srcdir)/compile \
|
||||
$(srcdir)/config.guess \
|
||||
$(srcdir)/config.h.in \
|
||||
$(srcdir)/config.sub \
|
||||
$(srcdir)/configure.scan \
|
||||
$(srcdir)/depcomp \
|
||||
$(srcdir)/install-sh \
|
||||
$(srcdir)/ltmain.sh \
|
||||
$(srcdir)/missing \
|
||||
$(srcdir)/mkinstalldirs \
|
||||
$(srcdir)/ChangeLog \
|
||||
`find "$(srcdir)" -type f -name Makefile.in -print`
|
||||
$(srcdir)/gtk-doc.make \
|
||||
$(srcdir)/m4/gtk-doc.m4 \
|
||||
$(NULL)
|
||||
|
||||
|
||||
#
|
||||
|
@ -36,28 +31,37 @@ MAINTAINERCLEANFILES = \
|
|||
CHANGELOG_RANGE =
|
||||
ChangeLog: $(srcdir)/ChangeLog
|
||||
$(srcdir)/ChangeLog:
|
||||
$(AM_V_GEN) if test -d "$(srcdir)/.git"; then \
|
||||
(GIT_DIR=$(top_srcdir)/.git ./missing --run \
|
||||
git log $(CHANGELOG_RANGE) --stat) | fmt --split-only > $@.tmp \
|
||||
&& mv -f $@.tmp $@ \
|
||||
$(AM_V_GEN) if test -d "$(top_srcdir)/.git"; then \
|
||||
(GIT_DIR=$(top_srcdir)/.git \
|
||||
$(GIT) log $(CHANGELOG_RANGE) --stat) | fmt --split-only > $@.tmp \
|
||||
&& mv -f $@.tmp "$(srcdir)/ChangeLog" \
|
||||
|| ($(RM) $@.tmp; \
|
||||
echo Failed to generate ChangeLog, your ChangeLog may be outdated >&2; \
|
||||
(test -f $@ || echo git-log is required to generate this file >> $@)); \
|
||||
(test -f $@ || echo git-log is required to generate this file >> "$(srcdir)/$@")); \
|
||||
else \
|
||||
test -f $@ || \
|
||||
(echo A git checkout and git-log is required to generate ChangeLog >&2 && \
|
||||
echo A git checkout and git-log is required to generate this file >> $@); \
|
||||
echo A git checkout and git-log is required to generate this file >> "$(srcdir)/$@"); \
|
||||
fi
|
||||
.PHONY: $(srcdir)/ChangeLog
|
||||
.PHONY: ChangeLog $(srcdir)/ChangeLog
|
||||
|
||||
|
||||
#
|
||||
# Release engineering
|
||||
#
|
||||
|
||||
DISTCHECK_CONFIGURE_FLAGS = \
|
||||
--enable-gtk-doc \
|
||||
--disable-doc-cross-references \
|
||||
--with-gobject \
|
||||
--enable-introspection \
|
||||
$(NULL)
|
||||
|
||||
# TODO: Copy infrastructure from cairo
|
||||
|
||||
# TAR_OPTIONS is not set as env var for 'make dist'. How to fix that?
|
||||
TAR_OPTIONS = --owner=0 --group=0
|
||||
|
||||
dist-hook: dist-clear-sticky-bits
|
||||
# Clean up any sticky bits we may inherit from parent dir
|
||||
dist-clear-sticky-bits:
|
||||
|
|
File diff suppressed because it is too large
Load Diff
|
@ -1,3 +1,8 @@
|
|||
[![Build Status](https://travis-ci.org/behdad/harfbuzz.svg)](https://travis-ci.org/behdad/harfbuzz)
|
||||
[![Build Status](https://ci.appveyor.com/api/projects/status/4oaq58ns2h0m2soa?svg=true)](https://ci.appveyor.com/project/behdad/harfbuzz)
|
||||
[![Coverage Status](https://img.shields.io/coveralls/behdad/harfbuzz.svg)](https://coveralls.io/r/behdad/harfbuzz)
|
||||
[ABI Tracker](http://abi-laboratory.pro/tracker/timeline/harfbuzz/)
|
||||
|
||||
This is HarfBuzz, a text shaping library.
|
||||
|
||||
For bug reports, mailing list, and other information please visit:
|
||||
|
|
|
@ -1,20 +1,21 @@
|
|||
gfx/harfbuzz status as of 2015-04-25:
|
||||
gfx/harfbuzz status as of 2017-09-05:
|
||||
|
||||
This directory contains the harfbuzz source from the 'master' branch of
|
||||
https://github.com/behdad/harfbuzz.
|
||||
|
||||
Current version: 1.5.1
|
||||
|
||||
UPDATING:
|
||||
|
||||
Note that gfx/harfbuzz/src/hb-version.h is not present in the upstream Git
|
||||
repository. It is created at build time by the harfbuzz build system;
|
||||
but as we don't use that build system in mozilla, it is necessary to refresh
|
||||
this files when updating harfbuzz, and check them into the mozilla tree.
|
||||
this file when updating harfbuzz, and check it into the mozilla tree.
|
||||
|
||||
The normal approach to updating harfbuzz, therefore, is to pull the latest HB
|
||||
source into a scratch directory and do a local build; then copy the original
|
||||
sources AND the generated headers mentioned above from the build directory into
|
||||
sources AND the generated header mentioned above from the build directory into
|
||||
the mozilla tree.
|
||||
|
||||
In addition, the src/Makefile.in file here is NOT from upstream, nor is it
|
||||
generated from src/Makefile.am (the original harfbuzz version); it is a mozilla-
|
||||
specific makefile that is maintained by hand.
|
||||
If the collection of source files changes, manual updates to moz.build may be
|
||||
needed, as we don't use the upstream makefiles.
|
||||
|
|
|
@ -0,0 +1,7 @@
|
|||
Bradley Grainger
|
||||
Khaled Hosny
|
||||
Kenichi Ishibashi
|
||||
Ryan Lortie
|
||||
Jeff Muizelaar
|
||||
suzuki toshiya
|
||||
Philip Withnall
|
|
@ -1,70 +1,55 @@
|
|||
General fixes:
|
||||
=============
|
||||
|
||||
- Move feature parsing from util into the library
|
||||
- AAT 'morx' implementation.
|
||||
|
||||
- Return "safe-to-break" bit from shaping.
|
||||
|
||||
- Implement 'rand' feature.
|
||||
|
||||
- mask propagation? (when ligation, "or" the masks).
|
||||
|
||||
|
||||
API issues:
|
||||
===========
|
||||
|
||||
- API to accept a list of languages?
|
||||
|
||||
- Add init_func to font_funcs. Adjust ft.
|
||||
|
||||
- 'const' for getter APIs? (use mutable internally)
|
||||
|
||||
- Fix TT 'kern' on/off and GPOS interaction (move kerning before GPOS)
|
||||
|
||||
- Do proper rounding when scaling from font space?
|
||||
|
||||
- Misc features:
|
||||
* init/medi/fina/isol for non-cursive scripts
|
||||
* vkna,hkna etc for kana, *jmo for hangul, etc
|
||||
|
||||
- Move non-native direction and normalization handling to the generic non-OT
|
||||
layer, such that uniscribe and other backends can use.
|
||||
|
||||
- Uniscribe backend needs to enforce one direction only, otherwise cluster
|
||||
values can confused the user.
|
||||
- Remove hb_ot_shape_glyphs_closure()?
|
||||
|
||||
|
||||
API issues to fix before 1.0:
|
||||
============================
|
||||
API additions
|
||||
=============
|
||||
|
||||
- Rename all internal symbols (static ones even) to have _hb prefix?
|
||||
- Language to/from script.
|
||||
|
||||
- Add pkg-config files for glue codes (harfbuzz-glib, etc)
|
||||
|
||||
- Figure out how many .so objects, how to link, etc
|
||||
- blob_from_file?
|
||||
|
||||
- Add hb-cairo glue
|
||||
|
||||
- Add sanitize API (and a cached version, that saves result on blob user-data)
|
||||
|
||||
- Add glib GBoxedType stuff and introspection
|
||||
|
||||
|
||||
API to add (maybe after 1.0):
|
||||
============================
|
||||
|
||||
- Add Uniscribe face / font get API
|
||||
|
||||
- BCP 47 language handling / API (language_matches?)
|
||||
|
||||
- Add hb_face_get_glyph_count()?
|
||||
- Add hb_font_create_unscaled()?
|
||||
|
||||
- Add hb_font_create_linear()?
|
||||
|
||||
- Add hb_shape_plan()/hb_shape_execute()
|
||||
|
||||
- Add query API for aalt-like features?
|
||||
- Add query / enumeration API for aalt-like features?
|
||||
|
||||
- SFNT api? get_num_faces? get_table_tags? (there's something in stash)
|
||||
|
||||
- Add segmentation API
|
||||
|
||||
- Add hb-fribidi?
|
||||
- Add hb-fribidi glue?
|
||||
|
||||
|
||||
hb-view enhancements:
|
||||
====================
|
||||
hb-view / hb-shape enhancements:
|
||||
===============================
|
||||
|
||||
- Add --format
|
||||
- Add --width, --height, --auto-size, --align, etc?
|
||||
- Port to GOption, --help
|
||||
- Add XML and JSON formats
|
||||
- Add --width, --height, --auto-size, --ink-box, --align, etc?
|
||||
|
||||
|
||||
Tests to write:
|
||||
|
@ -76,10 +61,9 @@ Tests to write:
|
|||
|
||||
- Finish test-unicode.c, grep for TODO
|
||||
|
||||
- GObject, FreeType, etc
|
||||
|
||||
Optimizations:
|
||||
=============
|
||||
- hb_cache_t and relatives
|
||||
|
||||
- Avoid allocating blob objects internally for for_data() faces?
|
||||
|
||||
- Add caching layer to hb-ft
|
||||
- hb_feature_to/from_string
|
||||
- hb_buffer_[sg]et_contents
|
||||
|
|
|
@ -19,9 +19,22 @@ which pkg-config || {
|
|||
exit 1
|
||||
}
|
||||
|
||||
echo -n "checking for libtoolize... "
|
||||
which glibtoolize || which libtoolize || {
|
||||
echo "*** No libtoolize (libtool) found, please install it ***"
|
||||
exit 1
|
||||
}
|
||||
echo -n "checking for gtkdocize... "
|
||||
if which gtkdocize ; then
|
||||
gtkdocize --copy || exit 1
|
||||
else
|
||||
echo "*** No gtkdocize (gtk-doc) found, skipping documentation ***"
|
||||
echo "EXTRA_DIST = " > gtk-doc.make
|
||||
fi
|
||||
|
||||
echo -n "checking for autoreconf... "
|
||||
which autoreconf || {
|
||||
echo "*** No autoreconf found, please install it ***"
|
||||
echo "*** No autoreconf (autoconf) found, please install it ***"
|
||||
exit 1
|
||||
}
|
||||
|
||||
|
|
|
@ -1,24 +1,32 @@
|
|||
AC_PREREQ([2.64])
|
||||
AC_INIT([harfbuzz],
|
||||
[0.7.0],
|
||||
[http://bugs.freedesktop.org/enter_bug.cgi?product=harfbuzz],
|
||||
AC_INIT([HarfBuzz],
|
||||
[1.5.1],
|
||||
[https://github.com/behdad/harfbuzz/issues/new],
|
||||
[harfbuzz],
|
||||
[http://harfbuzz.org/])
|
||||
|
||||
AC_CONFIG_SRCDIR([harfbuzz.pc.in])
|
||||
AC_CONFIG_MACRO_DIR([m4])
|
||||
AC_CONFIG_SRCDIR([src/harfbuzz.pc.in])
|
||||
AC_CONFIG_HEADERS([config.h])
|
||||
|
||||
AM_INIT_AUTOMAKE([1.11.1 gnu dist-bzip2 no-dist-gzip -Wall no-define])
|
||||
AM_INIT_AUTOMAKE([1.11.1 gnits tar-ustar dist-bzip2 no-dist-gzip -Wall no-define color-tests -Wno-portability])
|
||||
AM_CONDITIONAL(AUTOMAKE_OLDER_THAN_1_13, test $am__api_version = 1.11 -o $am__api_version = 1.12)
|
||||
AM_SILENT_RULES([yes])
|
||||
|
||||
# Initialize libtool
|
||||
m4_ifdef([AM_PROG_AR], [AM_PROG_AR])
|
||||
LT_PREREQ([2.2])
|
||||
LT_INIT([disable-static])
|
||||
|
||||
# Check for programs
|
||||
AC_USE_SYSTEM_EXTENSIONS
|
||||
AC_PROG_CC
|
||||
AM_PROG_CC_C_O
|
||||
AC_PROG_CXX
|
||||
|
||||
# Initialize libtool
|
||||
LT_PREREQ([2.2])
|
||||
LT_INIT([disable-static])
|
||||
AC_SYS_LARGEFILE
|
||||
PKG_PROG_PKG_CONFIG([0.20])
|
||||
AM_MISSING_PROG([RAGEL], [ragel])
|
||||
AM_MISSING_PROG([GIT], [git])
|
||||
|
||||
# Version
|
||||
m4_define(hb_version_triplet,m4_split(AC_PACKAGE_VERSION,[[.]]))
|
||||
|
@ -45,18 +53,28 @@ m4_if(m4_eval(hb_version_minor % 2), [1],
|
|||
m4_define([hb_libtool_age],
|
||||
m4_eval(hb_version_int - hb_libtool_revision))
|
||||
m4_define([hb_libtool_current],
|
||||
m4_eval(hb_version_major + hb_libtool_age))
|
||||
m4_eval(hb_libtool_age))
|
||||
HB_LIBTOOL_VERSION_INFO=hb_libtool_current:hb_libtool_revision:hb_libtool_age
|
||||
AC_SUBST(HB_LIBTOOL_VERSION_INFO)
|
||||
|
||||
dnl GTK_DOC_CHECK([1.15],[--flavour no-tmpl])
|
||||
# Documentation
|
||||
have_gtk_doc=false
|
||||
m4_ifdef([GTK_DOC_CHECK], [
|
||||
GTK_DOC_CHECK([1.15],[--flavour no-tmpl])
|
||||
if test "x$enable_gtk_doc" = xyes; then
|
||||
have_gtk_doc=true
|
||||
fi
|
||||
], [
|
||||
AM_CONDITIONAL([ENABLE_GTK_DOC], false)
|
||||
])
|
||||
|
||||
# Functions and headers
|
||||
AC_CHECK_FUNCS(mprotect sysconf getpagesize mmap _setmode)
|
||||
AC_CHECK_HEADERS(unistd.h sys/mman.h io.h)
|
||||
AC_CHECK_FUNCS(atexit mprotect sysconf getpagesize mmap isatty)
|
||||
AC_CHECK_HEADERS(unistd.h sys/mman.h)
|
||||
|
||||
# Compiler flags
|
||||
AC_CANONICAL_HOST
|
||||
AC_CHECK_ALIGNOF([struct{char;}])
|
||||
if test "x$GCC" = "xyes"; then
|
||||
|
||||
# Make symbols link locally
|
||||
|
@ -65,29 +83,96 @@ if test "x$GCC" = "xyes"; then
|
|||
# Make sure we don't link to libstdc++
|
||||
CXXFLAGS="$CXXFLAGS -fno-rtti -fno-exceptions"
|
||||
|
||||
# Assorted warnings
|
||||
CXXFLAGS="$CXXFLAGS -Wcast-align"
|
||||
|
||||
case "$host" in
|
||||
*-*-mingw*)
|
||||
;;
|
||||
*)
|
||||
# Hide inline methods
|
||||
CXXFLAGS="$CXXFLAGS -fvisibility-inlines-hidden"
|
||||
;;
|
||||
esac
|
||||
|
||||
case "$host" in
|
||||
arm-*-*)
|
||||
# Request byte alignment on arm
|
||||
CXXFLAGS="$CXXFLAGS -mstructure-size-boundary=8"
|
||||
if test "x$ac_cv_alignof_struct_char__" != x1; then
|
||||
# Request byte alignment
|
||||
CXXFLAGS="$CXXFLAGS -mstructure-size-boundary=8"
|
||||
fi
|
||||
;;
|
||||
esac
|
||||
fi
|
||||
|
||||
AM_CONDITIONAL(HAVE_GCC, test "x$GCC" = "xyes")
|
||||
|
||||
hb_os_win32=no
|
||||
AC_MSG_CHECKING([for native Win32])
|
||||
case "$host" in
|
||||
*-*-mingw*)
|
||||
hb_os_win32=yes
|
||||
;;
|
||||
esac
|
||||
AC_MSG_RESULT([$hb_os_win32])
|
||||
AM_CONDITIONAL(OS_WIN32, test "$hb_os_win32" = "yes")
|
||||
|
||||
have_pthread=false
|
||||
if test "$hb_os_win32" = no; then
|
||||
AX_PTHREAD([have_pthread=true])
|
||||
fi
|
||||
if $have_pthread; then
|
||||
AC_DEFINE(HAVE_PTHREAD, 1, [Have POSIX threads])
|
||||
fi
|
||||
AM_CONDITIONAL(HAVE_PTHREAD, $have_pthread)
|
||||
|
||||
dnl ==========================================================================
|
||||
|
||||
PKG_CHECK_MODULES(GLIB, glib-2.0 >= 2.16, have_glib=true, have_glib=false)
|
||||
have_ot=true
|
||||
if $have_ot; then
|
||||
AC_DEFINE(HAVE_OT, 1, [Have native OpenType Layout backend])
|
||||
fi
|
||||
AM_CONDITIONAL(HAVE_OT, $have_ot)
|
||||
|
||||
have_fallback=true
|
||||
if $have_fallback; then
|
||||
AC_DEFINE(HAVE_FALLBACK, 1, [Have simple TrueType Layout backend])
|
||||
fi
|
||||
AM_CONDITIONAL(HAVE_FALLBACK, $have_fallback)
|
||||
|
||||
dnl ===========================================================================
|
||||
|
||||
AC_ARG_WITH(glib,
|
||||
[AS_HELP_STRING([--with-glib=@<:@yes/no/auto@:>@],
|
||||
[Use glib @<:@default=auto@:>@])],,
|
||||
[with_glib=auto])
|
||||
have_glib=false
|
||||
GLIB_DEPS="glib-2.0 >= 2.19.1"
|
||||
AC_SUBST(GLIB_DEPS)
|
||||
if test "x$with_glib" = "xyes" -o "x$with_glib" = "xauto"; then
|
||||
PKG_CHECK_MODULES(GLIB, $GLIB_DEPS, have_glib=true, :)
|
||||
fi
|
||||
if test "x$with_glib" = "xyes" -a "x$have_glib" != "xtrue"; then
|
||||
AC_MSG_ERROR([glib support requested but glib-2.0 not found])
|
||||
fi
|
||||
if $have_glib; then
|
||||
AC_DEFINE(HAVE_GLIB, 1, [Have glib2 library])
|
||||
fi
|
||||
AM_CONDITIONAL(HAVE_GLIB, $have_glib)
|
||||
|
||||
PKG_CHECK_MODULES(GTHREAD, gthread-2.0, have_gthread=true, have_gthread=false)
|
||||
if $have_gthread; then
|
||||
AC_DEFINE(HAVE_GTHREAD, 1, [Have gthread2 library])
|
||||
fi
|
||||
AM_CONDITIONAL(HAVE_GTHREAD, $have_gthread)
|
||||
dnl ===========================================================================
|
||||
|
||||
PKG_CHECK_MODULES(GOBJECT, gobject-2.0 glib-2.0 >= 2.16, have_gobject=true, have_gobject=false)
|
||||
AC_ARG_WITH(gobject,
|
||||
[AS_HELP_STRING([--with-gobject=@<:@yes/no/auto@:>@],
|
||||
[Use gobject @<:@default=auto@:>@])],,
|
||||
[with_gobject=no])
|
||||
have_gobject=false
|
||||
if test "x$with_gobject" = "xyes" -o "x$with_gobject" = "xauto"; then
|
||||
PKG_CHECK_MODULES(GOBJECT, gobject-2.0 glib-2.0, have_gobject=true, :)
|
||||
fi
|
||||
if test "x$with_gobject" = "xyes" -a "x$have_gobject" != "xtrue"; then
|
||||
AC_MSG_ERROR([gobject support requested but gobject-2.0 / glib-2.0 not found])
|
||||
fi
|
||||
if $have_gobject; then
|
||||
AC_DEFINE(HAVE_GOBJECT, 1, [Have gobject2 library])
|
||||
GLIB_MKENUMS=`$PKG_CONFIG --variable=glib_mkenums glib-2.0`
|
||||
|
@ -95,15 +180,47 @@ if $have_gobject; then
|
|||
fi
|
||||
AM_CONDITIONAL(HAVE_GOBJECT, $have_gobject)
|
||||
|
||||
dnl ===========================================================================
|
||||
|
||||
|
||||
dnl ===========================================================================
|
||||
# Gobject-Introspection
|
||||
have_introspection=false
|
||||
m4_ifdef([GOBJECT_INTROSPECTION_CHECK], [
|
||||
if $have_gobject; then
|
||||
GOBJECT_INTROSPECTION_CHECK([1.34.0])
|
||||
if test "x$found_introspection" = xyes; then
|
||||
have_introspection=true
|
||||
fi
|
||||
else
|
||||
AM_CONDITIONAL([HAVE_INTROSPECTION], false)
|
||||
fi
|
||||
], [
|
||||
AM_CONDITIONAL([HAVE_INTROSPECTION], false)
|
||||
])
|
||||
|
||||
dnl ==========================================================================
|
||||
|
||||
PKG_CHECK_MODULES(CAIRO, cairo >= 1.8.0, have_cairo=true, have_cairo=false)
|
||||
AC_ARG_WITH(cairo,
|
||||
[AS_HELP_STRING([--with-cairo=@<:@yes/no/auto@:>@],
|
||||
[Use cairo @<:@default=auto@:>@])],,
|
||||
[with_cairo=auto])
|
||||
have_cairo=false
|
||||
if test "x$with_cairo" = "xyes" -o "x$with_cairo" = "xauto"; then
|
||||
PKG_CHECK_MODULES(CAIRO, cairo >= 1.8.0, have_cairo=true, :)
|
||||
fi
|
||||
if test "x$with_cairo" = "xyes" -a "x$have_cairo" != "xtrue"; then
|
||||
AC_MSG_ERROR([cairo support requested but not found])
|
||||
fi
|
||||
if $have_cairo; then
|
||||
AC_DEFINE(HAVE_CAIRO, 1, [Have cairo graphics library])
|
||||
fi
|
||||
AM_CONDITIONAL(HAVE_CAIRO, $have_cairo)
|
||||
|
||||
PKG_CHECK_MODULES(CAIRO_FT, cairo-ft, have_cairo_ft=true, have_cairo_ft=false)
|
||||
have_cairo_ft=false
|
||||
if $have_cairo; then
|
||||
PKG_CHECK_MODULES(CAIRO_FT, cairo-ft, have_cairo_ft=true, :)
|
||||
fi
|
||||
if $have_cairo_ft; then
|
||||
AC_DEFINE(HAVE_CAIRO_FT, 1, [Have cairo-ft support in cairo graphics library])
|
||||
fi
|
||||
|
@ -111,79 +228,304 @@ AM_CONDITIONAL(HAVE_CAIRO_FT, $have_cairo_ft)
|
|||
|
||||
dnl ==========================================================================
|
||||
|
||||
PKG_CHECK_MODULES(ICU, icu, have_icu=true, [
|
||||
have_icu=true
|
||||
AC_CHECK_HEADERS(unicode/uchar.h,, have_icu=false)
|
||||
AC_MSG_CHECKING([for libicuuc])
|
||||
LIBS_old=$LIBS
|
||||
LIBS="$LIBS -licuuc"
|
||||
AC_TRY_LINK([#include <unicode/uchar.h>],
|
||||
[u_getIntPropertyValue (0, (UProperty)0);],
|
||||
AC_MSG_RESULT(yes),
|
||||
AC_MSG_RESULT(no);have_icu=false)
|
||||
LIBS=$LIBS_old
|
||||
if $have_icu; then
|
||||
ICU_CFLAGS=-D_REENTRANT
|
||||
ICU_LIBS="-licuuc"
|
||||
AC_SUBST(ICU_CFLAGS)
|
||||
AC_SUBST(ICU_LIBS)
|
||||
AC_ARG_WITH(fontconfig,
|
||||
[AS_HELP_STRING([--with-fontconfig=@<:@yes/no/auto@:>@],
|
||||
[Use fontconfig @<:@default=auto@:>@])],,
|
||||
[with_fontconfig=auto])
|
||||
have_fontconfig=false
|
||||
if test "x$with_fontconfig" = "xyes" -o "x$with_fontconfig" = "xauto"; then
|
||||
PKG_CHECK_MODULES(FONTCONFIG, fontconfig, have_fontconfig=true, :)
|
||||
fi
|
||||
if test "x$with_fontconfig" = "xyes" -a "x$have_fontconfig" != "xtrue"; then
|
||||
AC_MSG_ERROR([fontconfig support requested but not found])
|
||||
fi
|
||||
if $have_fontconfig; then
|
||||
AC_DEFINE(HAVE_FONTCONFIG, 1, [Have fontconfig library])
|
||||
fi
|
||||
AM_CONDITIONAL(HAVE_FONTCONFIG, $have_fontconfig)
|
||||
|
||||
dnl ==========================================================================
|
||||
|
||||
AC_ARG_WITH(icu,
|
||||
[AS_HELP_STRING([--with-icu=@<:@yes/no/builtin/auto@:>@],
|
||||
[Use ICU @<:@default=auto@:>@])],,
|
||||
[with_icu=auto])
|
||||
have_icu=false
|
||||
if test "x$with_icu" = "xyes" -o "x$with_icu" = "xbuiltin" -o "x$with_icu" = "xauto"; then
|
||||
PKG_CHECK_MODULES(ICU, icu-uc, have_icu=true, :)
|
||||
|
||||
dnl Fallback to icu-config if ICU pkg-config files could not be found
|
||||
if test "$have_icu" != "true"; then
|
||||
AC_CHECK_TOOL(ICU_CONFIG, icu-config, no)
|
||||
AC_MSG_CHECKING([for ICU by using icu-config fallback])
|
||||
if test "$ICU_CONFIG" != "no" && "$ICU_CONFIG" --version >/dev/null; then
|
||||
have_icu=true
|
||||
# We don't use --cflags as this gives us a lot of things that we don't
|
||||
# necessarily want, like debugging and optimization flags
|
||||
# See man (1) icu-config for more info.
|
||||
ICU_CFLAGS=`$ICU_CONFIG --cppflags`
|
||||
ICU_LIBS=`$ICU_CONFIG --ldflags-searchpath --ldflags-libsonly`
|
||||
AC_SUBST(ICU_CFLAGS)
|
||||
AC_SUBST(ICU_LIBS)
|
||||
AC_MSG_RESULT([yes])
|
||||
else
|
||||
AC_MSG_RESULT([no])
|
||||
fi
|
||||
fi
|
||||
])
|
||||
fi
|
||||
if test \( "x$with_icu" = "xyes" -o "x$with_icu" = "xbuiltin" \) -a "x$have_icu" != "xtrue"; then
|
||||
AC_MSG_ERROR([icu support requested but icu-uc not found])
|
||||
fi
|
||||
|
||||
if $have_icu; then
|
||||
CXXFLAGS="$CXXFLAGS `$PKG_CONFIG --variable=CXXFLAGS icu-uc`"
|
||||
AC_DEFINE(HAVE_ICU, 1, [Have ICU library])
|
||||
if test "x$with_icu" = "xbuiltin"; then
|
||||
AC_DEFINE(HAVE_ICU_BUILTIN, 1, [Use hb-icu Unicode callbacks])
|
||||
fi
|
||||
fi
|
||||
AM_CONDITIONAL(HAVE_ICU, $have_icu)
|
||||
AM_CONDITIONAL(HAVE_ICU_BUILTIN, $have_icu && test "x$with_icu" = "xbuiltin")
|
||||
|
||||
dnl ==========================================================================
|
||||
dnl ===========================================================================
|
||||
|
||||
PKG_CHECK_MODULES(GRAPHITE, graphite2, have_graphite=true, have_graphite=false)
|
||||
if $have_graphite; then
|
||||
AC_DEFINE(HAVE_GRAPHITE, 1, [Have Graphite library])
|
||||
AC_ARG_WITH(ucdn,
|
||||
[AS_HELP_STRING([--with-ucdn=@<:@yes/no@:>@],
|
||||
[Use builtin UCDN library @<:@default=yes@:>@])],,
|
||||
[with_ucdn=yes])
|
||||
have_ucdn=false
|
||||
if test "x$with_ucdn" = "xyes"; then
|
||||
have_ucdn=true
|
||||
fi
|
||||
AM_CONDITIONAL(HAVE_GRAPHITE, $have_graphite)
|
||||
if $have_ucdn; then
|
||||
AC_DEFINE(HAVE_UCDN, 1, [Have UCDN Unicode functions])
|
||||
fi
|
||||
AM_CONDITIONAL(HAVE_UCDN, $have_ucdn)
|
||||
|
||||
dnl ==========================================================================
|
||||
|
||||
PKG_CHECK_MODULES(FREETYPE, freetype2 >= 2.3.8, have_freetype=true, have_freetype=false)
|
||||
AC_ARG_WITH(graphite2,
|
||||
[AS_HELP_STRING([--with-graphite2=@<:@yes/no/auto@:>@],
|
||||
[Use the graphite2 library @<:@default=no@:>@])],,
|
||||
[with_graphite2=no])
|
||||
have_graphite2=false
|
||||
GRAPHITE2_DEPS="graphite2"
|
||||
AC_SUBST(GRAPHITE2_DEPS)
|
||||
if test "x$with_graphite2" = "xyes" -o "x$with_graphite2" = "xauto"; then
|
||||
PKG_CHECK_MODULES(GRAPHITE2, $GRAPHITE2_DEPS, have_graphite2=true, :)
|
||||
if test "x$have_graphite2" != "xtrue"; then
|
||||
# If pkg-config is not available, graphite2 can still be there
|
||||
ac_save_CFLAGS="$CFLAGS"
|
||||
ac_save_CPPFLAGS="$CPPFLAGS"
|
||||
CFLAGS="$CFLAGS $GRAPHITE2_CFLAGS"
|
||||
CPPFLAGS="$CPPFLAGS $GRAPHITE2_CFLAGS"
|
||||
AC_CHECK_HEADER(graphite2/Segment.h, have_graphite2=true, :)
|
||||
CPPFLAGS="$ac_save_CPPFLAGS"
|
||||
CFLAGS="$ac_save_CFLAGS"
|
||||
fi
|
||||
fi
|
||||
if test "x$with_graphite2" = "xyes" -a "x$have_graphite2" != "xtrue"; then
|
||||
AC_MSG_ERROR([graphite2 support requested but libgraphite2 not found])
|
||||
fi
|
||||
if $have_graphite2; then
|
||||
AC_DEFINE(HAVE_GRAPHITE2, 1, [Have Graphite2 library])
|
||||
fi
|
||||
AM_CONDITIONAL(HAVE_GRAPHITE2, $have_graphite2)
|
||||
|
||||
dnl ==========================================================================
|
||||
|
||||
AC_ARG_WITH(freetype,
|
||||
[AS_HELP_STRING([--with-freetype=@<:@yes/no/auto@:>@],
|
||||
[Use the FreeType library @<:@default=auto@:>@])],,
|
||||
[with_freetype=auto])
|
||||
have_freetype=false
|
||||
FREETYPE_DEPS="freetype2 >= 12.0.6"
|
||||
AC_SUBST(FREETYPE_DEPS)
|
||||
if test "x$with_freetype" = "xyes" -o "x$with_freetype" = "xauto"; then
|
||||
# See freetype/docs/VERSION.DLL; 12.0.6 means freetype-2.4.2
|
||||
PKG_CHECK_MODULES(FREETYPE, $FREETYPE_DEPS, have_freetype=true, :)
|
||||
fi
|
||||
if test "x$with_freetype" = "xyes" -a "x$have_freetype" != "xtrue"; then
|
||||
AC_MSG_ERROR([FreeType support requested but libfreetype2 not found])
|
||||
fi
|
||||
if $have_freetype; then
|
||||
AC_DEFINE(HAVE_FREETYPE, 1, [Have FreeType 2 library])
|
||||
_save_libs="$LIBS"
|
||||
_save_cflags="$CFLAGS"
|
||||
save_libs=$LIBS
|
||||
LIBS="$LIBS $FREETYPE_LIBS"
|
||||
CFLAGS="$CFLAGS $FREETYPE_CFLAGS"
|
||||
AC_CHECK_FUNCS(FT_Face_GetCharVariantIndex)
|
||||
LIBS="$_save_libs"
|
||||
CFLAGS="$_save_cflags"
|
||||
AC_CHECK_FUNCS(FT_Get_Var_Blend_Coordinates)
|
||||
LIBS=$save_libs
|
||||
fi
|
||||
AM_CONDITIONAL(HAVE_FREETYPE, $have_freetype)
|
||||
|
||||
dnl ===========================================================================
|
||||
|
||||
have_ot=true;
|
||||
if $have_ot; then
|
||||
AC_DEFINE(HAVE_OT, 1, [Have native OpenType Layout backend])
|
||||
AC_ARG_WITH(uniscribe,
|
||||
[AS_HELP_STRING([--with-uniscribe=@<:@yes/no/auto@:>@],
|
||||
[Use the Uniscribe library @<:@default=no@:>@])],,
|
||||
[with_uniscribe=no])
|
||||
have_uniscribe=false
|
||||
if test "x$with_uniscribe" = "xyes" -o "x$with_uniscribe" = "xauto"; then
|
||||
AC_CHECK_HEADERS(usp10.h windows.h, have_uniscribe=true)
|
||||
fi
|
||||
if test "x$with_uniscribe" = "xyes" -a "x$have_uniscribe" != "xtrue"; then
|
||||
AC_MSG_ERROR([uniscribe support requested but not found])
|
||||
fi
|
||||
AM_CONDITIONAL(HAVE_OT, $have_ot)
|
||||
|
||||
dnl ===========================================================================
|
||||
|
||||
AC_CHECK_HEADERS(usp10.h windows.h, have_uniscribe=true, have_uniscribe=false)
|
||||
if $have_uniscribe; then
|
||||
UNISCRIBE_CFLAGS=
|
||||
UNISCRIBE_LIBS="-lusp10 -lgdi32"
|
||||
UNISCRIBE_LIBS="-lusp10 -lgdi32 -lrpcrt4"
|
||||
AC_SUBST(UNISCRIBE_CFLAGS)
|
||||
AC_SUBST(UNISCRIBE_LIBS)
|
||||
AC_DEFINE(HAVE_UNISCRIBE, 1, [Have Uniscribe backend])
|
||||
AC_DEFINE(HAVE_UNISCRIBE, 1, [Have Uniscribe library])
|
||||
fi
|
||||
AM_CONDITIONAL(HAVE_UNISCRIBE, $have_uniscribe)
|
||||
|
||||
dnl ===========================================================================
|
||||
|
||||
AC_ARG_WITH(directwrite,
|
||||
[AS_HELP_STRING([--with-directwrite=@<:@yes/no/auto@:>@],
|
||||
[Use the DirectWrite library (experimental) @<:@default=no@:>@])],,
|
||||
[with_directwrite=no])
|
||||
have_directwrite=false
|
||||
AC_LANG_PUSH([C++])
|
||||
if test "x$with_directwrite" = "xyes" -o "x$with_directwrite" = "xauto"; then
|
||||
AC_CHECK_HEADERS(dwrite.h, have_directwrite=true)
|
||||
fi
|
||||
AC_LANG_POP([C++])
|
||||
if test "x$with_directwrite" = "xyes" -a "x$have_directwrite" != "xtrue"; then
|
||||
AC_MSG_ERROR([directwrite support requested but not found])
|
||||
fi
|
||||
if $have_directwrite; then
|
||||
DIRECTWRITE_CXXFLAGS=
|
||||
DIRECTWRITE_LIBS="-ldwrite"
|
||||
AC_SUBST(DIRECTWRITE_CXXFLAGS)
|
||||
AC_SUBST(DIRECTWRITE_LIBS)
|
||||
AC_DEFINE(HAVE_DIRECTWRITE, 1, [Have DirectWrite library])
|
||||
fi
|
||||
AM_CONDITIONAL(HAVE_DIRECTWRITE, $have_directwrite)
|
||||
|
||||
dnl ===========================================================================
|
||||
|
||||
AC_ARG_WITH(coretext,
|
||||
[AS_HELP_STRING([--with-coretext=@<:@yes/no/auto@:>@],
|
||||
[Use CoreText @<:@default=no@:>@])],,
|
||||
[with_coretext=no])
|
||||
have_coretext=false
|
||||
if test "x$with_coretext" = "xyes" -o "x$with_coretext" = "xauto"; then
|
||||
AC_CHECK_TYPE(CTFontRef, have_coretext=true,, [#include <ApplicationServices/ApplicationServices.h>])
|
||||
|
||||
if $have_coretext; then
|
||||
CORETEXT_CFLAGS=
|
||||
CORETEXT_LIBS="-framework ApplicationServices"
|
||||
AC_SUBST(CORETEXT_CFLAGS)
|
||||
AC_SUBST(CORETEXT_LIBS)
|
||||
else
|
||||
# On iOS CoreText and CoreGraphics are stand-alone frameworks
|
||||
if test "x$have_coretext" != "xtrue"; then
|
||||
# Check for a different symbol to avoid getting cached result.
|
||||
AC_CHECK_TYPE(CTRunRef, have_coretext=true,, [#include <CoreText/CoreText.h>])
|
||||
fi
|
||||
|
||||
if $have_coretext; then
|
||||
CORETEXT_CFLAGS=
|
||||
CORETEXT_LIBS="-framework CoreText -framework CoreGraphics"
|
||||
AC_SUBST(CORETEXT_CFLAGS)
|
||||
AC_SUBST(CORETEXT_LIBS)
|
||||
fi
|
||||
fi
|
||||
fi
|
||||
if test "x$with_coretext" = "xyes" -a "x$have_coretext" != "xtrue"; then
|
||||
AC_MSG_ERROR([CoreText support requested but libcoretext not found])
|
||||
fi
|
||||
if $have_coretext; then
|
||||
AC_DEFINE(HAVE_CORETEXT, 1, [Have Core Text backend])
|
||||
fi
|
||||
AM_CONDITIONAL(HAVE_CORETEXT, $have_coretext)
|
||||
|
||||
dnl ===========================================================================
|
||||
|
||||
AC_CACHE_CHECK([for Intel atomic primitives], hb_cv_have_intel_atomic_primitives, [
|
||||
hb_cv_have_intel_atomic_primitives=false
|
||||
AC_TRY_LINK([
|
||||
void memory_barrier (void) { __sync_synchronize (); }
|
||||
int atomic_add (int *i) { return __sync_fetch_and_add (i, 1); }
|
||||
int mutex_trylock (int *m) { return __sync_lock_test_and_set (m, 1); }
|
||||
void mutex_unlock (int *m) { __sync_lock_release (m); }
|
||||
], [], hb_cv_have_intel_atomic_primitives=true
|
||||
)
|
||||
])
|
||||
if $hb_cv_have_intel_atomic_primitives; then
|
||||
AC_DEFINE(HAVE_INTEL_ATOMIC_PRIMITIVES, 1, [Have Intel __sync_* atomic primitives])
|
||||
fi
|
||||
|
||||
dnl ===========================================================================
|
||||
|
||||
AC_CACHE_CHECK([for Solaris atomic operations], hb_cv_have_solaris_atomic_ops, [
|
||||
hb_cv_have_solaris_atomic_ops=false
|
||||
AC_TRY_LINK([
|
||||
#include <atomic.h>
|
||||
/* This requires Solaris Studio 12.2 or newer: */
|
||||
#include <mbarrier.h>
|
||||
void memory_barrier (void) { __machine_rw_barrier (); }
|
||||
int atomic_add (volatile unsigned *i) { return atomic_add_int_nv (i, 1); }
|
||||
void *atomic_ptr_cmpxchg (volatile void **target, void *cmp, void *newval) { return atomic_cas_ptr (target, cmp, newval); }
|
||||
], [], hb_cv_have_solaris_atomic_ops=true
|
||||
)
|
||||
])
|
||||
if $hb_cv_have_solaris_atomic_ops; then
|
||||
AC_DEFINE(HAVE_SOLARIS_ATOMIC_OPS, 1, [Have Solaris __machine_*_barrier and atomic_* operations])
|
||||
fi
|
||||
|
||||
if test "$os_win32" = no && ! $have_pthread; then
|
||||
AC_CHECK_HEADERS(sched.h)
|
||||
AC_SEARCH_LIBS(sched_yield,rt,AC_DEFINE(HAVE_SCHED_YIELD, 1, [Have sched_yield]))
|
||||
fi
|
||||
|
||||
dnl ===========================================================================
|
||||
|
||||
AC_CONFIG_FILES([
|
||||
Makefile
|
||||
harfbuzz.pc
|
||||
src/Makefile
|
||||
src/hb-version.h
|
||||
src/hb-ucdn/Makefile
|
||||
util/Makefile
|
||||
test/Makefile
|
||||
test/api/Makefile
|
||||
test/fuzzing/Makefile
|
||||
test/shaping/Makefile
|
||||
docs/Makefile
|
||||
docs/version.xml
|
||||
win32/Makefile
|
||||
win32/config.h.win32
|
||||
])
|
||||
|
||||
AC_OUTPUT
|
||||
|
||||
AC_MSG_NOTICE([
|
||||
|
||||
Build configuration:
|
||||
|
||||
Unicode callbacks (you want at least one):
|
||||
Builtin (UCDN): ${have_ucdn}
|
||||
Glib: ${have_glib}
|
||||
ICU: ${have_icu}
|
||||
|
||||
Font callbacks (the more the better):
|
||||
FreeType: ${have_freetype}
|
||||
|
||||
Tools used for command-line utilities:
|
||||
Cairo: ${have_cairo}
|
||||
Fontconfig: ${have_fontconfig}
|
||||
|
||||
Additional shapers (the more the better):
|
||||
Graphite2: ${have_graphite2}
|
||||
|
||||
Platform shapers (not normally needed):
|
||||
CoreText: ${have_coretext}
|
||||
Uniscribe: ${have_uniscribe}
|
||||
DirectWrite: ${have_directwrite}
|
||||
|
||||
Other features:
|
||||
Documentation: ${have_gtk_doc}
|
||||
GObject bindings: ${have_gobject}
|
||||
Introspection: ${have_introspection}
|
||||
])
|
||||
|
|
|
@ -1,18 +1,25 @@
|
|||
# git.mk
|
||||
# git.mk, a small Makefile to autogenerate .gitignore files
|
||||
# for autotools-based projects.
|
||||
#
|
||||
# Copyright 2009, Red Hat, Inc.
|
||||
# Copyright 2010,2011,2012,2013 Behdad Esfahbod
|
||||
# Written by Behdad Esfahbod
|
||||
#
|
||||
# Copying and distribution of this file, with or without modification,
|
||||
# are permitted in any medium without royalty provided the copyright
|
||||
# is permitted in any medium without royalty provided the copyright
|
||||
# notice and this notice are preserved.
|
||||
#
|
||||
# The canonical source for this file is pango/git.mk, or whereever the
|
||||
# header of pango/git.mk suggests in the future.
|
||||
# The latest version of this file can be downloaded from:
|
||||
GIT_MK_URL = https://raw.githubusercontent.com/behdad/git.mk/master/git.mk
|
||||
#
|
||||
# Bugs, etc, should be reported upstream at:
|
||||
# https://github.com/behdad/git.mk
|
||||
#
|
||||
# To use in your project, import this file in your git repo's toplevel,
|
||||
# then do "make -f git.mk". This modifies all Makefile.am files in
|
||||
# your project to include git.mk.
|
||||
# your project to -include git.mk. Remember to add that line to new
|
||||
# Makefile.am files you create in your project, or just rerun the
|
||||
# "make -f git.mk".
|
||||
#
|
||||
# This enables automatic .gitignore generation. If you need to ignore
|
||||
# more files, add them to the GITIGNOREFILES variable in your Makefile.am.
|
||||
|
@ -22,7 +29,7 @@
|
|||
#
|
||||
# The only case that you need to manually add a file to GITIGNOREFILES is
|
||||
# when remove files in one of mostlyclean-local, clean-local, distclean-local,
|
||||
# or maintainer-clean-local.
|
||||
# or maintainer-clean-local make targets.
|
||||
#
|
||||
# Note that for files like editor backup, etc, there are better places to
|
||||
# ignore them. See "man gitignore".
|
||||
|
@ -30,18 +37,25 @@
|
|||
# If "make maintainer-clean" removes the files but they are not recognized
|
||||
# by this script (that is, if "git status" shows untracked files still), send
|
||||
# me the output of "git status" as well as your Makefile.am and Makefile for
|
||||
# the directories involved.
|
||||
# the directories involved and I'll diagnose.
|
||||
#
|
||||
# For a list of toplevel files that should be in MAINTAINERCLEANFILES, see
|
||||
# pango/Makefile.am.
|
||||
# Makefile.am.sample in the git.mk git repo.
|
||||
#
|
||||
# Don't EXTRA_DIST this file. It is supposed to only live in git clones,
|
||||
# not tarballs. It serves no useful purpose in tarballs and clutters the
|
||||
# build dir.
|
||||
#
|
||||
# This file knows how to handle autoconf, automake, libtool, gtk-doc,
|
||||
# gnome-doc-utils, intltool.
|
||||
# gnome-doc-utils, yelp.m4, mallard, intltool, gsettings, dejagnu, appdata,
|
||||
# appstream.
|
||||
#
|
||||
# This makefile provides the following targets:
|
||||
#
|
||||
# - all: "make all" will build all gitignore files.
|
||||
# - gitignore: makes all gitignore files in the current dir and subdirs.
|
||||
# - .gitignore: make gitignore file for the current dir.
|
||||
# - gitignore-recurse: makes all gitignore files in the subdirs.
|
||||
#
|
||||
# KNOWN ISSUES:
|
||||
#
|
||||
|
@ -53,13 +67,74 @@
|
|||
# example.
|
||||
#
|
||||
|
||||
|
||||
|
||||
###############################################################################
|
||||
# Variables user modules may want to add to toplevel MAINTAINERCLEANFILES:
|
||||
###############################################################################
|
||||
|
||||
#
|
||||
# Most autotools-using modules should be fine including this variable in their
|
||||
# toplevel MAINTAINERCLEANFILES:
|
||||
GITIGNORE_MAINTAINERCLEANFILES_TOPLEVEL = \
|
||||
$(srcdir)/aclocal.m4 \
|
||||
$(srcdir)/autoscan.log \
|
||||
$(srcdir)/configure.scan \
|
||||
`AUX_DIR=$(srcdir)/$$(cd $(top_srcdir); $(AUTOCONF) --trace 'AC_CONFIG_AUX_DIR:$$1' ./configure.ac); \
|
||||
test "x$$AUX_DIR" = "x$(srcdir)/" && AUX_DIR=$(srcdir); \
|
||||
for x in \
|
||||
ar-lib \
|
||||
compile \
|
||||
config.guess \
|
||||
config.sub \
|
||||
depcomp \
|
||||
install-sh \
|
||||
ltmain.sh \
|
||||
missing \
|
||||
mkinstalldirs \
|
||||
test-driver \
|
||||
ylwrap \
|
||||
; do echo "$$AUX_DIR/$$x"; done` \
|
||||
`cd $(top_srcdir); $(AUTOCONF) --trace 'AC_CONFIG_HEADERS:$$1' ./configure.ac | \
|
||||
head -n 1 | while read f; do echo "$(srcdir)/$$f.in"; done`
|
||||
#
|
||||
# All modules should also be fine including the following variable, which
|
||||
# removes automake-generated Makefile.in files:
|
||||
GITIGNORE_MAINTAINERCLEANFILES_MAKEFILE_IN = \
|
||||
`cd $(top_srcdir); $(AUTOCONF) --trace 'AC_CONFIG_FILES:$$1' ./configure.ac | \
|
||||
while read f; do \
|
||||
case $$f in Makefile|*/Makefile) \
|
||||
test -f "$(srcdir)/$$f.am" && echo "$(srcdir)/$$f.in";; esac; \
|
||||
done`
|
||||
#
|
||||
# Modules that use libtool and use AC_CONFIG_MACRO_DIR() may also include this,
|
||||
# though it's harmless to include regardless.
|
||||
GITIGNORE_MAINTAINERCLEANFILES_M4_LIBTOOL = \
|
||||
`MACRO_DIR=$(srcdir)/$$(cd $(top_srcdir); $(AUTOCONF) --trace 'AC_CONFIG_MACRO_DIR:$$1' ./configure.ac); \
|
||||
if test "x$$MACRO_DIR" != "x$(srcdir)/"; then \
|
||||
for x in \
|
||||
libtool.m4 \
|
||||
ltoptions.m4 \
|
||||
ltsugar.m4 \
|
||||
ltversion.m4 \
|
||||
lt~obsolete.m4 \
|
||||
; do echo "$$MACRO_DIR/$$x"; done; \
|
||||
fi`
|
||||
|
||||
|
||||
|
||||
###############################################################################
|
||||
# Default rule is to install ourselves in all Makefile.am files:
|
||||
###############################################################################
|
||||
|
||||
git-all: git-mk-install
|
||||
|
||||
git-mk-install:
|
||||
@echo Installing git makefile
|
||||
@any_failed=; find $(top_srcdir) -name Makefile.am | while read x; do \
|
||||
@echo "Installing git makefile"
|
||||
@any_failed=; \
|
||||
find "`test -z "$(top_srcdir)" && echo . || echo "$(top_srcdir)"`" -name Makefile.am | while read x; do \
|
||||
if grep 'include .*/git.mk' $$x >/dev/null; then \
|
||||
echo $$x already includes git.mk; \
|
||||
echo "$$x already includes git.mk"; \
|
||||
else \
|
||||
failed=; \
|
||||
echo "Updating $$x"; \
|
||||
|
@ -71,55 +146,114 @@ git-mk-install:
|
|||
mv $$x.tmp $$x || failed=1; \
|
||||
fi; \
|
||||
if test x$$failed = x; then : else \
|
||||
echo Failed updating $$x; >&2 \
|
||||
echo "Failed updating $$x"; >&2 \
|
||||
any_failed=1; \
|
||||
fi; \
|
||||
fi; done; test -z "$$any_failed"
|
||||
|
||||
.PHONY: git-all git-mk-install
|
||||
git-mk-update:
|
||||
wget $(GIT_MK_URL) -O $(top_srcdir)/git.mk
|
||||
|
||||
.PHONY: git-all git-mk-install git-mk-update
|
||||
|
||||
|
||||
### .gitignore generation
|
||||
|
||||
###############################################################################
|
||||
# Actual .gitignore generation:
|
||||
###############################################################################
|
||||
|
||||
$(srcdir)/.gitignore: Makefile.am $(top_srcdir)/git.mk
|
||||
$(AM_V_GEN) \
|
||||
{ \
|
||||
@echo "git.mk: Generating $@"
|
||||
@{ \
|
||||
if test "x$(DOC_MODULE)" = x -o "x$(DOC_MAIN_SGML_FILE)" = x; then :; else \
|
||||
for x in \
|
||||
$(DOC_MODULE)-decl-list.txt \
|
||||
$(DOC_MODULE)-decl.txt \
|
||||
tmpl/$(DOC_MODULE)-unused.sgml \
|
||||
"tmpl/*.bak" \
|
||||
$(REPORT_FILES) \
|
||||
$(DOC_MODULE).pdf \
|
||||
xml html \
|
||||
; do echo /$$x; done; \
|
||||
; do echo "/$$x"; done; \
|
||||
FLAVOR=$$(cd $(top_srcdir); $(AUTOCONF) --trace 'GTK_DOC_CHECK:$$2' ./configure.ac); \
|
||||
case $$FLAVOR in *no-tmpl*) echo /tmpl;; esac; \
|
||||
if echo "$(SCAN_OPTIONS)" | grep -q "\-\-rebuild-types"; then \
|
||||
echo "/$(DOC_MODULE).types"; \
|
||||
fi; \
|
||||
if echo "$(SCAN_OPTIONS)" | grep -q "\-\-rebuild-sections"; then \
|
||||
echo "/$(DOC_MODULE)-sections.txt"; \
|
||||
fi; \
|
||||
if test "$(abs_srcdir)" != "$(abs_builddir)" ; then \
|
||||
for x in \
|
||||
$(SETUP_FILES) \
|
||||
$(DOC_MODULE).types \
|
||||
; do echo "/$$x"; done; \
|
||||
fi; \
|
||||
fi; \
|
||||
if test "x$(DOC_MODULE)" = x -o "x$(DOC_LINGUAS)" = x; then :; else \
|
||||
if test "x$(DOC_MODULE)$(DOC_ID)" = x -o "x$(DOC_LINGUAS)" = x; then :; else \
|
||||
for lc in $(DOC_LINGUAS); do \
|
||||
for x in \
|
||||
$(if $(DOC_MODULE),$(DOC_MODULE).xml) \
|
||||
$(DOC_PAGES) \
|
||||
$(DOC_INCLUDES) \
|
||||
; do echo "/$$lc/$$x"; done; \
|
||||
done; \
|
||||
for x in \
|
||||
$(_DOC_C_DOCS) \
|
||||
$(_DOC_LC_DOCS) \
|
||||
$(_DOC_OMF_ALL) \
|
||||
$(_DOC_DSK_ALL) \
|
||||
$(_DOC_HTML_ALL) \
|
||||
$(_DOC_POFILES) \
|
||||
$(_DOC_MOFILES) \
|
||||
$(DOC_H_FILE) \
|
||||
"*/.xml2po.mo" \
|
||||
"*/*.omf.out" \
|
||||
; do echo /$$x; done; \
|
||||
fi; \
|
||||
if test "x$(HELP_ID)" = x -o "x$(HELP_LINGUAS)" = x; then :; else \
|
||||
for lc in $(HELP_LINGUAS); do \
|
||||
for x in \
|
||||
$(HELP_FILES) \
|
||||
"$$lc.stamp" \
|
||||
"$$lc.mo" \
|
||||
; do echo "/$$lc/$$x"; done; \
|
||||
done; \
|
||||
fi; \
|
||||
if test "x$(gsettings_SCHEMAS)" = x; then :; else \
|
||||
for x in \
|
||||
$(gsettings_SCHEMAS:.xml=.valid) \
|
||||
$(gsettings__enum_file) \
|
||||
; do echo "/$$x"; done; \
|
||||
fi; \
|
||||
if test "x$(appdata_XML)" = x; then :; else \
|
||||
for x in \
|
||||
$(appdata_XML:.xml=.valid) \
|
||||
; do echo "/$$x"; done; \
|
||||
fi; \
|
||||
if test "x$(appstream_XML)" = x; then :; else \
|
||||
for x in \
|
||||
$(appstream_XML:.xml=.valid) \
|
||||
; do echo "/$$x"; done; \
|
||||
fi; \
|
||||
if test -f $(srcdir)/po/Makefile.in.in; then \
|
||||
for x in \
|
||||
po/Makefile.in.in \
|
||||
po/Makefile.in.in~ \
|
||||
po/Makefile.in \
|
||||
po/Makefile \
|
||||
po/Makevars.template \
|
||||
po/POTFILES \
|
||||
po/Rules-quot \
|
||||
po/stamp-it \
|
||||
po/.intltool-merge-cache \
|
||||
"po/*.gmo" \
|
||||
"po/*.header" \
|
||||
"po/*.mo" \
|
||||
"po/*.sed" \
|
||||
"po/*.sin" \
|
||||
po/$(GETTEXT_PACKAGE).pot \
|
||||
intltool-extract.in \
|
||||
intltool-merge.in \
|
||||
intltool-update.in \
|
||||
; do echo /$$x; done; \
|
||||
; do echo "/$$x"; done; \
|
||||
fi; \
|
||||
if test -f $(srcdir)/configure; then \
|
||||
for x in \
|
||||
|
@ -129,21 +263,38 @@ $(srcdir)/.gitignore: Makefile.am $(top_srcdir)/git.mk
|
|||
stamp-h1 \
|
||||
libtool \
|
||||
config.lt \
|
||||
; do echo /$$x; done; \
|
||||
; do echo "/$$x"; done; \
|
||||
fi; \
|
||||
if test "x$(DEJATOOL)" = x; then :; else \
|
||||
for x in \
|
||||
$(DEJATOOL) \
|
||||
; do echo "/$$x.sum"; echo "/$$x.log"; done; \
|
||||
echo /site.exp; \
|
||||
fi; \
|
||||
if test "x$(am__dirstamp)" = x; then :; else \
|
||||
echo "$(am__dirstamp)"; \
|
||||
fi; \
|
||||
if test "x$(LTCOMPILE)" = x -a "x$(LTCXXCOMPILE)" = x -a "x$(GTKDOC_RUN)" = x; then :; else \
|
||||
for x in \
|
||||
"*.lo" \
|
||||
".libs" "_libs" \
|
||||
; do echo "$$x"; done; \
|
||||
fi; \
|
||||
for x in \
|
||||
.gitignore \
|
||||
$(GITIGNOREFILES) \
|
||||
$(CLEANFILES) \
|
||||
$(PROGRAMS) \
|
||||
$(check_PROGRAMS) \
|
||||
$(EXTRA_PROGRAMS) \
|
||||
$(LTLIBRARIES) \
|
||||
$(PROGRAMS) $(check_PROGRAMS) $(EXTRA_PROGRAMS) \
|
||||
$(LIBRARIES) $(check_LIBRARIES) $(EXTRA_LIBRARIES) \
|
||||
$(LTLIBRARIES) $(check_LTLIBRARIES) $(EXTRA_LTLIBRARIES) \
|
||||
so_locations \
|
||||
.libs _libs \
|
||||
$(MOSTLYCLEANFILES) \
|
||||
"*.$(OBJEXT)" \
|
||||
"*.lo" \
|
||||
$(TEST_LOGS) \
|
||||
$(TEST_LOGS:.log=.trs) \
|
||||
$(TEST_SUITE_LOG) \
|
||||
$(TESTS:=.test) \
|
||||
"*.gcda" \
|
||||
"*.gcno" \
|
||||
$(DISTCLEANFILES) \
|
||||
$(am__CONFIG_DISTCLEAN_FILES) \
|
||||
$(CONFIG_CLEAN_FILES) \
|
||||
|
@ -151,7 +302,10 @@ $(srcdir)/.gitignore: Makefile.am $(top_srcdir)/git.mk
|
|||
"*.tab.c" \
|
||||
$(MAINTAINERCLEANFILES) \
|
||||
$(BUILT_SOURCES) \
|
||||
$(DEPDIR) \
|
||||
$(patsubst %.vala,%.c,$(filter %.vala,$(SOURCES))) \
|
||||
$(filter %_vala.stamp,$(DIST_COMMON)) \
|
||||
$(filter %.vapi,$(DIST_COMMON)) \
|
||||
$(filter $(addprefix %,$(notdir $(patsubst %.vapi,%.h,$(filter %.vapi,$(DIST_COMMON))))),$(DIST_COMMON)) \
|
||||
Makefile \
|
||||
Makefile.in \
|
||||
"*.orig" \
|
||||
|
@ -159,7 +313,12 @@ $(srcdir)/.gitignore: Makefile.am $(top_srcdir)/git.mk
|
|||
"*.bak" \
|
||||
"*~" \
|
||||
".*.sw[nop]" \
|
||||
; do echo /$$x; done; \
|
||||
".dirstamp" \
|
||||
; do echo "/$$x"; done; \
|
||||
for x in \
|
||||
"*.$(OBJEXT)" \
|
||||
$(DEPDIR) \
|
||||
; do echo "$$x"; done; \
|
||||
} | \
|
||||
sed "s@^/`echo "$(srcdir)" | sed 's/\(.\)/[\1]/g'`/@/@" | \
|
||||
sed 's@/[.]/@/@g' | \
|
||||
|
@ -167,16 +326,20 @@ $(srcdir)/.gitignore: Makefile.am $(top_srcdir)/git.mk
|
|||
mv $@.tmp $@;
|
||||
|
||||
all: $(srcdir)/.gitignore gitignore-recurse-maybe
|
||||
gitignore-recurse-maybe:
|
||||
@if test "x$(SUBDIRS)" = "x$(DIST_SUBDIRS)"; then :; else \
|
||||
$(MAKE) $(AM_MAKEFLAGS) gitignore-recurse; \
|
||||
fi;
|
||||
gitignore-recurse:
|
||||
@list='$(DIST_SUBDIRS)'; for subdir in $$list; do \
|
||||
test "$$subdir" = . || (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) .gitignore gitignore-recurse || echo "Skipping $$subdir"); \
|
||||
done
|
||||
gitignore: $(srcdir)/.gitignore gitignore-recurse
|
||||
|
||||
gitignore-recurse-maybe:
|
||||
@for subdir in $(DIST_SUBDIRS); do \
|
||||
case " $(SUBDIRS) " in \
|
||||
*" $$subdir "*) :;; \
|
||||
*) test "$$subdir" = . -o -e "$$subdir/.git" || (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) gitignore || echo "Skipping $$subdir");; \
|
||||
esac; \
|
||||
done
|
||||
gitignore-recurse:
|
||||
@for subdir in $(DIST_SUBDIRS); do \
|
||||
test "$$subdir" = . -o -e "$$subdir/.git" || (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) gitignore || echo "Skipping $$subdir"); \
|
||||
done
|
||||
|
||||
maintainer-clean: gitignore-clean
|
||||
gitignore-clean:
|
||||
-rm -f $(srcdir)/.gitignore
|
||||
|
|
|
@ -0,0 +1,24 @@
|
|||
<Project xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
|
||||
xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
|
||||
xmlns:foaf="http://xmlns.com/foaf/0.1/"
|
||||
xmlns="http://usefulinc.com/ns/doap#">
|
||||
|
||||
<name xml:lang="en">harfbuzz</name>
|
||||
<shortdesc xml:lang="en">Text shaping library</shortdesc>
|
||||
|
||||
<homepage
|
||||
rdf:resource="http://harfbuzz.org/" />
|
||||
<mailing-list
|
||||
rdf:resource="http://lists.freedesktop.org/mailman/listinfo/harfbuzz" />
|
||||
<!--download-page
|
||||
rdf:resource=""/-->
|
||||
<bug-database
|
||||
rdf:resource="http://bugs.freedesktop.org/enter_bug.cgi?product=harfbuzz"/>
|
||||
|
||||
<maintainer>
|
||||
<foaf:Person>
|
||||
<foaf:name>Behdad Esfahbod</foaf:name>
|
||||
<foaf:mbox rdf:resource="mailto:harfbuzz@behdad.org" />
|
||||
</foaf:Person>
|
||||
</maintainer>
|
||||
</Project>
|
|
@ -1,11 +0,0 @@
|
|||
prefix=@prefix@
|
||||
exec_prefix=@exec_prefix@
|
||||
libdir=@libdir@
|
||||
includedir=@includedir@
|
||||
|
||||
Name: harfbuzz
|
||||
Description: Text shaping library
|
||||
Version: @VERSION@
|
||||
|
||||
Libs: -L${libdir} -lharfbuzz
|
||||
Cflags: -I${includedir}/harfbuzz
|
|
@ -1,6 +1,5 @@
|
|||
# Process this file with automake to produce Makefile.in
|
||||
|
||||
NULL =
|
||||
SUBDIRS =
|
||||
DIST_SUBDIRS =
|
||||
BUILT_SOURCES =
|
||||
|
@ -19,120 +18,25 @@ fuzzing: $(BUILT_SOURCES) libharfbuzz-fuzzing.la
|
|||
|
||||
lib_LTLIBRARIES = libharfbuzz.la
|
||||
|
||||
include Makefile.sources
|
||||
|
||||
HBCFLAGS =
|
||||
HBLIBS =
|
||||
HBNONPCLIBS =
|
||||
HBDEPS =
|
||||
HBSOURCES = \
|
||||
hb-atomic-private.hh \
|
||||
hb-blob.cc \
|
||||
hb-buffer-deserialize-json.hh \
|
||||
hb-buffer-deserialize-text.hh \
|
||||
hb-buffer-private.hh \
|
||||
hb-buffer-serialize.cc \
|
||||
hb-buffer.cc \
|
||||
hb-cache-private.hh \
|
||||
hb-common.cc \
|
||||
hb-face-private.hh \
|
||||
hb-face.cc \
|
||||
hb-font-private.hh \
|
||||
hb-font.cc \
|
||||
hb-mutex-private.hh \
|
||||
hb-object-private.hh \
|
||||
hb-open-file-private.hh \
|
||||
hb-open-type-private.hh \
|
||||
hb-ot-cmap-table.hh \
|
||||
hb-ot-glyf-table.hh \
|
||||
hb-ot-head-table.hh \
|
||||
hb-ot-hhea-table.hh \
|
||||
hb-ot-hmtx-table.hh \
|
||||
hb-ot-maxp-table.hh \
|
||||
hb-ot-name-table.hh \
|
||||
hb-ot-tag.cc \
|
||||
hb-private.hh \
|
||||
hb-set-private.hh \
|
||||
hb-set.cc \
|
||||
hb-shape.cc \
|
||||
hb-shape-plan-private.hh \
|
||||
hb-shape-plan.cc \
|
||||
hb-shaper-list.hh \
|
||||
hb-shaper-impl-private.hh \
|
||||
hb-shaper-private.hh \
|
||||
hb-shaper.cc \
|
||||
hb-unicode-private.hh \
|
||||
hb-unicode.cc \
|
||||
hb-utf-private.hh \
|
||||
hb-warning.cc \
|
||||
$(NULL)
|
||||
HBHEADERS = \
|
||||
hb.h \
|
||||
hb-blob.h \
|
||||
hb-buffer.h \
|
||||
hb-common.h \
|
||||
hb-deprecated.h \
|
||||
hb-face.h \
|
||||
hb-font.h \
|
||||
hb-set.h \
|
||||
hb-shape.h \
|
||||
hb-shape-plan.h \
|
||||
hb-unicode.h \
|
||||
$(NULL)
|
||||
HBNODISTHEADERS = \
|
||||
hb-version.h \
|
||||
$(NULL)
|
||||
HBSOURCES = $(HB_BASE_sources)
|
||||
HBSOURCES += $(HB_BASE_RAGEL_GENERATED_sources)
|
||||
HBHEADERS = $(HB_BASE_headers)
|
||||
HBNODISTHEADERS = $(HB_NODIST_headers)
|
||||
|
||||
if HAVE_OT
|
||||
HBSOURCES += \
|
||||
hb-ot-font.cc \
|
||||
hb-ot-layout.cc \
|
||||
hb-ot-layout-common-private.hh \
|
||||
hb-ot-layout-gdef-table.hh \
|
||||
hb-ot-layout-gpos-table.hh \
|
||||
hb-ot-layout-gsubgpos-private.hh \
|
||||
hb-ot-layout-gsub-table.hh \
|
||||
hb-ot-layout-jstf-table.hh \
|
||||
hb-ot-layout-private.hh \
|
||||
hb-ot-map.cc \
|
||||
hb-ot-map-private.hh \
|
||||
hb-ot-shape.cc \
|
||||
hb-ot-shape-complex-arabic.cc \
|
||||
hb-ot-shape-complex-arabic-fallback.hh \
|
||||
hb-ot-shape-complex-arabic-private.hh \
|
||||
hb-ot-shape-complex-arabic-table.hh \
|
||||
hb-ot-shape-complex-arabic-win1256.hh \
|
||||
hb-ot-shape-complex-default.cc \
|
||||
hb-ot-shape-complex-hangul.cc \
|
||||
hb-ot-shape-complex-hebrew.cc \
|
||||
hb-ot-shape-complex-indic.cc \
|
||||
hb-ot-shape-complex-indic-machine.hh \
|
||||
hb-ot-shape-complex-indic-private.hh \
|
||||
hb-ot-shape-complex-indic-table.cc \
|
||||
hb-ot-shape-complex-myanmar.cc \
|
||||
hb-ot-shape-complex-myanmar-machine.hh \
|
||||
hb-ot-shape-complex-thai.cc \
|
||||
hb-ot-shape-complex-tibetan.cc \
|
||||
hb-ot-shape-complex-use.cc \
|
||||
hb-ot-shape-complex-use-machine.hh \
|
||||
hb-ot-shape-complex-use-private.hh \
|
||||
hb-ot-shape-complex-use-table.cc \
|
||||
hb-ot-shape-complex-private.hh \
|
||||
hb-ot-shape-normalize-private.hh \
|
||||
hb-ot-shape-normalize.cc \
|
||||
hb-ot-shape-fallback-private.hh \
|
||||
hb-ot-shape-fallback.cc \
|
||||
hb-ot-shape-private.hh \
|
||||
$(NULL)
|
||||
HBHEADERS += \
|
||||
hb-ot.h \
|
||||
hb-ot-font.h \
|
||||
hb-ot-layout.h \
|
||||
hb-ot-shape.h \
|
||||
hb-ot-tag.h \
|
||||
$(NULL)
|
||||
HBSOURCES += $(HB_OT_sources)
|
||||
HBSOURCES += $(HB_OT_RAGEL_GENERATED_sources)
|
||||
HBHEADERS += $(HB_OT_headers)
|
||||
endif
|
||||
|
||||
if HAVE_FALLBACK
|
||||
HBSOURCES += hb-fallback-shape.cc
|
||||
HBSOURCES += $(HB_FALLBACK_sources)
|
||||
endif
|
||||
|
||||
if HAVE_PTHREAD
|
||||
|
@ -144,8 +48,8 @@ if HAVE_GLIB
|
|||
HBCFLAGS += $(GLIB_CFLAGS)
|
||||
HBLIBS += $(GLIB_LIBS)
|
||||
HBDEPS += $(GLIB_DEPS)
|
||||
HBSOURCES += hb-glib.cc
|
||||
HBHEADERS += hb-glib.h
|
||||
HBSOURCES += $(HB_GLIB_sources)
|
||||
HBHEADERS += $(HB_GLIB_headers)
|
||||
endif
|
||||
|
||||
if HAVE_FREETYPE
|
||||
|
@ -157,37 +61,44 @@ HBLIBS += $(FREETYPE_LIBS)
|
|||
# fine but pkg-config 0.26 as shipped in Ubuntu 14.04 crashes. Remove
|
||||
# in a year or two, or otherwise work around it...
|
||||
#HBDEPS += $(FREETYPE_DEPS)
|
||||
HBSOURCES += hb-ft.cc
|
||||
HBHEADERS += hb-ft.h
|
||||
HBSOURCES += $(HB_FT_sources)
|
||||
HBHEADERS += $(HB_FT_headers)
|
||||
endif
|
||||
|
||||
if HAVE_GRAPHITE2
|
||||
HBCFLAGS += $(GRAPHITE2_CFLAGS)
|
||||
HBLIBS += $(GRAPHITE2_LIBS)
|
||||
HBDEPS += $(GRAPHITE2_DEPS)
|
||||
HBSOURCES += hb-graphite2.cc
|
||||
HBHEADERS += hb-graphite2.h
|
||||
HBSOURCES += $(HB_GRAPHITE2_sources)
|
||||
HBHEADERS += $(HB_GRAPHITE2_headers)
|
||||
endif
|
||||
|
||||
if HAVE_UNISCRIBE
|
||||
HBCFLAGS += $(UNISCRIBE_CFLAGS)
|
||||
HBNONPCLIBS += $(UNISCRIBE_LIBS)
|
||||
HBSOURCES += hb-uniscribe.cc
|
||||
HBHEADERS += hb-uniscribe.h
|
||||
HBSOURCES += $(HB_UNISCRIBE_sources)
|
||||
HBHEADERS += $(HB_UNISCRIBE_headers)
|
||||
endif
|
||||
|
||||
if HAVE_DIRECTWRITE
|
||||
HBCFLAGS += $(DIRECTWRITE_CXXFLAGS)
|
||||
HBNONPCLIBS += $(DIRECTWRITE_LIBS)
|
||||
HBSOURCES += $(HB_DIRECTWRITE_sources)
|
||||
HBHEADERS += $(HB_DIRECTWRITE_headers)
|
||||
endif
|
||||
|
||||
if HAVE_CORETEXT
|
||||
HBCFLAGS += $(CORETEXT_CFLAGS)
|
||||
HBNONPCLIBS += $(CORETEXT_LIBS)
|
||||
HBSOURCES += hb-coretext.cc
|
||||
HBHEADERS += hb-coretext.h
|
||||
HBSOURCES += $(HB_CORETEXT_sources)
|
||||
HBHEADERS += $(HB_CORETEXT_headers)
|
||||
endif
|
||||
|
||||
if HAVE_UCDN
|
||||
SUBDIRS += hb-ucdn
|
||||
HBCFLAGS += -I$(srcdir)/hb-ucdn
|
||||
HBLIBS += hb-ucdn/libhb-ucdn.la
|
||||
HBSOURCES += hb-ucdn.cc
|
||||
HBSOURCES += $(HB_UCDN_sources)
|
||||
endif
|
||||
DIST_SUBDIRS += hb-ucdn
|
||||
|
||||
|
@ -221,6 +132,7 @@ pkgconfig_DATA = harfbuzz.pc
|
|||
EXTRA_DIST += harfbuzz.pc.in
|
||||
|
||||
FUZZING_CPPFLAGS= \
|
||||
-DHB_NDEBUG \
|
||||
-DHB_MAX_NESTING_LEVEL=3 \
|
||||
-DHB_SANITIZE_MAX_EDITS=3 \
|
||||
-DHB_BUFFER_MAX_EXPANSION_FACTOR=3 \
|
||||
|
@ -237,34 +149,41 @@ EXTRA_libharfbuzz_fuzzing_la_DEPENDENCIES = $(EXTRA_libharfbuzz_la_DEPENDENCIES)
|
|||
CLEANFILES += libharfbuzz-fuzzing.la
|
||||
|
||||
if HAVE_ICU
|
||||
if HAVE_ICU_BUILTIN
|
||||
HBCFLAGS += $(ICU_CFLAGS)
|
||||
HBLIBS += $(ICU_LIBS)
|
||||
HBSOURCES += $(HB_ICU_sources)
|
||||
HBHEADERS += $(HB_ICU_headers)
|
||||
else
|
||||
lib_LTLIBRARIES += libharfbuzz-icu.la
|
||||
libharfbuzz_icu_la_SOURCES = hb-icu.cc
|
||||
libharfbuzz_icu_la_SOURCES = $(HB_ICU_sources)
|
||||
libharfbuzz_icu_la_CPPFLAGS = $(ICU_CFLAGS)
|
||||
libharfbuzz_icu_la_LDFLAGS = $(AM_LDFLAGS) -version-info $(HB_LIBTOOL_VERSION_INFO) -no-undefined
|
||||
libharfbuzz_icu_la_LIBADD = $(ICU_LIBS) libharfbuzz.la
|
||||
pkginclude_HEADERS += hb-icu.h
|
||||
pkginclude_HEADERS += $(HB_ICU_headers)
|
||||
pkgconfig_DATA += harfbuzz-icu.pc
|
||||
endif
|
||||
endif
|
||||
EXTRA_DIST += harfbuzz-icu.pc.in
|
||||
|
||||
if HAVE_GOBJECT
|
||||
lib_LTLIBRARIES += libharfbuzz-gobject.la
|
||||
libharfbuzz_gobject_la_SOURCES = hb-gobject-structs.cc
|
||||
nodist_libharfbuzz_gobject_la_SOURCES = hb-gobject-enums.cc
|
||||
libharfbuzz_gobject_la_SOURCES = $(HB_GOBJECT_sources)
|
||||
nodist_libharfbuzz_gobject_la_SOURCES = $(HB_GOBJECT_ENUM_sources)
|
||||
libharfbuzz_gobject_la_CPPFLAGS = $(GOBJECT_CFLAGS)
|
||||
libharfbuzz_gobject_la_LDFLAGS = $(AM_LDFLAGS) -version-info $(HB_LIBTOOL_VERSION_INFO) -no-undefined
|
||||
libharfbuzz_gobject_la_LIBADD = $(GOBJECT_LIBS) libharfbuzz.la
|
||||
pkginclude_HEADERS += hb-gobject.h hb-gobject-structs.h
|
||||
nodist_pkginclude_HEADERS += hb-gobject-enums.h
|
||||
pkginclude_HEADERS += $(HB_GOBJECT_headers)
|
||||
nodist_pkginclude_HEADERS += $(HB_GOBJECT_ENUM_headers)
|
||||
pkgconfig_DATA += harfbuzz-gobject.pc
|
||||
|
||||
BUILT_SOURCES += \
|
||||
hb-gobject-enums.cc \
|
||||
hb-gobject-enums.h \
|
||||
$(HB_GOBJECT_ENUM_sources) \
|
||||
$(HB_GOBJECT_ENUM_headers) \
|
||||
$(NULL)
|
||||
DISTCLEANFILES += \
|
||||
hb-gobject-enums.cc \
|
||||
hb-gobject-enums.h \
|
||||
$(HB_GOBJECT_ENUM_sources) \
|
||||
$(HB_GOBJECT_ENUM_headers) \
|
||||
$(NULL)
|
||||
hb-gobject-enums.%: hb-gobject-enums.%.tmpl $(HBHEADERS)
|
||||
$(AM_V_GEN) $(GLIB_MKENUMS) \
|
||||
|
@ -301,7 +220,7 @@ harfbuzz.def: $(HBHEADERS) $(HBNODISTHEADERS)
|
|||
(cat $^ || echo 'hb_ERROR ()' ) | \
|
||||
$(EGREP) '^hb_.* \(' | \
|
||||
sed -e 's/ (.*//' | \
|
||||
LANG=C sort; \
|
||||
LC_ALL=C sort; \
|
||||
echo LIBRARY libharfbuzz-0.dll; \
|
||||
) >"$@"
|
||||
@ ! grep -q hb_ERROR "$@" \
|
||||
|
@ -334,19 +253,13 @@ built-sources: $(BUILT_SOURCES)
|
|||
.PHONY: unicode-tables arabic-table indic-table use-table built-sources
|
||||
|
||||
RAGEL_GENERATED = \
|
||||
$(srcdir)/hb-buffer-deserialize-json.hh \
|
||||
$(srcdir)/hb-buffer-deserialize-text.hh \
|
||||
$(srcdir)/hb-ot-shape-complex-indic-machine.hh \
|
||||
$(srcdir)/hb-ot-shape-complex-myanmar-machine.hh \
|
||||
$(srcdir)/hb-ot-shape-complex-use-machine.hh \
|
||||
$(patsubst %,$(srcdir)/%,$(HB_BASE_RAGEL_GENERATED_sources)) \
|
||||
$(patsubst %,$(srcdir)/%,$(HB_OT_RAGEL_GENERATED_sources)) \
|
||||
$(NULL)
|
||||
BUILT_SOURCES += $(RAGEL_GENERATED)
|
||||
EXTRA_DIST += \
|
||||
hb-buffer-deserialize-json.rl \
|
||||
hb-buffer-deserialize-text.rl \
|
||||
hb-ot-shape-complex-indic-machine.rl \
|
||||
hb-ot-shape-complex-myanmar-machine.rl \
|
||||
hb-ot-shape-complex-use-machine.rl \
|
||||
$(HB_BASE_RAGEL_sources) \
|
||||
$(HB_OT_RAGEL_sources) \
|
||||
$(NULL)
|
||||
MAINTAINERCLEANFILES += $(RAGEL_GENERATED)
|
||||
$(srcdir)/%.hh: $(srcdir)/%.rl
|
||||
|
@ -382,6 +295,8 @@ test_buffer_serialize_SOURCES = test-buffer-serialize.cc
|
|||
test_buffer_serialize_CPPFLAGS = $(HBCFLAGS)
|
||||
test_buffer_serialize_LDADD = libharfbuzz.la $(HBLIBS)
|
||||
|
||||
check: harfbuzz.def # For check-defs.sh
|
||||
|
||||
dist_check_SCRIPTS = \
|
||||
check-c-linkage-decls.sh \
|
||||
check-defs.sh \
|
||||
|
@ -392,7 +307,14 @@ dist_check_SCRIPTS = \
|
|||
check-symbols.sh \
|
||||
$(NULL)
|
||||
|
||||
TESTS = $(dist_check_SCRIPTS)
|
||||
check_PROGRAMS = \
|
||||
test-ot-tag \
|
||||
$(NULL)
|
||||
test_ot_tag_SOURCES = hb-ot-tag.cc
|
||||
test_ot_tag_CPPFLAGS = $(HBCFLAGS) -DMAIN
|
||||
test_ot_tag_LDADD = libharfbuzz.la $(HBLIBS)
|
||||
|
||||
TESTS = $(dist_check_SCRIPTS) $(check_PROGRAMS)
|
||||
TESTS_ENVIRONMENT = \
|
||||
srcdir="$(srcdir)" \
|
||||
MAKE="$(MAKE) $(AM_MAKEFLAGS)" \
|
||||
|
@ -419,6 +341,7 @@ HarfBuzz_0_0_gir_CFLAGS = \
|
|||
-DHB_OT_H_IN \
|
||||
-DHB_GOBJECT_H \
|
||||
-DHB_GOBJECT_H_IN \
|
||||
-DHB_EXTERN= \
|
||||
$(NULL)
|
||||
HarfBuzz_0_0_gir_LIBS = \
|
||||
libharfbuzz.la \
|
||||
|
@ -428,10 +351,10 @@ HarfBuzz_0_0_gir_FILES = \
|
|||
$(HBHEADERS) \
|
||||
$(HBNODISTHEADERS) \
|
||||
$(HBSOURCES) \
|
||||
hb-gobject-enums.cc \
|
||||
hb-gobject-enums.h \
|
||||
hb-gobject-structs.cc \
|
||||
hb-gobject-structs.h \
|
||||
$(HB_GOBJECT_ENUM_sources) \
|
||||
$(HB_GOBJECT_ENUM_headers) \
|
||||
$(HB_GOBJECT_sources) \
|
||||
$(HB_GOBJECT_STRUCTS_headers) \
|
||||
$(NULL)
|
||||
|
||||
girdir = $(datadir)/gir-1.0
|
||||
|
|
|
@ -1,31 +0,0 @@
|
|||
#
|
||||
# Copyright (C) 2010 Mozilla Foundation
|
||||
#
|
||||
# This is used to integrate the HarfBuzz library with the Mozilla build.
|
||||
#
|
||||
# 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.
|
||||
#
|
||||
# Mozilla author(s): Jonathan Kew
|
||||
#
|
||||
|
||||
include $(topsrcdir)/config/rules.mk
|
||||
|
||||
# Cancel the effect of the -DDEBUG macro if present,
|
||||
# because harfbuzz uses that name for its own purposes
|
||||
COMPILE_CXXFLAGS += -UDEBUG
|
|
@ -21,7 +21,7 @@ for def in $defs; do
|
|||
lib=`echo "$def" | sed 's/[.]def$//;s@.*/@@'`
|
||||
so=.libs/lib${lib}.so
|
||||
|
||||
EXPORTED_SYMBOLS="`nm "$so" | grep ' [BCDGINRSTVW] ' | grep -v ' _fini\>\| _init\>\| _fdata\>\| _ftext\>\| _fbss\>\| __bss_start\>\| __bss_start__\>\| __bss_end__\>\| _edata\>\| _end\>\| _bss_end__\>\| __end__\>\| __gcov_flush\>\| llvm_' | cut -d' ' -f3`"
|
||||
EXPORTED_SYMBOLS="`nm "$so" | grep ' [BCDGINRSTVW] .' | grep -v ' _fini\>\| _init\>\| _fdata\>\| _ftext\>\| _fbss\>\| __bss_start\>\| __bss_start__\>\| __bss_end__\>\| _edata\>\| _end\>\| _bss_end__\>\| __end__\>\| __gcov_flush\>\| llvm_' | cut -d' ' -f3`"
|
||||
|
||||
if test -f "$so"; then
|
||||
|
||||
|
|
|
@ -9,13 +9,12 @@ stat=0
|
|||
test "x$HBHEADERS" = x && HBHEADERS=`cd "$srcdir"; find . -maxdepth 1 -name 'hb*.h'`
|
||||
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"
|
||||
echo "$x" | grep '[^h]$' -q && continue;
|
||||
echo "$x" | grep -q '[^h]$' && continue;
|
||||
xx=`echo "$x" | sed 's@.*/@@'`
|
||||
tag=`echo "$xx" | tr 'a-z.-' 'A-Z_'`
|
||||
lines=`grep "\<$tag\>" "$x" | wc -l | sed 's/[ ]*//g'`
|
||||
lines=`grep -w "$tag" "$x" | wc -l | sed 's/[ ]*//g'`
|
||||
if test "x$lines" != x3; then
|
||||
echo "Ouch, header file $x does not have correct preprocessor guards"
|
||||
stat=1
|
||||
|
|
|
@ -19,8 +19,8 @@ tested=false
|
|||
for suffix in so dylib; do
|
||||
so=.libs/libharfbuzz.$suffix
|
||||
if ! test -f "$so"; then continue; fi
|
||||
|
||||
EXPORTED_SYMBOLS="`nm "$so" | grep ' [BCDGINRSTVW] ' | grep -v ' _fini\>\| _init\>\| _fdata\>\| _ftext\>\| _fbss\>\| __bss_start\>\| __bss_start__\>\| __bss_end__\>\| _edata\>\| _end\>\| _bss_end__\>\| __end__\>\| __gcov_flush\>\| llvm_' | cut -d' ' -f3`"
|
||||
|
||||
EXPORTED_SYMBOLS="`nm "$so" | grep ' [BCDGINRSTVW] .' | grep -v ' _fini\>\| _init\>\| _fdata\>\| _ftext\>\| _fbss\>\| __bss_start\>\| __bss_start__\>\| __bss_end__\>\| _edata\>\| _end\>\| _bss_end__\>\| __end__\>\| __gcov_flush\>\| ___gcov_flush\>\| llvm_\| _llvm_' | cut -d' ' -f3`"
|
||||
|
||||
prefix=`basename "$so" | sed 's/libharfbuzz/hb/; s/-/_/g; s/[.].*//'`
|
||||
|
||||
|
|
|
@ -134,7 +134,7 @@ def print_joining_table(f):
|
|||
for (start,end) in ranges:
|
||||
if p not in [start>>page_bits, end>>page_bits]: continue
|
||||
offset = "joining_offset_0x%04xu" % start
|
||||
print " if (hb_in_range (u, 0x%04Xu, 0x%04Xu)) return joining_table[u - 0x%04Xu + %s];" % (start, end, start, offset)
|
||||
print " if (hb_in_range<hb_codepoint_t> (u, 0x%04Xu, 0x%04Xu)) return joining_table[u - 0x%04Xu + %s];" % (start, end, start, offset)
|
||||
print " break;"
|
||||
print ""
|
||||
print " default:"
|
||||
|
|
|
@ -3,10 +3,32 @@
|
|||
import sys
|
||||
|
||||
if len (sys.argv) != 4:
|
||||
print >>sys.stderr, "usage: ./gen-indic-table.py IndicSyllabicCategory.txt IndicMatraCategory.txt Blocks.txt"
|
||||
print >>sys.stderr, "usage: ./gen-indic-table.py IndicSyllabicCategory.txt IndicPositionalCategory.txt Blocks.txt"
|
||||
sys.exit (1)
|
||||
|
||||
BLACKLISTED_BLOCKS = ["Thai", "Lao", "Tibetan"]
|
||||
ALLOWED_SINGLES = [0x00A0, 0x25CC]
|
||||
ALLOWED_BLOCKS = [
|
||||
'Basic Latin',
|
||||
'Latin-1 Supplement',
|
||||
'Devanagari',
|
||||
'Bengali',
|
||||
'Gurmukhi',
|
||||
'Gujarati',
|
||||
'Oriya',
|
||||
'Tamil',
|
||||
'Telugu',
|
||||
'Kannada',
|
||||
'Malayalam',
|
||||
'Sinhala',
|
||||
'Myanmar',
|
||||
'Khmer',
|
||||
'Vedic Extensions',
|
||||
'General Punctuation',
|
||||
'Superscripts and Subscripts',
|
||||
'Devanagari Extended',
|
||||
'Myanmar Extended-B',
|
||||
'Myanmar Extended-A',
|
||||
]
|
||||
|
||||
files = [file (x) for x in sys.argv[1:]]
|
||||
|
||||
|
@ -50,7 +72,7 @@ for i,d in enumerate (data):
|
|||
if not u in combined:
|
||||
combined[u] = list (defaults)
|
||||
combined[u][i] = v
|
||||
combined = {k:v for k,v in combined.items() if v[2] not in BLACKLISTED_BLOCKS}
|
||||
combined = {k:v for k,v in combined.items() if k in ALLOWED_SINGLES or v[2] in ALLOWED_BLOCKS}
|
||||
data = combined
|
||||
del combined
|
||||
num = len (data)
|
||||
|
@ -61,7 +83,7 @@ for u in [0x17CD, 0x17CE, 0x17CF, 0x17D0, 0x17D3]:
|
|||
|
||||
# Move the outliers NO-BREAK SPACE and DOTTED CIRCLE out
|
||||
singles = {}
|
||||
for u in [0x00A0, 0x25CC]:
|
||||
for u in ALLOWED_SINGLES:
|
||||
singles[u] = data[u]
|
||||
del data[u]
|
||||
|
||||
|
@ -69,7 +91,7 @@ print "/* == Start of generated table == */"
|
|||
print "/*"
|
||||
print " * The following table is generated by running:"
|
||||
print " *"
|
||||
print " * ./gen-indic-table.py IndicSyllabicCategory.txt IndicMatraCategory.txt Blocks.txt"
|
||||
print " * ./gen-indic-table.py IndicSyllabicCategory.txt IndicPositionalCategory.txt Blocks.txt"
|
||||
print " *"
|
||||
print " * on files with these headers:"
|
||||
print " *"
|
||||
|
@ -91,6 +113,7 @@ short = [{
|
|||
"Visarga": 'Vs',
|
||||
"Vowel": 'Vo',
|
||||
"Vowel_Dependent": 'M',
|
||||
"Consonant_Prefixed": 'CPrf',
|
||||
"Other": 'x',
|
||||
},{
|
||||
"Not_Applicable": 'x',
|
||||
|
@ -209,7 +232,7 @@ for p in sorted(pages):
|
|||
for (start,end) in zip (starts, ends):
|
||||
if p not in [start>>page_bits, end>>page_bits]: continue
|
||||
offset = "indic_offset_0x%04xu" % start
|
||||
print " if (hb_in_range (u, 0x%04Xu, 0x%04Xu)) return indic_table[u - 0x%04Xu + %s];" % (start, end-1, start, offset)
|
||||
print " if (hb_in_range<hb_codepoint_t> (u, 0x%04Xu, 0x%04Xu)) return indic_table[u - 0x%04Xu + %s];" % (start, end-1, start, offset)
|
||||
for u,d in singles.items ():
|
||||
if p != u>>page_bits: continue
|
||||
print " if (unlikely (u == 0x%04Xu)) return _(%s,%s);" % (u, short[0][d[0]], short[1][d[1]])
|
||||
|
|
|
@ -144,36 +144,38 @@ globals().update(property_values)
|
|||
|
||||
def is_BASE(U, UISC, UGC):
|
||||
return (UISC in [Number, Consonant, Consonant_Head_Letter,
|
||||
#SPEC-OUTDATED Consonant_Placeholder,
|
||||
Tone_Letter] or
|
||||
#SPEC-DRAFT Consonant_Placeholder,
|
||||
Tone_Letter,
|
||||
Vowel_Independent #SPEC-DRAFT
|
||||
] or
|
||||
(UGC == Lo and UISC in [Avagraha, Bindu, Consonant_Final, Consonant_Medial,
|
||||
Consonant_Subjoined, Vowel, Vowel_Dependent]))
|
||||
def is_BASE_VOWEL(U, UISC, UGC):
|
||||
return UISC == Vowel_Independent
|
||||
def is_BASE_IND(U, UISC, UGC):
|
||||
#SPEC-BROKEN return (UISC in [Consonant_Dead, Modifying_Letter] or UGC == Po)
|
||||
#SPEC-DRAFT return (UISC in [Consonant_Dead, Modifying_Letter] or UGC == Po)
|
||||
return (UISC in [Consonant_Dead, Modifying_Letter] or
|
||||
(UGC == Po and not is_BASE_OTHER(U, UISC, UGC))) # for 104E
|
||||
(UGC == Po and not U in [0x104E, 0x2022]) or
|
||||
False # SPEC-DRAFT-OUTDATED! U == 0x002D
|
||||
)
|
||||
def is_BASE_NUM(U, UISC, UGC):
|
||||
return UISC == Brahmi_Joining_Number
|
||||
def is_BASE_OTHER(U, UISC, UGC):
|
||||
if UISC == Consonant_Placeholder: return True #SPEC-OUTDATED
|
||||
return U in [0x00A0, 0x00D7, 0x2015, 0x2022, 0x25CC,
|
||||
0x25FB, 0x25FC, 0x25FD, 0x25FE]
|
||||
if UISC == Consonant_Placeholder: return True #SPEC-DRAFT
|
||||
#SPEC-DRAFT return U in [0x00A0, 0x00D7, 0x2015, 0x2022, 0x25CC, 0x25FB, 0x25FC, 0x25FD, 0x25FE]
|
||||
return U in [0x2015, 0x2022, 0x25FB, 0x25FC, 0x25FD, 0x25FE]
|
||||
def is_CGJ(U, UISC, UGC):
|
||||
return U == 0x034F
|
||||
def is_CONS_FINAL(U, UISC, UGC):
|
||||
return ((UISC == Consonant_Final and UGC != Lo) or
|
||||
UISC == Consonant_Succeeding_Repha)
|
||||
def is_CONS_FINAL_MOD(U, UISC, UGC):
|
||||
#SPEC-OUTDATED return UISC in [Consonant_Final_Modifier, Syllable_Modifier]
|
||||
#SPEC-DRAFT return UISC in [Consonant_Final_Modifier, Syllable_Modifier]
|
||||
return UISC == Syllable_Modifier
|
||||
def is_CONS_MED(U, UISC, UGC):
|
||||
return UISC == Consonant_Medial and UGC != Lo
|
||||
def is_CONS_MOD(U, UISC, UGC):
|
||||
return UISC in [Nukta, Gemination_Mark, Consonant_Killer]
|
||||
def is_CONS_SUB(U, UISC, UGC):
|
||||
#SPEC-OUTDATED return UISC == Consonant_Subjoined
|
||||
#SPEC-DRAFT return UISC == Consonant_Subjoined
|
||||
return UISC == Consonant_Subjoined and UGC != Lo
|
||||
def is_HALANT(U, UISC, UGC):
|
||||
return UISC in [Virama, Invisible_Stacker]
|
||||
|
@ -200,23 +202,24 @@ def is_REPHA(U, UISC, UGC):
|
|||
#SPEC-OUTDATED hack to categorize Consonant_With_Stacker and Consonant_Prefixed
|
||||
return UISC in [Consonant_Preceding_Repha, Consonant_With_Stacker, Consonant_Prefixed]
|
||||
def is_SYM(U, UISC, UGC):
|
||||
if U == 0x25CC: return False #SPEC-OUTDATED
|
||||
#SPEC-OUTDATED return UGC in [So, Sc] or UISC == Symbol_Letter
|
||||
if U == 0x25CC: return False #SPEC-DRAFT
|
||||
#SPEC-DRAFT return UGC in [So, Sc] or UISC == Symbol_Letter
|
||||
return UGC in [So, Sc]
|
||||
def is_SYM_MOD(U, UISC, UGC):
|
||||
return U in [0x1B6B, 0x1B6C, 0x1B6D, 0x1B6E, 0x1B6F, 0x1B70, 0x1B71, 0x1B72, 0x1B73]
|
||||
def is_VARIATION_SELECTOR(U, UISC, UGC):
|
||||
return 0xFE00 <= U <= 0xFE0F
|
||||
def is_VOWEL(U, UISC, UGC):
|
||||
# https://github.com/roozbehp/unicode-data/issues/6
|
||||
return (UISC == Pure_Killer or
|
||||
(UGC != Lo and UISC in [Vowel, Vowel_Dependent]))
|
||||
(UGC != Lo and UISC in [Vowel, Vowel_Dependent] and U not in [0xAA29]))
|
||||
def is_VOWEL_MOD(U, UISC, UGC):
|
||||
# https://github.com/roozbehp/unicode-data/issues/6
|
||||
return (UISC in [Tone_Mark, Cantillation_Mark, Register_Shifter, Visarga] or
|
||||
(UGC != Lo and UISC == Bindu))
|
||||
(UGC != Lo and (UISC == Bindu or U in [0xAA29])))
|
||||
|
||||
use_mapping = {
|
||||
'B': is_BASE,
|
||||
'IV': is_BASE_VOWEL,
|
||||
'IND': is_BASE_IND,
|
||||
'N': is_BASE_NUM,
|
||||
'GB': is_BASE_OTHER,
|
||||
|
@ -448,7 +451,7 @@ for p in sorted(pages):
|
|||
for (start,end) in zip (starts, ends):
|
||||
if p not in [start>>page_bits, end>>page_bits]: continue
|
||||
offset = "use_offset_0x%04xu" % start
|
||||
print " if (hb_in_range (u, 0x%04Xu, 0x%04Xu)) return use_table[u - 0x%04Xu + %s];" % (start, end-1, start, offset)
|
||||
print " if (hb_in_range<hb_codepoint_t> (u, 0x%04Xu, 0x%04Xu)) return use_table[u - 0x%04Xu + %s];" % (start, end-1, start, offset)
|
||||
for u,d in singles.items ():
|
||||
if p != u>>page_bits: continue
|
||||
print " if (unlikely (u == 0x%04Xu)) return %s;" % (u, d[0])
|
||||
|
|
|
@ -5,7 +5,7 @@ includedir=/usr/local/include
|
|||
|
||||
Name: harfbuzz
|
||||
Description: HarfBuzz text shaping library ICU integration
|
||||
Version: 1.0.1
|
||||
Version: 1.5.1
|
||||
|
||||
Requires: harfbuzz
|
||||
Requires.private: icu-uc
|
||||
|
|
|
@ -5,7 +5,9 @@ includedir=/usr/local/include
|
|||
|
||||
Name: harfbuzz
|
||||
Description: HarfBuzz text shaping library
|
||||
Version: 1.0.1
|
||||
Version: 1.5.1
|
||||
|
||||
Libs: -L${libdir} -lharfbuzz
|
||||
Libs.private:
|
||||
Requires.private: glib-2.0 >= 2.19.1
|
||||
Cflags: -I${includedir}/harfbuzz
|
||||
|
|
|
@ -119,6 +119,31 @@ typedef unsigned int hb_atomic_int_impl_t;
|
|||
#define hb_atomic_ptr_impl_cmpexch(P,O,N) ( ({__machine_rw_barrier ();}), atomic_cas_ptr ((void **) (P), (void *) (O), (void *) (N)) == (void *) (O) ? true : false)
|
||||
|
||||
|
||||
#elif !defined(HB_NO_MT) && defined(_AIX) && defined(__IBMCPP__)
|
||||
|
||||
#include <builtins.h>
|
||||
|
||||
|
||||
static inline int _hb_fetch_and_add(volatile int* AI, unsigned int V) {
|
||||
__lwsync();
|
||||
int result = __fetch_and_add(AI, V);
|
||||
__isync();
|
||||
return result;
|
||||
}
|
||||
static inline int _hb_compare_and_swaplp(volatile long* P, long O, long N) {
|
||||
__sync();
|
||||
int result = __compare_and_swaplp (P, &O, N);
|
||||
__sync();
|
||||
return result;
|
||||
}
|
||||
|
||||
typedef int hb_atomic_int_impl_t;
|
||||
#define HB_ATOMIC_INT_IMPL_INIT(V) (V)
|
||||
#define hb_atomic_int_impl_add(AI, V) _hb_fetch_and_add (&(AI), (V))
|
||||
|
||||
#define hb_atomic_ptr_impl_get(P) (__sync(), (void *) *(P))
|
||||
#define hb_atomic_ptr_impl_cmpexch(P,O,N) _hb_compare_and_swaplp ((long*)(P), (long)(O), (long)(N))
|
||||
|
||||
#elif !defined(HB_NO_MT)
|
||||
|
||||
#define HB_ATOMIC_INT_NIL 1 /* Warn that fallback implementation is in use. */
|
||||
|
|
|
@ -104,7 +104,6 @@ hb_blob_create (const char *data,
|
|||
|
||||
if (!length ||
|
||||
length >= 1u << 31 ||
|
||||
data + length < data /* overflows */ ||
|
||||
!(blob = hb_object_create<hb_blob_t> ())) {
|
||||
if (destroy)
|
||||
destroy (user_data);
|
||||
|
@ -328,7 +327,7 @@ hb_blob_is_immutable (hb_blob_t *blob)
|
|||
unsigned int
|
||||
hb_blob_get_length (hb_blob_t *blob)
|
||||
{
|
||||
if (!blob) return 0; // wallpaper TenFourFox issue 309
|
||||
if(unlikely(!blob)) return 0; // wallpaper TenFourFox issue 309
|
||||
return blob->length;
|
||||
}
|
||||
|
||||
|
|
|
@ -64,7 +64,7 @@ typedef enum {
|
|||
|
||||
typedef struct hb_blob_t hb_blob_t;
|
||||
|
||||
hb_blob_t *
|
||||
HB_EXTERN hb_blob_t *
|
||||
hb_blob_create (const char *data,
|
||||
unsigned int length,
|
||||
hb_memory_mode_t mode,
|
||||
|
@ -77,21 +77,21 @@ hb_blob_create (const char *data,
|
|||
* modify the parent data as that data may be
|
||||
* shared among multiple sub-blobs.
|
||||
*/
|
||||
hb_blob_t *
|
||||
HB_EXTERN hb_blob_t *
|
||||
hb_blob_create_sub_blob (hb_blob_t *parent,
|
||||
unsigned int offset,
|
||||
unsigned int length);
|
||||
|
||||
hb_blob_t *
|
||||
HB_EXTERN hb_blob_t *
|
||||
hb_blob_get_empty (void);
|
||||
|
||||
hb_blob_t *
|
||||
HB_EXTERN hb_blob_t *
|
||||
hb_blob_reference (hb_blob_t *blob);
|
||||
|
||||
void
|
||||
HB_EXTERN void
|
||||
hb_blob_destroy (hb_blob_t *blob);
|
||||
|
||||
hb_bool_t
|
||||
HB_EXTERN hb_bool_t
|
||||
hb_blob_set_user_data (hb_blob_t *blob,
|
||||
hb_user_data_key_t *key,
|
||||
void * data,
|
||||
|
@ -99,25 +99,25 @@ hb_blob_set_user_data (hb_blob_t *blob,
|
|||
hb_bool_t replace);
|
||||
|
||||
|
||||
void *
|
||||
HB_EXTERN void *
|
||||
hb_blob_get_user_data (hb_blob_t *blob,
|
||||
hb_user_data_key_t *key);
|
||||
|
||||
|
||||
void
|
||||
HB_EXTERN void
|
||||
hb_blob_make_immutable (hb_blob_t *blob);
|
||||
|
||||
hb_bool_t
|
||||
HB_EXTERN hb_bool_t
|
||||
hb_blob_is_immutable (hb_blob_t *blob);
|
||||
|
||||
|
||||
unsigned int
|
||||
HB_EXTERN unsigned int
|
||||
hb_blob_get_length (hb_blob_t *blob);
|
||||
|
||||
const char *
|
||||
HB_EXTERN const char *
|
||||
hb_blob_get_data (hb_blob_t *blob, unsigned int *length);
|
||||
|
||||
char *
|
||||
HB_EXTERN char *
|
||||
hb_blob_get_data_writable (hb_blob_t *blob, unsigned int *length);
|
||||
|
||||
|
||||
|
|
|
@ -50,14 +50,16 @@ ASSERT_STATIC (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);
|
||||
HB_MARK_AS_FLAG_T (hb_buffer_diff_flags_t);
|
||||
|
||||
enum hb_buffer_scratch_flags_t {
|
||||
HB_BUFFER_SCRATCH_FLAG_DEFAULT = 0x00000000u,
|
||||
HB_BUFFER_SCRATCH_FLAG_HAS_NON_ASCII = 0x00000001u,
|
||||
HB_BUFFER_SCRATCH_FLAG_HAS_DEFAULT_IGNORABLES = 0x00000002u,
|
||||
HB_BUFFER_SCRATCH_FLAG_HAS_SPACE_FALLBACK = 0x00000004u,
|
||||
HB_BUFFER_SCRATCH_FLAG_HAS_GPOS_CURSIVE = 0x00000008u,
|
||||
HB_BUFFER_SCRATCH_FLAG_HAS_GPOS_ATTACHMENT = 0x00000010u,
|
||||
HB_BUFFER_SCRATCH_FLAG_HAS_GPOS_ATTACHMENT = 0x00000008u,
|
||||
HB_BUFFER_SCRATCH_FLAG_HAS_UNSAFE_TO_BREAK = 0x00000010u,
|
||||
|
||||
/* Reserved for complex shapers' internal use. */
|
||||
HB_BUFFER_SCRATCH_FLAG_COMPLEX0 = 0x01000000u,
|
||||
HB_BUFFER_SCRATCH_FLAG_COMPLEX1 = 0x02000000u,
|
||||
|
@ -113,10 +115,6 @@ struct hb_buffer_t {
|
|||
|
||||
unsigned int serial;
|
||||
|
||||
/* These reflect current allocations of the bytes in glyph_info_t's var1 and var2. */
|
||||
uint8_t allocated_var_bytes[8];
|
||||
const char *allocated_var_owner[8];
|
||||
|
||||
/* Text before / after the main buffer contents.
|
||||
* Always in Unicode, and ordered outward.
|
||||
* Index 0 is for "pre-context", 1 for "post-context". */
|
||||
|
@ -124,6 +122,52 @@ struct hb_buffer_t {
|
|||
hb_codepoint_t context[2][CONTEXT_LENGTH];
|
||||
unsigned int context_len[2];
|
||||
|
||||
/* Debugging API */
|
||||
hb_buffer_message_func_t message_func;
|
||||
void *message_data;
|
||||
hb_destroy_func_t message_destroy;
|
||||
|
||||
/* Internal debugging. */
|
||||
/* The bits here reflect current allocations of the bytes in glyph_info_t's var1 and var2. */
|
||||
#ifndef HB_NDEBUG
|
||||
uint8_t allocated_var_bits;
|
||||
#endif
|
||||
inline void allocate_var (unsigned int start, unsigned int count)
|
||||
{
|
||||
#ifndef HB_NDEBUG
|
||||
unsigned int end = start + count;
|
||||
assert (end <= 8);
|
||||
unsigned int bits = (1u<<end) - (1u<<start);
|
||||
assert (0 == (allocated_var_bits & bits));
|
||||
allocated_var_bits |= bits;
|
||||
#endif
|
||||
}
|
||||
inline void deallocate_var (unsigned int start, unsigned int count)
|
||||
{
|
||||
#ifndef HB_NDEBUG
|
||||
unsigned int end = start + count;
|
||||
assert (end <= 8);
|
||||
unsigned int bits = (1u<<end) - (1u<<start);
|
||||
assert (bits == (allocated_var_bits & bits));
|
||||
allocated_var_bits &= ~bits;
|
||||
#endif
|
||||
}
|
||||
inline void assert_var (unsigned int start, unsigned int count)
|
||||
{
|
||||
#ifndef HB_NDEBUG
|
||||
unsigned int end = start + count;
|
||||
assert (end <= 8);
|
||||
unsigned int bits = (1u<<end) - (1u<<start);
|
||||
assert (bits == (allocated_var_bits & bits));
|
||||
#endif
|
||||
}
|
||||
inline void deallocate_var_all (void)
|
||||
{
|
||||
#ifndef HB_NDEBUG
|
||||
allocated_var_bits = 0;
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
/* Methods */
|
||||
|
||||
|
@ -136,11 +180,6 @@ struct hb_buffer_t {
|
|||
{ return len - idx; }
|
||||
inline unsigned int next_serial (void) { return serial++; }
|
||||
|
||||
HB_INTERNAL void allocate_var (unsigned int byte_i, unsigned int count, const char *owner);
|
||||
HB_INTERNAL void deallocate_var (unsigned int byte_i, unsigned int count, const char *owner);
|
||||
HB_INTERNAL void assert_var (unsigned int byte_i, unsigned int count, const char *owner);
|
||||
HB_INTERNAL void deallocate_var_all (void);
|
||||
|
||||
HB_INTERNAL void add (hb_codepoint_t codepoint,
|
||||
unsigned int cluster);
|
||||
HB_INTERNAL void add_info (const hb_glyph_info_t &glyph_info);
|
||||
|
@ -174,13 +213,12 @@ struct hb_buffer_t {
|
|||
if (have_output)
|
||||
{
|
||||
if (unlikely (out_info != info || out_len != idx)) {
|
||||
if (unlikely (!make_room_for (1, 1)))
|
||||
goto done;
|
||||
if (unlikely (!make_room_for (1, 1))) return;
|
||||
out_info[out_len] = info[idx];
|
||||
}
|
||||
out_len++;
|
||||
}
|
||||
done:
|
||||
|
||||
idx++;
|
||||
}
|
||||
|
||||
|
@ -197,25 +235,31 @@ struct hb_buffer_t {
|
|||
for (unsigned int j = 0; j < len; j++)
|
||||
info[j].mask |= mask;
|
||||
}
|
||||
HB_INTERNAL void set_masks (hb_mask_t value,
|
||||
hb_mask_t mask,
|
||||
unsigned int cluster_start,
|
||||
unsigned int cluster_end);
|
||||
HB_INTERNAL void set_masks (hb_mask_t value, hb_mask_t mask,
|
||||
unsigned int cluster_start, unsigned int cluster_end);
|
||||
|
||||
HB_INTERNAL void merge_clusters (unsigned int start,
|
||||
unsigned int end)
|
||||
inline void merge_clusters (unsigned int start, unsigned int end)
|
||||
{
|
||||
if (end - start < 2)
|
||||
return;
|
||||
merge_clusters_impl (start, end);
|
||||
}
|
||||
HB_INTERNAL void merge_clusters_impl (unsigned int start,
|
||||
unsigned int end);
|
||||
HB_INTERNAL void merge_out_clusters (unsigned int start,
|
||||
unsigned int end);
|
||||
HB_INTERNAL void merge_clusters_impl (unsigned int start, unsigned int end);
|
||||
HB_INTERNAL void merge_out_clusters (unsigned int start, unsigned int end);
|
||||
/* Merge clusters for deleting current glyph, and skip it. */
|
||||
HB_INTERNAL void delete_glyph (void);
|
||||
|
||||
inline void unsafe_to_break (unsigned int start,
|
||||
unsigned int end)
|
||||
{
|
||||
if (end - start < 2)
|
||||
return;
|
||||
unsafe_to_break_impl (start, end);
|
||||
}
|
||||
HB_INTERNAL void unsafe_to_break_impl (unsigned int start, unsigned int end);
|
||||
HB_INTERNAL void unsafe_to_break_from_outbuffer (unsigned int start, unsigned int end);
|
||||
|
||||
|
||||
/* Internal methods */
|
||||
HB_INTERNAL bool enlarge (unsigned int size);
|
||||
|
||||
|
@ -234,18 +278,85 @@ struct hb_buffer_t {
|
|||
inline void clear_context (unsigned int side) { context_len[side] = 0; }
|
||||
|
||||
HB_INTERNAL void sort (unsigned int start, unsigned int end, int(*compar)(const hb_glyph_info_t *, const hb_glyph_info_t *));
|
||||
|
||||
inline bool messaging (void) { return unlikely (message_func); }
|
||||
inline bool message (hb_font_t *font, const char *fmt, ...) HB_PRINTF_FUNC(3, 4)
|
||||
{
|
||||
if (!messaging ())
|
||||
return true;
|
||||
va_list ap;
|
||||
va_start (ap, fmt);
|
||||
bool ret = message_impl (font, fmt, ap);
|
||||
va_end (ap);
|
||||
return ret;
|
||||
}
|
||||
HB_INTERNAL bool message_impl (hb_font_t *font, const char *fmt, va_list ap) HB_PRINTF_FUNC(3, 0);
|
||||
|
||||
static inline void
|
||||
set_cluster (hb_glyph_info_t &info, unsigned int cluster, unsigned int mask = 0)
|
||||
{
|
||||
if (info.cluster != cluster)
|
||||
{
|
||||
if (mask & HB_GLYPH_FLAG_UNSAFE_TO_BREAK)
|
||||
info.mask |= HB_GLYPH_FLAG_UNSAFE_TO_BREAK;
|
||||
else
|
||||
info.mask &= ~HB_GLYPH_FLAG_UNSAFE_TO_BREAK;
|
||||
}
|
||||
info.cluster = cluster;
|
||||
}
|
||||
|
||||
int
|
||||
_unsafe_to_break_find_min_cluster (const hb_glyph_info_t *info,
|
||||
unsigned int start, unsigned int end,
|
||||
unsigned int cluster) const
|
||||
{
|
||||
for (unsigned int i = start; i < end; i++)
|
||||
cluster = MIN (cluster, info[i].cluster);
|
||||
return cluster;
|
||||
}
|
||||
void
|
||||
_unsafe_to_break_set_mask (hb_glyph_info_t *info,
|
||||
unsigned int start, unsigned int end,
|
||||
unsigned int cluster)
|
||||
{
|
||||
for (unsigned int i = start; i < end; i++)
|
||||
if (cluster != info[i].cluster)
|
||||
{
|
||||
scratch_flags |= HB_BUFFER_SCRATCH_FLAG_HAS_UNSAFE_TO_BREAK;
|
||||
info[i].mask |= HB_GLYPH_FLAG_UNSAFE_TO_BREAK;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
#define HB_BUFFER_XALLOCATE_VAR(b, func, var, owner) \
|
||||
/* Loop over clusters. Duplicated in foreach_syllable(). */
|
||||
#define foreach_cluster(buffer, start, end) \
|
||||
for (unsigned int \
|
||||
_count = buffer->len, \
|
||||
start = 0, end = _count ? _next_cluster (buffer, 0) : 0; \
|
||||
start < _count; \
|
||||
start = end, end = _next_cluster (buffer, start))
|
||||
|
||||
static inline unsigned int
|
||||
_next_cluster (hb_buffer_t *buffer, unsigned int start)
|
||||
{
|
||||
hb_glyph_info_t *info = buffer->info;
|
||||
unsigned int count = buffer->len;
|
||||
|
||||
unsigned int cluster = info[start].cluster;
|
||||
while (++start < count && cluster == info[start].cluster)
|
||||
;
|
||||
|
||||
return start;
|
||||
}
|
||||
|
||||
|
||||
#define HB_BUFFER_XALLOCATE_VAR(b, func, var) \
|
||||
b->func (offsetof (hb_glyph_info_t, var) - offsetof(hb_glyph_info_t, var1), \
|
||||
sizeof (b->info[0].var), owner)
|
||||
#define HB_BUFFER_ALLOCATE_VAR(b, var) \
|
||||
HB_BUFFER_XALLOCATE_VAR (b, allocate_var, var (), #var)
|
||||
#define HB_BUFFER_DEALLOCATE_VAR(b, var) \
|
||||
HB_BUFFER_XALLOCATE_VAR (b, deallocate_var, var (), #var)
|
||||
#define HB_BUFFER_ASSERT_VAR(b, var) \
|
||||
HB_BUFFER_XALLOCATE_VAR (b, assert_var, var (), #var)
|
||||
sizeof (b->info[0].var))
|
||||
#define HB_BUFFER_ALLOCATE_VAR(b, var) HB_BUFFER_XALLOCATE_VAR (b, allocate_var, var ())
|
||||
#define HB_BUFFER_DEALLOCATE_VAR(b, var) HB_BUFFER_XALLOCATE_VAR (b, deallocate_var, var ())
|
||||
#define HB_BUFFER_ASSERT_VAR(b, var) HB_BUFFER_XALLOCATE_VAR (b, assert_var, var ())
|
||||
|
||||
|
||||
#endif /* HB_BUFFER_PRIVATE_HH */
|
||||
|
|
|
@ -36,11 +36,12 @@ static const char *serialize_formats[] = {
|
|||
/**
|
||||
* hb_buffer_serialize_list_formats:
|
||||
*
|
||||
*
|
||||
* Returns a list of supported buffer serialization formats.
|
||||
*
|
||||
* Return value: (transfer none):
|
||||
* A string array of buffer serialization formats. Should not be freed.
|
||||
*
|
||||
* Since: 0.9.2
|
||||
* Since: 0.9.7
|
||||
**/
|
||||
const char **
|
||||
hb_buffer_serialize_list_formats (void)
|
||||
|
@ -50,14 +51,17 @@ hb_buffer_serialize_list_formats (void)
|
|||
|
||||
/**
|
||||
* hb_buffer_serialize_format_from_string:
|
||||
* @str:
|
||||
* @len:
|
||||
* @str: (array length=len) (element-type uint8_t): a string to parse
|
||||
* @len: length of @str, or -1 if string is %NULL terminated
|
||||
*
|
||||
*
|
||||
* Parses a string into an #hb_buffer_serialize_format_t. Does not check if
|
||||
* @str is a valid buffer serialization format, use
|
||||
* hb_buffer_serialize_list_formats() to get the list of supported formats.
|
||||
*
|
||||
* Return value:
|
||||
* The parsed #hb_buffer_serialize_format_t.
|
||||
*
|
||||
* Since: 0.9.2
|
||||
* Since: 0.9.7
|
||||
**/
|
||||
hb_buffer_serialize_format_t
|
||||
hb_buffer_serialize_format_from_string (const char *str, int len)
|
||||
|
@ -68,13 +72,15 @@ hb_buffer_serialize_format_from_string (const char *str, int len)
|
|||
|
||||
/**
|
||||
* hb_buffer_serialize_format_to_string:
|
||||
* @format:
|
||||
* @format: an #hb_buffer_serialize_format_t to convert.
|
||||
*
|
||||
*
|
||||
* Converts @format to the string corresponding it, or %NULL if it is not a valid
|
||||
* #hb_buffer_serialize_format_t.
|
||||
*
|
||||
* Return value:
|
||||
* Return value: (transfer none):
|
||||
* A %NULL terminated string corresponding to @format. Should not be freed.
|
||||
*
|
||||
* Since: 0.9.2
|
||||
* Since: 0.9.7
|
||||
**/
|
||||
const char *
|
||||
hb_buffer_serialize_format_to_string (hb_buffer_serialize_format_t format)
|
||||
|
@ -139,10 +145,16 @@ _hb_buffer_serialize_glyphs_json (hb_buffer_t *buffer,
|
|||
|
||||
if (!(flags & HB_BUFFER_SERIALIZE_FLAG_NO_POSITIONS))
|
||||
{
|
||||
p += snprintf (p, ARRAY_LENGTH (b) - (p - b), ",\"dx\":%d,\"dy\":%d",
|
||||
pos[i].x_offset, pos[i].y_offset);
|
||||
p += snprintf (p, ARRAY_LENGTH (b) - (p - b), ",\"ax\":%d,\"ay\":%d",
|
||||
pos[i].x_advance, pos[i].y_advance);
|
||||
p += MAX (0, snprintf (p, ARRAY_LENGTH (b) - (p - b), ",\"dx\":%d,\"dy\":%d",
|
||||
pos[i].x_offset, pos[i].y_offset));
|
||||
p += MAX (0, snprintf (p, ARRAY_LENGTH (b) - (p - b), ",\"ax\":%d,\"ay\":%d",
|
||||
pos[i].x_advance, pos[i].y_advance));
|
||||
}
|
||||
|
||||
if (flags & HB_BUFFER_SERIALIZE_FLAG_GLYPH_FLAGS)
|
||||
{
|
||||
if (info[i].mask & HB_GLYPH_FLAG_DEFINED)
|
||||
p += MAX (0, snprintf (p, ARRAY_LENGTH (b) - (p - b), ",\"fl\":%u", info[i].mask & HB_GLYPH_FLAG_DEFINED));
|
||||
}
|
||||
|
||||
if (flags & HB_BUFFER_SERIALIZE_FLAG_GLYPH_EXTENTS)
|
||||
|
@ -150,9 +162,9 @@ _hb_buffer_serialize_glyphs_json (hb_buffer_t *buffer,
|
|||
hb_glyph_extents_t extents;
|
||||
hb_font_get_glyph_extents(font, info[i].codepoint, &extents);
|
||||
p += MAX (0, snprintf (p, ARRAY_LENGTH (b) - (p - b), ",\"xb\":%d,\"yb\":%d",
|
||||
extents.x_bearing, extents.y_bearing));
|
||||
extents.x_bearing, extents.y_bearing));
|
||||
p += MAX (0, snprintf (p, ARRAY_LENGTH (b) - (p - b), ",\"w\":%d,\"h\":%d",
|
||||
extents.width, extents.height));
|
||||
extents.width, extents.height));
|
||||
}
|
||||
|
||||
*p++ = '}';
|
||||
|
@ -220,6 +232,12 @@ _hb_buffer_serialize_glyphs_text (hb_buffer_t *buffer,
|
|||
p += MAX (0, snprintf (p, ARRAY_LENGTH (b) - (p - b), ",%d", pos[i].y_advance));
|
||||
}
|
||||
|
||||
if (flags & HB_BUFFER_SERIALIZE_FLAG_GLYPH_FLAGS)
|
||||
{
|
||||
if (info[i].mask &HB_GLYPH_FLAG_DEFINED)
|
||||
p += MAX (0, snprintf (p, ARRAY_LENGTH (b) - (p - b), "#%X", info[i].mask &HB_GLYPH_FLAG_DEFINED));
|
||||
}
|
||||
|
||||
if (flags & HB_BUFFER_SERIALIZE_FLAG_GLYPH_EXTENTS)
|
||||
{
|
||||
hb_glyph_extents_t extents;
|
||||
|
@ -242,24 +260,51 @@ _hb_buffer_serialize_glyphs_text (hb_buffer_t *buffer,
|
|||
return end - start;
|
||||
}
|
||||
|
||||
/* Returns number of items, starting at start, that were serialized. */
|
||||
/**
|
||||
* hb_buffer_serialize_glyphs:
|
||||
* @buffer: a buffer.
|
||||
* @start:
|
||||
* @end:
|
||||
* @buf: (array length=buf_size):
|
||||
* @buf_size:
|
||||
* @buf_consumed: (out):
|
||||
* @font:
|
||||
* @format:
|
||||
* @flags:
|
||||
* @buffer: an #hb_buffer_t buffer.
|
||||
* @start: the first item in @buffer to serialize.
|
||||
* @end: the last item in @buffer to serialize.
|
||||
* @buf: (out) (array length=buf_size) (element-type uint8_t): output string to
|
||||
* write serialized buffer into.
|
||||
* @buf_size: the size of @buf.
|
||||
* @buf_consumed: (out) (allow-none): if not %NULL, will be set to the number of byes written into @buf.
|
||||
* @font: (allow-none): the #hb_font_t used to shape this buffer, needed to
|
||||
* read glyph names and extents. If %NULL, and empty font will be used.
|
||||
* @format: the #hb_buffer_serialize_format_t to use for formatting the output.
|
||||
* @flags: the #hb_buffer_serialize_flags_t that control what glyph properties
|
||||
* to serialize.
|
||||
*
|
||||
*
|
||||
* Serializes @buffer into a textual representation of its glyph content,
|
||||
* useful for showing the contents of the buffer, for example during debugging.
|
||||
* There are currently two supported serialization formats:
|
||||
*
|
||||
* ## text
|
||||
* A human-readable, plain text format.
|
||||
* The serialized glyphs will look something like:
|
||||
*
|
||||
* ```
|
||||
* [uni0651=0@518,0+0|uni0628=0+1897]
|
||||
* ```
|
||||
* - The serialized glyphs are delimited with `[` and `]`.
|
||||
* - Glyphs are separated with `|`
|
||||
* - Each glyph starts with glyph name, or glyph index if
|
||||
* #HB_BUFFER_SERIALIZE_FLAG_NO_GLYPH_NAMES flag is set. Then,
|
||||
* - If #HB_BUFFER_SERIALIZE_FLAG_NO_CLUSTERS is not set, `=` then #hb_glyph_info_t.cluster.
|
||||
* - If #HB_BUFFER_SERIALIZE_FLAG_NO_POSITIONS is not set, the #hb_glyph_position_t in the format:
|
||||
* - If both #hb_glyph_position_t.x_offset and #hb_glyph_position_t.y_offset are not 0, `@x_offset,y_offset`. Then,
|
||||
* - `+x_advance`, then `,y_advance` if #hb_glyph_position_t.y_advance is not 0. Then,
|
||||
* - If #HB_BUFFER_SERIALIZE_FLAG_GLYPH_EXTENTS is set, the
|
||||
* #hb_glyph_extents_t in the format
|
||||
* `<x_bearing,y_bearing,width,height>`
|
||||
*
|
||||
* ## json
|
||||
* TODO.
|
||||
*
|
||||
* Return value:
|
||||
* The number of serialized items.
|
||||
*
|
||||
* Since: 0.9.2
|
||||
* Since: 0.9.7
|
||||
**/
|
||||
unsigned int
|
||||
hb_buffer_serialize_glyphs (hb_buffer_t *buffer,
|
||||
|
@ -267,8 +312,8 @@ hb_buffer_serialize_glyphs (hb_buffer_t *buffer,
|
|||
unsigned int end,
|
||||
char *buf,
|
||||
unsigned int buf_size,
|
||||
unsigned int *buf_consumed, /* May be NULL */
|
||||
hb_font_t *font, /* May be NULL */
|
||||
unsigned int *buf_consumed,
|
||||
hb_font_t *font,
|
||||
hb_buffer_serialize_format_t format,
|
||||
hb_buffer_serialize_flags_t flags)
|
||||
{
|
||||
|
@ -278,10 +323,15 @@ hb_buffer_serialize_glyphs (hb_buffer_t *buffer,
|
|||
if (!buf_consumed)
|
||||
buf_consumed = &sconsumed;
|
||||
*buf_consumed = 0;
|
||||
if (buf_size)
|
||||
*buf = '\0';
|
||||
|
||||
assert ((!buffer->len && buffer->content_type == HB_BUFFER_CONTENT_TYPE_INVALID) ||
|
||||
buffer->content_type == HB_BUFFER_CONTENT_TYPE_GLYPHS);
|
||||
|
||||
if (!buffer->have_positions)
|
||||
flags |= HB_BUFFER_SERIALIZE_FLAG_NO_POSITIONS;
|
||||
|
||||
if (unlikely (start == end))
|
||||
return 0;
|
||||
|
||||
|
@ -355,7 +405,7 @@ parse_int (const char *pp, const char *end, int32_t *pv)
|
|||
|
||||
/**
|
||||
* hb_buffer_deserialize_glyphs:
|
||||
* @buffer: a buffer.
|
||||
* @buffer: an #hb_buffer_t buffer.
|
||||
* @buf: (array length=buf_len):
|
||||
* @buf_len:
|
||||
* @end_ptr: (out):
|
||||
|
@ -366,7 +416,7 @@ parse_int (const char *pp, const char *end, int32_t *pv)
|
|||
*
|
||||
* Return value:
|
||||
*
|
||||
* Since: 0.9.2
|
||||
* Since: 0.9.7
|
||||
**/
|
||||
hb_bool_t
|
||||
hb_buffer_deserialize_glyphs (hb_buffer_t *buffer,
|
||||
|
|
File diff suppressed because it is too large
Load Diff
|
@ -40,10 +40,30 @@
|
|||
|
||||
HB_BEGIN_DECLS
|
||||
|
||||
|
||||
/**
|
||||
* hb_glyph_info_t:
|
||||
* @codepoint: either a Unicode code point (before shaping) or a glyph index
|
||||
* (after shaping).
|
||||
* @mask:
|
||||
* @cluster: the index of the character in the original text that corresponds
|
||||
* to this #hb_glyph_info_t, or whatever the client passes to
|
||||
* hb_buffer_add(). More than one #hb_glyph_info_t can have the same
|
||||
* @cluster value, if they resulted from the same character (e.g. one
|
||||
* to many glyph substitution), and when more than one character gets
|
||||
* merged in the same glyph (e.g. many to one glyph substitution) the
|
||||
* #hb_glyph_info_t will have the smallest cluster value of them.
|
||||
* By default some characters are merged into the same cluster
|
||||
* (e.g. combining marks have the same cluster as their bases)
|
||||
* even if they are separate glyphs, hb_buffer_set_cluster_level()
|
||||
* allow selecting more fine-grained cluster handling.
|
||||
*
|
||||
* The #hb_glyph_info_t is the structure that holds information about the
|
||||
* glyphs and their relation to input text.
|
||||
*
|
||||
*/
|
||||
typedef struct hb_glyph_info_t {
|
||||
hb_codepoint_t codepoint;
|
||||
hb_mask_t mask;
|
||||
hb_mask_t mask; /* Holds hb_glyph_flags_t after hb_shape(), plus other things. */
|
||||
uint32_t cluster;
|
||||
|
||||
/*< private >*/
|
||||
|
@ -51,6 +71,35 @@ typedef struct hb_glyph_info_t {
|
|||
hb_var_int_t var2;
|
||||
} hb_glyph_info_t;
|
||||
|
||||
typedef enum { /*< flags >*/
|
||||
HB_GLYPH_FLAG_UNSAFE_TO_BREAK = 0x00000001,
|
||||
|
||||
HB_GLYPH_FLAG_DEFINED = 0x00000001 /* OR of all defined flags */
|
||||
} hb_glyph_flags_t;
|
||||
|
||||
HB_EXTERN hb_glyph_flags_t
|
||||
hb_glyph_info_get_glyph_flags (const hb_glyph_info_t *info);
|
||||
|
||||
#define hb_glyph_info_get_glyph_flags(info) \
|
||||
((hb_glyph_flags_t) ((unsigned int) (info)->mask & HB_GLYPH_FLAG_DEFINED))
|
||||
|
||||
|
||||
/**
|
||||
* hb_glyph_position_t:
|
||||
* @x_advance: how much the line advances after drawing this glyph when setting
|
||||
* text in horizontal direction.
|
||||
* @y_advance: how much the line advances after drawing this glyph when setting
|
||||
* text in vertical direction.
|
||||
* @x_offset: how much the glyph moves on the X-axis before drawing it, this
|
||||
* should not affect how much the line advances.
|
||||
* @y_offset: how much the glyph moves on the Y-axis before drawing it, this
|
||||
* should not affect how much the line advances.
|
||||
*
|
||||
* The #hb_glyph_position_t is the structure that holds the positions of the
|
||||
* glyph in both horizontal and vertical directions. All positions in
|
||||
* #hb_glyph_position_t are relative to the current point.
|
||||
*
|
||||
*/
|
||||
typedef struct hb_glyph_position_t {
|
||||
hb_position_t x_advance;
|
||||
hb_position_t y_advance;
|
||||
|
@ -61,7 +110,16 @@ typedef struct hb_glyph_position_t {
|
|||
hb_var_int_t var;
|
||||
} hb_glyph_position_t;
|
||||
|
||||
|
||||
/**
|
||||
* hb_segment_properties_t:
|
||||
* @direction: the #hb_direction_t of the buffer, see hb_buffer_set_direction().
|
||||
* @script: the #hb_script_t of the buffer, see hb_buffer_set_script().
|
||||
* @language: the #hb_language_t of the buffer, see hb_buffer_set_language().
|
||||
*
|
||||
* The structure that holds various text properties of an #hb_buffer_t. Can be
|
||||
* set and retrieved using hb_buffer_set_segment_properties() and
|
||||
* hb_buffer_get_segment_properties(), respectively.
|
||||
*/
|
||||
typedef struct hb_segment_properties_t {
|
||||
hb_direction_t direction;
|
||||
hb_script_t script;
|
||||
|
@ -77,101 +135,126 @@ typedef struct hb_segment_properties_t {
|
|||
NULL, \
|
||||
NULL}
|
||||
|
||||
hb_bool_t
|
||||
HB_EXTERN hb_bool_t
|
||||
hb_segment_properties_equal (const hb_segment_properties_t *a,
|
||||
const hb_segment_properties_t *b);
|
||||
|
||||
unsigned int
|
||||
HB_EXTERN unsigned int
|
||||
hb_segment_properties_hash (const hb_segment_properties_t *p);
|
||||
|
||||
|
||||
|
||||
/*
|
||||
* hb_buffer_t
|
||||
/**
|
||||
* hb_buffer_t:
|
||||
*
|
||||
* The main structure holding the input text and its properties before shaping,
|
||||
* and output glyphs and their information after shaping.
|
||||
*/
|
||||
|
||||
typedef struct hb_buffer_t hb_buffer_t;
|
||||
|
||||
hb_buffer_t *
|
||||
HB_EXTERN hb_buffer_t *
|
||||
hb_buffer_create (void);
|
||||
|
||||
hb_buffer_t *
|
||||
HB_EXTERN hb_buffer_t *
|
||||
hb_buffer_get_empty (void);
|
||||
|
||||
hb_buffer_t *
|
||||
HB_EXTERN hb_buffer_t *
|
||||
hb_buffer_reference (hb_buffer_t *buffer);
|
||||
|
||||
void
|
||||
HB_EXTERN void
|
||||
hb_buffer_destroy (hb_buffer_t *buffer);
|
||||
|
||||
hb_bool_t
|
||||
HB_EXTERN hb_bool_t
|
||||
hb_buffer_set_user_data (hb_buffer_t *buffer,
|
||||
hb_user_data_key_t *key,
|
||||
void * data,
|
||||
hb_destroy_func_t destroy,
|
||||
hb_bool_t replace);
|
||||
|
||||
void *
|
||||
HB_EXTERN void *
|
||||
hb_buffer_get_user_data (hb_buffer_t *buffer,
|
||||
hb_user_data_key_t *key);
|
||||
|
||||
|
||||
/**
|
||||
* hb_buffer_content_type_t:
|
||||
* @HB_BUFFER_CONTENT_TYPE_INVALID: Initial value for new buffer.
|
||||
* @HB_BUFFER_CONTENT_TYPE_UNICODE: The buffer contains input characters (before shaping).
|
||||
* @HB_BUFFER_CONTENT_TYPE_GLYPHS: The buffer contains output glyphs (after shaping).
|
||||
*/
|
||||
typedef enum {
|
||||
HB_BUFFER_CONTENT_TYPE_INVALID = 0,
|
||||
HB_BUFFER_CONTENT_TYPE_UNICODE,
|
||||
HB_BUFFER_CONTENT_TYPE_GLYPHS
|
||||
} hb_buffer_content_type_t;
|
||||
|
||||
void
|
||||
HB_EXTERN void
|
||||
hb_buffer_set_content_type (hb_buffer_t *buffer,
|
||||
hb_buffer_content_type_t content_type);
|
||||
|
||||
hb_buffer_content_type_t
|
||||
HB_EXTERN hb_buffer_content_type_t
|
||||
hb_buffer_get_content_type (hb_buffer_t *buffer);
|
||||
|
||||
|
||||
void
|
||||
HB_EXTERN void
|
||||
hb_buffer_set_unicode_funcs (hb_buffer_t *buffer,
|
||||
hb_unicode_funcs_t *unicode_funcs);
|
||||
|
||||
hb_unicode_funcs_t *
|
||||
HB_EXTERN hb_unicode_funcs_t *
|
||||
hb_buffer_get_unicode_funcs (hb_buffer_t *buffer);
|
||||
|
||||
void
|
||||
HB_EXTERN void
|
||||
hb_buffer_set_direction (hb_buffer_t *buffer,
|
||||
hb_direction_t direction);
|
||||
|
||||
hb_direction_t
|
||||
HB_EXTERN hb_direction_t
|
||||
hb_buffer_get_direction (hb_buffer_t *buffer);
|
||||
|
||||
void
|
||||
HB_EXTERN void
|
||||
hb_buffer_set_script (hb_buffer_t *buffer,
|
||||
hb_script_t script);
|
||||
|
||||
hb_script_t
|
||||
HB_EXTERN hb_script_t
|
||||
hb_buffer_get_script (hb_buffer_t *buffer);
|
||||
|
||||
void
|
||||
HB_EXTERN void
|
||||
hb_buffer_set_language (hb_buffer_t *buffer,
|
||||
hb_language_t language);
|
||||
|
||||
|
||||
hb_language_t
|
||||
HB_EXTERN hb_language_t
|
||||
hb_buffer_get_language (hb_buffer_t *buffer);
|
||||
|
||||
void
|
||||
HB_EXTERN void
|
||||
hb_buffer_set_segment_properties (hb_buffer_t *buffer,
|
||||
const hb_segment_properties_t *props);
|
||||
|
||||
void
|
||||
HB_EXTERN void
|
||||
hb_buffer_get_segment_properties (hb_buffer_t *buffer,
|
||||
hb_segment_properties_t *props);
|
||||
|
||||
void
|
||||
HB_EXTERN void
|
||||
hb_buffer_guess_segment_properties (hb_buffer_t *buffer);
|
||||
|
||||
|
||||
/*
|
||||
/**
|
||||
* hb_buffer_flags_t:
|
||||
* @HB_BUFFER_FLAG_DEFAULT: the default buffer flag.
|
||||
* @HB_BUFFER_FLAG_BOT: flag indicating that special handling of the beginning
|
||||
* of text paragraph can be applied to this buffer. Should usually
|
||||
* be set, unless you are passing to the buffer only part
|
||||
* of the text without the full context.
|
||||
* @HB_BUFFER_FLAG_EOT: flag indicating that special handling of the end of text
|
||||
* paragraph can be applied to this buffer, similar to
|
||||
* @HB_BUFFER_FLAG_EOT.
|
||||
* @HB_BUFFER_FLAG_PRESERVE_DEFAULT_IGNORABLES:
|
||||
* flag indication that character with Default_Ignorable
|
||||
* Unicode property should use the corresponding glyph
|
||||
* from the font, instead of hiding them (currently done
|
||||
* by replacing them with the space glyph and zeroing the
|
||||
* advance width.)
|
||||
*
|
||||
* Since: 0.9.20
|
||||
*/
|
||||
typedef enum { /*< flags >*/
|
||||
|
@ -181,11 +264,11 @@ typedef enum { /*< flags >*/
|
|||
HB_BUFFER_FLAG_PRESERVE_DEFAULT_IGNORABLES = 0x00000004u
|
||||
} hb_buffer_flags_t;
|
||||
|
||||
void
|
||||
HB_EXTERN void
|
||||
hb_buffer_set_flags (hb_buffer_t *buffer,
|
||||
hb_buffer_flags_t flags);
|
||||
|
||||
hb_buffer_flags_t
|
||||
HB_EXTERN hb_buffer_flags_t
|
||||
hb_buffer_get_flags (hb_buffer_t *buffer);
|
||||
|
||||
/*
|
||||
|
@ -198,126 +281,123 @@ typedef enum {
|
|||
HB_BUFFER_CLUSTER_LEVEL_DEFAULT = HB_BUFFER_CLUSTER_LEVEL_MONOTONE_GRAPHEMES
|
||||
} hb_buffer_cluster_level_t;
|
||||
|
||||
void
|
||||
HB_EXTERN void
|
||||
hb_buffer_set_cluster_level (hb_buffer_t *buffer,
|
||||
hb_buffer_cluster_level_t cluster_level);
|
||||
|
||||
hb_buffer_cluster_level_t
|
||||
HB_EXTERN hb_buffer_cluster_level_t
|
||||
hb_buffer_get_cluster_level (hb_buffer_t *buffer);
|
||||
|
||||
/**
|
||||
* HB_BUFFER_REPLACEMENT_CODEPOINT_DEFAULT:
|
||||
*
|
||||
* The default code point for replacing invalid characters in a given encoding.
|
||||
* Set to U+FFFD REPLACEMENT CHARACTER.
|
||||
*
|
||||
* Since: 0.9.31
|
||||
*/
|
||||
#define HB_BUFFER_REPLACEMENT_CODEPOINT_DEFAULT 0xFFFDu
|
||||
|
||||
/* Sets codepoint used to replace invalid UTF-8/16/32 entries.
|
||||
* Default is 0xFFFDu. */
|
||||
void
|
||||
HB_EXTERN void
|
||||
hb_buffer_set_replacement_codepoint (hb_buffer_t *buffer,
|
||||
hb_codepoint_t replacement);
|
||||
|
||||
hb_codepoint_t
|
||||
HB_EXTERN hb_codepoint_t
|
||||
hb_buffer_get_replacement_codepoint (hb_buffer_t *buffer);
|
||||
|
||||
|
||||
/* Resets the buffer. Afterwards it's as if it was just created,
|
||||
* except that it has a larger buffer allocated perhaps... */
|
||||
void
|
||||
HB_EXTERN void
|
||||
hb_buffer_reset (hb_buffer_t *buffer);
|
||||
|
||||
/* Like reset, but does NOT clear unicode_funcs and replacement_codepoint. */
|
||||
void
|
||||
HB_EXTERN void
|
||||
hb_buffer_clear_contents (hb_buffer_t *buffer);
|
||||
|
||||
/* Returns false if allocation failed */
|
||||
hb_bool_t
|
||||
HB_EXTERN hb_bool_t
|
||||
hb_buffer_pre_allocate (hb_buffer_t *buffer,
|
||||
unsigned int size);
|
||||
|
||||
|
||||
/* Returns false if allocation has failed before */
|
||||
hb_bool_t
|
||||
HB_EXTERN hb_bool_t
|
||||
hb_buffer_allocation_successful (hb_buffer_t *buffer);
|
||||
|
||||
void
|
||||
HB_EXTERN void
|
||||
hb_buffer_reverse (hb_buffer_t *buffer);
|
||||
|
||||
void
|
||||
HB_EXTERN void
|
||||
hb_buffer_reverse_range (hb_buffer_t *buffer,
|
||||
unsigned int start, unsigned int end);
|
||||
|
||||
void
|
||||
HB_EXTERN void
|
||||
hb_buffer_reverse_clusters (hb_buffer_t *buffer);
|
||||
|
||||
|
||||
/* Filling the buffer in */
|
||||
|
||||
void
|
||||
HB_EXTERN void
|
||||
hb_buffer_add (hb_buffer_t *buffer,
|
||||
hb_codepoint_t codepoint,
|
||||
unsigned int cluster);
|
||||
|
||||
void
|
||||
HB_EXTERN void
|
||||
hb_buffer_add_utf8 (hb_buffer_t *buffer,
|
||||
const char *text,
|
||||
int text_length,
|
||||
unsigned int item_offset,
|
||||
int item_length);
|
||||
|
||||
void
|
||||
HB_EXTERN void
|
||||
hb_buffer_add_utf16 (hb_buffer_t *buffer,
|
||||
const uint16_t *text,
|
||||
int text_length,
|
||||
unsigned int item_offset,
|
||||
int item_length);
|
||||
|
||||
void
|
||||
HB_EXTERN void
|
||||
hb_buffer_add_utf32 (hb_buffer_t *buffer,
|
||||
const uint32_t *text,
|
||||
int text_length,
|
||||
unsigned int item_offset,
|
||||
int item_length);
|
||||
|
||||
/* Allows only access to first 256 Unicode codepoints. */
|
||||
void
|
||||
HB_EXTERN void
|
||||
hb_buffer_add_latin1 (hb_buffer_t *buffer,
|
||||
const uint8_t *text,
|
||||
int text_length,
|
||||
unsigned int item_offset,
|
||||
int item_length);
|
||||
|
||||
/* Like add_utf32 but does NOT check for invalid Unicode codepoints. */
|
||||
void
|
||||
HB_EXTERN void
|
||||
hb_buffer_add_codepoints (hb_buffer_t *buffer,
|
||||
const hb_codepoint_t *text,
|
||||
int text_length,
|
||||
unsigned int item_offset,
|
||||
int item_length);
|
||||
|
||||
HB_EXTERN void
|
||||
hb_buffer_append (hb_buffer_t *buffer,
|
||||
hb_buffer_t *source,
|
||||
unsigned int start,
|
||||
unsigned int end);
|
||||
|
||||
/* Clears any new items added at the end */
|
||||
hb_bool_t
|
||||
HB_EXTERN hb_bool_t
|
||||
hb_buffer_set_length (hb_buffer_t *buffer,
|
||||
unsigned int length);
|
||||
|
||||
/* Return value valid as long as buffer not modified */
|
||||
unsigned int
|
||||
HB_EXTERN unsigned int
|
||||
hb_buffer_get_length (hb_buffer_t *buffer);
|
||||
|
||||
/* Getting glyphs out of the buffer */
|
||||
|
||||
/* Return value valid as long as buffer not modified */
|
||||
hb_glyph_info_t *
|
||||
HB_EXTERN hb_glyph_info_t *
|
||||
hb_buffer_get_glyph_infos (hb_buffer_t *buffer,
|
||||
unsigned int *length);
|
||||
|
||||
/* Return value valid as long as buffer not modified */
|
||||
hb_glyph_position_t *
|
||||
HB_EXTERN hb_glyph_position_t *
|
||||
hb_buffer_get_glyph_positions (hb_buffer_t *buffer,
|
||||
unsigned int *length);
|
||||
|
||||
|
||||
/* Reorders a glyph buffer to have canonical in-cluster glyph order / position.
|
||||
* The resulting clusters should behave identical to pre-reordering clusters.
|
||||
* NOTE: This has nothing to do with Unicode normalization. */
|
||||
void
|
||||
HB_EXTERN void
|
||||
hb_buffer_normalize_glyphs (hb_buffer_t *buffer);
|
||||
|
||||
|
||||
|
@ -325,7 +405,16 @@ hb_buffer_normalize_glyphs (hb_buffer_t *buffer);
|
|||
* Serialize
|
||||
*/
|
||||
|
||||
/*
|
||||
/**
|
||||
* hb_buffer_serialize_flags_t:
|
||||
* @HB_BUFFER_SERIALIZE_FLAG_DEFAULT: serialize glyph names, clusters and positions.
|
||||
* @HB_BUFFER_SERIALIZE_FLAG_NO_CLUSTERS: do not serialize glyph cluster.
|
||||
* @HB_BUFFER_SERIALIZE_FLAG_NO_POSITIONS: do not serialize glyph position information.
|
||||
* @HB_BUFFER_SERIALIZE_FLAG_NO_GLYPH_NAMES: do no serialize glyph name.
|
||||
* @HB_BUFFER_SERIALIZE_FLAG_GLYPH_EXTENTS: serialize glyph extents.
|
||||
*
|
||||
* Flags that control what glyph information are serialized in hb_buffer_serialize_glyphs().
|
||||
*
|
||||
* Since: 0.9.20
|
||||
*/
|
||||
typedef enum { /*< flags >*/
|
||||
|
@ -333,46 +422,110 @@ typedef enum { /*< flags >*/
|
|||
HB_BUFFER_SERIALIZE_FLAG_NO_CLUSTERS = 0x00000001u,
|
||||
HB_BUFFER_SERIALIZE_FLAG_NO_POSITIONS = 0x00000002u,
|
||||
HB_BUFFER_SERIALIZE_FLAG_NO_GLYPH_NAMES = 0x00000004u,
|
||||
HB_BUFFER_SERIALIZE_FLAG_GLYPH_EXTENTS = 0x00000008u
|
||||
HB_BUFFER_SERIALIZE_FLAG_GLYPH_EXTENTS = 0x00000008u,
|
||||
HB_BUFFER_SERIALIZE_FLAG_GLYPH_FLAGS = 0x00000010u
|
||||
} hb_buffer_serialize_flags_t;
|
||||
|
||||
/**
|
||||
* hb_buffer_serialize_format_t:
|
||||
* @HB_BUFFER_SERIALIZE_FORMAT_TEXT: a human-readable, plain text format.
|
||||
* @HB_BUFFER_SERIALIZE_FORMAT_JSON: a machine-readable JSON format.
|
||||
* @HB_BUFFER_SERIALIZE_FORMAT_INVALID: invalid format.
|
||||
*
|
||||
* The buffer serialization and de-serialization format used in
|
||||
* hb_buffer_serialize_glyphs() and hb_buffer_deserialize_glyphs().
|
||||
*
|
||||
* Since: 0.9.2
|
||||
*/
|
||||
typedef enum {
|
||||
HB_BUFFER_SERIALIZE_FORMAT_TEXT = HB_TAG('T','E','X','T'),
|
||||
HB_BUFFER_SERIALIZE_FORMAT_JSON = HB_TAG('J','S','O','N'),
|
||||
HB_BUFFER_SERIALIZE_FORMAT_INVALID = HB_TAG_NONE
|
||||
} hb_buffer_serialize_format_t;
|
||||
|
||||
/* len=-1 means str is NUL-terminated. */
|
||||
hb_buffer_serialize_format_t
|
||||
HB_EXTERN hb_buffer_serialize_format_t
|
||||
hb_buffer_serialize_format_from_string (const char *str, int len);
|
||||
|
||||
const char *
|
||||
HB_EXTERN const char *
|
||||
hb_buffer_serialize_format_to_string (hb_buffer_serialize_format_t format);
|
||||
|
||||
const char **
|
||||
HB_EXTERN const char **
|
||||
hb_buffer_serialize_list_formats (void);
|
||||
|
||||
/* Returns number of items, starting at start, that were serialized. */
|
||||
unsigned int
|
||||
HB_EXTERN unsigned int
|
||||
hb_buffer_serialize_glyphs (hb_buffer_t *buffer,
|
||||
unsigned int start,
|
||||
unsigned int end,
|
||||
char *buf,
|
||||
unsigned int buf_size,
|
||||
unsigned int *buf_consumed, /* May be NULL */
|
||||
hb_font_t *font, /* May be NULL */
|
||||
unsigned int *buf_consumed,
|
||||
hb_font_t *font,
|
||||
hb_buffer_serialize_format_t format,
|
||||
hb_buffer_serialize_flags_t flags);
|
||||
|
||||
hb_bool_t
|
||||
HB_EXTERN 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 */
|
||||
int buf_len,
|
||||
const char **end_ptr,
|
||||
hb_font_t *font,
|
||||
hb_buffer_serialize_format_t format);
|
||||
|
||||
|
||||
/*
|
||||
* Compare buffers
|
||||
*/
|
||||
|
||||
typedef enum { /*< flags >*/
|
||||
HB_BUFFER_DIFF_FLAG_EQUAL = 0x0000,
|
||||
|
||||
/* Buffers with different content_type cannot be meaningfully compared
|
||||
* in any further detail. */
|
||||
HB_BUFFER_DIFF_FLAG_CONTENT_TYPE_MISMATCH = 0x0001,
|
||||
|
||||
/* For buffers with differing length, the per-glyph comparison is not
|
||||
* attempted, though we do still scan reference for dottedcircle / .notdef
|
||||
* glyphs. */
|
||||
HB_BUFFER_DIFF_FLAG_LENGTH_MISMATCH = 0x0002,
|
||||
|
||||
/* We want to know if dottedcircle / .notdef glyphs are present in the
|
||||
* reference, as we may not care so much about other differences in this
|
||||
* case. */
|
||||
HB_BUFFER_DIFF_FLAG_NOTDEF_PRESENT = 0x0004,
|
||||
HB_BUFFER_DIFF_FLAG_DOTTED_CIRCLE_PRESENT = 0x0008,
|
||||
|
||||
/* If the buffers have the same length, we compare them glyph-by-glyph
|
||||
* and report which aspect(s) of the glyph info/position are different. */
|
||||
HB_BUFFER_DIFF_FLAG_CODEPOINT_MISMATCH = 0x0010,
|
||||
HB_BUFFER_DIFF_FLAG_CLUSTER_MISMATCH = 0x0020,
|
||||
HB_BUFFER_DIFF_FLAG_GLYPH_FLAGS_MISMATCH = 0x0040,
|
||||
HB_BUFFER_DIFF_FLAG_POSITION_MISMATCH = 0x0080
|
||||
|
||||
} hb_buffer_diff_flags_t;
|
||||
|
||||
/* Compare the contents of two buffers, report types of differences. */
|
||||
hb_buffer_diff_flags_t
|
||||
hb_buffer_diff (hb_buffer_t *buffer,
|
||||
hb_buffer_t *reference,
|
||||
hb_codepoint_t dottedcircle_glyph,
|
||||
unsigned int position_fuzz);
|
||||
|
||||
|
||||
/*
|
||||
* Debugging.
|
||||
*/
|
||||
|
||||
typedef hb_bool_t (*hb_buffer_message_func_t) (hb_buffer_t *buffer,
|
||||
hb_font_t *font,
|
||||
const char *message,
|
||||
void *user_data);
|
||||
|
||||
HB_EXTERN void
|
||||
hb_buffer_set_message_func (hb_buffer_t *buffer,
|
||||
hb_buffer_message_func_t func,
|
||||
void *user_data, hb_destroy_func_t destroy);
|
||||
|
||||
|
||||
HB_END_DECLS
|
||||
|
||||
#endif /* HB_BUFFER_H */
|
||||
|
|
|
@ -45,11 +45,11 @@ struct hb_cache_t
|
|||
|
||||
inline bool get (unsigned int key, unsigned int *value)
|
||||
{
|
||||
unsigned int k = key & ((1<<cache_bits)-1);
|
||||
unsigned int k = key & ((1u<<cache_bits)-1);
|
||||
unsigned int v = values[k];
|
||||
if ((v >> value_bits) != (key >> cache_bits))
|
||||
return false;
|
||||
*value = v & ((1<<value_bits)-1);
|
||||
*value = v & ((1u<<value_bits)-1);
|
||||
return true;
|
||||
}
|
||||
|
||||
|
@ -57,14 +57,14 @@ struct hb_cache_t
|
|||
{
|
||||
if (unlikely ((key >> key_bits) || (value >> value_bits)))
|
||||
return false; /* Overflows */
|
||||
unsigned int k = key & ((1<<cache_bits)-1);
|
||||
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[1<<cache_bits];
|
||||
unsigned int values[1u<<cache_bits];
|
||||
};
|
||||
|
||||
typedef hb_cache_t<21, 16, 8> hb_cmap_cache_t;
|
||||
|
|
|
@ -88,7 +88,7 @@ hb_tag_from_string (const char *str, int len)
|
|||
/**
|
||||
* hb_tag_to_string:
|
||||
* @tag:
|
||||
* @buf: (array fixed-size=4):
|
||||
* @buf: (out caller-allocates) (array fixed-size=4) (element-type uint8_t):
|
||||
*
|
||||
*
|
||||
*
|
||||
|
@ -186,8 +186,10 @@ lang_equal (hb_language_t v1,
|
|||
const unsigned char *p1 = (const unsigned char *) v1;
|
||||
const unsigned char *p2 = (const unsigned char *) v2;
|
||||
|
||||
while (*p1 && *p1 == canon_map[*p2])
|
||||
p1++, p2++;
|
||||
while (*p1 && *p1 == canon_map[*p2]) {
|
||||
p1++;
|
||||
p2++;
|
||||
}
|
||||
|
||||
return *p1 == canon_map[*p2];
|
||||
}
|
||||
|
@ -219,9 +221,18 @@ struct hb_language_item_t {
|
|||
}
|
||||
|
||||
inline hb_language_item_t & operator = (const char *s) {
|
||||
lang = (hb_language_t) strdup (s);
|
||||
for (unsigned char *p = (unsigned char *) lang; *p; p++)
|
||||
*p = canon_map[*p];
|
||||
/* If a custom allocated is used calling strdup() pairs
|
||||
badly with a call to the custom free() in finish() below.
|
||||
Therefore don't call strdup(), implement its behavior.
|
||||
*/
|
||||
size_t len = strlen(s) + 1;
|
||||
lang = (hb_language_t) malloc(len);
|
||||
if (likely (lang))
|
||||
{
|
||||
memcpy((unsigned char *) lang, s, len);
|
||||
for (unsigned char *p = (unsigned char *) lang; *p; p++)
|
||||
*p = canon_map[*p];
|
||||
}
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
@ -263,6 +274,11 @@ retry:
|
|||
return NULL;
|
||||
lang->next = first_lang;
|
||||
*lang = key;
|
||||
if (unlikely (!lang->lang))
|
||||
{
|
||||
free (lang);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (!hb_atomic_ptr_cmpexch (&langs, first_lang, lang)) {
|
||||
lang->finish ();
|
||||
|
@ -281,12 +297,15 @@ retry:
|
|||
|
||||
/**
|
||||
* hb_language_from_string:
|
||||
* @str: (array length=len) (element-type uint8_t):
|
||||
* @len:
|
||||
* @str: (array length=len) (element-type uint8_t): a string representing
|
||||
* ISO 639 language code
|
||||
* @len: length of the @str, or -1 if it is %NULL-terminated.
|
||||
*
|
||||
*
|
||||
* Converts @str representing an ISO 639 language code to the corresponding
|
||||
* #hb_language_t.
|
||||
*
|
||||
* Return value: (transfer none):
|
||||
* The #hb_language_t corresponding to the ISO 639 language code.
|
||||
*
|
||||
* Since: 0.9.2
|
||||
**/
|
||||
|
@ -314,11 +333,13 @@ hb_language_from_string (const char *str, int len)
|
|||
|
||||
/**
|
||||
* hb_language_to_string:
|
||||
* @language:
|
||||
* @language: an #hb_language_t to convert.
|
||||
*
|
||||
*
|
||||
* See hb_language_from_string().
|
||||
*
|
||||
* Return value: (transfer none):
|
||||
* Return value: (transfer none):
|
||||
* A %NULL-terminated string representing the @language. Must not be freed by
|
||||
* the caller.
|
||||
*
|
||||
* Since: 0.9.2
|
||||
**/
|
||||
|
@ -357,11 +378,12 @@ hb_language_get_default (void)
|
|||
|
||||
/**
|
||||
* hb_script_from_iso15924_tag:
|
||||
* @tag:
|
||||
* @tag: an #hb_tag_t representing an ISO 15924 tag.
|
||||
*
|
||||
*
|
||||
* Converts an ISO 15924 script tag to a corresponding #hb_script_t.
|
||||
*
|
||||
* Return value:
|
||||
* An #hb_script_t corresponding to the ISO 15924 tag.
|
||||
*
|
||||
* Since: 0.9.2
|
||||
**/
|
||||
|
@ -401,28 +423,33 @@ hb_script_from_iso15924_tag (hb_tag_t tag)
|
|||
|
||||
/**
|
||||
* hb_script_from_string:
|
||||
* @s: (array length=len) (element-type uint8_t):
|
||||
* @len:
|
||||
* @str: (array length=len) (element-type uint8_t): a string representing an
|
||||
* ISO 15924 tag.
|
||||
* @len: length of the @str, or -1 if it is %NULL-terminated.
|
||||
*
|
||||
*
|
||||
* Converts a string @str representing an ISO 15924 script tag to a
|
||||
* corresponding #hb_script_t. Shorthand for hb_tag_from_string() then
|
||||
* hb_script_from_iso15924_tag().
|
||||
*
|
||||
* Return value:
|
||||
* An #hb_script_t corresponding to the ISO 15924 tag.
|
||||
*
|
||||
* Since: 0.9.2
|
||||
**/
|
||||
hb_script_t
|
||||
hb_script_from_string (const char *s, int len)
|
||||
hb_script_from_string (const char *str, int len)
|
||||
{
|
||||
return hb_script_from_iso15924_tag (hb_tag_from_string (s, len));
|
||||
return hb_script_from_iso15924_tag (hb_tag_from_string (str, len));
|
||||
}
|
||||
|
||||
/**
|
||||
* hb_script_to_iso15924_tag:
|
||||
* @script:
|
||||
* @script: an #hb_script_ to convert.
|
||||
*
|
||||
*
|
||||
* See hb_script_from_iso15924_tag().
|
||||
*
|
||||
* Return value:
|
||||
* Return value:
|
||||
* An #hb_tag_t representing an ISO 15924 script tag.
|
||||
*
|
||||
* Since: 0.9.2
|
||||
**/
|
||||
|
@ -496,6 +523,9 @@ hb_script_get_horizontal_direction (hb_script_t script)
|
|||
/* Unicode-8.0 additions */
|
||||
case HB_SCRIPT_OLD_HUNGARIAN:
|
||||
|
||||
/* Unicode-9.0 additions */
|
||||
case HB_SCRIPT_ADLAM:
|
||||
|
||||
return HB_DIRECTION_RTL;
|
||||
}
|
||||
|
||||
|
@ -521,7 +551,7 @@ hb_user_data_array_t::set (hb_user_data_key_t *key,
|
|||
}
|
||||
}
|
||||
hb_user_data_item_t item = {key, data, destroy};
|
||||
bool ret = !!items.replace_or_insert (item, lock, replace);
|
||||
bool ret = !!items.replace_or_insert (item, lock, (bool) replace);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
@ -529,7 +559,7 @@ 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 };
|
||||
hb_user_data_item_t item = {NULL, NULL, NULL};
|
||||
|
||||
return items.find (key, &item, lock) ? item.data : NULL;
|
||||
}
|
||||
|
@ -591,3 +621,371 @@ hb_version_atleast (unsigned int major,
|
|||
{
|
||||
return HB_VERSION_ATLEAST (major, minor, micro);
|
||||
}
|
||||
|
||||
|
||||
|
||||
/* hb_feature_t and hb_variation_t */
|
||||
|
||||
static bool
|
||||
parse_space (const char **pp, const char *end)
|
||||
{
|
||||
while (*pp < end && ISSPACE (**pp))
|
||||
(*pp)++;
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool
|
||||
parse_char (const char **pp, const char *end, char c)
|
||||
{
|
||||
parse_space (pp, end);
|
||||
|
||||
if (*pp == end || **pp != c)
|
||||
return false;
|
||||
|
||||
(*pp)++;
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool
|
||||
parse_uint (const char **pp, const char *end, unsigned int *pv)
|
||||
{
|
||||
char buf[32];
|
||||
unsigned int len = MIN (ARRAY_LENGTH (buf) - 1, (unsigned int) (end - *pp));
|
||||
strncpy (buf, *pp, len);
|
||||
buf[len] = '\0';
|
||||
|
||||
char *p = buf;
|
||||
char *pend = p;
|
||||
unsigned int v;
|
||||
|
||||
/* Intentionally use strtol instead of strtoul, such that
|
||||
* -1 turns into "big number"... */
|
||||
errno = 0;
|
||||
v = strtol (p, &pend, 0);
|
||||
if (errno || p == pend)
|
||||
return false;
|
||||
|
||||
*pv = v;
|
||||
*pp += pend - p;
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool
|
||||
parse_uint32 (const char **pp, const char *end, uint32_t *pv)
|
||||
{
|
||||
char buf[32];
|
||||
unsigned int len = MIN (ARRAY_LENGTH (buf) - 1, (unsigned int) (end - *pp));
|
||||
strncpy (buf, *pp, len);
|
||||
buf[len] = '\0';
|
||||
|
||||
char *p = buf;
|
||||
char *pend = p;
|
||||
unsigned int v;
|
||||
|
||||
/* Intentionally use strtol instead of strtoul, such that
|
||||
* -1 turns into "big number"... */
|
||||
errno = 0;
|
||||
v = strtol (p, &pend, 0);
|
||||
if (errno || p == pend)
|
||||
return false;
|
||||
|
||||
*pv = v;
|
||||
*pp += pend - p;
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool
|
||||
parse_float (const char **pp, const char *end, float *pv)
|
||||
{
|
||||
char buf[32];
|
||||
unsigned int len = MIN (ARRAY_LENGTH (buf) - 1, (unsigned int) (end - *pp));
|
||||
strncpy (buf, *pp, len);
|
||||
buf[len] = '\0';
|
||||
|
||||
char *p = buf;
|
||||
char *pend = p;
|
||||
float v;
|
||||
|
||||
errno = 0;
|
||||
v = strtod (p, &pend);
|
||||
if (errno || p == pend)
|
||||
return false;
|
||||
|
||||
*pv = v;
|
||||
*pp += pend - p;
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool
|
||||
parse_bool (const char **pp, const char *end, uint32_t *pv)
|
||||
{
|
||||
parse_space (pp, end);
|
||||
|
||||
const char *p = *pp;
|
||||
while (*pp < end && ISALPHA(**pp))
|
||||
(*pp)++;
|
||||
|
||||
/* CSS allows on/off as aliases 1/0. */
|
||||
if (*pp - p == 2 || 0 == strncmp (p, "on", 2))
|
||||
*pv = 1;
|
||||
else if (*pp - p == 3 || 0 == strncmp (p, "off", 2))
|
||||
*pv = 0;
|
||||
else
|
||||
return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/* hb_feature_t */
|
||||
|
||||
static bool
|
||||
parse_feature_value_prefix (const char **pp, const char *end, hb_feature_t *feature)
|
||||
{
|
||||
if (parse_char (pp, end, '-'))
|
||||
feature->value = 0;
|
||||
else {
|
||||
parse_char (pp, end, '+');
|
||||
feature->value = 1;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool
|
||||
parse_tag (const char **pp, const char *end, hb_tag_t *tag)
|
||||
{
|
||||
parse_space (pp, end);
|
||||
|
||||
char quote = 0;
|
||||
|
||||
if (*pp < end && (**pp == '\'' || **pp == '"'))
|
||||
{
|
||||
quote = **pp;
|
||||
(*pp)++;
|
||||
}
|
||||
|
||||
const char *p = *pp;
|
||||
while (*pp < end && ISALNUM(**pp))
|
||||
(*pp)++;
|
||||
|
||||
if (p == *pp || *pp - p > 4)
|
||||
return false;
|
||||
|
||||
*tag = hb_tag_from_string (p, *pp - p);
|
||||
|
||||
if (quote)
|
||||
{
|
||||
/* CSS expects exactly four bytes. And we only allow quotations for
|
||||
* CSS compatibility. So, enforce the length. */
|
||||
if (*pp - p != 4)
|
||||
return false;
|
||||
if (*pp == end || **pp != quote)
|
||||
return false;
|
||||
(*pp)++;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool
|
||||
parse_feature_indices (const char **pp, const char *end, hb_feature_t *feature)
|
||||
{
|
||||
parse_space (pp, end);
|
||||
|
||||
bool has_start;
|
||||
|
||||
feature->start = 0;
|
||||
feature->end = (unsigned int) -1;
|
||||
|
||||
if (!parse_char (pp, end, '['))
|
||||
return true;
|
||||
|
||||
has_start = parse_uint (pp, end, &feature->start);
|
||||
|
||||
if (parse_char (pp, end, ':')) {
|
||||
parse_uint (pp, end, &feature->end);
|
||||
} else {
|
||||
if (has_start)
|
||||
feature->end = feature->start + 1;
|
||||
}
|
||||
|
||||
return parse_char (pp, end, ']');
|
||||
}
|
||||
|
||||
static bool
|
||||
parse_feature_value_postfix (const char **pp, const char *end, hb_feature_t *feature)
|
||||
{
|
||||
bool had_equal = parse_char (pp, end, '=');
|
||||
bool had_value = parse_uint32 (pp, end, &feature->value) ||
|
||||
parse_bool (pp, end, &feature->value);
|
||||
/* CSS doesn't use equal-sign between tag and value.
|
||||
* If there was an equal-sign, then there *must* be a value.
|
||||
* A value without an eqaul-sign is ok, but not required. */
|
||||
return !had_equal || had_value;
|
||||
}
|
||||
|
||||
static bool
|
||||
parse_one_feature (const char **pp, const char *end, hb_feature_t *feature)
|
||||
{
|
||||
return parse_feature_value_prefix (pp, end, feature) &&
|
||||
parse_tag (pp, end, &feature->tag) &&
|
||||
parse_feature_indices (pp, end, feature) &&
|
||||
parse_feature_value_postfix (pp, end, feature) &&
|
||||
parse_space (pp, end) &&
|
||||
*pp == end;
|
||||
}
|
||||
|
||||
/**
|
||||
* hb_feature_from_string:
|
||||
* @str: (array length=len) (element-type uint8_t): a string to parse
|
||||
* @len: length of @str, or -1 if string is %NULL terminated
|
||||
* @feature: (out): the #hb_feature_t to initialize with the parsed values
|
||||
*
|
||||
* Parses a string into a #hb_feature_t.
|
||||
*
|
||||
* TODO: document the syntax here.
|
||||
*
|
||||
* Return value:
|
||||
* %true if @str is successfully parsed, %false otherwise.
|
||||
*
|
||||
* Since: 0.9.5
|
||||
**/
|
||||
hb_bool_t
|
||||
hb_feature_from_string (const char *str, int len,
|
||||
hb_feature_t *feature)
|
||||
{
|
||||
hb_feature_t feat;
|
||||
|
||||
if (len < 0)
|
||||
len = strlen (str);
|
||||
|
||||
if (likely (parse_one_feature (&str, str + len, &feat)))
|
||||
{
|
||||
if (feature)
|
||||
*feature = feat;
|
||||
return true;
|
||||
}
|
||||
|
||||
if (feature)
|
||||
memset (feature, 0, sizeof (*feature));
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* hb_feature_to_string:
|
||||
* @feature: an #hb_feature_t to convert
|
||||
* @buf: (array length=size) (out): output string
|
||||
* @size: the allocated size of @buf
|
||||
*
|
||||
* Converts a #hb_feature_t into a %NULL-terminated string in the format
|
||||
* understood by hb_feature_from_string(). The client in responsible for
|
||||
* allocating big enough size for @buf, 128 bytes is more than enough.
|
||||
*
|
||||
* Since: 0.9.5
|
||||
**/
|
||||
void
|
||||
hb_feature_to_string (hb_feature_t *feature,
|
||||
char *buf, unsigned int size)
|
||||
{
|
||||
if (unlikely (!size)) return;
|
||||
|
||||
char s[128];
|
||||
unsigned int len = 0;
|
||||
if (feature->value == 0)
|
||||
s[len++] = '-';
|
||||
hb_tag_to_string (feature->tag, s + len);
|
||||
len += 4;
|
||||
while (len && s[len - 1] == ' ')
|
||||
len--;
|
||||
if (feature->start != 0 || feature->end != (unsigned int) -1)
|
||||
{
|
||||
s[len++] = '[';
|
||||
if (feature->start)
|
||||
len += MAX (0, snprintf (s + len, ARRAY_LENGTH (s) - len, "%u", feature->start));
|
||||
if (feature->end != feature->start + 1) {
|
||||
s[len++] = ':';
|
||||
if (feature->end != (unsigned int) -1)
|
||||
len += MAX (0, snprintf (s + len, ARRAY_LENGTH (s) - len, "%u", feature->end));
|
||||
}
|
||||
s[len++] = ']';
|
||||
}
|
||||
if (feature->value > 1)
|
||||
{
|
||||
s[len++] = '=';
|
||||
len += MAX (0, snprintf (s + len, ARRAY_LENGTH (s) - len, "%u", feature->value));
|
||||
}
|
||||
assert (len < ARRAY_LENGTH (s));
|
||||
len = MIN (len, size - 1);
|
||||
memcpy (buf, s, len);
|
||||
buf[len] = '\0';
|
||||
}
|
||||
|
||||
/* hb_variation_t */
|
||||
|
||||
static bool
|
||||
parse_variation_value (const char **pp, const char *end, hb_variation_t *variation)
|
||||
{
|
||||
parse_char (pp, end, '='); /* Optional. */
|
||||
return parse_float (pp, end, &variation->value);
|
||||
}
|
||||
|
||||
static bool
|
||||
parse_one_variation (const char **pp, const char *end, hb_variation_t *variation)
|
||||
{
|
||||
return parse_tag (pp, end, &variation->tag) &&
|
||||
parse_variation_value (pp, end, variation) &&
|
||||
parse_space (pp, end) &&
|
||||
*pp == end;
|
||||
}
|
||||
|
||||
/**
|
||||
* hb_variation_from_string:
|
||||
*
|
||||
* Since: 1.4.2
|
||||
*/
|
||||
hb_bool_t
|
||||
hb_variation_from_string (const char *str, int len,
|
||||
hb_variation_t *variation)
|
||||
{
|
||||
hb_variation_t var;
|
||||
|
||||
if (len < 0)
|
||||
len = strlen (str);
|
||||
|
||||
if (likely (parse_one_variation (&str, str + len, &var)))
|
||||
{
|
||||
if (variation)
|
||||
*variation = var;
|
||||
return true;
|
||||
}
|
||||
|
||||
if (variation)
|
||||
memset (variation, 0, sizeof (*variation));
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* hb_variation_to_string:
|
||||
*
|
||||
* Since: 1.4.2
|
||||
*/
|
||||
void
|
||||
hb_variation_to_string (hb_variation_t *variation,
|
||||
char *buf, unsigned int size)
|
||||
{
|
||||
if (unlikely (!size)) return;
|
||||
|
||||
char s[128];
|
||||
unsigned int len = 0;
|
||||
hb_tag_to_string (variation->tag, s + len);
|
||||
len += 4;
|
||||
while (len && s[len - 1] == ' ')
|
||||
len--;
|
||||
s[len++] = '=';
|
||||
len += MAX (0, snprintf (s + len, ARRAY_LENGTH (s) - len, "%g", variation->value));
|
||||
|
||||
assert (len < ARRAY_LENGTH (s));
|
||||
len = MIN (len, size - 1);
|
||||
memcpy (buf, s, len);
|
||||
buf[len] = '\0';
|
||||
}
|
||||
|
|
|
@ -98,16 +98,22 @@ typedef uint32_t hb_tag_t;
|
|||
#define HB_TAG_MAX_SIGNED HB_TAG(0x7f,0xff,0xff,0xff)
|
||||
|
||||
/* len=-1 means str is NUL-terminated. */
|
||||
hb_tag_t
|
||||
HB_EXTERN hb_tag_t
|
||||
hb_tag_from_string (const char *str, int len);
|
||||
|
||||
/* buf should have 4 bytes. */
|
||||
void
|
||||
HB_EXTERN void
|
||||
hb_tag_to_string (hb_tag_t tag, char *buf);
|
||||
|
||||
|
||||
/* hb_direction_t */
|
||||
|
||||
/**
|
||||
* hb_direction_t:
|
||||
* @HB_DIRECTION_INVALID: Initial, unset direction.
|
||||
* @HB_DIRECTION_LTR: Text is set horizontally from left to right.
|
||||
* @HB_DIRECTION_RTL: Text is set horizontally from right to left.
|
||||
* @HB_DIRECTION_TTB: Text is set vertically from top to bottom.
|
||||
* @HB_DIRECTION_BTT: Text is set vertically from bottom to top.
|
||||
*/
|
||||
typedef enum {
|
||||
HB_DIRECTION_INVALID = 0,
|
||||
HB_DIRECTION_LTR = 4,
|
||||
|
@ -117,10 +123,10 @@ typedef enum {
|
|||
} hb_direction_t;
|
||||
|
||||
/* len=-1 means str is NUL-terminated */
|
||||
hb_direction_t
|
||||
HB_EXTERN hb_direction_t
|
||||
hb_direction_from_string (const char *str, int len);
|
||||
|
||||
const char *
|
||||
HB_EXTERN const char *
|
||||
hb_direction_to_string (hb_direction_t direction);
|
||||
|
||||
#define HB_DIRECTION_IS_VALID(dir) ((((unsigned int) (dir)) & ~3U) == 4)
|
||||
|
@ -136,16 +142,15 @@ hb_direction_to_string (hb_direction_t direction);
|
|||
|
||||
typedef const struct hb_language_impl_t *hb_language_t;
|
||||
|
||||
/* len=-1 means str is NUL-terminated */
|
||||
hb_language_t
|
||||
HB_EXTERN hb_language_t
|
||||
hb_language_from_string (const char *str, int len);
|
||||
|
||||
const char *
|
||||
HB_EXTERN const char *
|
||||
hb_language_to_string (hb_language_t language);
|
||||
|
||||
#define HB_LANGUAGE_INVALID ((hb_language_t) NULL)
|
||||
|
||||
hb_language_t
|
||||
HB_EXTERN hb_language_t
|
||||
hb_language_get_default (void);
|
||||
|
||||
|
||||
|
@ -299,12 +304,22 @@ typedef enum
|
|||
/*7.0*/ HB_SCRIPT_TIRHUTA = HB_TAG ('T','i','r','h'),
|
||||
/*7.0*/ HB_SCRIPT_WARANG_CITI = HB_TAG ('W','a','r','a'),
|
||||
|
||||
/*8.0*/ HB_SCRIPT_AHOM = HB_TAG ('A','h','o','m'),
|
||||
/*8.0*/ HB_SCRIPT_ANATOLIAN_HIEROGLYPHS = HB_TAG ('H','l','u','w'),
|
||||
/*8.0*/ HB_SCRIPT_HATRAN = HB_TAG ('H','a','t','r'),
|
||||
/*8.0*/ HB_SCRIPT_MULTANI = HB_TAG ('M','u','l','t'),
|
||||
/*8.0*/ HB_SCRIPT_OLD_HUNGARIAN = HB_TAG ('H','u','n','g'),
|
||||
/*8.0*/ HB_SCRIPT_SIGNWRITING = HB_TAG ('S','g','n','w'),
|
||||
/*8.0*/ HB_SCRIPT_AHOM = HB_TAG ('A','h','o','m'),
|
||||
/*8.0*/ HB_SCRIPT_ANATOLIAN_HIEROGLYPHS = HB_TAG ('H','l','u','w'),
|
||||
/*8.0*/ HB_SCRIPT_HATRAN = HB_TAG ('H','a','t','r'),
|
||||
/*8.0*/ HB_SCRIPT_MULTANI = HB_TAG ('M','u','l','t'),
|
||||
/*8.0*/ HB_SCRIPT_OLD_HUNGARIAN = HB_TAG ('H','u','n','g'),
|
||||
/*8.0*/ HB_SCRIPT_SIGNWRITING = HB_TAG ('S','g','n','w'),
|
||||
|
||||
/*
|
||||
* Since 1.3.0
|
||||
*/
|
||||
/*9.0*/ HB_SCRIPT_ADLAM = HB_TAG ('A','d','l','m'),
|
||||
/*9.0*/ HB_SCRIPT_BHAIKSUKI = HB_TAG ('B','h','k','s'),
|
||||
/*9.0*/ HB_SCRIPT_MARCHEN = HB_TAG ('M','a','r','c'),
|
||||
/*9.0*/ HB_SCRIPT_OSAGE = HB_TAG ('O','s','g','e'),
|
||||
/*9.0*/ HB_SCRIPT_TANGUT = HB_TAG ('T','a','n','g'),
|
||||
/*9.0*/ HB_SCRIPT_NEWA = HB_TAG ('N','e','w','a'),
|
||||
|
||||
/* No script set. */
|
||||
HB_SCRIPT_INVALID = HB_TAG_NONE,
|
||||
|
@ -324,18 +339,16 @@ typedef enum
|
|||
|
||||
/* Script functions */
|
||||
|
||||
hb_script_t
|
||||
HB_EXTERN hb_script_t
|
||||
hb_script_from_iso15924_tag (hb_tag_t tag);
|
||||
|
||||
/* sugar for tag_from_string() then script_from_iso15924_tag */
|
||||
/* len=-1 means s is NUL-terminated */
|
||||
hb_script_t
|
||||
hb_script_from_string (const char *s, int len);
|
||||
HB_EXTERN hb_script_t
|
||||
hb_script_from_string (const char *str, int len);
|
||||
|
||||
hb_tag_t
|
||||
HB_EXTERN hb_tag_t
|
||||
hb_script_to_iso15924_tag (hb_script_t script);
|
||||
|
||||
hb_direction_t
|
||||
HB_EXTERN hb_direction_t
|
||||
hb_script_get_horizontal_direction (hb_script_t script);
|
||||
|
||||
|
||||
|
@ -349,6 +362,42 @@ typedef struct hb_user_data_key_t {
|
|||
typedef void (*hb_destroy_func_t) (void *user_data);
|
||||
|
||||
|
||||
/* Font features and variations. */
|
||||
|
||||
typedef struct hb_feature_t {
|
||||
hb_tag_t tag;
|
||||
uint32_t value;
|
||||
unsigned int start;
|
||||
unsigned int end;
|
||||
} hb_feature_t;
|
||||
|
||||
HB_EXTERN hb_bool_t
|
||||
hb_feature_from_string (const char *str, int len,
|
||||
hb_feature_t *feature);
|
||||
|
||||
HB_EXTERN void
|
||||
hb_feature_to_string (hb_feature_t *feature,
|
||||
char *buf, unsigned int size);
|
||||
|
||||
/**
|
||||
* hb_variation_t:
|
||||
*
|
||||
* Since: 1.4.2
|
||||
*/
|
||||
typedef struct hb_variation_t {
|
||||
hb_tag_t tag;
|
||||
float value;
|
||||
} hb_variation_t;
|
||||
|
||||
HB_EXTERN hb_bool_t
|
||||
hb_variation_from_string (const char *str, int len,
|
||||
hb_variation_t *variation);
|
||||
|
||||
HB_EXTERN void
|
||||
hb_variation_to_string (hb_variation_t *variation,
|
||||
char *buf, unsigned int size);
|
||||
|
||||
|
||||
HB_END_DECLS
|
||||
|
||||
#endif /* HB_COMMON_H */
|
||||
|
|
|
@ -27,7 +27,6 @@
|
|||
*/
|
||||
|
||||
#define HB_SHAPER coretext
|
||||
#define hb_coretext_shaper_face_data_t CGFont
|
||||
#include "hb-shaper-impl-private.hh"
|
||||
|
||||
#include "hb-coretext.h"
|
||||
|
@ -70,14 +69,37 @@ hb_coretext_face_create (CGFontRef cg_font)
|
|||
}
|
||||
|
||||
|
||||
HB_SHAPER_DATA_ENSURE_DECLARE(coretext, face)
|
||||
HB_SHAPER_DATA_ENSURE_DECLARE(coretext, font)
|
||||
HB_SHAPER_DATA_ENSURE_DEFINE(coretext, face)
|
||||
HB_SHAPER_DATA_ENSURE_DEFINE(coretext, font)
|
||||
|
||||
|
||||
/*
|
||||
* shaper face data
|
||||
*/
|
||||
|
||||
static CTFontDescriptorRef
|
||||
get_last_resort_font_desc (void)
|
||||
{
|
||||
// TODO Handle allocation failures?
|
||||
CTFontDescriptorRef last_resort = CTFontDescriptorCreateWithNameAndSize (CFSTR("LastResort"), 0);
|
||||
CFArrayRef cascade_list = CFArrayCreate (kCFAllocatorDefault,
|
||||
(const void **) &last_resort,
|
||||
1,
|
||||
&kCFTypeArrayCallBacks);
|
||||
CFRelease (last_resort);
|
||||
CFDictionaryRef attributes = CFDictionaryCreate (kCFAllocatorDefault,
|
||||
(const void **) &kCTFontCascadeListAttribute,
|
||||
(const void **) &cascade_list,
|
||||
1,
|
||||
&kCFTypeDictionaryKeyCallBacks,
|
||||
&kCFTypeDictionaryValueCallBacks);
|
||||
CFRelease (cascade_list);
|
||||
|
||||
CTFontDescriptorRef font_desc = CTFontDescriptorCreateWithAttributes (attributes);
|
||||
CFRelease (attributes);
|
||||
return font_desc;
|
||||
}
|
||||
|
||||
static void
|
||||
release_data (void *info, const void *data, size_t size)
|
||||
{
|
||||
|
@ -87,14 +109,13 @@ release_data (void *info, const void *data, size_t size)
|
|||
hb_blob_destroy ((hb_blob_t *) info);
|
||||
}
|
||||
|
||||
hb_coretext_shaper_face_data_t *
|
||||
_hb_coretext_shaper_face_data_create (hb_face_t *face)
|
||||
static CGFontRef
|
||||
create_cg_font (hb_face_t *face)
|
||||
{
|
||||
hb_coretext_shaper_face_data_t *data = NULL;
|
||||
|
||||
CGFontRef cg_font = NULL;
|
||||
if (face->destroy == (hb_destroy_func_t) CGFontRelease)
|
||||
{
|
||||
data = CGFontRetain ((CGFontRef) face->user_data);
|
||||
cg_font = CGFontRetain ((CGFontRef) face->user_data);
|
||||
}
|
||||
else
|
||||
{
|
||||
|
@ -107,13 +128,114 @@ _hb_coretext_shaper_face_data_create (hb_face_t *face)
|
|||
CGDataProviderRef provider = CGDataProviderCreateWithData (blob, blob_data, blob_length, &release_data);
|
||||
if (likely (provider))
|
||||
{
|
||||
data = CGFontCreateWithDataProvider (provider);
|
||||
cg_font = CGFontCreateWithDataProvider (provider);
|
||||
if (unlikely (!cg_font))
|
||||
DEBUG_MSG (CORETEXT, face, "Face CGFontCreateWithDataProvider() failed");
|
||||
CGDataProviderRelease (provider);
|
||||
}
|
||||
}
|
||||
return cg_font;
|
||||
}
|
||||
|
||||
if (unlikely (!data)) {
|
||||
DEBUG_MSG (CORETEXT, face, "Face CGFontCreateWithDataProvider() failed");
|
||||
static CTFontRef
|
||||
create_ct_font (CGFontRef cg_font, CGFloat font_size)
|
||||
{
|
||||
CTFontRef ct_font = CTFontCreateWithGraphicsFont (cg_font, font_size, NULL, NULL);
|
||||
if (unlikely (!ct_font)) {
|
||||
DEBUG_MSG (CORETEXT, cg_font, "Font CTFontCreateWithGraphicsFont() failed");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* crbug.com/576941 and crbug.com/625902 and the investigation in the latter
|
||||
* bug indicate that the cascade list reconfiguration occasionally causes
|
||||
* crashes in CoreText on OS X 10.9, thus let's skip this step on older
|
||||
* operating system versions. Except for the emoji font, where _not_
|
||||
* 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) {
|
||||
CFStringRef fontName = CTFontCopyPostScriptName (ct_font);
|
||||
bool isEmojiFont = CFStringCompare (fontName, CFSTR("AppleColorEmoji"), 0) == kCFCompareEqualTo;
|
||||
CFRelease (fontName);
|
||||
if (!isEmojiFont)
|
||||
return ct_font;
|
||||
}
|
||||
|
||||
CFURLRef original_url = (CFURLRef)CTFontCopyAttribute(ct_font, kCTFontURLAttribute);
|
||||
|
||||
/* Create font copy with cascade list that has LastResort first; this speeds up CoreText
|
||||
* 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);
|
||||
CFRelease (last_resort_font_desc);
|
||||
if (new_ct_font)
|
||||
{
|
||||
/* The CTFontCreateCopyWithAttributes call fails to stay on the same font
|
||||
* when reconfiguring the cascade list and may switch to a different font
|
||||
* when there are fonts that go by the same name, since the descriptor is
|
||||
* just name and size.
|
||||
*
|
||||
* Avoid reconfiguring the cascade lists if the new font is outside the
|
||||
* system locations that we cannot access from the sandboxed renderer
|
||||
* process in Blink. This can be detected by the new file URL location
|
||||
* that the newly found font points to. */
|
||||
CFURLRef new_url = (CFURLRef) CTFontCopyAttribute (new_ct_font, kCTFontURLAttribute);
|
||||
// Keep reconfigured font if URL cannot be retrieved (seems to be the case
|
||||
// on Mac OS 10.12 Sierra), speculative fix for crbug.com/625606
|
||||
if (!original_url || !new_url || CFEqual (original_url, new_url)) {
|
||||
CFRelease (ct_font);
|
||||
ct_font = new_ct_font;
|
||||
} else {
|
||||
CFRelease (new_ct_font);
|
||||
DEBUG_MSG (CORETEXT, ct_font, "Discarding reconfigured CTFont, location changed.");
|
||||
}
|
||||
if (new_url)
|
||||
CFRelease (new_url);
|
||||
}
|
||||
else
|
||||
DEBUG_MSG (CORETEXT, ct_font, "Font copy with empty cascade list failed");
|
||||
}
|
||||
|
||||
if (original_url)
|
||||
CFRelease (original_url);
|
||||
return ct_font;
|
||||
}
|
||||
|
||||
struct hb_coretext_shaper_face_data_t {
|
||||
CGFontRef cg_font;
|
||||
CTFontRef ct_font;
|
||||
};
|
||||
|
||||
hb_coretext_shaper_face_data_t *
|
||||
_hb_coretext_shaper_face_data_create (hb_face_t *face)
|
||||
{
|
||||
hb_coretext_shaper_face_data_t *data = (hb_coretext_shaper_face_data_t *) calloc (1, sizeof (hb_coretext_shaper_face_data_t));
|
||||
if (unlikely (!data))
|
||||
return NULL;
|
||||
|
||||
data->cg_font = create_cg_font (face);
|
||||
if (unlikely (!data->cg_font))
|
||||
{
|
||||
DEBUG_MSG (CORETEXT, face, "CGFont creation failed..");
|
||||
free (data);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* We use 36pt size instead of UPEM, because CoreText implements the 'trak' table,
|
||||
* which can make the font too tight at large sizes. 36pt should be a good semi-neutral
|
||||
* size.
|
||||
*
|
||||
* Since we always create CTFont at a fixed size, our CTFont lives in face_data
|
||||
* instead of font_data. Which is good, because when people change scale on
|
||||
* hb_font_t, we won't need to update our CTFont. */
|
||||
data->ct_font = create_ct_font (data->cg_font, 36.);
|
||||
if (unlikely (!data->ct_font))
|
||||
{
|
||||
DEBUG_MSG (CORETEXT, face, "CTFont creation failed.");
|
||||
CFRelease (data->cg_font);
|
||||
free (data);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return data;
|
||||
|
@ -122,7 +244,9 @@ _hb_coretext_shaper_face_data_create (hb_face_t *face)
|
|||
void
|
||||
_hb_coretext_shaper_face_data_destroy (hb_coretext_shaper_face_data_t *data)
|
||||
{
|
||||
CFRelease (data);
|
||||
CFRelease (data->ct_font);
|
||||
CFRelease (data->cg_font);
|
||||
free (data);
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -133,7 +257,7 @@ hb_coretext_face_get_cg_font (hb_face_t *face)
|
|||
{
|
||||
if (unlikely (!hb_coretext_shaper_face_data_ensure (face))) return NULL;
|
||||
hb_coretext_shaper_face_data_t *face_data = HB_SHAPER_DATA_GET (face);
|
||||
return face_data;
|
||||
return face_data->cg_font;
|
||||
}
|
||||
|
||||
|
||||
|
@ -141,49 +265,17 @@ hb_coretext_face_get_cg_font (hb_face_t *face)
|
|||
* shaper font data
|
||||
*/
|
||||
|
||||
struct hb_coretext_shaper_font_data_t {
|
||||
CTFontRef ct_font;
|
||||
CGFloat x_mult, y_mult; /* From CT space to HB space. */
|
||||
};
|
||||
struct hb_coretext_shaper_font_data_t {};
|
||||
|
||||
hb_coretext_shaper_font_data_t *
|
||||
_hb_coretext_shaper_font_data_create (hb_font_t *font)
|
||||
_hb_coretext_shaper_font_data_create (hb_font_t *font HB_UNUSED)
|
||||
{
|
||||
if (unlikely (!hb_coretext_shaper_face_data_ensure (font->face))) return NULL;
|
||||
|
||||
hb_coretext_shaper_font_data_t *data = (hb_coretext_shaper_font_data_t *) calloc (1, sizeof (hb_coretext_shaper_font_data_t));
|
||||
if (unlikely (!data))
|
||||
return NULL;
|
||||
|
||||
hb_face_t *face = font->face;
|
||||
hb_coretext_shaper_face_data_t *face_data = HB_SHAPER_DATA_GET (face);
|
||||
|
||||
/* Choose a CoreText font size and calculate multipliers to convert to HarfBuzz space. */
|
||||
/* TODO: use upem instead of 36? */
|
||||
CGFloat font_size = 36.; /* Default... */
|
||||
/* No idea if the following is even a good idea. */
|
||||
if (font->y_ppem)
|
||||
font_size = font->y_ppem;
|
||||
|
||||
if (font_size < 0)
|
||||
font_size = -font_size;
|
||||
data->x_mult = (CGFloat) font->x_scale / font_size;
|
||||
data->y_mult = (CGFloat) font->y_scale / font_size;
|
||||
data->ct_font = CTFontCreateWithGraphicsFont (face_data, font_size, NULL, NULL);
|
||||
if (unlikely (!data->ct_font)) {
|
||||
DEBUG_MSG (CORETEXT, font, "Font CTFontCreateWithGraphicsFont() failed");
|
||||
free (data);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return data;
|
||||
return (hb_coretext_shaper_font_data_t *) HB_SHAPER_DATA_SUCCEEDED;
|
||||
}
|
||||
|
||||
void
|
||||
_hb_coretext_shaper_font_data_destroy (hb_coretext_shaper_font_data_t *data)
|
||||
{
|
||||
CFRelease (data->ct_font);
|
||||
free (data);
|
||||
}
|
||||
|
||||
|
||||
|
@ -196,7 +288,9 @@ struct hb_coretext_shaper_shape_plan_data_t {};
|
|||
hb_coretext_shaper_shape_plan_data_t *
|
||||
_hb_coretext_shaper_shape_plan_data_create (hb_shape_plan_t *shape_plan HB_UNUSED,
|
||||
const hb_feature_t *user_features HB_UNUSED,
|
||||
unsigned int num_user_features HB_UNUSED)
|
||||
unsigned int num_user_features HB_UNUSED,
|
||||
const int *coords HB_UNUSED,
|
||||
unsigned int num_coords HB_UNUSED)
|
||||
{
|
||||
return (hb_coretext_shaper_shape_plan_data_t *) HB_SHAPER_DATA_SUCCEEDED;
|
||||
}
|
||||
|
@ -209,9 +303,10 @@ _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;
|
||||
hb_coretext_shaper_font_data_t *font_data = HB_SHAPER_DATA_GET (font);
|
||||
return font_data->ct_font;
|
||||
hb_face_t *face = font->face;
|
||||
if (unlikely (!hb_coretext_shaper_face_data_ensure (face))) return NULL;
|
||||
hb_coretext_shaper_face_data_t *face_data = HB_SHAPER_DATA_GET (face);
|
||||
return face_data->ct_font;
|
||||
}
|
||||
|
||||
|
||||
|
@ -444,7 +539,10 @@ _hb_coretext_shape (hb_shape_plan_t *shape_plan,
|
|||
{
|
||||
hb_face_t *face = font->face;
|
||||
hb_coretext_shaper_face_data_t *face_data = HB_SHAPER_DATA_GET (face);
|
||||
hb_coretext_shaper_font_data_t *font_data = HB_SHAPER_DATA_GET (font);
|
||||
|
||||
CGFloat ct_font_size = CTFontGetSize (face_data->ct_font);
|
||||
CGFloat x_mult = (CGFloat) font->x_scale / ct_font_size;
|
||||
CGFloat y_mult = (CGFloat) font->y_scale / ct_font_size;
|
||||
|
||||
/* Attach marks to their bases, to match the 'ot' shaper.
|
||||
* Adapted from hb-ot-shape:hb_form_clusters().
|
||||
|
@ -453,6 +551,7 @@ _hb_coretext_shape (hb_shape_plan_t *shape_plan,
|
|||
* B1 M1 B2 M2, and B1-B2 form a ligature, M2's cluster will
|
||||
* continue pointing to B2 even though B2 was merged into B1's
|
||||
* cluster... */
|
||||
if (buffer->cluster_level == HB_BUFFER_CLUSTER_LEVEL_MONOTONE_GRAPHEMES)
|
||||
{
|
||||
hb_unicode_funcs_t *unicode = buffer->unicode;
|
||||
unsigned int count = buffer->len;
|
||||
|
@ -542,22 +641,23 @@ _hb_coretext_shape (hb_shape_plan_t *shape_plan,
|
|||
/* active_features.qsort (); */
|
||||
for (unsigned int j = 0; j < active_features.len; j++)
|
||||
{
|
||||
CFStringRef keys[2] = {
|
||||
CFStringRef keys[] = {
|
||||
kCTFontFeatureTypeIdentifierKey,
|
||||
kCTFontFeatureSelectorIdentifierKey
|
||||
};
|
||||
CFNumberRef values[2] = {
|
||||
CFNumberRef values[] = {
|
||||
CFNumberCreate (kCFAllocatorDefault, kCFNumberIntType, &active_features[j].rec.feature),
|
||||
CFNumberCreate (kCFAllocatorDefault, kCFNumberIntType, &active_features[j].rec.setting)
|
||||
};
|
||||
ASSERT_STATIC (ARRAY_LENGTH (keys) == ARRAY_LENGTH (values));
|
||||
CFDictionaryRef dict = CFDictionaryCreate (kCFAllocatorDefault,
|
||||
(const void **) keys,
|
||||
(const void **) values,
|
||||
2,
|
||||
ARRAY_LENGTH (keys),
|
||||
&kCFTypeDictionaryKeyCallBacks,
|
||||
&kCFTypeDictionaryValueCallBacks);
|
||||
CFRelease (values[0]);
|
||||
CFRelease (values[1]);
|
||||
for (unsigned int i = 0; i < ARRAY_LENGTH (values); i++)
|
||||
CFRelease (values[i]);
|
||||
|
||||
CFArrayAppendValue (features_array, dict);
|
||||
CFRelease (dict);
|
||||
|
@ -575,7 +675,7 @@ _hb_coretext_shape (hb_shape_plan_t *shape_plan,
|
|||
CTFontDescriptorRef font_desc = CTFontDescriptorCreateWithAttributes (attributes);
|
||||
CFRelease (attributes);
|
||||
|
||||
range->font = CTFontCreateCopyWithAttributes (font_data->ct_font, 0.0, NULL, font_desc);
|
||||
range->font = CTFontCreateCopyWithAttributes (face_data->ct_font, 0.0, NULL, font_desc);
|
||||
CFRelease (font_desc);
|
||||
}
|
||||
else
|
||||
|
@ -600,9 +700,6 @@ _hb_coretext_shape (hb_shape_plan_t *shape_plan,
|
|||
active_features.remove (feature - active_features.array);
|
||||
}
|
||||
}
|
||||
|
||||
if (!range_records.len) /* No active feature found. */
|
||||
goto fail_features;
|
||||
}
|
||||
else
|
||||
{
|
||||
|
@ -636,7 +733,7 @@ _hb_coretext_shape (hb_shape_plan_t *shape_plan,
|
|||
pchars[chars_len++] = 0xFFFDu;
|
||||
else {
|
||||
pchars[chars_len++] = 0xD800u + ((c - 0x10000u) >> 10);
|
||||
pchars[chars_len++] = 0xDC00u + ((c - 0x10000u) & ((1 << 10) - 1));
|
||||
pchars[chars_len++] = 0xDC00u + ((c - 0x10000u) & ((1u << 10) - 1));
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -693,7 +790,6 @@ resize_and_retry:
|
|||
scratch += old_scratch_used;
|
||||
scratch_size -= old_scratch_used;
|
||||
}
|
||||
retry:
|
||||
{
|
||||
string_ref = CFStringCreateWithCharactersNoCopy (NULL,
|
||||
pchars, chars_len,
|
||||
|
@ -733,9 +829,9 @@ retry:
|
|||
CFRelease (lang);
|
||||
}
|
||||
CFAttributedStringSetAttribute (attr_string, CFRangeMake (0, chars_len),
|
||||
kCTFontAttributeName, font_data->ct_font);
|
||||
kCTFontAttributeName, face_data->ct_font);
|
||||
|
||||
if (num_features)
|
||||
if (num_features && range_records.len)
|
||||
{
|
||||
unsigned int start = 0;
|
||||
range_record_t *last_range = &range_records[0];
|
||||
|
@ -761,6 +857,30 @@ retry:
|
|||
CFAttributedStringSetAttribute (attr_string, CFRangeMake (start, chars_len - start),
|
||||
kCTFontAttributeName, last_range->font);
|
||||
}
|
||||
/* Enable/disable kern if requested.
|
||||
*
|
||||
* Note: once kern is disabled, reenabling it doesn't currently seem to work in CoreText.
|
||||
*/
|
||||
if (num_features)
|
||||
{
|
||||
unsigned int zeroint = 0;
|
||||
CFNumberRef zero = CFNumberCreate (kCFAllocatorDefault, kCFNumberIntType, &zeroint);
|
||||
for (unsigned int i = 0; i < num_features; i++)
|
||||
{
|
||||
const hb_feature_t &feature = features[i];
|
||||
if (feature.tag == HB_TAG('k','e','r','n') &&
|
||||
feature.start < chars_len && feature.start < feature.end)
|
||||
{
|
||||
CFRange feature_range = CFRangeMake (feature.start,
|
||||
MIN (feature.end, chars_len) - feature.start);
|
||||
if (feature.value)
|
||||
CFAttributedStringRemoveAttribute (attr_string, feature_range, kCTKernAttributeName);
|
||||
else
|
||||
CFAttributedStringSetAttribute (attr_string, feature_range, kCTKernAttributeName, zero);
|
||||
}
|
||||
}
|
||||
CFRelease (zero);
|
||||
}
|
||||
|
||||
int level = HB_DIRECTION_IS_FORWARD (buffer->props.direction) ? 0 : 1;
|
||||
CFNumberRef level_number = CFNumberCreate (kCFAllocatorDefault, kCFNumberIntType, &level);
|
||||
|
@ -770,6 +890,7 @@ retry:
|
|||
1,
|
||||
&kCFTypeDictionaryKeyCallBacks,
|
||||
&kCFTypeDictionaryValueCallBacks);
|
||||
CFRelease (level_number);
|
||||
if (unlikely (!options))
|
||||
FAIL ("CFDictionaryCreate failed");
|
||||
|
||||
|
@ -826,7 +947,7 @@ retry:
|
|||
*/
|
||||
CFDictionaryRef attributes = CTRunGetAttributes (run);
|
||||
CTFontRef run_ct_font = static_cast<CTFontRef>(CFDictionaryGetValue (attributes, kCTFontAttributeName));
|
||||
if (!CFEqual (run_ct_font, font_data->ct_font))
|
||||
if (!CFEqual (run_ct_font, face_data->ct_font))
|
||||
{
|
||||
/* The run doesn't use our main font instance. We have to figure out
|
||||
* whether font fallback happened, or this is just CoreText giving us
|
||||
|
@ -846,15 +967,11 @@ retry:
|
|||
* backend.
|
||||
*
|
||||
* However, even that wouldn't work if we were passed in the CGFont to
|
||||
* begin with.
|
||||
*
|
||||
* Webkit uses a slightly different approach: it installs LastResort
|
||||
* as fallback chain, and then checks PS name of used font against
|
||||
* LastResort. That one is safe for any font except for LastResort,
|
||||
* as opposed to ours, which can fail if we are using any uninstalled
|
||||
* font that has the same name as an installed font.
|
||||
* construct a hb_face to begin with.
|
||||
*
|
||||
* See: http://github.com/behdad/harfbuzz/pull/36
|
||||
*
|
||||
* Also see: https://bugs.chromium.org/p/chromium/issues/detail?id=597098
|
||||
*/
|
||||
bool matched = false;
|
||||
for (unsigned int i = 0; i < range_records.len; i++)
|
||||
|
@ -868,13 +985,13 @@ retry:
|
|||
CGFontRef run_cg_font = CTFontCopyGraphicsFont (run_ct_font, 0);
|
||||
if (run_cg_font)
|
||||
{
|
||||
matched = CFEqual (run_cg_font, face_data);
|
||||
matched = CFEqual (run_cg_font, face_data->cg_font);
|
||||
CFRelease (run_cg_font);
|
||||
}
|
||||
}
|
||||
if (!matched)
|
||||
{
|
||||
CFStringRef font_ps_name = CTFontCopyName (font_data->ct_font, kCTFontPostScriptNameKey);
|
||||
CFStringRef font_ps_name = CTFontCopyName (face_data->ct_font, kCTFontPostScriptNameKey);
|
||||
CFStringRef run_ps_name = CTFontCopyName (run_ct_font, kCTFontPostScriptNameKey);
|
||||
CFComparisonResult result = CFStringCompare (run_ps_name, font_ps_name, 0);
|
||||
CFRelease (run_ps_name);
|
||||
|
@ -994,7 +1111,6 @@ retry:
|
|||
positions = position_buf;
|
||||
}
|
||||
hb_glyph_info_t *info = run_info;
|
||||
CGFloat x_mult = font_data->x_mult, y_mult = font_data->y_mult;
|
||||
if (HB_DIRECTION_IS_HORIZONTAL (buffer->props.direction))
|
||||
{
|
||||
hb_position_t x_offset = (positions[0].x - advances_so_far) * x_mult;
|
||||
|
@ -1064,6 +1180,9 @@ retry:
|
|||
pos->x_advance = info->mask;
|
||||
pos->x_offset = info->var1.i32;
|
||||
pos->y_offset = info->var2.i32;
|
||||
|
||||
info->mask = HB_GLYPH_FLAG_UNSAFE_TO_BREAK;
|
||||
|
||||
info++, pos++;
|
||||
}
|
||||
else
|
||||
|
@ -1072,6 +1191,9 @@ retry:
|
|||
pos->y_advance = info->mask;
|
||||
pos->x_offset = info->var1.i32;
|
||||
pos->y_offset = info->var2.i32;
|
||||
|
||||
info->mask = HB_GLYPH_FLAG_UNSAFE_TO_BREAK;
|
||||
|
||||
info++, pos++;
|
||||
}
|
||||
|
||||
|
@ -1129,9 +1251,8 @@ fail:
|
|||
* AAT shaper
|
||||
*/
|
||||
|
||||
HB_SHAPER_DATA_ENSURE_DECLARE(coretext_aat, face)
|
||||
HB_SHAPER_DATA_ENSURE_DECLARE(coretext_aat, font)
|
||||
|
||||
HB_SHAPER_DATA_ENSURE_DEFINE(coretext_aat, face)
|
||||
HB_SHAPER_DATA_ENSURE_DEFINE(coretext_aat, font)
|
||||
|
||||
/*
|
||||
* shaper face data
|
||||
|
@ -1193,7 +1314,9 @@ struct hb_coretext_aat_shaper_shape_plan_data_t {};
|
|||
hb_coretext_aat_shaper_shape_plan_data_t *
|
||||
_hb_coretext_aat_shaper_shape_plan_data_create (hb_shape_plan_t *shape_plan HB_UNUSED,
|
||||
const hb_feature_t *user_features HB_UNUSED,
|
||||
unsigned int num_user_features HB_UNUSED)
|
||||
unsigned int num_user_features HB_UNUSED,
|
||||
const int *coords HB_UNUSED,
|
||||
unsigned int num_coords HB_UNUSED)
|
||||
{
|
||||
return (hb_coretext_aat_shaper_shape_plan_data_t *) HB_SHAPER_DATA_SUCCEEDED;
|
||||
}
|
||||
|
|
|
@ -44,14 +44,14 @@ HB_BEGIN_DECLS
|
|||
#define HB_CORETEXT_TAG_MORX HB_TAG('m','o','r','x')
|
||||
|
||||
|
||||
hb_face_t *
|
||||
HB_EXTERN hb_face_t *
|
||||
hb_coretext_face_create (CGFontRef cg_font);
|
||||
|
||||
|
||||
CGFontRef
|
||||
HB_EXTERN CGFontRef
|
||||
hb_coretext_face_get_cg_font (hb_face_t *face);
|
||||
|
||||
CTFontRef
|
||||
HB_EXTERN CTFontRef
|
||||
hb_coretext_font_get_ct_font (hb_font_t *font);
|
||||
|
||||
|
||||
|
|
|
@ -44,6 +44,16 @@ HB_BEGIN_DECLS
|
|||
#define HB_BUFFER_FLAGS_DEFAULT HB_BUFFER_FLAG_DEFAULT
|
||||
#define HB_BUFFER_SERIALIZE_FLAGS_DEFAULT HB_BUFFER_SERIALIZE_FLAG_DEFAULT
|
||||
|
||||
typedef hb_bool_t (*hb_font_get_glyph_func_t) (hb_font_t *font, void *font_data,
|
||||
hb_codepoint_t unicode, hb_codepoint_t variation_selector,
|
||||
hb_codepoint_t *glyph,
|
||||
void *user_data);
|
||||
|
||||
HB_EXTERN void
|
||||
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);
|
||||
|
||||
#endif
|
||||
|
||||
HB_END_DECLS
|
||||
|
|
|
@ -0,0 +1,936 @@
|
|||
/*
|
||||
* Copyright © 2015-2016 Ebrahim Byagowi
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#define HB_SHAPER directwrite
|
||||
#include "hb-shaper-impl-private.hh"
|
||||
|
||||
#include <DWrite_1.h>
|
||||
|
||||
#include "hb-directwrite.h"
|
||||
|
||||
|
||||
#ifndef HB_DEBUG_DIRECTWRITE
|
||||
#define HB_DEBUG_DIRECTWRITE (HB_DEBUG+0)
|
||||
#endif
|
||||
|
||||
HB_SHAPER_DATA_ENSURE_DEFINE(directwrite, face)
|
||||
HB_SHAPER_DATA_ENSURE_DEFINE(directwrite, font)
|
||||
|
||||
|
||||
/*
|
||||
* DirectWrite font stream helpers
|
||||
*/
|
||||
|
||||
// This is a font loader which provides only one font (unlike its original design).
|
||||
// For a better implementation which was also source of this
|
||||
// and DWriteFontFileStream, have a look at to NativeFontResourceDWrite.cpp in Mozilla
|
||||
class DWriteFontFileLoader : public IDWriteFontFileLoader
|
||||
{
|
||||
private:
|
||||
IDWriteFontFileStream *mFontFileStream;
|
||||
public:
|
||||
DWriteFontFileLoader (IDWriteFontFileStream *fontFileStream) {
|
||||
mFontFileStream = fontFileStream;
|
||||
}
|
||||
|
||||
// IUnknown interface
|
||||
IFACEMETHOD(QueryInterface)(IID const& iid, OUT void** ppObject) { return S_OK; }
|
||||
IFACEMETHOD_(ULONG, AddRef)() { return 1; }
|
||||
IFACEMETHOD_(ULONG, Release)() { return 1; }
|
||||
|
||||
// IDWriteFontFileLoader methods
|
||||
virtual HRESULT STDMETHODCALLTYPE CreateStreamFromKey(void const* fontFileReferenceKey,
|
||||
UINT32 fontFileReferenceKeySize,
|
||||
OUT IDWriteFontFileStream** fontFileStream)
|
||||
{
|
||||
*fontFileStream = mFontFileStream;
|
||||
return S_OK;
|
||||
}
|
||||
};
|
||||
|
||||
class DWriteFontFileStream : public IDWriteFontFileStream
|
||||
{
|
||||
private:
|
||||
uint8_t *mData;
|
||||
uint32_t mSize;
|
||||
public:
|
||||
DWriteFontFileStream(uint8_t *aData, uint32_t aSize)
|
||||
{
|
||||
mData = aData;
|
||||
mSize = aSize;
|
||||
}
|
||||
|
||||
// IUnknown interface
|
||||
IFACEMETHOD(QueryInterface)(IID const& iid, OUT void** ppObject) { return S_OK; }
|
||||
IFACEMETHOD_(ULONG, AddRef)() { return 1; }
|
||||
IFACEMETHOD_(ULONG, Release)() { return 1; }
|
||||
|
||||
// IDWriteFontFileStream methods
|
||||
virtual HRESULT STDMETHODCALLTYPE ReadFileFragment(void const** fragmentStart,
|
||||
UINT64 fileOffset,
|
||||
UINT64 fragmentSize,
|
||||
OUT void** fragmentContext)
|
||||
{
|
||||
// We are required to do bounds checking.
|
||||
if (fileOffset + fragmentSize > mSize) {
|
||||
return E_FAIL;
|
||||
}
|
||||
|
||||
// truncate the 64 bit fileOffset to size_t sized index into mData
|
||||
size_t index = static_cast<size_t> (fileOffset);
|
||||
|
||||
// We should be alive for the duration of this.
|
||||
*fragmentStart = &mData[index];
|
||||
*fragmentContext = nullptr;
|
||||
return S_OK;
|
||||
}
|
||||
|
||||
virtual void STDMETHODCALLTYPE ReleaseFileFragment(void* fragmentContext) { }
|
||||
|
||||
virtual HRESULT STDMETHODCALLTYPE GetFileSize(OUT UINT64* fileSize)
|
||||
{
|
||||
*fileSize = mSize;
|
||||
return S_OK;
|
||||
}
|
||||
|
||||
virtual HRESULT STDMETHODCALLTYPE GetLastWriteTime(OUT UINT64* lastWriteTime)
|
||||
{
|
||||
return E_NOTIMPL;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
/*
|
||||
* shaper face data
|
||||
*/
|
||||
|
||||
struct hb_directwrite_shaper_face_data_t {
|
||||
IDWriteFactory *dwriteFactory;
|
||||
IDWriteFontFile *fontFile;
|
||||
IDWriteFontFileStream *fontFileStream;
|
||||
IDWriteFontFileLoader *fontFileLoader;
|
||||
IDWriteFontFace *fontFace;
|
||||
hb_blob_t *faceBlob;
|
||||
};
|
||||
|
||||
hb_directwrite_shaper_face_data_t *
|
||||
_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;
|
||||
|
||||
// TODO: factory and fontFileLoader should be cached separately
|
||||
IDWriteFactory* dwriteFactory;
|
||||
DWriteCreateFactory (
|
||||
DWRITE_FACTORY_TYPE_SHARED,
|
||||
__uuidof (IDWriteFactory),
|
||||
(IUnknown**) &dwriteFactory
|
||||
);
|
||||
|
||||
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));
|
||||
|
||||
IDWriteFontFileLoader *fontFileLoader = new DWriteFontFileLoader (fontFileStream);
|
||||
dwriteFactory->RegisterFontFileLoader (fontFileLoader);
|
||||
|
||||
IDWriteFontFile *fontFile;
|
||||
uint64_t fontFileKey = 0;
|
||||
hr = dwriteFactory->CreateCustomFontFileReference (&fontFileKey, sizeof (fontFileKey),
|
||||
fontFileLoader, &fontFile);
|
||||
|
||||
#define FAIL(...) \
|
||||
HB_STMT_START { \
|
||||
DEBUG_MSG (DIRECTWRITE, NULL, __VA_ARGS__); \
|
||||
return false; \
|
||||
} HB_STMT_END;
|
||||
|
||||
if (FAILED (hr)) {
|
||||
FAIL ("Failed to load font file from data!");
|
||||
return false;
|
||||
}
|
||||
|
||||
BOOL isSupported;
|
||||
DWRITE_FONT_FILE_TYPE fileType;
|
||||
DWRITE_FONT_FACE_TYPE faceType;
|
||||
UINT32 numberOfFaces;
|
||||
hr = fontFile->Analyze (&isSupported, &fileType, &faceType, &numberOfFaces);
|
||||
if (FAILED (hr) || !isSupported) {
|
||||
FAIL ("Font file is not supported.");
|
||||
return false;
|
||||
}
|
||||
|
||||
#undef FAIL
|
||||
|
||||
IDWriteFontFace *fontFace;
|
||||
dwriteFactory->CreateFontFace (faceType, 1, &fontFile, 0,
|
||||
DWRITE_FONT_SIMULATIONS_NONE, &fontFace);
|
||||
|
||||
data->dwriteFactory = dwriteFactory;
|
||||
data->fontFile = fontFile;
|
||||
data->fontFileStream = fontFileStream;
|
||||
data->fontFileLoader = fontFileLoader;
|
||||
data->fontFace = fontFace;
|
||||
data->faceBlob = blob;
|
||||
|
||||
return data;
|
||||
}
|
||||
|
||||
void
|
||||
_hb_directwrite_shaper_face_data_destroy(hb_directwrite_shaper_face_data_t *data)
|
||||
{
|
||||
if (data->fontFace)
|
||||
data->fontFace->Release ();
|
||||
if (data->fontFile)
|
||||
data->fontFile->Release ();
|
||||
if (data->dwriteFactory) {
|
||||
if (data->fontFileLoader)
|
||||
data->dwriteFactory->UnregisterFontFileLoader (data->fontFileLoader);
|
||||
data->dwriteFactory->Release ();
|
||||
}
|
||||
if (data->fontFileLoader)
|
||||
delete data->fontFileLoader;
|
||||
if (data->fontFileStream)
|
||||
delete data->fontFileStream;
|
||||
if (data->faceBlob)
|
||||
hb_blob_destroy (data->faceBlob);
|
||||
if (data)
|
||||
free (data);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* shaper font data
|
||||
*/
|
||||
|
||||
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;
|
||||
|
||||
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 data;
|
||||
}
|
||||
|
||||
void
|
||||
_hb_directwrite_shaper_font_data_destroy (hb_directwrite_shaper_font_data_t *data)
|
||||
{
|
||||
free (data);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* shaper shape_plan data
|
||||
*/
|
||||
|
||||
struct hb_directwrite_shaper_shape_plan_data_t {};
|
||||
|
||||
hb_directwrite_shaper_shape_plan_data_t *
|
||||
_hb_directwrite_shaper_shape_plan_data_create (hb_shape_plan_t *shape_plan HB_UNUSED,
|
||||
const hb_feature_t *user_features HB_UNUSED,
|
||||
unsigned int num_user_features HB_UNUSED,
|
||||
const int *coords HB_UNUSED,
|
||||
unsigned int num_coords HB_UNUSED)
|
||||
{
|
||||
return (hb_directwrite_shaper_shape_plan_data_t *) HB_SHAPER_DATA_SUCCEEDED;
|
||||
}
|
||||
|
||||
void
|
||||
_hb_directwrite_shaper_shape_plan_data_destroy (hb_directwrite_shaper_shape_plan_data_t *data HB_UNUSED)
|
||||
{
|
||||
}
|
||||
|
||||
// Most of TextAnalysis is originally written by Bas Schouten for Mozilla project
|
||||
// but now is relicensed to MIT for HarfBuzz use
|
||||
class TextAnalysis
|
||||
: public IDWriteTextAnalysisSource, public IDWriteTextAnalysisSink
|
||||
{
|
||||
public:
|
||||
|
||||
IFACEMETHOD(QueryInterface)(IID const& iid, OUT void** ppObject) { return S_OK; }
|
||||
IFACEMETHOD_(ULONG, AddRef)() { return 1; }
|
||||
IFACEMETHOD_(ULONG, Release)() { return 1; }
|
||||
|
||||
// A single contiguous run of characters containing the same analysis
|
||||
// results.
|
||||
struct Run
|
||||
{
|
||||
uint32_t mTextStart; // starting text position of this run
|
||||
uint32_t mTextLength; // number of contiguous code units covered
|
||||
uint32_t mGlyphStart; // starting glyph in the glyphs array
|
||||
uint32_t mGlyphCount; // number of glyphs associated with this run of
|
||||
// text
|
||||
DWRITE_SCRIPT_ANALYSIS mScript;
|
||||
uint8_t mBidiLevel;
|
||||
bool mIsSideways;
|
||||
|
||||
inline bool ContainsTextPosition(uint32_t aTextPosition) const
|
||||
{
|
||||
return aTextPosition >= mTextStart
|
||||
&& aTextPosition < mTextStart + mTextLength;
|
||||
}
|
||||
|
||||
Run *nextRun;
|
||||
};
|
||||
|
||||
public:
|
||||
TextAnalysis(const wchar_t* text,
|
||||
uint32_t textLength,
|
||||
const wchar_t* localeName,
|
||||
DWRITE_READING_DIRECTION readingDirection)
|
||||
: mText(text)
|
||||
, mTextLength(textLength)
|
||||
, mLocaleName(localeName)
|
||||
, mReadingDirection(readingDirection)
|
||||
, mCurrentRun(NULL) { };
|
||||
|
||||
~TextAnalysis() {
|
||||
// delete runs, except mRunHead which is part of the TextAnalysis object
|
||||
for (Run *run = mRunHead.nextRun; run;) {
|
||||
Run *origRun = run;
|
||||
run = run->nextRun;
|
||||
free (origRun);
|
||||
}
|
||||
}
|
||||
|
||||
STDMETHODIMP GenerateResults(IDWriteTextAnalyzer* textAnalyzer,
|
||||
Run **runHead) {
|
||||
// Analyzes the text using the script analyzer and returns
|
||||
// the result as a series of runs.
|
||||
|
||||
HRESULT hr = S_OK;
|
||||
|
||||
// Initially start out with one result that covers the entire range.
|
||||
// This result will be subdivided by the analysis processes.
|
||||
mRunHead.mTextStart = 0;
|
||||
mRunHead.mTextLength = mTextLength;
|
||||
mRunHead.mBidiLevel =
|
||||
(mReadingDirection == DWRITE_READING_DIRECTION_RIGHT_TO_LEFT);
|
||||
mRunHead.nextRun = NULL;
|
||||
mCurrentRun = &mRunHead;
|
||||
|
||||
// Call each of the analyzers in sequence, recording their results.
|
||||
if (SUCCEEDED (hr = textAnalyzer->AnalyzeScript (this, 0, mTextLength, this))) {
|
||||
*runHead = &mRunHead;
|
||||
}
|
||||
|
||||
return hr;
|
||||
}
|
||||
|
||||
// IDWriteTextAnalysisSource implementation
|
||||
|
||||
IFACEMETHODIMP GetTextAtPosition(uint32_t textPosition,
|
||||
OUT wchar_t const** textString,
|
||||
OUT uint32_t* textLength)
|
||||
{
|
||||
if (textPosition >= mTextLength) {
|
||||
// No text at this position, valid query though.
|
||||
*textString = NULL;
|
||||
*textLength = 0;
|
||||
}
|
||||
else {
|
||||
*textString = mText + textPosition;
|
||||
*textLength = mTextLength - textPosition;
|
||||
}
|
||||
return S_OK;
|
||||
}
|
||||
|
||||
IFACEMETHODIMP GetTextBeforePosition(uint32_t textPosition,
|
||||
OUT wchar_t const** textString,
|
||||
OUT uint32_t* textLength)
|
||||
{
|
||||
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;
|
||||
*textLength = 0;
|
||||
}
|
||||
else {
|
||||
*textString = mText;
|
||||
*textLength = textPosition;
|
||||
}
|
||||
return S_OK;
|
||||
}
|
||||
|
||||
IFACEMETHODIMP_(DWRITE_READING_DIRECTION)
|
||||
GetParagraphReadingDirection() { return mReadingDirection; }
|
||||
|
||||
IFACEMETHODIMP GetLocaleName(uint32_t textPosition,
|
||||
uint32_t* textLength,
|
||||
wchar_t const** localeName)
|
||||
{
|
||||
return S_OK;
|
||||
}
|
||||
|
||||
IFACEMETHODIMP
|
||||
GetNumberSubstitution(uint32_t textPosition,
|
||||
OUT uint32_t* textLength,
|
||||
OUT IDWriteNumberSubstitution** numberSubstitution)
|
||||
{
|
||||
// We do not support number substitution.
|
||||
*numberSubstitution = NULL;
|
||||
*textLength = mTextLength - textPosition;
|
||||
|
||||
return S_OK;
|
||||
}
|
||||
|
||||
// IDWriteTextAnalysisSink implementation
|
||||
|
||||
IFACEMETHODIMP
|
||||
SetScriptAnalysis(uint32_t textPosition,
|
||||
uint32_t textLength,
|
||||
DWRITE_SCRIPT_ANALYSIS const* scriptAnalysis)
|
||||
{
|
||||
SetCurrentRun(textPosition);
|
||||
SplitCurrentRun(textPosition);
|
||||
while (textLength > 0)
|
||||
{
|
||||
Run *run = FetchNextRun(&textLength);
|
||||
run->mScript = *scriptAnalysis;
|
||||
}
|
||||
|
||||
return S_OK;
|
||||
}
|
||||
|
||||
IFACEMETHODIMP
|
||||
SetLineBreakpoints(uint32_t textPosition,
|
||||
uint32_t textLength,
|
||||
const DWRITE_LINE_BREAKPOINT* lineBreakpoints) { return S_OK; }
|
||||
|
||||
IFACEMETHODIMP SetBidiLevel(uint32_t textPosition,
|
||||
uint32_t textLength,
|
||||
uint8_t explicitLevel,
|
||||
uint8_t resolvedLevel) { return S_OK; }
|
||||
|
||||
IFACEMETHODIMP
|
||||
SetNumberSubstitution(uint32_t textPosition,
|
||||
uint32_t textLength,
|
||||
IDWriteNumberSubstitution* numberSubstitution) { return S_OK; }
|
||||
|
||||
protected:
|
||||
Run *FetchNextRun(IN OUT uint32_t* textLength)
|
||||
{
|
||||
// Used by the sink setters, this returns a reference to the next run.
|
||||
// Position and length are adjusted to now point after the current run
|
||||
// being returned.
|
||||
|
||||
Run *origRun = mCurrentRun;
|
||||
// Split the tail if needed (the length remaining is less than the
|
||||
// current run's size).
|
||||
if (*textLength < mCurrentRun->mTextLength)
|
||||
{
|
||||
SplitCurrentRun (mCurrentRun->mTextStart + *textLength);
|
||||
}
|
||||
else
|
||||
{
|
||||
// Just advance the current run.
|
||||
mCurrentRun = mCurrentRun->nextRun;
|
||||
}
|
||||
*textLength -= origRun->mTextLength;
|
||||
|
||||
// Return a reference to the run that was just current.
|
||||
return origRun;
|
||||
}
|
||||
|
||||
void SetCurrentRun(uint32_t textPosition)
|
||||
{
|
||||
// Move the current run to the given position.
|
||||
// Since the analyzers generally return results in a forward manner,
|
||||
// this will usually just return early. If not, find the
|
||||
// corresponding run for the text position.
|
||||
|
||||
if (mCurrentRun && mCurrentRun->ContainsTextPosition (textPosition))
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
for (Run *run = &mRunHead; run; run = run->nextRun) {
|
||||
if (run->ContainsTextPosition (textPosition))
|
||||
{
|
||||
mCurrentRun = run;
|
||||
return;
|
||||
}
|
||||
}
|
||||
//NS_NOTREACHED("We should always be able to find the text position in one \
|
||||
// of our runs");
|
||||
}
|
||||
|
||||
void SplitCurrentRun(uint32_t splitPosition)
|
||||
{
|
||||
if (!mCurrentRun)
|
||||
{
|
||||
//NS_ASSERTION(false, "SplitCurrentRun called without current run.");
|
||||
// Shouldn't be calling this when no current run is set!
|
||||
return;
|
||||
}
|
||||
// Split the current run.
|
||||
if (splitPosition <= mCurrentRun->mTextStart)
|
||||
{
|
||||
// No need to split, already the start of a run
|
||||
// or before it. Usually the first.
|
||||
return;
|
||||
}
|
||||
Run *newRun = (Run*) malloc (sizeof (Run));
|
||||
|
||||
*newRun = *mCurrentRun;
|
||||
|
||||
// Insert the new run in our linked list.
|
||||
newRun->nextRun = mCurrentRun->nextRun;
|
||||
mCurrentRun->nextRun = newRun;
|
||||
|
||||
// Adjust runs' text positions and lengths.
|
||||
uint32_t splitPoint = splitPosition - mCurrentRun->mTextStart;
|
||||
newRun->mTextStart += splitPoint;
|
||||
newRun->mTextLength -= splitPoint;
|
||||
mCurrentRun->mTextLength = splitPoint;
|
||||
mCurrentRun = newRun;
|
||||
}
|
||||
|
||||
protected:
|
||||
// Input
|
||||
// (weak references are fine here, since this class is a transient
|
||||
// stack-based helper that doesn't need to copy data)
|
||||
uint32_t mTextLength;
|
||||
const wchar_t* mText;
|
||||
const wchar_t* mLocaleName;
|
||||
DWRITE_READING_DIRECTION mReadingDirection;
|
||||
|
||||
// Current processing state.
|
||||
Run *mCurrentRun;
|
||||
|
||||
// Output is a list of runs starting here
|
||||
Run mRunHead;
|
||||
};
|
||||
|
||||
static inline uint16_t hb_uint16_swap (const uint16_t v)
|
||||
{ return (v >> 8) | (v << 8); }
|
||||
static inline uint32_t hb_uint32_swap (const uint32_t v)
|
||||
{ return (hb_uint16_swap(v) << 16) | hb_uint16_swap(v >> 16); }
|
||||
|
||||
/*
|
||||
* shaper
|
||||
*/
|
||||
|
||||
static hb_bool_t
|
||||
_hb_directwrite_shape_full(hb_shape_plan_t *shape_plan,
|
||||
hb_font_t *font,
|
||||
hb_buffer_t *buffer,
|
||||
const hb_feature_t *features,
|
||||
unsigned int num_features,
|
||||
float lineWidth)
|
||||
{
|
||||
hb_face_t *face = font->face;
|
||||
hb_directwrite_shaper_face_data_t *face_data = HB_SHAPER_DATA_GET (face);
|
||||
hb_directwrite_shaper_font_data_t *font_data = HB_SHAPER_DATA_GET (font);
|
||||
IDWriteFactory *dwriteFactory = face_data->dwriteFactory;
|
||||
IDWriteFontFace *fontFace = face_data->fontFace;
|
||||
|
||||
IDWriteTextAnalyzer* analyzer;
|
||||
dwriteFactory->CreateTextAnalyzer(&analyzer);
|
||||
|
||||
unsigned int scratch_size;
|
||||
hb_buffer_t::scratch_buffer_t *scratch = buffer->get_scratch_buffer (&scratch_size);
|
||||
#define ALLOCATE_ARRAY(Type, name, len) \
|
||||
Type *name = (Type *) scratch; \
|
||||
{ \
|
||||
unsigned int _consumed = DIV_CEIL ((len) * sizeof (Type), sizeof (*scratch)); \
|
||||
assert (_consumed <= scratch_size); \
|
||||
scratch += _consumed; \
|
||||
scratch_size -= _consumed; \
|
||||
}
|
||||
|
||||
#define utf16_index() var1.u32
|
||||
|
||||
ALLOCATE_ARRAY(wchar_t, textString, buffer->len * 2);
|
||||
|
||||
unsigned int chars_len = 0;
|
||||
for (unsigned int i = 0; i < buffer->len; i++)
|
||||
{
|
||||
hb_codepoint_t c = buffer->info[i].codepoint;
|
||||
buffer->info[i].utf16_index() = chars_len;
|
||||
if (likely(c <= 0xFFFFu))
|
||||
textString[chars_len++] = c;
|
||||
else if (unlikely(c > 0x10FFFFu))
|
||||
textString[chars_len++] = 0xFFFDu;
|
||||
else {
|
||||
textString[chars_len++] = 0xD800u + ((c - 0x10000u) >> 10);
|
||||
textString[chars_len++] = 0xDC00u + ((c - 0x10000u) & ((1u << 10) - 1));
|
||||
}
|
||||
}
|
||||
|
||||
ALLOCATE_ARRAY(WORD, log_clusters, chars_len);
|
||||
// if (num_features)
|
||||
{
|
||||
/* Need log_clusters to assign features. */
|
||||
chars_len = 0;
|
||||
for (unsigned int i = 0; i < buffer->len; i++)
|
||||
{
|
||||
hb_codepoint_t c = buffer->info[i].codepoint;
|
||||
unsigned int cluster = buffer->info[i].cluster;
|
||||
log_clusters[chars_len++] = cluster;
|
||||
if (hb_in_range(c, 0x10000u, 0x10FFFFu))
|
||||
log_clusters[chars_len++] = cluster; /* Surrogates. */
|
||||
}
|
||||
}
|
||||
|
||||
// TODO: Handle TEST_DISABLE_OPTIONAL_LIGATURES
|
||||
|
||||
DWRITE_READING_DIRECTION readingDirection = buffer->props.direction ?
|
||||
DWRITE_READING_DIRECTION_RIGHT_TO_LEFT :
|
||||
DWRITE_READING_DIRECTION_LEFT_TO_RIGHT;
|
||||
|
||||
/*
|
||||
* There's an internal 16-bit limit on some things inside the analyzer,
|
||||
* but we never attempt to shape a word longer than 64K characters
|
||||
* in a single gfxShapedWord, so we cannot exceed that limit.
|
||||
*/
|
||||
uint32_t textLength = buffer->len;
|
||||
|
||||
TextAnalysis analysis(textString, textLength, NULL, readingDirection);
|
||||
TextAnalysis::Run *runHead;
|
||||
HRESULT hr;
|
||||
hr = analysis.GenerateResults(analyzer, &runHead);
|
||||
|
||||
#define FAIL(...) \
|
||||
HB_STMT_START { \
|
||||
DEBUG_MSG (DIRECTWRITE, NULL, __VA_ARGS__); \
|
||||
return false; \
|
||||
} HB_STMT_END;
|
||||
|
||||
if (FAILED (hr))
|
||||
{
|
||||
FAIL ("Analyzer failed to generate results.");
|
||||
return false;
|
||||
}
|
||||
|
||||
uint32_t maxGlyphCount = 3 * textLength / 2 + 16;
|
||||
uint32_t glyphCount;
|
||||
bool isRightToLeft = HB_DIRECTION_IS_BACKWARD (buffer->props.direction);
|
||||
|
||||
const wchar_t localeName[20] = {0};
|
||||
if (buffer->props.language != NULL)
|
||||
{
|
||||
mbstowcs ((wchar_t*) localeName,
|
||||
hb_language_to_string (buffer->props.language), 20);
|
||||
}
|
||||
|
||||
DWRITE_TYPOGRAPHIC_FEATURES singleFeatures;
|
||||
singleFeatures.featureCount = num_features;
|
||||
if (num_features)
|
||||
{
|
||||
DWRITE_FONT_FEATURE* dwfeatureArray = (DWRITE_FONT_FEATURE*)
|
||||
malloc (sizeof (DWRITE_FONT_FEATURE) * num_features);
|
||||
for (unsigned int i = 0; i < num_features; ++i)
|
||||
{
|
||||
dwfeatureArray[i].nameTag = (DWRITE_FONT_FEATURE_TAG)
|
||||
hb_uint32_swap (features[i].tag);
|
||||
dwfeatureArray[i].parameter = features[i].value;
|
||||
}
|
||||
singleFeatures.features = dwfeatureArray;
|
||||
}
|
||||
const DWRITE_TYPOGRAPHIC_FEATURES* dwFeatures =
|
||||
(const DWRITE_TYPOGRAPHIC_FEATURES*) &singleFeatures;
|
||||
const uint32_t featureRangeLengths[] = { textLength };
|
||||
|
||||
uint16_t* clusterMap = (uint16_t*) malloc (textLength * sizeof (uint16_t));
|
||||
DWRITE_SHAPING_TEXT_PROPERTIES* textProperties = (DWRITE_SHAPING_TEXT_PROPERTIES*)
|
||||
malloc (textLength * sizeof (DWRITE_SHAPING_TEXT_PROPERTIES));
|
||||
retry_getglyphs:
|
||||
uint16_t* glyphIndices = (uint16_t*) malloc (maxGlyphCount * sizeof (uint16_t));
|
||||
DWRITE_SHAPING_GLYPH_PROPERTIES* glyphProperties = (DWRITE_SHAPING_GLYPH_PROPERTIES*)
|
||||
malloc (maxGlyphCount * sizeof (DWRITE_SHAPING_GLYPH_PROPERTIES));
|
||||
|
||||
hr = analyzer->GetGlyphs (textString, textLength, fontFace, false,
|
||||
isRightToLeft, &runHead->mScript, localeName, NULL, &dwFeatures,
|
||||
featureRangeLengths, 1, maxGlyphCount, clusterMap, textProperties, glyphIndices,
|
||||
glyphProperties, &glyphCount);
|
||||
|
||||
if (unlikely (hr == HRESULT_FROM_WIN32 (ERROR_INSUFFICIENT_BUFFER)))
|
||||
{
|
||||
free (glyphIndices);
|
||||
free (glyphProperties);
|
||||
|
||||
maxGlyphCount *= 2;
|
||||
|
||||
goto retry_getglyphs;
|
||||
}
|
||||
if (FAILED (hr))
|
||||
{
|
||||
FAIL ("Analyzer failed to get glyphs.");
|
||||
return false;
|
||||
}
|
||||
|
||||
float* glyphAdvances = (float*) malloc (maxGlyphCount * sizeof (float));
|
||||
DWRITE_GLYPH_OFFSET* glyphOffsets = (DWRITE_GLYPH_OFFSET*)
|
||||
malloc(maxGlyphCount * sizeof (DWRITE_GLYPH_OFFSET));
|
||||
|
||||
/* The -2 in the following is to compensate for possible
|
||||
* alignment needed after the WORD array. sizeof(WORD) == 2. */
|
||||
unsigned int glyphs_size = (scratch_size * sizeof(int) - 2)
|
||||
/ (sizeof(WORD) +
|
||||
sizeof(DWRITE_SHAPING_GLYPH_PROPERTIES) +
|
||||
sizeof(int) +
|
||||
sizeof(DWRITE_GLYPH_OFFSET) +
|
||||
sizeof(uint32_t));
|
||||
ALLOCATE_ARRAY (uint32_t, vis_clusters, glyphs_size);
|
||||
|
||||
#undef ALLOCATE_ARRAY
|
||||
|
||||
int fontEmSize = font->face->get_upem();
|
||||
if (fontEmSize < 0)
|
||||
fontEmSize = -fontEmSize;
|
||||
|
||||
if (fontEmSize < 0)
|
||||
fontEmSize = -fontEmSize;
|
||||
double x_mult = (double) font->x_scale / fontEmSize;
|
||||
double y_mult = (double) font->y_scale / fontEmSize;
|
||||
|
||||
hr = analyzer->GetGlyphPlacements (textString,
|
||||
clusterMap, textProperties, textLength, glyphIndices,
|
||||
glyphProperties, glyphCount, fontFace, fontEmSize,
|
||||
false, isRightToLeft, &runHead->mScript, localeName,
|
||||
&dwFeatures, featureRangeLengths, 1,
|
||||
glyphAdvances, glyphOffsets);
|
||||
|
||||
if (FAILED (hr))
|
||||
{
|
||||
FAIL ("Analyzer failed to get glyph placements.");
|
||||
return false;
|
||||
}
|
||||
|
||||
IDWriteTextAnalyzer1* analyzer1;
|
||||
analyzer->QueryInterface (&analyzer1);
|
||||
|
||||
if (analyzer1 && lineWidth)
|
||||
{
|
||||
|
||||
DWRITE_JUSTIFICATION_OPPORTUNITY* justificationOpportunities =
|
||||
(DWRITE_JUSTIFICATION_OPPORTUNITY*)
|
||||
malloc (maxGlyphCount * sizeof (DWRITE_JUSTIFICATION_OPPORTUNITY));
|
||||
hr = analyzer1->GetJustificationOpportunities (fontFace, fontEmSize,
|
||||
runHead->mScript, textLength, glyphCount, textString, clusterMap,
|
||||
glyphProperties, justificationOpportunities);
|
||||
|
||||
if (FAILED (hr))
|
||||
{
|
||||
FAIL ("Analyzer failed to get justification opportunities.");
|
||||
return false;
|
||||
}
|
||||
|
||||
float* justifiedGlyphAdvances =
|
||||
(float*) malloc (maxGlyphCount * sizeof (float));
|
||||
DWRITE_GLYPH_OFFSET* justifiedGlyphOffsets = (DWRITE_GLYPH_OFFSET*)
|
||||
malloc (glyphCount * sizeof (DWRITE_GLYPH_OFFSET));
|
||||
hr = analyzer1->JustifyGlyphAdvances (lineWidth, glyphCount, justificationOpportunities,
|
||||
glyphAdvances, glyphOffsets, justifiedGlyphAdvances, justifiedGlyphOffsets);
|
||||
|
||||
if (FAILED (hr))
|
||||
{
|
||||
FAIL("Analyzer failed to get justified glyph advances.");
|
||||
return false;
|
||||
}
|
||||
|
||||
DWRITE_SCRIPT_PROPERTIES scriptProperties;
|
||||
hr = analyzer1->GetScriptProperties (runHead->mScript, &scriptProperties);
|
||||
if (FAILED (hr))
|
||||
{
|
||||
FAIL("Analyzer failed to get script properties.");
|
||||
return false;
|
||||
}
|
||||
uint32_t justificationCharacter = scriptProperties.justificationCharacter;
|
||||
|
||||
// if a script justificationCharacter is not space, it can have GetJustifiedGlyphs
|
||||
if (justificationCharacter != 32)
|
||||
{
|
||||
uint16_t* modifiedClusterMap = (uint16_t*) malloc (textLength * sizeof (uint16_t));
|
||||
retry_getjustifiedglyphs:
|
||||
uint16_t* modifiedGlyphIndices = (uint16_t*) malloc (maxGlyphCount * sizeof (uint16_t));
|
||||
float* modifiedGlyphAdvances = (float*) malloc (maxGlyphCount * sizeof (float));
|
||||
DWRITE_GLYPH_OFFSET* modifiedGlyphOffsets = (DWRITE_GLYPH_OFFSET*)
|
||||
malloc (maxGlyphCount * sizeof (DWRITE_GLYPH_OFFSET));
|
||||
uint32_t actualGlyphsCount;
|
||||
hr = analyzer1->GetJustifiedGlyphs (fontFace, fontEmSize, runHead->mScript,
|
||||
textLength, glyphCount, maxGlyphCount, clusterMap, glyphIndices,
|
||||
glyphAdvances, justifiedGlyphAdvances, justifiedGlyphOffsets,
|
||||
glyphProperties, &actualGlyphsCount, modifiedClusterMap, modifiedGlyphIndices,
|
||||
modifiedGlyphAdvances, modifiedGlyphOffsets);
|
||||
|
||||
if (hr == HRESULT_FROM_WIN32 (ERROR_INSUFFICIENT_BUFFER))
|
||||
{
|
||||
maxGlyphCount = actualGlyphsCount;
|
||||
free (modifiedGlyphIndices);
|
||||
free (modifiedGlyphAdvances);
|
||||
free (modifiedGlyphOffsets);
|
||||
|
||||
maxGlyphCount = actualGlyphsCount;
|
||||
|
||||
goto retry_getjustifiedglyphs;
|
||||
}
|
||||
if (FAILED (hr))
|
||||
{
|
||||
FAIL ("Analyzer failed to get justified glyphs.");
|
||||
return false;
|
||||
}
|
||||
|
||||
free (clusterMap);
|
||||
free (glyphIndices);
|
||||
free (glyphAdvances);
|
||||
free (glyphOffsets);
|
||||
|
||||
glyphCount = actualGlyphsCount;
|
||||
clusterMap = modifiedClusterMap;
|
||||
glyphIndices = modifiedGlyphIndices;
|
||||
glyphAdvances = modifiedGlyphAdvances;
|
||||
glyphOffsets = modifiedGlyphOffsets;
|
||||
|
||||
free (justifiedGlyphAdvances);
|
||||
free (justifiedGlyphOffsets);
|
||||
}
|
||||
else
|
||||
{
|
||||
free (glyphAdvances);
|
||||
free (glyphOffsets);
|
||||
|
||||
glyphAdvances = justifiedGlyphAdvances;
|
||||
glyphOffsets = justifiedGlyphOffsets;
|
||||
}
|
||||
|
||||
free (justificationOpportunities);
|
||||
|
||||
}
|
||||
|
||||
/* Ok, we've got everything we need, now compose output buffer,
|
||||
* very, *very*, carefully! */
|
||||
|
||||
/* Calculate visual-clusters. That's what we ship. */
|
||||
for (unsigned int i = 0; i < glyphCount; i++)
|
||||
vis_clusters[i] = -1;
|
||||
for (unsigned int i = 0; i < buffer->len; i++)
|
||||
{
|
||||
uint32_t *p =
|
||||
&vis_clusters[log_clusters[buffer->info[i].utf16_index()]];
|
||||
*p = MIN (*p, buffer->info[i].cluster);
|
||||
}
|
||||
for (unsigned int i = 1; i < glyphCount; i++)
|
||||
if (vis_clusters[i] == -1)
|
||||
vis_clusters[i] = vis_clusters[i - 1];
|
||||
|
||||
#undef utf16_index
|
||||
|
||||
if (unlikely (!buffer->ensure (glyphCount)))
|
||||
FAIL ("Buffer in error");
|
||||
|
||||
#undef FAIL
|
||||
|
||||
/* Set glyph infos */
|
||||
buffer->len = 0;
|
||||
for (unsigned int i = 0; i < glyphCount; i++)
|
||||
{
|
||||
hb_glyph_info_t *info = &buffer->info[buffer->len++];
|
||||
|
||||
info->codepoint = glyphIndices[i];
|
||||
info->cluster = vis_clusters[i];
|
||||
|
||||
/* The rest is crap. Let's store position info there for now. */
|
||||
info->mask = glyphAdvances[i];
|
||||
info->var1.i32 = glyphOffsets[i].advanceOffset;
|
||||
info->var2.i32 = glyphOffsets[i].ascenderOffset;
|
||||
}
|
||||
|
||||
/* Set glyph positions */
|
||||
buffer->clear_positions ();
|
||||
for (unsigned int i = 0; i < glyphCount; i++)
|
||||
{
|
||||
hb_glyph_info_t *info = &buffer->info[i];
|
||||
hb_glyph_position_t *pos = &buffer->pos[i];
|
||||
|
||||
/* TODO vertical */
|
||||
pos->x_advance = x_mult * (int32_t) info->mask;
|
||||
pos->x_offset =
|
||||
x_mult * (isRightToLeft ? -info->var1.i32 : info->var1.i32);
|
||||
pos->y_offset = y_mult * info->var2.i32;
|
||||
|
||||
info->mask = HB_GLYPH_FLAG_UNSAFE_TO_BREAK;
|
||||
}
|
||||
|
||||
if (isRightToLeft)
|
||||
hb_buffer_reverse (buffer);
|
||||
|
||||
free (clusterMap);
|
||||
free (glyphIndices);
|
||||
free (textProperties);
|
||||
free (glyphProperties);
|
||||
free (glyphAdvances);
|
||||
free (glyphOffsets);
|
||||
|
||||
if (num_features)
|
||||
free (singleFeatures.features);
|
||||
|
||||
/* Wow, done! */
|
||||
return true;
|
||||
}
|
||||
|
||||
hb_bool_t
|
||||
_hb_directwrite_shape(hb_shape_plan_t *shape_plan,
|
||||
hb_font_t *font,
|
||||
hb_buffer_t *buffer,
|
||||
const hb_feature_t *features,
|
||||
unsigned int num_features)
|
||||
{
|
||||
return _hb_directwrite_shape_full(shape_plan, font, buffer,
|
||||
features, num_features, 0);
|
||||
}
|
||||
|
||||
/*
|
||||
* Public [experimental] API
|
||||
*/
|
||||
|
||||
hb_bool_t
|
||||
hb_directwrite_shape_experimental_width(hb_font_t *font,
|
||||
hb_buffer_t *buffer,
|
||||
const hb_feature_t *features,
|
||||
unsigned int num_features,
|
||||
float width)
|
||||
{
|
||||
static char *shapers = "directwrite";
|
||||
hb_shape_plan_t *shape_plan = hb_shape_plan_create_cached (font->face,
|
||||
&buffer->props, features, num_features, &shapers);
|
||||
hb_bool_t res = _hb_directwrite_shape_full (shape_plan, font, buffer,
|
||||
features, num_features, width);
|
||||
|
||||
if (res)
|
||||
buffer->content_type = HB_BUFFER_CONTENT_TYPE_GLYPHS;
|
||||
|
||||
return res;
|
||||
}
|
|
@ -0,0 +1,38 @@
|
|||
/*
|
||||
* Copyright © 2015 Ebrahim Byagowi
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#ifndef HB_DIRECTWRITE_H
|
||||
#define HB_DIRECTWRITE_H
|
||||
|
||||
#include "hb.h"
|
||||
|
||||
HB_BEGIN_DECLS
|
||||
|
||||
HB_EXTERN hb_bool_t
|
||||
hb_directwrite_shape_experimental_width(hb_font_t *font, hb_buffer_t *buffer,
|
||||
const hb_feature_t *features, unsigned int num_features, float width);
|
||||
|
||||
HB_END_DECLS
|
||||
|
||||
#endif /* HB_DIRECTWRITE_H */
|
|
@ -50,12 +50,23 @@ struct hb_face_t {
|
|||
void *user_data;
|
||||
hb_destroy_func_t destroy;
|
||||
|
||||
unsigned int index;
|
||||
mutable unsigned int upem;
|
||||
mutable unsigned int num_glyphs;
|
||||
unsigned int index; /* Face index in a collection, zero-based. */
|
||||
mutable unsigned int upem; /* Units-per-EM. */
|
||||
mutable unsigned int num_glyphs; /* Number of glyphs. */
|
||||
|
||||
struct hb_shaper_data_t shaper_data;
|
||||
enum dirty_t {
|
||||
DIRTY_NOTHING = 0x0000,
|
||||
DIRTY_INDEX = 0x0001,
|
||||
DIRTY_UPEM = 0x0002,
|
||||
DIRTY_NUM_GLYPHS = 0x0004,
|
||||
} dirty;
|
||||
|
||||
struct hb_shaper_data_t shaper_data; /* Various shaper data. */
|
||||
|
||||
/* Various non-shaping data. */
|
||||
/* ... */
|
||||
|
||||
/* Cache */
|
||||
struct plan_node_t {
|
||||
hb_shape_plan_t *shape_plan;
|
||||
plan_node_t *next;
|
||||
|
@ -95,6 +106,8 @@ struct hb_face_t {
|
|||
HB_INTERNAL void load_num_glyphs (void) const;
|
||||
};
|
||||
|
||||
HB_MARK_AS_FLAG_T (hb_face_t::dirty_t);
|
||||
|
||||
extern HB_INTERNAL const hb_face_t _hb_face_nil;
|
||||
|
||||
#define HB_SHAPER_DATA_CREATE_FUNC_EXTRA_ARGS
|
||||
|
|
|
@ -28,17 +28,11 @@
|
|||
|
||||
#include "hb-private.hh"
|
||||
|
||||
#include "hb-ot-layout-private.hh"
|
||||
|
||||
#include "hb-font-private.hh"
|
||||
#include "hb-face-private.hh"
|
||||
#include "hb-open-file-private.hh"
|
||||
#include "hb-ot-head-table.hh"
|
||||
#include "hb-ot-maxp-table.hh"
|
||||
|
||||
#include "hb-cache-private.hh"
|
||||
|
||||
#include <string.h>
|
||||
|
||||
|
||||
/*
|
||||
* hb_face_t
|
||||
|
@ -57,6 +51,8 @@ const hb_face_t _hb_face_nil = {
|
|||
1000, /* upem */
|
||||
0, /* num_glyphs */
|
||||
|
||||
hb_face_t::DIRTY_NOTHING, /* dirty */
|
||||
|
||||
{
|
||||
#define HB_SHAPER_IMPLEMENT(shaper) HB_SHAPER_DATA_INVALID,
|
||||
#include "hb-shaper-list.hh"
|
||||
|
@ -177,7 +173,7 @@ hb_face_create (hb_blob_t *blob,
|
|||
closure,
|
||||
(hb_destroy_func_t) _hb_face_for_data_closure_destroy);
|
||||
|
||||
hb_face_set_index (face, index);
|
||||
face->index = index;
|
||||
|
||||
return face;
|
||||
}
|
||||
|
@ -371,6 +367,11 @@ hb_face_set_index (hb_face_t *face,
|
|||
if (face->immutable)
|
||||
return;
|
||||
|
||||
if (face->index == index)
|
||||
return;
|
||||
|
||||
face->dirty |= face->DIRTY_INDEX;
|
||||
|
||||
face->index = index;
|
||||
}
|
||||
|
||||
|
@ -406,6 +407,11 @@ hb_face_set_upem (hb_face_t *face,
|
|||
if (face->immutable)
|
||||
return;
|
||||
|
||||
if (face->upem == upem)
|
||||
return;
|
||||
|
||||
face->dirty |= face->DIRTY_UPEM;
|
||||
|
||||
face->upem = upem;
|
||||
}
|
||||
|
||||
|
@ -450,6 +456,11 @@ hb_face_set_glyph_count (hb_face_t *face,
|
|||
if (face->immutable)
|
||||
return;
|
||||
|
||||
if (face->num_glyphs == glyph_count)
|
||||
return;
|
||||
|
||||
face->dirty |= face->DIRTY_NUM_GLYPHS;
|
||||
|
||||
face->num_glyphs = glyph_count;
|
||||
}
|
||||
|
||||
|
|
|
@ -43,28 +43,28 @@ HB_BEGIN_DECLS
|
|||
|
||||
typedef struct hb_face_t hb_face_t;
|
||||
|
||||
hb_face_t *
|
||||
HB_EXTERN hb_face_t *
|
||||
hb_face_create (hb_blob_t *blob,
|
||||
unsigned int index);
|
||||
|
||||
typedef hb_blob_t * (*hb_reference_table_func_t) (hb_face_t *face, hb_tag_t tag, void *user_data);
|
||||
|
||||
/* calls destroy() when not needing user_data anymore */
|
||||
hb_face_t *
|
||||
HB_EXTERN hb_face_t *
|
||||
hb_face_create_for_tables (hb_reference_table_func_t reference_table_func,
|
||||
void *user_data,
|
||||
hb_destroy_func_t destroy);
|
||||
|
||||
hb_face_t *
|
||||
HB_EXTERN hb_face_t *
|
||||
hb_face_get_empty (void);
|
||||
|
||||
hb_face_t *
|
||||
HB_EXTERN hb_face_t *
|
||||
hb_face_reference (hb_face_t *face);
|
||||
|
||||
void
|
||||
HB_EXTERN void
|
||||
hb_face_destroy (hb_face_t *face);
|
||||
|
||||
hb_bool_t
|
||||
HB_EXTERN hb_bool_t
|
||||
hb_face_set_user_data (hb_face_t *face,
|
||||
hb_user_data_key_t *key,
|
||||
void * data,
|
||||
|
@ -72,43 +72,43 @@ hb_face_set_user_data (hb_face_t *face,
|
|||
hb_bool_t replace);
|
||||
|
||||
|
||||
void *
|
||||
HB_EXTERN void *
|
||||
hb_face_get_user_data (hb_face_t *face,
|
||||
hb_user_data_key_t *key);
|
||||
|
||||
void
|
||||
HB_EXTERN void
|
||||
hb_face_make_immutable (hb_face_t *face);
|
||||
|
||||
hb_bool_t
|
||||
HB_EXTERN hb_bool_t
|
||||
hb_face_is_immutable (hb_face_t *face);
|
||||
|
||||
|
||||
hb_blob_t *
|
||||
HB_EXTERN hb_blob_t *
|
||||
hb_face_reference_table (hb_face_t *face,
|
||||
hb_tag_t tag);
|
||||
|
||||
hb_blob_t *
|
||||
HB_EXTERN hb_blob_t *
|
||||
hb_face_reference_blob (hb_face_t *face);
|
||||
|
||||
void
|
||||
HB_EXTERN void
|
||||
hb_face_set_index (hb_face_t *face,
|
||||
unsigned int index);
|
||||
|
||||
unsigned int
|
||||
HB_EXTERN unsigned int
|
||||
hb_face_get_index (hb_face_t *face);
|
||||
|
||||
void
|
||||
HB_EXTERN void
|
||||
hb_face_set_upem (hb_face_t *face,
|
||||
unsigned int upem);
|
||||
|
||||
unsigned int
|
||||
HB_EXTERN unsigned int
|
||||
hb_face_get_upem (hb_face_t *face);
|
||||
|
||||
void
|
||||
HB_EXTERN void
|
||||
hb_face_set_glyph_count (hb_face_t *face,
|
||||
unsigned int glyph_count);
|
||||
|
||||
unsigned int
|
||||
HB_EXTERN unsigned int
|
||||
hb_face_get_glyph_count (hb_face_t *face);
|
||||
|
||||
|
||||
|
|
|
@ -28,6 +28,10 @@
|
|||
#include "hb-shaper-impl-private.hh"
|
||||
|
||||
|
||||
HB_SHAPER_DATA_ENSURE_DEFINE(fallback, face)
|
||||
HB_SHAPER_DATA_ENSURE_DEFINE(fallback, font)
|
||||
|
||||
|
||||
/*
|
||||
* shaper face data
|
||||
*/
|
||||
|
@ -73,7 +77,9 @@ struct hb_fallback_shaper_shape_plan_data_t {};
|
|||
hb_fallback_shaper_shape_plan_data_t *
|
||||
_hb_fallback_shaper_shape_plan_data_create (hb_shape_plan_t *shape_plan HB_UNUSED,
|
||||
const hb_feature_t *user_features HB_UNUSED,
|
||||
unsigned int num_user_features HB_UNUSED)
|
||||
unsigned int num_user_features HB_UNUSED,
|
||||
const int *coords HB_UNUSED,
|
||||
unsigned int num_coords HB_UNUSED)
|
||||
{
|
||||
return (hb_fallback_shaper_shape_plan_data_t *) HB_SHAPER_DATA_SUCCEEDED;
|
||||
}
|
||||
|
@ -106,7 +112,7 @@ _hb_fallback_shape (hb_shape_plan_t *shape_plan HB_UNUSED,
|
|||
*/
|
||||
|
||||
hb_codepoint_t space;
|
||||
bool has_space = font->get_glyph (' ', 0, &space);
|
||||
bool has_space = (bool) font->get_nominal_glyph (' ', &space);
|
||||
|
||||
buffer->clear_positions ();
|
||||
|
||||
|
@ -123,7 +129,7 @@ _hb_fallback_shape (hb_shape_plan_t *shape_plan HB_UNUSED,
|
|||
pos[i].y_advance = 0;
|
||||
continue;
|
||||
}
|
||||
font->get_glyph (info[i].codepoint, 0, &info[i].codepoint);
|
||||
(void) font->get_nominal_glyph (info[i].codepoint, &info[i].codepoint);
|
||||
font->get_glyph_advance_for_direction (info[i].codepoint,
|
||||
direction,
|
||||
&pos[i].x_advance,
|
||||
|
|
|
@ -42,7 +42,10 @@
|
|||
*/
|
||||
|
||||
#define HB_FONT_FUNCS_IMPLEMENT_CALLBACKS \
|
||||
HB_FONT_FUNC_IMPLEMENT (glyph) \
|
||||
HB_FONT_FUNC_IMPLEMENT (font_h_extents) \
|
||||
HB_FONT_FUNC_IMPLEMENT (font_v_extents) \
|
||||
HB_FONT_FUNC_IMPLEMENT (nominal_glyph) \
|
||||
HB_FONT_FUNC_IMPLEMENT (variation_glyph) \
|
||||
HB_FONT_FUNC_IMPLEMENT (glyph_h_advance) \
|
||||
HB_FONT_FUNC_IMPLEMENT (glyph_v_advance) \
|
||||
HB_FONT_FUNC_IMPLEMENT (glyph_h_origin) \
|
||||
|
@ -105,16 +108,36 @@ struct hb_font_t {
|
|||
unsigned int x_ppem;
|
||||
unsigned int y_ppem;
|
||||
|
||||
/* Font variation coordinates. */
|
||||
unsigned int num_coords;
|
||||
int *coords;
|
||||
|
||||
hb_font_funcs_t *klass;
|
||||
void *user_data;
|
||||
hb_destroy_func_t destroy;
|
||||
|
||||
enum dirty_t {
|
||||
DIRTY_NOTHING = 0x0000,
|
||||
DIRTY_FACE = 0x0001,
|
||||
DIRTY_PARENT = 0x0002,
|
||||
DIRTY_FUNCS = 0x0004,
|
||||
DIRTY_SCALE = 0x0008,
|
||||
DIRTY_PPEM = 0x0010,
|
||||
DIRTY_VARIATIONS = 0x0020,
|
||||
} dirty;
|
||||
|
||||
struct hb_shaper_data_t shaper_data;
|
||||
|
||||
|
||||
/* Convert from font-space to user-space */
|
||||
inline hb_position_t em_scale_x (int16_t v) { return em_scale (v, this->x_scale); }
|
||||
inline hb_position_t em_scale_y (int16_t v) { return em_scale (v, this->y_scale); }
|
||||
inline int dir_scale (hb_direction_t direction)
|
||||
{ return HB_DIRECTION_IS_VERTICAL(direction) ? y_scale : x_scale; }
|
||||
inline hb_position_t em_scale_x (int16_t v) { return em_scale (v, x_scale); }
|
||||
inline hb_position_t em_scale_y (int16_t v) { return em_scale (v, y_scale); }
|
||||
inline hb_position_t em_scalef_x (float v) { return em_scalef (v, this->x_scale); }
|
||||
inline hb_position_t em_scalef_y (float v) { return em_scalef (v, this->y_scale); }
|
||||
inline hb_position_t em_scale_dir (int16_t v, hb_direction_t direction)
|
||||
{ return em_scale (v, dir_scale (direction)); }
|
||||
|
||||
/* Convert from parent-font user-space to our user-space */
|
||||
inline hb_position_t parent_scale_x_distance (hb_position_t v) {
|
||||
|
@ -160,19 +183,43 @@ struct hb_font_t {
|
|||
HB_FONT_FUNCS_IMPLEMENT_CALLBACKS
|
||||
#undef HB_FONT_FUNC_IMPLEMENT
|
||||
|
||||
inline hb_bool_t has_glyph (hb_codepoint_t unicode)
|
||||
inline hb_bool_t get_font_h_extents (hb_font_extents_t *extents)
|
||||
{
|
||||
hb_codepoint_t glyph;
|
||||
return get_glyph (unicode, 0, &glyph);
|
||||
memset (extents, 0, sizeof (*extents));
|
||||
return klass->get.f.font_h_extents (this, user_data,
|
||||
extents,
|
||||
klass->user_data.font_h_extents);
|
||||
}
|
||||
inline hb_bool_t get_font_v_extents (hb_font_extents_t *extents)
|
||||
{
|
||||
memset (extents, 0, sizeof (*extents));
|
||||
return klass->get.f.font_v_extents (this, user_data,
|
||||
extents,
|
||||
klass->user_data.font_v_extents);
|
||||
}
|
||||
|
||||
inline hb_bool_t get_glyph (hb_codepoint_t unicode, hb_codepoint_t variation_selector,
|
||||
hb_codepoint_t *glyph)
|
||||
inline bool has_glyph (hb_codepoint_t unicode)
|
||||
{
|
||||
hb_codepoint_t glyph;
|
||||
return get_nominal_glyph (unicode, &glyph);
|
||||
}
|
||||
|
||||
inline hb_bool_t get_nominal_glyph (hb_codepoint_t unicode,
|
||||
hb_codepoint_t *glyph)
|
||||
{
|
||||
*glyph = 0;
|
||||
return klass->get.f.glyph (this, user_data,
|
||||
unicode, variation_selector, glyph,
|
||||
klass->user_data.glyph);
|
||||
return klass->get.f.nominal_glyph (this, user_data,
|
||||
unicode, glyph,
|
||||
klass->user_data.nominal_glyph);
|
||||
}
|
||||
|
||||
inline hb_bool_t get_variation_glyph (hb_codepoint_t unicode, hb_codepoint_t variation_selector,
|
||||
hb_codepoint_t *glyph)
|
||||
{
|
||||
*glyph = 0;
|
||||
return klass->get.f.variation_glyph (this, user_data,
|
||||
unicode, variation_selector, glyph,
|
||||
klass->user_data.variation_glyph);
|
||||
}
|
||||
|
||||
inline hb_position_t get_glyph_h_advance (hb_codepoint_t glyph)
|
||||
|
@ -265,6 +312,34 @@ struct hb_font_t {
|
|||
|
||||
/* A bit higher-level, and with fallback */
|
||||
|
||||
inline void get_h_extents_with_fallback (hb_font_extents_t *extents)
|
||||
{
|
||||
if (!get_font_h_extents (extents))
|
||||
{
|
||||
extents->ascender = y_scale * .8;
|
||||
extents->descender = extents->ascender - y_scale;
|
||||
extents->line_gap = 0;
|
||||
}
|
||||
}
|
||||
inline void get_v_extents_with_fallback (hb_font_extents_t *extents)
|
||||
{
|
||||
if (!get_font_v_extents (extents))
|
||||
{
|
||||
extents->ascender = x_scale / 2;
|
||||
extents->descender = extents->ascender - x_scale;
|
||||
extents->line_gap = 0;
|
||||
}
|
||||
}
|
||||
|
||||
inline void get_extents_for_direction (hb_direction_t direction,
|
||||
hb_font_extents_t *extents)
|
||||
{
|
||||
if (likely (HB_DIRECTION_IS_HORIZONTAL (direction)))
|
||||
get_h_extents_with_fallback (extents);
|
||||
else
|
||||
get_v_extents_with_fallback (extents);
|
||||
}
|
||||
|
||||
inline void get_glyph_advance_for_direction (hb_codepoint_t glyph,
|
||||
hb_direction_t direction,
|
||||
hb_position_t *x, hb_position_t *y)
|
||||
|
@ -278,14 +353,38 @@ struct hb_font_t {
|
|||
}
|
||||
}
|
||||
|
||||
/* Internal only */
|
||||
inline void guess_v_origin_minus_h_origin (hb_codepoint_t glyph,
|
||||
hb_position_t *x, hb_position_t *y)
|
||||
{
|
||||
*x = get_glyph_h_advance (glyph) / 2;
|
||||
|
||||
/* TODO use font_metrics.ascent */
|
||||
*y = y_scale;
|
||||
/* TODO cache this somehow?! */
|
||||
hb_font_extents_t extents;
|
||||
get_h_extents_with_fallback (&extents);
|
||||
*y = extents.ascender;
|
||||
}
|
||||
|
||||
inline void get_glyph_h_origin_with_fallback (hb_codepoint_t glyph,
|
||||
hb_position_t *x, hb_position_t *y)
|
||||
{
|
||||
if (!get_glyph_h_origin (glyph, x, y) &&
|
||||
get_glyph_v_origin (glyph, x, y))
|
||||
{
|
||||
hb_position_t dx, dy;
|
||||
guess_v_origin_minus_h_origin (glyph, &dx, &dy);
|
||||
*x -= dx; *y -= dy;
|
||||
}
|
||||
}
|
||||
inline void get_glyph_v_origin_with_fallback (hb_codepoint_t glyph,
|
||||
hb_position_t *x, hb_position_t *y)
|
||||
{
|
||||
if (!get_glyph_v_origin (glyph, x, y) &&
|
||||
get_glyph_h_origin (glyph, x, y))
|
||||
{
|
||||
hb_position_t dx, dy;
|
||||
guess_v_origin_minus_h_origin (glyph, &dx, &dy);
|
||||
*x += dx; *y += dy;
|
||||
}
|
||||
}
|
||||
|
||||
inline void get_glyph_origin_for_direction (hb_codepoint_t glyph,
|
||||
|
@ -293,25 +392,9 @@ struct hb_font_t {
|
|||
hb_position_t *x, hb_position_t *y)
|
||||
{
|
||||
if (likely (HB_DIRECTION_IS_HORIZONTAL (direction)))
|
||||
{
|
||||
if (!get_glyph_h_origin (glyph, x, y) &&
|
||||
get_glyph_v_origin (glyph, x, y))
|
||||
{
|
||||
hb_position_t dx, dy;
|
||||
guess_v_origin_minus_h_origin (glyph, &dx, &dy);
|
||||
*x -= dx; *y -= dy;
|
||||
}
|
||||
}
|
||||
get_glyph_h_origin_with_fallback (glyph, x, y);
|
||||
else
|
||||
{
|
||||
if (!get_glyph_v_origin (glyph, x, y) &&
|
||||
get_glyph_h_origin (glyph, x, y))
|
||||
{
|
||||
hb_position_t dx, dy;
|
||||
guess_v_origin_minus_h_origin (glyph, &dx, &dy);
|
||||
*x += dx; *y += dy;
|
||||
}
|
||||
}
|
||||
get_glyph_v_origin_with_fallback (glyph, x, y);
|
||||
}
|
||||
|
||||
inline void add_glyph_h_origin (hb_codepoint_t glyph,
|
||||
|
@ -319,7 +402,7 @@ struct hb_font_t {
|
|||
{
|
||||
hb_position_t origin_x, origin_y;
|
||||
|
||||
get_glyph_h_origin (glyph, &origin_x, &origin_y);
|
||||
get_glyph_h_origin_with_fallback (glyph, &origin_x, &origin_y);
|
||||
|
||||
*x += origin_x;
|
||||
*y += origin_y;
|
||||
|
@ -329,7 +412,7 @@ struct hb_font_t {
|
|||
{
|
||||
hb_position_t origin_x, origin_y;
|
||||
|
||||
get_glyph_v_origin (glyph, &origin_x, &origin_y);
|
||||
get_glyph_v_origin_with_fallback (glyph, &origin_x, &origin_y);
|
||||
|
||||
*x += origin_x;
|
||||
*y += origin_y;
|
||||
|
@ -351,7 +434,7 @@ struct hb_font_t {
|
|||
{
|
||||
hb_position_t origin_x, origin_y;
|
||||
|
||||
get_glyph_h_origin (glyph, &origin_x, &origin_y);
|
||||
get_glyph_h_origin_with_fallback (glyph, &origin_x, &origin_y);
|
||||
|
||||
*x -= origin_x;
|
||||
*y -= origin_y;
|
||||
|
@ -361,7 +444,7 @@ struct hb_font_t {
|
|||
{
|
||||
hb_position_t origin_x, origin_y;
|
||||
|
||||
get_glyph_v_origin (glyph, &origin_x, &origin_y);
|
||||
get_glyph_v_origin_with_fallback (glyph, &origin_x, &origin_y);
|
||||
|
||||
*x -= origin_x;
|
||||
*y -= origin_y;
|
||||
|
@ -450,17 +533,28 @@ struct hb_font_t {
|
|||
hb_codepoint_t unichar;
|
||||
if (0 == strncmp (s, "uni", 3) &&
|
||||
hb_codepoint_parse (s + 3, len - 3, 16, &unichar) &&
|
||||
get_glyph (unichar, 0, glyph))
|
||||
get_nominal_glyph (unichar, glyph))
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
private:
|
||||
inline hb_position_t em_scale (int16_t v, int scale) { return (hb_position_t) (v * (int64_t) scale / face->get_upem ()); }
|
||||
inline hb_position_t em_scale (int16_t v, int scale)
|
||||
{
|
||||
int upem = face->get_upem ();
|
||||
int64_t scaled = v * (int64_t) scale;
|
||||
scaled += scaled >= 0 ? upem/2 : -upem/2; /* Round. */
|
||||
return (hb_position_t) (scaled / upem);
|
||||
}
|
||||
inline hb_position_t em_scalef (float v, int scale)
|
||||
{
|
||||
return (hb_position_t) (v * scale / face->get_upem ());
|
||||
}
|
||||
};
|
||||
|
||||
HB_MARK_AS_FLAG_T (hb_font_t::dirty_t);
|
||||
|
||||
#define HB_SHAPER_DATA_CREATE_FUNC_EXTRA_ARGS
|
||||
#define HB_SHAPER_IMPLEMENT(shaper) HB_SHAPER_DATA_PROTOTYPE(shaper, font);
|
||||
#include "hb-shaper-list.hh"
|
||||
|
|
|
@ -28,16 +28,7 @@
|
|||
|
||||
#include "hb-private.hh"
|
||||
|
||||
#include "hb-ot-layout-private.hh"
|
||||
|
||||
#include "hb-font-private.hh"
|
||||
#include "hb-open-file-private.hh"
|
||||
#include "hb-ot-head-table.hh"
|
||||
#include "hb-ot-maxp-table.hh"
|
||||
|
||||
#include "hb-cache-private.hh"
|
||||
|
||||
#include <string.h>
|
||||
|
||||
|
||||
/*
|
||||
|
@ -45,27 +36,96 @@
|
|||
*/
|
||||
|
||||
static hb_bool_t
|
||||
hb_font_get_glyph_nil (hb_font_t *font HB_UNUSED,
|
||||
void *font_data HB_UNUSED,
|
||||
hb_codepoint_t unicode,
|
||||
hb_codepoint_t variation_selector,
|
||||
hb_codepoint_t *glyph,
|
||||
void *user_data HB_UNUSED)
|
||||
hb_font_get_font_h_extents_nil (hb_font_t *font,
|
||||
void *font_data HB_UNUSED,
|
||||
hb_font_extents_t *metrics,
|
||||
void *user_data HB_UNUSED)
|
||||
{
|
||||
memset (metrics, 0, sizeof (*metrics));
|
||||
return false;
|
||||
}
|
||||
static hb_bool_t
|
||||
hb_font_get_font_h_extents_parent (hb_font_t *font,
|
||||
void *font_data HB_UNUSED,
|
||||
hb_font_extents_t *metrics,
|
||||
void *user_data HB_UNUSED)
|
||||
{
|
||||
hb_bool_t ret = font->parent->get_font_h_extents (metrics);
|
||||
if (ret) {
|
||||
metrics->ascender = font->parent_scale_y_distance (metrics->ascender);
|
||||
metrics->descender = font->parent_scale_y_distance (metrics->descender);
|
||||
metrics->line_gap = font->parent_scale_y_distance (metrics->line_gap);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
static hb_bool_t
|
||||
hb_font_get_font_v_extents_nil (hb_font_t *font,
|
||||
void *font_data HB_UNUSED,
|
||||
hb_font_extents_t *metrics,
|
||||
void *user_data HB_UNUSED)
|
||||
{
|
||||
memset (metrics, 0, sizeof (*metrics));
|
||||
return false;
|
||||
}
|
||||
static hb_bool_t
|
||||
hb_font_get_font_v_extents_parent (hb_font_t *font,
|
||||
void *font_data HB_UNUSED,
|
||||
hb_font_extents_t *metrics,
|
||||
void *user_data HB_UNUSED)
|
||||
{
|
||||
hb_bool_t ret = font->parent->get_font_v_extents (metrics);
|
||||
if (ret) {
|
||||
metrics->ascender = font->parent_scale_x_distance (metrics->ascender);
|
||||
metrics->descender = font->parent_scale_x_distance (metrics->descender);
|
||||
metrics->line_gap = font->parent_scale_x_distance (metrics->line_gap);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
static hb_bool_t
|
||||
hb_font_get_nominal_glyph_nil (hb_font_t *font HB_UNUSED,
|
||||
void *font_data HB_UNUSED,
|
||||
hb_codepoint_t unicode,
|
||||
hb_codepoint_t *glyph,
|
||||
void *user_data HB_UNUSED)
|
||||
{
|
||||
*glyph = 0;
|
||||
return false;
|
||||
}
|
||||
static hb_bool_t
|
||||
hb_font_get_glyph_parent (hb_font_t *font,
|
||||
void *font_data HB_UNUSED,
|
||||
hb_codepoint_t unicode,
|
||||
hb_codepoint_t variation_selector,
|
||||
hb_codepoint_t *glyph,
|
||||
void *user_data HB_UNUSED)
|
||||
hb_font_get_nominal_glyph_parent (hb_font_t *font,
|
||||
void *font_data HB_UNUSED,
|
||||
hb_codepoint_t unicode,
|
||||
hb_codepoint_t *glyph,
|
||||
void *user_data HB_UNUSED)
|
||||
{
|
||||
return font->parent->get_glyph (unicode, variation_selector, glyph);
|
||||
return font->parent->get_nominal_glyph (unicode, glyph);
|
||||
}
|
||||
|
||||
static hb_bool_t
|
||||
hb_font_get_variation_glyph_nil (hb_font_t *font HB_UNUSED,
|
||||
void *font_data HB_UNUSED,
|
||||
hb_codepoint_t unicode,
|
||||
hb_codepoint_t variation_selector,
|
||||
hb_codepoint_t *glyph,
|
||||
void *user_data HB_UNUSED)
|
||||
{
|
||||
*glyph = 0;
|
||||
return false;
|
||||
}
|
||||
static hb_bool_t
|
||||
hb_font_get_variation_glyph_parent (hb_font_t *font,
|
||||
void *font_data HB_UNUSED,
|
||||
hb_codepoint_t unicode,
|
||||
hb_codepoint_t variation_selector,
|
||||
hb_codepoint_t *glyph,
|
||||
void *user_data HB_UNUSED)
|
||||
{
|
||||
return font->parent->get_variation_glyph (unicode, variation_selector, glyph);
|
||||
}
|
||||
|
||||
|
||||
static hb_position_t
|
||||
hb_font_get_glyph_h_advance_nil (hb_font_t *font HB_UNUSED,
|
||||
void *font_data HB_UNUSED,
|
||||
|
@ -89,6 +149,7 @@ hb_font_get_glyph_v_advance_nil (hb_font_t *font HB_UNUSED,
|
|||
hb_codepoint_t glyph,
|
||||
void *user_data HB_UNUSED)
|
||||
{
|
||||
/* TODO use font_extents.ascender+descender */
|
||||
return font->y_scale;
|
||||
}
|
||||
static hb_position_t
|
||||
|
@ -109,7 +170,7 @@ hb_font_get_glyph_h_origin_nil (hb_font_t *font HB_UNUSED,
|
|||
void *user_data HB_UNUSED)
|
||||
{
|
||||
*x = *y = 0;
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
static hb_bool_t
|
||||
hb_font_get_glyph_h_origin_parent (hb_font_t *font,
|
||||
|
@ -280,7 +341,6 @@ hb_font_get_glyph_from_name_parent (hb_font_t *font,
|
|||
return font->parent->get_glyph_from_name (name, len, glyph);
|
||||
}
|
||||
|
||||
|
||||
static const hb_font_funcs_t _hb_font_funcs_nil = {
|
||||
HB_OBJECT_HEADER_STATIC,
|
||||
|
||||
|
@ -521,6 +581,42 @@ hb_font_t::has_func (unsigned int i)
|
|||
|
||||
/* Public getters */
|
||||
|
||||
/**
|
||||
* hb_font_get_h_extents:
|
||||
* @font: a font.
|
||||
* @extents: (out):
|
||||
*
|
||||
*
|
||||
*
|
||||
* Return value:
|
||||
*
|
||||
* Since: 1.1.3
|
||||
**/
|
||||
hb_bool_t
|
||||
hb_font_get_h_extents (hb_font_t *font,
|
||||
hb_font_extents_t *extents)
|
||||
{
|
||||
return font->get_font_h_extents (extents);
|
||||
}
|
||||
|
||||
/**
|
||||
* hb_font_get_v_extents:
|
||||
* @font: a font.
|
||||
* @extents: (out):
|
||||
*
|
||||
*
|
||||
*
|
||||
* Return value:
|
||||
*
|
||||
* Since: 1.1.3
|
||||
**/
|
||||
hb_bool_t
|
||||
hb_font_get_v_extents (hb_font_t *font,
|
||||
hb_font_extents_t *extents)
|
||||
{
|
||||
return font->get_font_v_extents (extents);
|
||||
}
|
||||
|
||||
/**
|
||||
* hb_font_get_glyph:
|
||||
* @font: a font.
|
||||
|
@ -539,7 +635,50 @@ hb_font_get_glyph (hb_font_t *font,
|
|||
hb_codepoint_t unicode, hb_codepoint_t variation_selector,
|
||||
hb_codepoint_t *glyph)
|
||||
{
|
||||
return font->get_glyph (unicode, variation_selector, glyph);
|
||||
if (unlikely (variation_selector))
|
||||
return font->get_variation_glyph (unicode, variation_selector, glyph);
|
||||
return font->get_nominal_glyph (unicode, glyph);
|
||||
}
|
||||
|
||||
/**
|
||||
* hb_font_get_nominal_glyph:
|
||||
* @font: a font.
|
||||
* @unicode:
|
||||
* @glyph: (out):
|
||||
*
|
||||
*
|
||||
*
|
||||
* Return value:
|
||||
*
|
||||
* Since: 1.2.3
|
||||
**/
|
||||
hb_bool_t
|
||||
hb_font_get_nominal_glyph (hb_font_t *font,
|
||||
hb_codepoint_t unicode,
|
||||
hb_codepoint_t *glyph)
|
||||
{
|
||||
return font->get_nominal_glyph (unicode, glyph);
|
||||
}
|
||||
|
||||
/**
|
||||
* hb_font_get_variation_glyph:
|
||||
* @font: a font.
|
||||
* @unicode:
|
||||
* @variation_selector:
|
||||
* @glyph: (out):
|
||||
*
|
||||
*
|
||||
*
|
||||
* Return value:
|
||||
*
|
||||
* Since: 1.2.3
|
||||
**/
|
||||
hb_bool_t
|
||||
hb_font_get_variation_glyph (hb_font_t *font,
|
||||
hb_codepoint_t unicode, hb_codepoint_t variation_selector,
|
||||
hb_codepoint_t *glyph)
|
||||
{
|
||||
return font->get_variation_glyph (unicode, variation_selector, glyph);
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -745,6 +884,23 @@ hb_font_get_glyph_from_name (hb_font_t *font,
|
|||
|
||||
/* A bit higher-level, and with fallback */
|
||||
|
||||
/**
|
||||
* hb_font_get_extents_for_direction:
|
||||
* @font: a font.
|
||||
* @direction:
|
||||
* @extents:
|
||||
*
|
||||
*
|
||||
*
|
||||
* Since: 1.1.3
|
||||
**/
|
||||
void
|
||||
hb_font_get_extents_for_direction (hb_font_t *font,
|
||||
hb_direction_t direction,
|
||||
hb_font_extents_t *extents)
|
||||
{
|
||||
return font->get_extents_for_direction (direction, extents);
|
||||
}
|
||||
/**
|
||||
* hb_font_get_glyph_advance_for_direction:
|
||||
* @font: a font.
|
||||
|
@ -1002,6 +1158,8 @@ hb_font_create_sub_font (hb_font_t *parent)
|
|||
font->x_ppem = parent->x_ppem;
|
||||
font->y_ppem = parent->y_ppem;
|
||||
|
||||
/* TODO: copy variation coordinates. */
|
||||
|
||||
return font;
|
||||
}
|
||||
|
||||
|
@ -1031,10 +1189,15 @@ hb_font_get_empty (void)
|
|||
0, /* x_ppem */
|
||||
0, /* y_ppem */
|
||||
|
||||
0, /* num_coords */
|
||||
NULL, /* coords */
|
||||
|
||||
const_cast<hb_font_funcs_t *> (&_hb_font_funcs_nil), /* klass */
|
||||
NULL, /* user_data */
|
||||
NULL, /* destroy */
|
||||
|
||||
hb_font_t::DIRTY_NOTHING, /* dirty */
|
||||
|
||||
{
|
||||
#define HB_SHAPER_IMPLEMENT(shaper) HB_SHAPER_DATA_INVALID,
|
||||
#include "hb-shaper-list.hh"
|
||||
|
@ -1085,6 +1248,8 @@ hb_font_destroy (hb_font_t *font)
|
|||
hb_face_destroy (font->face);
|
||||
hb_font_funcs_destroy (font->klass);
|
||||
|
||||
free (font->coords);
|
||||
|
||||
free (font);
|
||||
}
|
||||
|
||||
|
@ -1185,6 +1350,11 @@ hb_font_set_parent (hb_font_t *font,
|
|||
if (!parent)
|
||||
parent = hb_font_get_empty ();
|
||||
|
||||
if (parent == font->parent)
|
||||
return;
|
||||
|
||||
font->dirty |= font->DIRTY_PARENT;
|
||||
|
||||
hb_font_t *old = font->parent;
|
||||
|
||||
font->parent = hb_font_reference (parent);
|
||||
|
@ -1208,6 +1378,37 @@ hb_font_get_parent (hb_font_t *font)
|
|||
return font->parent;
|
||||
}
|
||||
|
||||
/**
|
||||
* hb_font_set_face:
|
||||
* @font: a font.
|
||||
* @face: new face.
|
||||
*
|
||||
* Sets font-face of @font.
|
||||
*
|
||||
* Since: 1.4.3
|
||||
**/
|
||||
void
|
||||
hb_font_set_face (hb_font_t *font,
|
||||
hb_face_t *face)
|
||||
{
|
||||
if (font->immutable)
|
||||
return;
|
||||
|
||||
if (unlikely (!face))
|
||||
face = hb_face_get_empty ();
|
||||
|
||||
if (font->face == face)
|
||||
return;
|
||||
|
||||
font->dirty |= font->DIRTY_FACE;
|
||||
|
||||
hb_face_t *old = font->face;
|
||||
|
||||
font->face = hb_face_reference (face);
|
||||
|
||||
hb_face_destroy (old);
|
||||
}
|
||||
|
||||
/**
|
||||
* hb_font_get_face:
|
||||
* @font: a font.
|
||||
|
@ -1254,6 +1455,8 @@ hb_font_set_funcs (hb_font_t *font,
|
|||
if (!klass)
|
||||
klass = hb_font_funcs_get_empty ();
|
||||
|
||||
font->dirty |= font->DIRTY_FUNCS;
|
||||
|
||||
hb_font_funcs_reference (klass);
|
||||
hb_font_funcs_destroy (font->klass);
|
||||
font->klass = klass;
|
||||
|
@ -1309,6 +1512,11 @@ hb_font_set_scale (hb_font_t *font,
|
|||
if (font->immutable)
|
||||
return;
|
||||
|
||||
if (font->x_scale == x_scale && font->y_scale == y_scale)
|
||||
return;
|
||||
|
||||
font->dirty |= font->DIRTY_SCALE;
|
||||
|
||||
font->x_scale = x_scale;
|
||||
font->y_scale = y_scale;
|
||||
}
|
||||
|
@ -1350,6 +1558,11 @@ hb_font_set_ppem (hb_font_t *font,
|
|||
if (font->immutable)
|
||||
return;
|
||||
|
||||
if (font->x_ppem == x_ppem && font->y_ppem == y_ppem)
|
||||
return;
|
||||
|
||||
font->dirty |= font->DIRTY_PPEM;
|
||||
|
||||
font->x_ppem = x_ppem;
|
||||
font->y_ppem = y_ppem;
|
||||
}
|
||||
|
@ -1372,3 +1585,249 @@ hb_font_get_ppem (hb_font_t *font,
|
|||
if (x_ppem) *x_ppem = font->x_ppem;
|
||||
if (y_ppem) *y_ppem = font->y_ppem;
|
||||
}
|
||||
|
||||
/*
|
||||
* Variations
|
||||
*/
|
||||
|
||||
static void
|
||||
_hb_font_adopt_var_coords_normalized (hb_font_t *font,
|
||||
int *coords, /* 2.14 normalized */
|
||||
unsigned int coords_length)
|
||||
{
|
||||
if (font->num_coords == coords_length &&
|
||||
(coords_length == 0 ||
|
||||
0 == memcmp (font->coords, coords, coords_length * sizeof (coords[0]))))
|
||||
{
|
||||
free (coords);
|
||||
return;
|
||||
}
|
||||
|
||||
font->dirty |= font->DIRTY_VARIATIONS;
|
||||
|
||||
free (font->coords);
|
||||
|
||||
font->coords = coords;
|
||||
font->num_coords = coords_length;
|
||||
}
|
||||
|
||||
/**
|
||||
* hb_font_set_variations:
|
||||
*
|
||||
* Since: 1.4.2
|
||||
*/
|
||||
void
|
||||
hb_font_set_variations (hb_font_t *font,
|
||||
const hb_variation_t *variations,
|
||||
unsigned int variations_length)
|
||||
{
|
||||
if (font->immutable)
|
||||
return;
|
||||
|
||||
if (!variations_length)
|
||||
{
|
||||
hb_font_set_var_coords_normalized (font, NULL, 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;
|
||||
if (unlikely (coords_length && !normalized))
|
||||
return;
|
||||
|
||||
hb_ot_var_normalize_variations (font->face,
|
||||
variations, variations_length,
|
||||
normalized, coords_length);
|
||||
_hb_font_adopt_var_coords_normalized (font, normalized, coords_length);
|
||||
}
|
||||
|
||||
/**
|
||||
* hb_font_set_var_coords_design:
|
||||
*
|
||||
* Since: 1.4.2
|
||||
*/
|
||||
void
|
||||
hb_font_set_var_coords_design (hb_font_t *font,
|
||||
const float *coords,
|
||||
unsigned int coords_length)
|
||||
{
|
||||
if (font->immutable)
|
||||
return;
|
||||
|
||||
int *normalized = coords_length ? (int *) calloc (coords_length, sizeof (int)) : NULL;
|
||||
if (unlikely (coords_length && !normalized))
|
||||
return;
|
||||
|
||||
hb_ot_var_normalize_coords (font->face, coords_length, coords, normalized);
|
||||
_hb_font_adopt_var_coords_normalized (font, normalized, coords_length);
|
||||
}
|
||||
|
||||
/**
|
||||
* hb_font_set_var_coords_normalized:
|
||||
*
|
||||
* Since: 1.4.2
|
||||
*/
|
||||
void
|
||||
hb_font_set_var_coords_normalized (hb_font_t *font,
|
||||
const int *coords, /* 2.14 normalized */
|
||||
unsigned int coords_length)
|
||||
{
|
||||
if (font->immutable)
|
||||
return;
|
||||
|
||||
int *copy = coords_length ? (int *) calloc (coords_length, sizeof (coords[0])) : NULL;
|
||||
if (unlikely (coords_length && !copy))
|
||||
return;
|
||||
|
||||
if (coords_length)
|
||||
memcpy (copy, coords, coords_length * sizeof (coords[0]));
|
||||
|
||||
_hb_font_adopt_var_coords_normalized (font, copy, coords_length);
|
||||
}
|
||||
|
||||
/**
|
||||
* hb_font_get_var_coords_normalized:
|
||||
*
|
||||
* Return value is valid as long as variation coordinates of the font
|
||||
* are not modified.
|
||||
*
|
||||
* Since: 1.4.2
|
||||
*/
|
||||
const int *
|
||||
hb_font_get_var_coords_normalized (hb_font_t *font,
|
||||
unsigned int *length)
|
||||
{
|
||||
if (length)
|
||||
*length = font->num_coords;
|
||||
|
||||
return font->coords;
|
||||
}
|
||||
|
||||
|
||||
#ifndef HB_DISABLE_DEPRECATED
|
||||
|
||||
/*
|
||||
* Deprecated get_glyph_func():
|
||||
*/
|
||||
|
||||
struct hb_trampoline_closure_t
|
||||
{
|
||||
void *user_data;
|
||||
hb_destroy_func_t destroy;
|
||||
unsigned int ref_count;
|
||||
};
|
||||
|
||||
template <typename FuncType>
|
||||
struct hb_trampoline_t
|
||||
{
|
||||
hb_trampoline_closure_t closure; /* Must be first. */
|
||||
FuncType func;
|
||||
};
|
||||
|
||||
template <typename FuncType>
|
||||
static hb_trampoline_t<FuncType> *
|
||||
trampoline_create (FuncType func,
|
||||
void *user_data,
|
||||
hb_destroy_func_t destroy)
|
||||
{
|
||||
typedef hb_trampoline_t<FuncType> trampoline_t;
|
||||
|
||||
trampoline_t *trampoline = (trampoline_t *) calloc (1, sizeof (trampoline_t));
|
||||
|
||||
if (unlikely (!trampoline))
|
||||
return NULL;
|
||||
|
||||
trampoline->closure.user_data = user_data;
|
||||
trampoline->closure.destroy = destroy;
|
||||
trampoline->closure.ref_count = 1;
|
||||
trampoline->func = func;
|
||||
|
||||
return trampoline;
|
||||
}
|
||||
|
||||
static void
|
||||
trampoline_reference (hb_trampoline_closure_t *closure)
|
||||
{
|
||||
closure->ref_count++;
|
||||
}
|
||||
|
||||
static void
|
||||
trampoline_destroy (void *user_data)
|
||||
{
|
||||
hb_trampoline_closure_t *closure = (hb_trampoline_closure_t *) user_data;
|
||||
|
||||
if (--closure->ref_count)
|
||||
return;
|
||||
|
||||
if (closure->destroy)
|
||||
closure->destroy (closure->user_data);
|
||||
free (closure);
|
||||
}
|
||||
|
||||
typedef hb_trampoline_t<hb_font_get_glyph_func_t> hb_font_get_glyph_trampoline_t;
|
||||
|
||||
static hb_bool_t
|
||||
hb_font_get_nominal_glyph_trampoline (hb_font_t *font,
|
||||
void *font_data,
|
||||
hb_codepoint_t unicode,
|
||||
hb_codepoint_t *glyph,
|
||||
void *user_data)
|
||||
{
|
||||
hb_font_get_glyph_trampoline_t *trampoline = (hb_font_get_glyph_trampoline_t *) user_data;
|
||||
return trampoline->func (font, font_data, unicode, 0, glyph, trampoline->closure.user_data);
|
||||
}
|
||||
|
||||
static hb_bool_t
|
||||
hb_font_get_variation_glyph_trampoline (hb_font_t *font,
|
||||
void *font_data,
|
||||
hb_codepoint_t unicode,
|
||||
hb_codepoint_t variation_selector,
|
||||
hb_codepoint_t *glyph,
|
||||
void *user_data)
|
||||
{
|
||||
hb_font_get_glyph_trampoline_t *trampoline = (hb_font_get_glyph_trampoline_t *) user_data;
|
||||
return trampoline->func (font, font_data, unicode, variation_selector, glyph, trampoline->closure.user_data);
|
||||
}
|
||||
|
||||
/**
|
||||
* hb_font_funcs_set_glyph_func:
|
||||
* @ffuncs: font functions.
|
||||
* @func: (closure user_data) (destroy destroy) (scope notified):
|
||||
* @user_data:
|
||||
* @destroy:
|
||||
*
|
||||
* Deprecated. Use hb_font_funcs_set_nominal_glyph_func() and
|
||||
* hb_font_funcs_set_variation_glyph_func() instead.
|
||||
*
|
||||
* Since: 0.9.2
|
||||
* Deprecated: 1.2.3
|
||||
**/
|
||||
void
|
||||
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_font_get_glyph_trampoline_t *trampoline;
|
||||
|
||||
trampoline = trampoline_create (func, user_data, destroy);
|
||||
if (unlikely (!trampoline))
|
||||
{
|
||||
if (destroy)
|
||||
destroy (user_data);
|
||||
return;
|
||||
}
|
||||
|
||||
hb_font_funcs_set_nominal_glyph_func (ffuncs,
|
||||
hb_font_get_nominal_glyph_trampoline,
|
||||
trampoline,
|
||||
trampoline_destroy);
|
||||
|
||||
trampoline_reference (&trampoline->closure);
|
||||
hb_font_funcs_set_variation_glyph_func (ffuncs,
|
||||
hb_font_get_variation_glyph_trampoline,
|
||||
trampoline,
|
||||
trampoline_destroy);
|
||||
}
|
||||
|
||||
#endif /* HB_DISABLE_DEPRECATED */
|
||||
|
|
|
@ -46,19 +46,19 @@ typedef struct hb_font_t hb_font_t;
|
|||
|
||||
typedef struct hb_font_funcs_t hb_font_funcs_t;
|
||||
|
||||
hb_font_funcs_t *
|
||||
HB_EXTERN hb_font_funcs_t *
|
||||
hb_font_funcs_create (void);
|
||||
|
||||
hb_font_funcs_t *
|
||||
HB_EXTERN hb_font_funcs_t *
|
||||
hb_font_funcs_get_empty (void);
|
||||
|
||||
hb_font_funcs_t *
|
||||
HB_EXTERN hb_font_funcs_t *
|
||||
hb_font_funcs_reference (hb_font_funcs_t *ffuncs);
|
||||
|
||||
void
|
||||
HB_EXTERN void
|
||||
hb_font_funcs_destroy (hb_font_funcs_t *ffuncs);
|
||||
|
||||
hb_bool_t
|
||||
HB_EXTERN hb_bool_t
|
||||
hb_font_funcs_set_user_data (hb_font_funcs_t *ffuncs,
|
||||
hb_user_data_key_t *key,
|
||||
void * data,
|
||||
|
@ -66,19 +66,37 @@ hb_font_funcs_set_user_data (hb_font_funcs_t *ffuncs,
|
|||
hb_bool_t replace);
|
||||
|
||||
|
||||
void *
|
||||
HB_EXTERN void *
|
||||
hb_font_funcs_get_user_data (hb_font_funcs_t *ffuncs,
|
||||
hb_user_data_key_t *key);
|
||||
|
||||
|
||||
void
|
||||
HB_EXTERN void
|
||||
hb_font_funcs_make_immutable (hb_font_funcs_t *ffuncs);
|
||||
|
||||
hb_bool_t
|
||||
HB_EXTERN hb_bool_t
|
||||
hb_font_funcs_is_immutable (hb_font_funcs_t *ffuncs);
|
||||
|
||||
|
||||
/* glyph extents */
|
||||
/* font and glyph extents */
|
||||
|
||||
/* Note that typically ascender is positive and descender negative in coordinate systems that grow up. */
|
||||
typedef struct hb_font_extents_t
|
||||
{
|
||||
hb_position_t ascender; /* typographic ascender. */
|
||||
hb_position_t descender; /* typographic descender. */
|
||||
hb_position_t line_gap; /* suggested line spacing gap. */
|
||||
/*< private >*/
|
||||
hb_position_t reserved9;
|
||||
hb_position_t reserved8;
|
||||
hb_position_t reserved7;
|
||||
hb_position_t reserved6;
|
||||
hb_position_t reserved5;
|
||||
hb_position_t reserved4;
|
||||
hb_position_t reserved3;
|
||||
hb_position_t reserved2;
|
||||
hb_position_t reserved1;
|
||||
} hb_font_extents_t;
|
||||
|
||||
/* Note that height is negative in coordinate systems that grow up. */
|
||||
typedef struct hb_glyph_extents_t
|
||||
|
@ -89,13 +107,23 @@ typedef struct hb_glyph_extents_t
|
|||
hb_position_t height; /* distance from top to bottom side. */
|
||||
} hb_glyph_extents_t;
|
||||
|
||||
|
||||
/* func types */
|
||||
|
||||
typedef hb_bool_t (*hb_font_get_glyph_func_t) (hb_font_t *font, void *font_data,
|
||||
hb_codepoint_t unicode, hb_codepoint_t variation_selector,
|
||||
hb_codepoint_t *glyph,
|
||||
void *user_data);
|
||||
typedef hb_bool_t (*hb_font_get_font_extents_func_t) (hb_font_t *font, void *font_data,
|
||||
hb_font_extents_t *metrics,
|
||||
void *user_data);
|
||||
typedef hb_font_get_font_extents_func_t hb_font_get_font_h_extents_func_t;
|
||||
typedef hb_font_get_font_extents_func_t hb_font_get_font_v_extents_func_t;
|
||||
|
||||
|
||||
typedef hb_bool_t (*hb_font_get_nominal_glyph_func_t) (hb_font_t *font, void *font_data,
|
||||
hb_codepoint_t unicode,
|
||||
hb_codepoint_t *glyph,
|
||||
void *user_data);
|
||||
typedef hb_bool_t (*hb_font_get_variation_glyph_func_t) (hb_font_t *font, void *font_data,
|
||||
hb_codepoint_t unicode, hb_codepoint_t variation_selector,
|
||||
hb_codepoint_t *glyph,
|
||||
void *user_data);
|
||||
|
||||
|
||||
typedef hb_position_t (*hb_font_get_glyph_advance_func_t) (hb_font_t *font, void *font_data,
|
||||
|
@ -141,7 +169,39 @@ typedef hb_bool_t (*hb_font_get_glyph_from_name_func_t) (hb_font_t *font, void *
|
|||
/* func setters */
|
||||
|
||||
/**
|
||||
* hb_font_funcs_set_glyph_func:
|
||||
* hb_font_funcs_set_font_h_extents_func:
|
||||
* @ffuncs: font functions.
|
||||
* @func: (closure user_data) (destroy destroy) (scope notified):
|
||||
* @user_data:
|
||||
* @destroy:
|
||||
*
|
||||
*
|
||||
*
|
||||
* Since: 1.1.2
|
||||
**/
|
||||
HB_EXTERN void
|
||||
hb_font_funcs_set_font_h_extents_func (hb_font_funcs_t *ffuncs,
|
||||
hb_font_get_font_h_extents_func_t func,
|
||||
void *user_data, hb_destroy_func_t destroy);
|
||||
|
||||
/**
|
||||
* hb_font_funcs_set_font_v_extents_func:
|
||||
* @ffuncs: font functions.
|
||||
* @func: (closure user_data) (destroy destroy) (scope notified):
|
||||
* @user_data:
|
||||
* @destroy:
|
||||
*
|
||||
*
|
||||
*
|
||||
* Since: 1.1.2
|
||||
**/
|
||||
HB_EXTERN void
|
||||
hb_font_funcs_set_font_v_extents_func (hb_font_funcs_t *ffuncs,
|
||||
hb_font_get_font_v_extents_func_t func,
|
||||
void *user_data, hb_destroy_func_t destroy);
|
||||
|
||||
/**
|
||||
* hb_font_funcs_set_nominal_glyph_func:
|
||||
* @ffuncs: font functions.
|
||||
* @func: (closure user_data) (destroy destroy) (scope notified):
|
||||
* @user_data:
|
||||
|
@ -149,12 +209,28 @@ typedef hb_bool_t (*hb_font_get_glyph_from_name_func_t) (hb_font_t *font, void *
|
|||
*
|
||||
*
|
||||
*
|
||||
* Since: 0.9.2
|
||||
* Since: 1.2.3
|
||||
**/
|
||||
void
|
||||
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_font_funcs_set_nominal_glyph_func (hb_font_funcs_t *ffuncs,
|
||||
hb_font_get_nominal_glyph_func_t func,
|
||||
void *user_data, hb_destroy_func_t destroy);
|
||||
|
||||
/**
|
||||
* hb_font_funcs_set_variation_glyph_func:
|
||||
* @ffuncs: font functions.
|
||||
* @func: (closure user_data) (destroy destroy) (scope notified):
|
||||
* @user_data:
|
||||
* @destroy:
|
||||
*
|
||||
*
|
||||
*
|
||||
* Since: 1.2.3
|
||||
**/
|
||||
HB_EXTERN void
|
||||
hb_font_funcs_set_variation_glyph_func (hb_font_funcs_t *ffuncs,
|
||||
hb_font_get_variation_glyph_func_t func,
|
||||
void *user_data, hb_destroy_func_t destroy);
|
||||
|
||||
/**
|
||||
* hb_font_funcs_set_glyph_h_advance_func:
|
||||
|
@ -167,7 +243,7 @@ hb_font_funcs_set_glyph_func (hb_font_funcs_t *ffuncs,
|
|||
*
|
||||
* Since: 0.9.2
|
||||
**/
|
||||
void
|
||||
HB_EXTERN void
|
||||
hb_font_funcs_set_glyph_h_advance_func (hb_font_funcs_t *ffuncs,
|
||||
hb_font_get_glyph_h_advance_func_t func,
|
||||
void *user_data, hb_destroy_func_t destroy);
|
||||
|
@ -183,7 +259,7 @@ hb_font_funcs_set_glyph_h_advance_func (hb_font_funcs_t *ffuncs,
|
|||
*
|
||||
* Since: 0.9.2
|
||||
**/
|
||||
void
|
||||
HB_EXTERN void
|
||||
hb_font_funcs_set_glyph_v_advance_func (hb_font_funcs_t *ffuncs,
|
||||
hb_font_get_glyph_v_advance_func_t func,
|
||||
void *user_data, hb_destroy_func_t destroy);
|
||||
|
@ -199,7 +275,7 @@ hb_font_funcs_set_glyph_v_advance_func (hb_font_funcs_t *ffuncs,
|
|||
*
|
||||
* Since: 0.9.2
|
||||
**/
|
||||
void
|
||||
HB_EXTERN void
|
||||
hb_font_funcs_set_glyph_h_origin_func (hb_font_funcs_t *ffuncs,
|
||||
hb_font_get_glyph_h_origin_func_t func,
|
||||
void *user_data, hb_destroy_func_t destroy);
|
||||
|
@ -215,7 +291,7 @@ hb_font_funcs_set_glyph_h_origin_func (hb_font_funcs_t *ffuncs,
|
|||
*
|
||||
* Since: 0.9.2
|
||||
**/
|
||||
void
|
||||
HB_EXTERN void
|
||||
hb_font_funcs_set_glyph_v_origin_func (hb_font_funcs_t *ffuncs,
|
||||
hb_font_get_glyph_v_origin_func_t func,
|
||||
void *user_data, hb_destroy_func_t destroy);
|
||||
|
@ -231,7 +307,7 @@ hb_font_funcs_set_glyph_v_origin_func (hb_font_funcs_t *ffuncs,
|
|||
*
|
||||
* Since: 0.9.2
|
||||
**/
|
||||
void
|
||||
HB_EXTERN void
|
||||
hb_font_funcs_set_glyph_h_kerning_func (hb_font_funcs_t *ffuncs,
|
||||
hb_font_get_glyph_h_kerning_func_t func,
|
||||
void *user_data, hb_destroy_func_t destroy);
|
||||
|
@ -247,7 +323,7 @@ hb_font_funcs_set_glyph_h_kerning_func (hb_font_funcs_t *ffuncs,
|
|||
*
|
||||
* Since: 0.9.2
|
||||
**/
|
||||
void
|
||||
HB_EXTERN void
|
||||
hb_font_funcs_set_glyph_v_kerning_func (hb_font_funcs_t *ffuncs,
|
||||
hb_font_get_glyph_v_kerning_func_t func,
|
||||
void *user_data, hb_destroy_func_t destroy);
|
||||
|
@ -263,7 +339,7 @@ hb_font_funcs_set_glyph_v_kerning_func (hb_font_funcs_t *ffuncs,
|
|||
*
|
||||
* Since: 0.9.2
|
||||
**/
|
||||
void
|
||||
HB_EXTERN void
|
||||
hb_font_funcs_set_glyph_extents_func (hb_font_funcs_t *ffuncs,
|
||||
hb_font_get_glyph_extents_func_t func,
|
||||
void *user_data, hb_destroy_func_t destroy);
|
||||
|
@ -279,7 +355,7 @@ hb_font_funcs_set_glyph_extents_func (hb_font_funcs_t *ffuncs,
|
|||
*
|
||||
* Since: 0.9.2
|
||||
**/
|
||||
void
|
||||
HB_EXTERN void
|
||||
hb_font_funcs_set_glyph_contour_point_func (hb_font_funcs_t *ffuncs,
|
||||
hb_font_get_glyph_contour_point_func_t func,
|
||||
void *user_data, hb_destroy_func_t destroy);
|
||||
|
@ -295,7 +371,7 @@ hb_font_funcs_set_glyph_contour_point_func (hb_font_funcs_t *ffuncs,
|
|||
*
|
||||
* Since: 0.9.2
|
||||
**/
|
||||
void
|
||||
HB_EXTERN void
|
||||
hb_font_funcs_set_glyph_name_func (hb_font_funcs_t *ffuncs,
|
||||
hb_font_get_glyph_name_func_t func,
|
||||
void *user_data, hb_destroy_func_t destroy);
|
||||
|
@ -311,57 +387,67 @@ hb_font_funcs_set_glyph_name_func (hb_font_funcs_t *ffuncs,
|
|||
*
|
||||
* Since: 0.9.2
|
||||
**/
|
||||
void
|
||||
HB_EXTERN void
|
||||
hb_font_funcs_set_glyph_from_name_func (hb_font_funcs_t *ffuncs,
|
||||
hb_font_get_glyph_from_name_func_t func,
|
||||
void *user_data, hb_destroy_func_t destroy);
|
||||
|
||||
|
||||
/* func dispatch */
|
||||
|
||||
hb_bool_t
|
||||
hb_font_get_glyph (hb_font_t *font,
|
||||
hb_codepoint_t unicode, hb_codepoint_t variation_selector,
|
||||
hb_codepoint_t *glyph);
|
||||
HB_EXTERN hb_bool_t
|
||||
hb_font_get_h_extents (hb_font_t *font,
|
||||
hb_font_extents_t *extents);
|
||||
HB_EXTERN hb_bool_t
|
||||
hb_font_get_v_extents (hb_font_t *font,
|
||||
hb_font_extents_t *extents);
|
||||
|
||||
hb_position_t
|
||||
HB_EXTERN hb_bool_t
|
||||
hb_font_get_nominal_glyph (hb_font_t *font,
|
||||
hb_codepoint_t unicode,
|
||||
hb_codepoint_t *glyph);
|
||||
HB_EXTERN hb_bool_t
|
||||
hb_font_get_variation_glyph (hb_font_t *font,
|
||||
hb_codepoint_t unicode, hb_codepoint_t variation_selector,
|
||||
hb_codepoint_t *glyph);
|
||||
|
||||
HB_EXTERN hb_position_t
|
||||
hb_font_get_glyph_h_advance (hb_font_t *font,
|
||||
hb_codepoint_t glyph);
|
||||
hb_position_t
|
||||
HB_EXTERN hb_position_t
|
||||
hb_font_get_glyph_v_advance (hb_font_t *font,
|
||||
hb_codepoint_t glyph);
|
||||
|
||||
hb_bool_t
|
||||
HB_EXTERN hb_bool_t
|
||||
hb_font_get_glyph_h_origin (hb_font_t *font,
|
||||
hb_codepoint_t glyph,
|
||||
hb_position_t *x, hb_position_t *y);
|
||||
hb_bool_t
|
||||
HB_EXTERN hb_bool_t
|
||||
hb_font_get_glyph_v_origin (hb_font_t *font,
|
||||
hb_codepoint_t glyph,
|
||||
hb_position_t *x, hb_position_t *y);
|
||||
|
||||
hb_position_t
|
||||
HB_EXTERN hb_position_t
|
||||
hb_font_get_glyph_h_kerning (hb_font_t *font,
|
||||
hb_codepoint_t left_glyph, hb_codepoint_t right_glyph);
|
||||
hb_position_t
|
||||
HB_EXTERN hb_position_t
|
||||
hb_font_get_glyph_v_kerning (hb_font_t *font,
|
||||
hb_codepoint_t top_glyph, hb_codepoint_t bottom_glyph);
|
||||
|
||||
hb_bool_t
|
||||
HB_EXTERN hb_bool_t
|
||||
hb_font_get_glyph_extents (hb_font_t *font,
|
||||
hb_codepoint_t glyph,
|
||||
hb_glyph_extents_t *extents);
|
||||
|
||||
hb_bool_t
|
||||
HB_EXTERN hb_bool_t
|
||||
hb_font_get_glyph_contour_point (hb_font_t *font,
|
||||
hb_codepoint_t glyph, unsigned int point_index,
|
||||
hb_position_t *x, hb_position_t *y);
|
||||
|
||||
hb_bool_t
|
||||
HB_EXTERN hb_bool_t
|
||||
hb_font_get_glyph_name (hb_font_t *font,
|
||||
hb_codepoint_t glyph,
|
||||
char *name, unsigned int size);
|
||||
hb_bool_t
|
||||
HB_EXTERN hb_bool_t
|
||||
hb_font_get_glyph_from_name (hb_font_t *font,
|
||||
const char *name, int len, /* -1 means nul-terminated */
|
||||
hb_codepoint_t *glyph);
|
||||
|
@ -369,52 +455,63 @@ hb_font_get_glyph_from_name (hb_font_t *font,
|
|||
|
||||
/* high-level funcs, with fallback */
|
||||
|
||||
void
|
||||
/* Calls either hb_font_get_nominal_glyph() if variation_selector is 0,
|
||||
* otherwise callse hb_font_get_variation_glyph(). */
|
||||
HB_EXTERN hb_bool_t
|
||||
hb_font_get_glyph (hb_font_t *font,
|
||||
hb_codepoint_t unicode, hb_codepoint_t variation_selector,
|
||||
hb_codepoint_t *glyph);
|
||||
|
||||
HB_EXTERN void
|
||||
hb_font_get_extents_for_direction (hb_font_t *font,
|
||||
hb_direction_t direction,
|
||||
hb_font_extents_t *extents);
|
||||
HB_EXTERN void
|
||||
hb_font_get_glyph_advance_for_direction (hb_font_t *font,
|
||||
hb_codepoint_t glyph,
|
||||
hb_direction_t direction,
|
||||
hb_position_t *x, hb_position_t *y);
|
||||
void
|
||||
HB_EXTERN void
|
||||
hb_font_get_glyph_origin_for_direction (hb_font_t *font,
|
||||
hb_codepoint_t glyph,
|
||||
hb_direction_t direction,
|
||||
hb_position_t *x, hb_position_t *y);
|
||||
void
|
||||
HB_EXTERN void
|
||||
hb_font_add_glyph_origin_for_direction (hb_font_t *font,
|
||||
hb_codepoint_t glyph,
|
||||
hb_direction_t direction,
|
||||
hb_position_t *x, hb_position_t *y);
|
||||
void
|
||||
HB_EXTERN void
|
||||
hb_font_subtract_glyph_origin_for_direction (hb_font_t *font,
|
||||
hb_codepoint_t glyph,
|
||||
hb_direction_t direction,
|
||||
hb_position_t *x, hb_position_t *y);
|
||||
|
||||
void
|
||||
HB_EXTERN void
|
||||
hb_font_get_glyph_kerning_for_direction (hb_font_t *font,
|
||||
hb_codepoint_t first_glyph, hb_codepoint_t second_glyph,
|
||||
hb_direction_t direction,
|
||||
hb_position_t *x, hb_position_t *y);
|
||||
|
||||
hb_bool_t
|
||||
HB_EXTERN hb_bool_t
|
||||
hb_font_get_glyph_extents_for_origin (hb_font_t *font,
|
||||
hb_codepoint_t glyph,
|
||||
hb_direction_t direction,
|
||||
hb_glyph_extents_t *extents);
|
||||
|
||||
hb_bool_t
|
||||
HB_EXTERN hb_bool_t
|
||||
hb_font_get_glyph_contour_point_for_origin (hb_font_t *font,
|
||||
hb_codepoint_t glyph, unsigned int point_index,
|
||||
hb_direction_t direction,
|
||||
hb_position_t *x, hb_position_t *y);
|
||||
|
||||
/* Generates gidDDD if glyph has no name. */
|
||||
void
|
||||
HB_EXTERN void
|
||||
hb_font_glyph_to_string (hb_font_t *font,
|
||||
hb_codepoint_t glyph,
|
||||
char *s, unsigned int size);
|
||||
/* Parses gidDDD and uniUUUU strings automatically. */
|
||||
hb_bool_t
|
||||
HB_EXTERN hb_bool_t
|
||||
hb_font_glyph_from_string (hb_font_t *font,
|
||||
const char *s, int len, /* -1 means nul-terminated */
|
||||
hb_codepoint_t *glyph);
|
||||
|
@ -426,22 +523,22 @@ hb_font_glyph_from_string (hb_font_t *font,
|
|||
|
||||
/* Fonts are very light-weight objects */
|
||||
|
||||
hb_font_t *
|
||||
HB_EXTERN hb_font_t *
|
||||
hb_font_create (hb_face_t *face);
|
||||
|
||||
hb_font_t *
|
||||
HB_EXTERN hb_font_t *
|
||||
hb_font_create_sub_font (hb_font_t *parent);
|
||||
|
||||
hb_font_t *
|
||||
HB_EXTERN hb_font_t *
|
||||
hb_font_get_empty (void);
|
||||
|
||||
hb_font_t *
|
||||
HB_EXTERN hb_font_t *
|
||||
hb_font_reference (hb_font_t *font);
|
||||
|
||||
void
|
||||
HB_EXTERN void
|
||||
hb_font_destroy (hb_font_t *font);
|
||||
|
||||
hb_bool_t
|
||||
HB_EXTERN hb_bool_t
|
||||
hb_font_set_user_data (hb_font_t *font,
|
||||
hb_user_data_key_t *key,
|
||||
void * data,
|
||||
|
@ -449,46 +546,50 @@ hb_font_set_user_data (hb_font_t *font,
|
|||
hb_bool_t replace);
|
||||
|
||||
|
||||
void *
|
||||
HB_EXTERN void *
|
||||
hb_font_get_user_data (hb_font_t *font,
|
||||
hb_user_data_key_t *key);
|
||||
|
||||
void
|
||||
HB_EXTERN void
|
||||
hb_font_make_immutable (hb_font_t *font);
|
||||
|
||||
hb_bool_t
|
||||
HB_EXTERN hb_bool_t
|
||||
hb_font_is_immutable (hb_font_t *font);
|
||||
|
||||
void
|
||||
HB_EXTERN void
|
||||
hb_font_set_parent (hb_font_t *font,
|
||||
hb_font_t *parent);
|
||||
|
||||
hb_font_t *
|
||||
HB_EXTERN hb_font_t *
|
||||
hb_font_get_parent (hb_font_t *font);
|
||||
|
||||
hb_face_t *
|
||||
HB_EXTERN void
|
||||
hb_font_set_face (hb_font_t *font,
|
||||
hb_face_t *face);
|
||||
|
||||
HB_EXTERN hb_face_t *
|
||||
hb_font_get_face (hb_font_t *font);
|
||||
|
||||
|
||||
void
|
||||
HB_EXTERN void
|
||||
hb_font_set_funcs (hb_font_t *font,
|
||||
hb_font_funcs_t *klass,
|
||||
void *font_data,
|
||||
hb_destroy_func_t destroy);
|
||||
|
||||
/* Be *very* careful with this function! */
|
||||
void
|
||||
HB_EXTERN void
|
||||
hb_font_set_funcs_data (hb_font_t *font,
|
||||
void *font_data,
|
||||
hb_destroy_func_t destroy);
|
||||
|
||||
|
||||
void
|
||||
HB_EXTERN void
|
||||
hb_font_set_scale (hb_font_t *font,
|
||||
int x_scale,
|
||||
int y_scale);
|
||||
|
||||
void
|
||||
HB_EXTERN void
|
||||
hb_font_get_scale (hb_font_t *font,
|
||||
int *x_scale,
|
||||
int *y_scale);
|
||||
|
@ -496,16 +597,34 @@ hb_font_get_scale (hb_font_t *font,
|
|||
/*
|
||||
* A zero value means "no hinting in that direction"
|
||||
*/
|
||||
void
|
||||
HB_EXTERN void
|
||||
hb_font_set_ppem (hb_font_t *font,
|
||||
unsigned int x_ppem,
|
||||
unsigned int y_ppem);
|
||||
|
||||
void
|
||||
HB_EXTERN void
|
||||
hb_font_get_ppem (hb_font_t *font,
|
||||
unsigned int *x_ppem,
|
||||
unsigned int *y_ppem);
|
||||
|
||||
HB_EXTERN void
|
||||
hb_font_set_variations (hb_font_t *font,
|
||||
const hb_variation_t *variations,
|
||||
unsigned int variations_length);
|
||||
|
||||
HB_EXTERN void
|
||||
hb_font_set_var_coords_design (hb_font_t *font,
|
||||
const float *coords,
|
||||
unsigned int coords_length);
|
||||
|
||||
HB_EXTERN void
|
||||
hb_font_set_var_coords_normalized (hb_font_t *font,
|
||||
const int *coords, /* 2.14 normalized */
|
||||
unsigned int coords_length);
|
||||
|
||||
HB_EXTERN const int *
|
||||
hb_font_get_var_coords_normalized (hb_font_t *font,
|
||||
unsigned int *length);
|
||||
|
||||
HB_END_DECLS
|
||||
|
||||
|
|
|
@ -33,7 +33,10 @@
|
|||
|
||||
#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
|
||||
|
||||
|
||||
|
@ -70,11 +73,12 @@ struct hb_ft_font_t
|
|||
{
|
||||
FT_Face ft_face;
|
||||
int load_flags;
|
||||
bool symbol; /* Whether selected cmap is symbol cmap. */
|
||||
bool unref; /* Whether to destroy ft_face when done. */
|
||||
};
|
||||
|
||||
static hb_ft_font_t *
|
||||
_hb_ft_font_create (FT_Face ft_face, bool unref)
|
||||
_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));
|
||||
|
||||
|
@ -82,6 +86,7 @@ _hb_ft_font_create (FT_Face ft_face, bool unref)
|
|||
return NULL;
|
||||
|
||||
ft_font->ft_face = ft_face;
|
||||
ft_font->symbol = symbol;
|
||||
ft_font->unref = unref;
|
||||
|
||||
ft_font->load_flags = FT_LOAD_DEFAULT | FT_LOAD_NO_HINTING;
|
||||
|
@ -89,11 +94,17 @@ _hb_ft_font_create (FT_Face ft_face, bool unref)
|
|||
return ft_font;
|
||||
}
|
||||
|
||||
static void
|
||||
_hb_ft_face_destroy (FT_Face ft_face)
|
||||
{
|
||||
FT_Done_Face (ft_face);
|
||||
}
|
||||
|
||||
static void
|
||||
_hb_ft_font_destroy (hb_ft_font_t *ft_font)
|
||||
{
|
||||
if (ft_font->unref)
|
||||
FT_Done_Face (ft_font->ft_face);
|
||||
_hb_ft_face_destroy (ft_font->ft_face);
|
||||
|
||||
free (ft_font);
|
||||
}
|
||||
|
@ -155,21 +166,46 @@ hb_ft_font_get_face (hb_font_t *font)
|
|||
|
||||
|
||||
static hb_bool_t
|
||||
hb_ft_get_glyph (hb_font_t *font HB_UNUSED,
|
||||
void *font_data,
|
||||
hb_codepoint_t unicode,
|
||||
hb_codepoint_t variation_selector,
|
||||
hb_codepoint_t *glyph,
|
||||
void *user_data HB_UNUSED)
|
||||
|
||||
hb_ft_get_nominal_glyph (hb_font_t *font HB_UNUSED,
|
||||
void *font_data,
|
||||
hb_codepoint_t unicode,
|
||||
hb_codepoint_t *glyph,
|
||||
void *user_data HB_UNUSED)
|
||||
{
|
||||
const hb_ft_font_t *ft_font = (const hb_ft_font_t *) font_data;
|
||||
unsigned int g;
|
||||
unsigned int g = FT_Get_Char_Index (ft_font->ft_face, unicode);
|
||||
|
||||
if (likely (!variation_selector))
|
||||
g = FT_Get_Char_Index (ft_font->ft_face, unicode);
|
||||
else
|
||||
g = FT_Face_GetCharVariantIndex (ft_font->ft_face, unicode, variation_selector);
|
||||
if (unlikely (!g))
|
||||
{
|
||||
if (unlikely (ft_font->symbol) && unicode <= 0x00FFu)
|
||||
{
|
||||
/* For symbol-encoded OpenType fonts, we duplicate the
|
||||
* U+F000..F0FF range at U+0000..U+00FF. That's what
|
||||
* Windows seems to do, and that's hinted about at:
|
||||
* http://www.microsoft.com/typography/otspec/recom.htm
|
||||
* under "Non-Standard (Symbol) Fonts". */
|
||||
g = FT_Get_Char_Index (ft_font->ft_face, 0xF000u + unicode);
|
||||
if (!g)
|
||||
return false;
|
||||
}
|
||||
else
|
||||
return false;
|
||||
}
|
||||
|
||||
*glyph = g;
|
||||
return true;
|
||||
}
|
||||
|
||||
static hb_bool_t
|
||||
hb_ft_get_variation_glyph (hb_font_t *font HB_UNUSED,
|
||||
void *font_data,
|
||||
hb_codepoint_t unicode,
|
||||
hb_codepoint_t variation_selector,
|
||||
hb_codepoint_t *glyph,
|
||||
void *user_data HB_UNUSED)
|
||||
{
|
||||
const hb_ft_font_t *ft_font = (const hb_ft_font_t *) font_data;
|
||||
unsigned int g = FT_Face_GetCharVariantIndex (ft_font->ft_face, unicode, variation_selector);
|
||||
|
||||
if (unlikely (!g))
|
||||
return false;
|
||||
|
@ -366,6 +402,25 @@ hb_ft_get_glyph_from_name (hb_font_t *font HB_UNUSED,
|
|||
return *glyph != 0;
|
||||
}
|
||||
|
||||
static hb_bool_t
|
||||
hb_ft_get_font_h_extents (hb_font_t *font HB_UNUSED,
|
||||
void *font_data,
|
||||
hb_font_extents_t *metrics,
|
||||
void *user_data HB_UNUSED)
|
||||
{
|
||||
const hb_ft_font_t *ft_font = (const hb_ft_font_t *) font_data;
|
||||
FT_Face ft_face = ft_font->ft_face;
|
||||
metrics->ascender = ft_face->size->metrics.ascender;
|
||||
metrics->descender = ft_face->size->metrics.descender;
|
||||
metrics->line_gap = ft_face->size->metrics.height - (ft_face->size->metrics.ascender - ft_face->size->metrics.descender);
|
||||
if (font->y_scale < 0)
|
||||
{
|
||||
metrics->ascender = -metrics->ascender;
|
||||
metrics->descender = -metrics->descender;
|
||||
metrics->line_gap = -metrics->line_gap;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
static hb_font_funcs_t *static_ft_funcs = NULL;
|
||||
|
||||
|
@ -387,7 +442,10 @@ retry:
|
|||
{
|
||||
funcs = hb_font_funcs_create ();
|
||||
|
||||
hb_font_funcs_set_glyph_func (funcs, hb_ft_get_glyph, NULL, NULL);
|
||||
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);
|
||||
|
@ -411,9 +469,11 @@ retry:
|
|||
#endif
|
||||
};
|
||||
|
||||
bool symbol = ft_face->charmap && ft_face->charmap->encoding == FT_ENCODING_MS_SYMBOL;
|
||||
|
||||
hb_font_set_funcs (font,
|
||||
funcs,
|
||||
_hb_ft_font_create (ft_face, unref),
|
||||
_hb_ft_font_create (ft_face, symbol, unref),
|
||||
(hb_destroy_func_t) _hb_ft_font_destroy);
|
||||
}
|
||||
|
||||
|
@ -433,7 +493,7 @@ reference_table (hb_face_t *face HB_UNUSED, hb_tag_t tag, void *user_data)
|
|||
return NULL;
|
||||
|
||||
buffer = (FT_Byte *) malloc (length);
|
||||
if (buffer == NULL)
|
||||
if (!buffer)
|
||||
return NULL;
|
||||
|
||||
error = FT_Load_Sfnt_Table (ft_face, tag, 0, buffer, &length);
|
||||
|
@ -461,7 +521,7 @@ hb_ft_face_create (FT_Face ft_face,
|
|||
{
|
||||
hb_face_t *face;
|
||||
|
||||
if (ft_face->stream->read == NULL) {
|
||||
if (!ft_face->stream->read) {
|
||||
hb_blob_t *blob;
|
||||
|
||||
blob = hb_blob_create ((const char *) ft_face->stream->base,
|
||||
|
@ -493,7 +553,7 @@ hb_face_t *
|
|||
hb_ft_face_create_referenced (FT_Face ft_face)
|
||||
{
|
||||
FT_Reference_Face (ft_face);
|
||||
return hb_ft_face_create (ft_face, (hb_destroy_func_t) FT_Done_Face);
|
||||
return hb_ft_face_create (ft_face, (hb_destroy_func_t) _hb_ft_face_destroy);
|
||||
}
|
||||
|
||||
static void
|
||||
|
@ -549,14 +609,36 @@ hb_ft_font_create (FT_Face ft_face,
|
|||
hb_face_destroy (face);
|
||||
_hb_ft_font_set_funcs (font, ft_face, false);
|
||||
hb_font_set_scale (font,
|
||||
(int) (((uint64_t) ft_face->size->metrics.x_scale * (uint64_t) ft_face->units_per_EM + (1<<15)) >> 16),
|
||||
(int) (((uint64_t) ft_face->size->metrics.y_scale * (uint64_t) ft_face->units_per_EM + (1<<15)) >> 16));
|
||||
(int) (((uint64_t) ft_face->size->metrics.x_scale * (uint64_t) ft_face->units_per_EM + (1u<<15)) >> 16),
|
||||
(int) (((uint64_t) ft_face->size->metrics.y_scale * (uint64_t) ft_face->units_per_EM + (1u<<15)) >> 16));
|
||||
#if 0 /* hb-ft works in no-hinting model */
|
||||
hb_font_set_ppem (font,
|
||||
ft_face->size->metrics.x_ppem,
|
||||
ft_face->size->metrics.y_ppem);
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_FT_GET_VAR_BLEND_COORDINATES
|
||||
FT_MM_Var *mm_var = NULL;
|
||||
if (!FT_Get_MM_Var (ft_face, &mm_var))
|
||||
{
|
||||
FT_Fixed *ft_coords = (FT_Fixed *) calloc (mm_var->num_axis, sizeof (FT_Fixed));
|
||||
int *coords = (int *) calloc (mm_var->num_axis, sizeof (int));
|
||||
if (coords && ft_coords)
|
||||
{
|
||||
if (!FT_Get_Var_Blend_Coordinates (ft_face, mm_var->num_axis, ft_coords))
|
||||
{
|
||||
for (unsigned int i = 0; i < mm_var->num_axis; ++i)
|
||||
coords[i] = ft_coords[i] >>= 2;
|
||||
|
||||
hb_font_set_var_coords_normalized (font, coords, mm_var->num_axis);
|
||||
}
|
||||
}
|
||||
free (coords);
|
||||
free (ft_coords);
|
||||
free (mm_var);
|
||||
}
|
||||
#endif
|
||||
|
||||
return font;
|
||||
}
|
||||
|
||||
|
@ -573,7 +655,7 @@ hb_font_t *
|
|||
hb_ft_font_create_referenced (FT_Face ft_face)
|
||||
{
|
||||
FT_Reference_Face (ft_face);
|
||||
return hb_ft_font_create (ft_face, (hb_destroy_func_t) FT_Done_Face);
|
||||
return hb_ft_font_create (ft_face, (hb_destroy_func_t) _hb_ft_face_destroy);
|
||||
}
|
||||
|
||||
|
||||
|
@ -642,7 +724,8 @@ hb_ft_font_set_funcs (hb_font_t *font)
|
|||
return;
|
||||
}
|
||||
|
||||
FT_Select_Charmap (ft_face, FT_ENCODING_UNICODE);
|
||||
if (FT_Select_Charmap (ft_face, FT_ENCODING_UNICODE))
|
||||
FT_Select_Charmap (ft_face, FT_ENCODING_MS_SYMBOL);
|
||||
|
||||
FT_Set_Char_Size (ft_face,
|
||||
abs (font->x_scale), abs (font->y_scale),
|
||||
|
@ -658,6 +741,20 @@ hb_ft_font_set_funcs (hb_font_t *font)
|
|||
FT_Set_Transform (ft_face, &matrix, NULL);
|
||||
}
|
||||
|
||||
unsigned int num_coords;
|
||||
const int *coords = hb_font_get_var_coords_normalized (font, &num_coords);
|
||||
if (num_coords)
|
||||
{
|
||||
FT_Fixed *ft_coords = (FT_Fixed *) calloc (num_coords, sizeof (FT_Fixed));
|
||||
if (ft_coords)
|
||||
{
|
||||
for (unsigned int i = 0; i < num_coords; i++)
|
||||
ft_coords[i] = coords[i] << 2;
|
||||
FT_Set_Var_Blend_Coordinates (ft_face, num_coords, ft_coords);
|
||||
free (ft_coords);
|
||||
}
|
||||
}
|
||||
|
||||
ft_face->generic.data = blob;
|
||||
ft_face->generic.finalizer = (FT_Generic_Finalizer) _release_blob;
|
||||
|
||||
|
|
|
@ -59,7 +59,7 @@ HB_BEGIN_DECLS
|
|||
* probably should use (the more recent) hb_ft_face_create_referenced()
|
||||
* instead.
|
||||
*/
|
||||
hb_face_t *
|
||||
HB_EXTERN hb_face_t *
|
||||
hb_ft_face_create (FT_Face ft_face,
|
||||
hb_destroy_func_t destroy);
|
||||
|
||||
|
@ -71,7 +71,7 @@ hb_ft_face_create (FT_Face ft_face,
|
|||
* Client is still responsible for making sure that ft-face is destroyed
|
||||
* after hb-face is.
|
||||
*/
|
||||
hb_face_t *
|
||||
HB_EXTERN hb_face_t *
|
||||
hb_ft_face_create_cached (FT_Face ft_face);
|
||||
|
||||
/* This version is like hb_ft_face_create(), except that it calls
|
||||
|
@ -81,7 +81,7 @@ hb_ft_face_create_cached (FT_Face ft_face);
|
|||
* This is the most convenient version to use. Use it unless you have
|
||||
* very good reasons not to.
|
||||
*/
|
||||
hb_face_t *
|
||||
HB_EXTERN hb_face_t *
|
||||
hb_ft_face_create_referenced (FT_Face ft_face);
|
||||
|
||||
|
||||
|
@ -98,26 +98,26 @@ hb_ft_face_create_referenced (FT_Face ft_face);
|
|||
|
||||
/* See notes on hb_ft_face_create(). Same issues re lifecycle-management
|
||||
* apply here. Use hb_ft_font_create_referenced() if you can. */
|
||||
hb_font_t *
|
||||
HB_EXTERN hb_font_t *
|
||||
hb_ft_font_create (FT_Face ft_face,
|
||||
hb_destroy_func_t destroy);
|
||||
|
||||
/* See notes on hb_ft_face_create_referenced() re lifecycle-management
|
||||
* issues. */
|
||||
hb_font_t *
|
||||
HB_EXTERN hb_font_t *
|
||||
hb_ft_font_create_referenced (FT_Face ft_face);
|
||||
|
||||
FT_Face
|
||||
HB_EXTERN FT_Face
|
||||
hb_ft_font_get_face (hb_font_t *font);
|
||||
|
||||
void
|
||||
HB_EXTERN void
|
||||
hb_ft_font_set_load_flags (hb_font_t *font, int load_flags);
|
||||
|
||||
int
|
||||
HB_EXTERN int
|
||||
hb_ft_font_get_load_flags (hb_font_t *font);
|
||||
|
||||
/* Makes an hb_font_t use FreeType internally to implement font functions. */
|
||||
void
|
||||
HB_EXTERN void
|
||||
hb_ft_font_set_funcs (hb_font_t *font);
|
||||
|
||||
|
||||
|
|
|
@ -382,7 +382,10 @@ hb_glib_get_unicode_funcs (void)
|
|||
return const_cast<hb_unicode_funcs_t *> (&_hb_glib_unicode_funcs);
|
||||
}
|
||||
|
||||
#if GLIB_CHECK_VERSION(2,31,10)
|
||||
/**
|
||||
* hb_glib_blob_create:
|
||||
*
|
||||
* Since: 0.9.38
|
||||
**/
|
||||
hb_blob_t *
|
||||
|
@ -396,3 +399,4 @@ hb_glib_blob_create (GBytes *gbytes)
|
|||
g_bytes_ref (gbytes),
|
||||
(hb_destroy_func_t) g_bytes_unref);
|
||||
}
|
||||
#endif
|
||||
|
|
|
@ -36,19 +36,20 @@
|
|||
HB_BEGIN_DECLS
|
||||
|
||||
|
||||
hb_script_t
|
||||
HB_EXTERN hb_script_t
|
||||
hb_glib_script_to_script (GUnicodeScript script);
|
||||
|
||||
GUnicodeScript
|
||||
HB_EXTERN GUnicodeScript
|
||||
hb_glib_script_from_script (hb_script_t script);
|
||||
|
||||
|
||||
hb_unicode_funcs_t *
|
||||
HB_EXTERN hb_unicode_funcs_t *
|
||||
hb_glib_get_unicode_funcs (void);
|
||||
|
||||
hb_blob_t *
|
||||
#if GLIB_CHECK_VERSION(2,31,10)
|
||||
HB_EXTERN hb_blob_t *
|
||||
hb_glib_blob_create (GBytes *gbytes);
|
||||
|
||||
#endif
|
||||
|
||||
HB_END_DECLS
|
||||
|
||||
|
|
|
@ -42,7 +42,7 @@ HB_BEGIN_DECLS
|
|||
/*** END file-header ***/
|
||||
|
||||
/*** BEGIN value-header ***/
|
||||
GType @enum_name@_get_type (void) G_GNUC_CONST;
|
||||
HB_EXTERN GType @enum_name@_get_type (void) G_GNUC_CONST;
|
||||
#define @ENUMPREFIX@_TYPE_@ENUMSHORT@ (@enum_name@_get_type ())
|
||||
|
||||
/*** END value-header ***/
|
||||
|
|
|
@ -78,3 +78,6 @@ HB_DEFINE_VALUE_TYPE (glyph_info)
|
|||
HB_DEFINE_VALUE_TYPE (glyph_position)
|
||||
HB_DEFINE_VALUE_TYPE (segment_properties)
|
||||
HB_DEFINE_VALUE_TYPE (user_data_key)
|
||||
|
||||
HB_DEFINE_VALUE_TYPE (ot_math_glyph_variant)
|
||||
HB_DEFINE_VALUE_TYPE (ot_math_glyph_part)
|
||||
|
|
|
@ -41,62 +41,74 @@ HB_BEGIN_DECLS
|
|||
/* Object types */
|
||||
|
||||
/**
|
||||
* hb_gobject_blob_get_type:
|
||||
*
|
||||
* Since: 0.9.2
|
||||
**/
|
||||
GType hb_gobject_blob_get_type (void);
|
||||
HB_EXTERN GType hb_gobject_blob_get_type (void);
|
||||
#define HB_GOBJECT_TYPE_BLOB (hb_gobject_blob_get_type ())
|
||||
|
||||
/**
|
||||
* hb_gobject_buffer_get_type:
|
||||
*
|
||||
* Since: 0.9.2
|
||||
**/
|
||||
GType hb_gobject_buffer_get_type (void);
|
||||
HB_EXTERN GType hb_gobject_buffer_get_type (void);
|
||||
#define HB_GOBJECT_TYPE_BUFFER (hb_gobject_buffer_get_type ())
|
||||
|
||||
/**
|
||||
* hb_gobject_face_get_type:
|
||||
*
|
||||
* Since: 0.9.2
|
||||
**/
|
||||
GType hb_gobject_face_get_type (void);
|
||||
HB_EXTERN GType hb_gobject_face_get_type (void);
|
||||
#define HB_GOBJECT_TYPE_FACE (hb_gobject_face_get_type ())
|
||||
|
||||
/**
|
||||
* hb_gobject_font_get_type:
|
||||
*
|
||||
* Since: 0.9.2
|
||||
**/
|
||||
GType hb_gobject_font_get_type (void);
|
||||
HB_EXTERN GType hb_gobject_font_get_type (void);
|
||||
#define HB_GOBJECT_TYPE_FONT (hb_gobject_font_get_type ())
|
||||
|
||||
/**
|
||||
* hb_gobject_font_funcs_get_type:
|
||||
*
|
||||
* Since: 0.9.2
|
||||
**/
|
||||
GType hb_gobject_font_funcs_get_type (void);
|
||||
HB_EXTERN GType hb_gobject_font_funcs_get_type (void);
|
||||
#define HB_GOBJECT_TYPE_FONT_FUNCS (hb_gobject_font_funcs_get_type ())
|
||||
|
||||
GType hb_gobject_set_get_type (void);
|
||||
HB_EXTERN GType hb_gobject_set_get_type (void);
|
||||
#define HB_GOBJECT_TYPE_SET (hb_gobject_set_get_type ())
|
||||
|
||||
GType hb_gobject_shape_plan_get_type (void);
|
||||
HB_EXTERN GType hb_gobject_shape_plan_get_type (void);
|
||||
#define HB_GOBJECT_TYPE_SHAPE_PLAN (hb_gobject_shape_plan_get_type ())
|
||||
|
||||
/**
|
||||
* hb_gobject_unicode_funcs_get_type:
|
||||
*
|
||||
* Since: 0.9.2
|
||||
**/
|
||||
GType hb_gobject_unicode_funcs_get_type (void);
|
||||
HB_EXTERN GType hb_gobject_unicode_funcs_get_type (void);
|
||||
#define HB_GOBJECT_TYPE_UNICODE_FUNCS (hb_gobject_unicode_funcs_get_type ())
|
||||
|
||||
/* Value types */
|
||||
|
||||
GType hb_gobject_feature_get_type (void);
|
||||
HB_EXTERN GType hb_gobject_feature_get_type (void);
|
||||
#define HB_GOBJECT_TYPE_FEATURE (hb_gobject_feature_get_type ())
|
||||
|
||||
GType hb_gobject_glyph_info_get_type (void);
|
||||
HB_EXTERN GType hb_gobject_glyph_info_get_type (void);
|
||||
#define HB_GOBJECT_TYPE_GLYPH_INFO (hb_gobject_glyph_info_get_type ())
|
||||
|
||||
GType hb_gobject_glyph_position_get_type (void);
|
||||
HB_EXTERN GType hb_gobject_glyph_position_get_type (void);
|
||||
#define HB_GOBJECT_TYPE_GLYPH_POSITION (hb_gobject_glyph_position_get_type ())
|
||||
|
||||
GType hb_gobject_segment_properties_get_type (void);
|
||||
HB_EXTERN GType hb_gobject_segment_properties_get_type (void);
|
||||
#define HB_GOBJECT_TYPE_SEGMENT_PROPERTIES (hb_gobject_segment_properties_get_type ())
|
||||
|
||||
GType hb_gobject_user_data_key_get_type (void);
|
||||
HB_EXTERN GType hb_gobject_user_data_key_get_type (void);
|
||||
#define HB_GOBJECT_TYPE_USER_DATA_KEY (hb_gobject_user_data_key_get_type ())
|
||||
|
||||
|
||||
|
|
|
@ -27,7 +27,6 @@
|
|||
*/
|
||||
|
||||
#define HB_SHAPER graphite2
|
||||
#define hb_graphite2_shaper_font_data_t gr_font
|
||||
#include "hb-shaper-impl-private.hh"
|
||||
|
||||
#include "hb-graphite2.h"
|
||||
|
@ -35,8 +34,8 @@
|
|||
#include <graphite2/Segment.h>
|
||||
|
||||
|
||||
HB_SHAPER_DATA_ENSURE_DECLARE(graphite2, face)
|
||||
HB_SHAPER_DATA_ENSURE_DECLARE(graphite2, font)
|
||||
HB_SHAPER_DATA_ENSURE_DEFINE(graphite2, face)
|
||||
HB_SHAPER_DATA_ENSURE_DEFINE(graphite2, font)
|
||||
|
||||
|
||||
/*
|
||||
|
@ -153,26 +152,17 @@ hb_graphite2_face_get_gr_face (hb_face_t *face)
|
|||
* shaper font data
|
||||
*/
|
||||
|
||||
static float hb_graphite2_get_advance (const void *hb_font, unsigned short gid)
|
||||
{
|
||||
return ((hb_font_t *) hb_font)->get_glyph_h_advance (gid);
|
||||
}
|
||||
struct hb_graphite2_shaper_font_data_t {};
|
||||
|
||||
hb_graphite2_shaper_font_data_t *
|
||||
_hb_graphite2_shaper_font_data_create (hb_font_t *font)
|
||||
_hb_graphite2_shaper_font_data_create (hb_font_t *font HB_UNUSED)
|
||||
{
|
||||
if (unlikely (!hb_graphite2_shaper_face_data_ensure (font->face))) return NULL;
|
||||
|
||||
hb_face_t *face = font->face;
|
||||
hb_graphite2_shaper_face_data_t *face_data = HB_SHAPER_DATA_GET (face);
|
||||
|
||||
return gr_make_font_with_advance_fn (font->x_scale, font, &hb_graphite2_get_advance, face_data->grface);
|
||||
return (hb_graphite2_shaper_font_data_t *) HB_SHAPER_DATA_SUCCEEDED;
|
||||
}
|
||||
|
||||
void
|
||||
_hb_graphite2_shaper_font_data_destroy (hb_graphite2_shaper_font_data_t *data)
|
||||
_hb_graphite2_shaper_font_data_destroy (hb_graphite2_shaper_font_data_t *data HB_UNUSED)
|
||||
{
|
||||
gr_font_destroy (data);
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -181,8 +171,7 @@ _hb_graphite2_shaper_font_data_destroy (hb_graphite2_shaper_font_data_t *data)
|
|||
gr_font *
|
||||
hb_graphite2_font_get_gr_font (hb_font_t *font)
|
||||
{
|
||||
if (unlikely (!hb_graphite2_shaper_font_data_ensure (font))) return NULL;
|
||||
return HB_SHAPER_DATA_GET (font);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
|
@ -195,7 +184,9 @@ struct hb_graphite2_shaper_shape_plan_data_t {};
|
|||
hb_graphite2_shaper_shape_plan_data_t *
|
||||
_hb_graphite2_shaper_shape_plan_data_create (hb_shape_plan_t *shape_plan HB_UNUSED,
|
||||
const hb_feature_t *user_features HB_UNUSED,
|
||||
unsigned int num_user_features HB_UNUSED)
|
||||
unsigned int num_user_features HB_UNUSED,
|
||||
const int *coords HB_UNUSED,
|
||||
unsigned int num_coords HB_UNUSED)
|
||||
{
|
||||
return (hb_graphite2_shaper_shape_plan_data_t *) HB_SHAPER_DATA_SUCCEEDED;
|
||||
}
|
||||
|
@ -216,6 +207,7 @@ struct hb_graphite2_cluster_t {
|
|||
unsigned int base_glyph;
|
||||
unsigned int num_glyphs;
|
||||
unsigned int cluster;
|
||||
float advance;
|
||||
};
|
||||
|
||||
hb_bool_t
|
||||
|
@ -227,7 +219,6 @@ _hb_graphite2_shape (hb_shape_plan_t *shape_plan,
|
|||
{
|
||||
hb_face_t *face = font->face;
|
||||
gr_face *grface = HB_SHAPER_DATA_GET (face)->grface;
|
||||
gr_font *grfont = HB_SHAPER_DATA_GET (font);
|
||||
|
||||
const char *lang = hb_language_to_string (hb_buffer_get_language (buffer));
|
||||
const char *lang_end = lang ? strchr (lang, '-') : NULL;
|
||||
|
@ -259,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 (grfont, grface,
|
||||
seg = gr_make_seg (NULL, grface,
|
||||
script_tag[1] == HB_TAG_NONE ? script_tag[0] : script_tag[1],
|
||||
feats,
|
||||
gr_utf32, chars, buffer->len,
|
||||
|
@ -310,6 +301,12 @@ _hb_graphite2_shape (hb_shape_plan_t *shape_plan,
|
|||
|
||||
hb_codepoint_t *pg = gids;
|
||||
clusters[0].cluster = buffer->info[0].cluster;
|
||||
float curradv = 0.;
|
||||
if (HB_DIRECTION_IS_BACKWARD(buffer->props.direction))
|
||||
{
|
||||
curradv = gr_slot_origin_X(gr_seg_first_slot(seg));
|
||||
clusters[0].advance = gr_seg_advance_X(seg) - curradv;
|
||||
}
|
||||
for (is = gr_seg_first_slot (seg), ic = 0; is; is = gr_slot_next_in_segment (is), ic++)
|
||||
{
|
||||
unsigned int before = gr_slot_before (is);
|
||||
|
@ -320,6 +317,7 @@ _hb_graphite2_shape (hb_shape_plan_t *shape_plan,
|
|||
{
|
||||
clusters[ci-1].num_chars += clusters[ci].num_chars;
|
||||
clusters[ci-1].num_glyphs += clusters[ci].num_glyphs;
|
||||
clusters[ci-1].advance += clusters[ci].advance;
|
||||
ci--;
|
||||
}
|
||||
|
||||
|
@ -331,13 +329,23 @@ _hb_graphite2_shape (hb_shape_plan_t *shape_plan,
|
|||
c->num_chars = before - c->base_char;
|
||||
c->base_glyph = ic;
|
||||
c->num_glyphs = 0;
|
||||
if (HB_DIRECTION_IS_BACKWARD(buffer->props.direction))
|
||||
c->advance = curradv - gr_slot_origin_X(is);
|
||||
else
|
||||
clusters[ci].advance = gr_slot_origin_X(is) - curradv;
|
||||
ci++;
|
||||
curradv = gr_slot_origin_X(is);
|
||||
}
|
||||
clusters[ci].num_glyphs++;
|
||||
|
||||
if (clusters[ci].base_char + clusters[ci].num_chars < after + 1)
|
||||
clusters[ci].num_chars = after + 1 - clusters[ci].base_char;
|
||||
}
|
||||
|
||||
if (HB_DIRECTION_IS_BACKWARD(buffer->props.direction))
|
||||
clusters[ci].advance += curradv;
|
||||
else
|
||||
clusters[ci].advance = gr_seg_advance_X(seg) - curradv;
|
||||
ci++;
|
||||
|
||||
for (unsigned int i = 0; i < ci; ++i)
|
||||
|
@ -347,57 +355,55 @@ _hb_graphite2_shape (hb_shape_plan_t *shape_plan,
|
|||
hb_glyph_info_t *info = &buffer->info[clusters[i].base_glyph + j];
|
||||
info->codepoint = gids[clusters[i].base_glyph + j];
|
||||
info->cluster = clusters[i].cluster;
|
||||
info->mask = HB_GLYPH_FLAG_UNSAFE_TO_BREAK;
|
||||
info->var1.i32 = clusters[i].advance; // all glyphs in the cluster get the same advance
|
||||
}
|
||||
}
|
||||
buffer->len = glyph_count;
|
||||
|
||||
unsigned int upem = hb_face_get_upem (face);
|
||||
float xscale = (float) font->x_scale / upem;
|
||||
float yscale = (float) font->y_scale / upem;
|
||||
yscale *= yscale / xscale;
|
||||
/* 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);
|
||||
if (!HB_DIRECTION_IS_BACKWARD(buffer->props.direction))
|
||||
{
|
||||
hb_glyph_position_t *pPos;
|
||||
for (pPos = hb_buffer_get_glyph_positions (buffer, NULL), is = gr_seg_first_slot (seg);
|
||||
is; pPos++, is = gr_slot_next_in_segment (is))
|
||||
curradvx = 0;
|
||||
for (is = gr_seg_first_slot (seg); is; pPos++, ++info, is = gr_slot_next_in_segment (is))
|
||||
{
|
||||
pPos->x_offset = gr_slot_origin_X (is) - curradvx;
|
||||
pPos->y_offset = gr_slot_origin_Y (is) - curradvy;
|
||||
pPos->x_advance = gr_slot_advance_X (is, grface, grfont);
|
||||
pPos->y_advance = gr_slot_advance_Y (is, grface, grfont);
|
||||
curradvx += pPos->x_advance;
|
||||
pPos->x_offset = gr_slot_origin_X (is) * xscale - curradvx;
|
||||
pPos->y_offset = gr_slot_origin_Y (is) * yscale - curradvy;
|
||||
if (info->cluster != currclus) {
|
||||
pPos->x_advance = info->var1.i32 * xscale;
|
||||
curradvx += pPos->x_advance;
|
||||
currclus = info->cluster;
|
||||
} else
|
||||
pPos->x_advance = 0.;
|
||||
|
||||
pPos->y_advance = gr_slot_advance_Y (is, grface, NULL) * yscale;
|
||||
curradvy += pPos->y_advance;
|
||||
}
|
||||
pPos[-1].x_advance += gr_seg_advance_X(seg) - curradvx;
|
||||
}
|
||||
else
|
||||
{
|
||||
hb_glyph_position_t *pPos = hb_buffer_get_glyph_positions (buffer, NULL) + buffer->len - 1;
|
||||
const hb_glyph_info_t *info = buffer->info + buffer->len - 1;
|
||||
const hb_glyph_info_t *tinfo;
|
||||
const gr_slot *tis;
|
||||
int currclus = -1;
|
||||
float clusx = 0., clusy = 0.;
|
||||
for (is = gr_seg_last_slot (seg); is; pPos--, info--, is = gr_slot_prev_in_segment (is))
|
||||
curradvx = gr_seg_advance_X(seg);
|
||||
for (is = gr_seg_first_slot (seg); is; pPos++, info++, is = gr_slot_next_in_segment (is))
|
||||
{
|
||||
if (info->cluster != currclus)
|
||||
{
|
||||
curradvx += clusx;
|
||||
curradvy += clusy;
|
||||
pPos->x_advance = info->var1.i32 * xscale;
|
||||
curradvx -= pPos->x_advance;
|
||||
currclus = info->cluster;
|
||||
clusx = 0.;
|
||||
clusy = 0.;
|
||||
for (tis = is, tinfo = info; tis && tinfo->cluster == currclus; tis = gr_slot_prev_in_segment (tis), tinfo--)
|
||||
{
|
||||
clusx += gr_slot_advance_X (tis, grface, grfont);
|
||||
clusy += gr_slot_advance_Y (tis, grface, grfont);
|
||||
}
|
||||
curradvx += clusx;
|
||||
curradvy += clusy;
|
||||
}
|
||||
pPos->x_advance = gr_slot_advance_X (is, grface, grfont);
|
||||
pPos->y_advance = gr_slot_advance_Y (is, grface, grfont);
|
||||
curradvx -= pPos->x_advance;
|
||||
} else
|
||||
pPos->x_advance = 0.;
|
||||
|
||||
pPos->y_advance = gr_slot_advance_Y (is, grface, NULL) * yscale;
|
||||
curradvy -= pPos->y_advance;
|
||||
pPos->x_offset = gr_slot_origin_X (is) - curradvx;
|
||||
pPos->y_offset = gr_slot_origin_Y (is) - curradvy;
|
||||
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;
|
||||
}
|
||||
hb_buffer_reverse_clusters (buffer);
|
||||
}
|
||||
|
|
|
@ -36,12 +36,16 @@ HB_BEGIN_DECLS
|
|||
#define HB_GRAPHITE2_TAG_SILF HB_TAG('S','i','l','f')
|
||||
|
||||
|
||||
gr_face *
|
||||
HB_EXTERN gr_face *
|
||||
hb_graphite2_face_get_gr_face (hb_face_t *face);
|
||||
|
||||
gr_font *
|
||||
#ifndef HB_DISABLE_DEPRECATED
|
||||
|
||||
HB_EXTERN gr_font *
|
||||
hb_graphite2_font_get_gr_font (hb_font_t *font);
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
HB_END_DECLS
|
||||
|
||||
|
|
|
@ -36,6 +36,7 @@
|
|||
#include <unicode/uchar.h>
|
||||
#include <unicode/unorm.h>
|
||||
#include <unicode/ustring.h>
|
||||
#include <unicode/utf16.h>
|
||||
#include <unicode/uversion.h>
|
||||
|
||||
|
||||
|
|
|
@ -36,14 +36,14 @@
|
|||
HB_BEGIN_DECLS
|
||||
|
||||
|
||||
hb_script_t
|
||||
HB_EXTERN hb_script_t
|
||||
hb_icu_script_to_script (UScriptCode script);
|
||||
|
||||
UScriptCode
|
||||
HB_EXTERN UScriptCode
|
||||
hb_icu_script_from_script (hb_script_t script);
|
||||
|
||||
|
||||
hb_unicode_funcs_t *
|
||||
HB_EXTERN hb_unicode_funcs_t *
|
||||
hb_icu_get_unicode_funcs (void);
|
||||
|
||||
|
||||
|
|
|
@ -140,9 +140,9 @@ struct TTCHeaderVersion1
|
|||
|
||||
protected:
|
||||
Tag ttcTag; /* TrueType Collection ID string: 'ttcf' */
|
||||
FixedVersion version; /* Version of the TTC Header (1.0),
|
||||
FixedVersion<>version; /* Version of the TTC Header (1.0),
|
||||
* 0x00010000u */
|
||||
ArrayOf<OffsetTo<OffsetTable, ULONG>, ULONG>
|
||||
ArrayOf<LOffsetTo<OffsetTable>, ULONG>
|
||||
table; /* Array of offsets to the OffsetTable for each font
|
||||
* from the beginning of the file */
|
||||
public:
|
||||
|
@ -187,7 +187,7 @@ struct TTCHeader
|
|||
union {
|
||||
struct {
|
||||
Tag ttcTag; /* TrueType Collection ID string: 'ttcf' */
|
||||
FixedVersion version; /* Version of the TTC Header (1.0 or 2.0),
|
||||
FixedVersion<>version; /* Version of the TTC Header (1.0 or 2.0),
|
||||
* 0x00010000u or 0x00020000u */
|
||||
} header;
|
||||
TTCHeaderVersion1 version1;
|
||||
|
|
|
@ -30,6 +30,7 @@
|
|||
#define HB_OPEN_TYPE_PRIVATE_HH
|
||||
|
||||
#include "hb-private.hh"
|
||||
#include "hb-face-private.hh"
|
||||
|
||||
|
||||
namespace OT {
|
||||
|
@ -101,10 +102,11 @@ static inline Type& StructAfter(TObject &X)
|
|||
#define DEFINE_SIZE_STATIC(size) \
|
||||
DEFINE_INSTANCE_ASSERTION (sizeof (*this) == (size)); \
|
||||
static const unsigned int static_size = (size); \
|
||||
static const unsigned int min_size = (size)
|
||||
static const unsigned int min_size = (size); \
|
||||
inline unsigned int get_size (void) const { return (size); }
|
||||
|
||||
#define DEFINE_SIZE_UNION(size, _member) \
|
||||
DEFINE_INSTANCE_ASSERTION (this->u._member.static_size == (size)); \
|
||||
DEFINE_INSTANCE_ASSERTION (0*sizeof(this->u._member.static_size) + sizeof(this->u._member) == (size)); \
|
||||
static const unsigned int min_size = (size)
|
||||
|
||||
#define DEFINE_SIZE_MIN(size) \
|
||||
|
@ -182,7 +184,7 @@ struct hb_dispatch_context_t
|
|||
|
||||
/* This limits sanitizing time on really broken fonts. */
|
||||
#ifndef HB_SANITIZE_MAX_EDITS
|
||||
#define HB_SANITIZE_MAX_EDITS 8
|
||||
#define HB_SANITIZE_MAX_EDITS 32
|
||||
#endif
|
||||
|
||||
struct hb_sanitize_context_t :
|
||||
|
@ -649,7 +651,9 @@ struct IntType
|
|||
DEFINE_SIZE_STATIC (Size);
|
||||
};
|
||||
|
||||
typedef IntType<int8_t , 1> CHAR; /* 8-bit signed integer. */
|
||||
typedef IntType<uint8_t , 1> BYTE; /* 8-bit unsigned integer. */
|
||||
typedef IntType<int8_t , 1> INT8; /* 8-bit signed integer. */
|
||||
typedef IntType<uint16_t, 2> USHORT; /* 16-bit unsigned integer. */
|
||||
typedef IntType<int16_t, 2> SHORT; /* 16-bit signed integer. */
|
||||
typedef IntType<uint32_t, 4> ULONG; /* 32-bit unsigned integer. */
|
||||
|
@ -662,6 +666,24 @@ typedef SHORT FWORD;
|
|||
/* 16-bit unsigned integer (USHORT) that describes a quantity in FUnits. */
|
||||
typedef USHORT UFWORD;
|
||||
|
||||
/* 16-bit signed fixed number with the low 14 bits of fraction (2.14). */
|
||||
struct F2DOT14 : SHORT
|
||||
{
|
||||
//inline float to_float (void) const { return ???; }
|
||||
//inline void set_float (float f) { v.set (f * ???); }
|
||||
public:
|
||||
DEFINE_SIZE_STATIC (2);
|
||||
};
|
||||
|
||||
/* 32-bit signed fixed-point number (16.16). */
|
||||
struct Fixed: LONG
|
||||
{
|
||||
//inline float to_float (void) const { return ???; }
|
||||
//inline void set_float (float f) { v.set (f * ???); }
|
||||
public:
|
||||
DEFINE_SIZE_STATIC (4);
|
||||
};
|
||||
|
||||
/* Date represented in number of seconds since 12:00 midnight, January 1,
|
||||
* 1904. The value is represented as a signed 64-bit integer. */
|
||||
struct LONGDATETIME
|
||||
|
@ -739,9 +761,10 @@ struct CheckSum : ULONG
|
|||
* Version Numbers
|
||||
*/
|
||||
|
||||
template <typename FixedType=USHORT>
|
||||
struct FixedVersion
|
||||
{
|
||||
inline uint32_t to_int (void) const { return (major << 16) + minor; }
|
||||
inline uint32_t to_int (void) const { return (major << (sizeof(FixedType) * 8)) + minor; }
|
||||
|
||||
inline bool sanitize (hb_sanitize_context_t *c) const
|
||||
{
|
||||
|
@ -749,10 +772,10 @@ struct FixedVersion
|
|||
return_trace (c->check_struct (this));
|
||||
}
|
||||
|
||||
USHORT major;
|
||||
USHORT minor;
|
||||
FixedType major;
|
||||
FixedType minor;
|
||||
public:
|
||||
DEFINE_SIZE_STATIC (4);
|
||||
DEFINE_SIZE_STATIC (2 * sizeof(FixedType));
|
||||
};
|
||||
|
||||
|
||||
|
@ -785,6 +808,7 @@ struct OffsetTo : Offset<OffsetType>
|
|||
if (unlikely (!c->check_struct (this))) return_trace (false);
|
||||
unsigned int offset = *this;
|
||||
if (unlikely (!offset)) return_trace (true);
|
||||
if (unlikely (!c->check_range (base, offset))) return_trace (false);
|
||||
const Type &obj = StructAtOffset<Type> (base, offset);
|
||||
return_trace (likely (obj.sanitize (c)) || neuter (c));
|
||||
}
|
||||
|
@ -795,6 +819,7 @@ struct OffsetTo : Offset<OffsetType>
|
|||
if (unlikely (!c->check_struct (this))) return_trace (false);
|
||||
unsigned int offset = *this;
|
||||
if (unlikely (!offset)) return_trace (true);
|
||||
if (unlikely (!c->check_range (base, offset))) return_trace (false);
|
||||
const Type &obj = StructAtOffset<Type> (base, offset);
|
||||
return_trace (likely (obj.sanitize (c, user_data)) || neuter (c));
|
||||
}
|
||||
|
@ -805,6 +830,7 @@ struct OffsetTo : Offset<OffsetType>
|
|||
}
|
||||
DEFINE_SIZE_STATIC (sizeof(OffsetType));
|
||||
};
|
||||
template <typename Type> struct LOffsetTo : OffsetTo<Type, ULONG> {};
|
||||
template <typename Base, typename OffsetType, typename Type>
|
||||
static inline const Type& operator + (const Base &base, const OffsetTo<Type, OffsetType> &offset) { return offset (base); }
|
||||
template <typename Base, typename OffsetType, typename Type>
|
||||
|
@ -926,10 +952,11 @@ struct ArrayOf
|
|||
public:
|
||||
DEFINE_SIZE_ARRAY (sizeof (LenType), array);
|
||||
};
|
||||
template <typename Type> struct LArrayOf : ArrayOf<Type, ULONG> {};
|
||||
|
||||
/* Array of Offset's */
|
||||
template <typename Type>
|
||||
struct OffsetArrayOf : ArrayOf<OffsetTo<Type> > {};
|
||||
template <typename Type, typename OffsetType=USHORT>
|
||||
struct OffsetArrayOf : ArrayOf<OffsetTo<Type, OffsetType> > {};
|
||||
|
||||
/* Array of offsets relative to the beginning of the array itself. */
|
||||
template <typename Type>
|
||||
|
@ -1037,6 +1064,104 @@ struct SortedArrayOf : ArrayOf<Type, LenType>
|
|||
};
|
||||
|
||||
|
||||
/* Lazy struct and blob loaders. */
|
||||
|
||||
/* Logic is shared between hb_lazy_loader_t and hb_lazy_table_loader_t */
|
||||
template <typename T>
|
||||
struct hb_lazy_loader_t
|
||||
{
|
||||
inline void init (hb_face_t *face_)
|
||||
{
|
||||
face = face_;
|
||||
instance = NULL;
|
||||
}
|
||||
|
||||
inline void fini (void)
|
||||
{
|
||||
if (instance && instance != &OT::Null(T))
|
||||
{
|
||||
instance->fini();
|
||||
free (instance);
|
||||
}
|
||||
}
|
||||
|
||||
inline const T* get (void) const
|
||||
{
|
||||
retry:
|
||||
T *p = (T *) hb_atomic_ptr_get (&instance);
|
||||
if (unlikely (!p))
|
||||
{
|
||||
p = (T *) calloc (1, sizeof (T));
|
||||
if (unlikely (!p))
|
||||
p = const_cast<T *> (&OT::Null(T));
|
||||
else
|
||||
p->init (face);
|
||||
if (unlikely (!hb_atomic_ptr_cmpexch (const_cast<T **>(&instance), NULL, p)))
|
||||
{
|
||||
if (p != &OT::Null(T))
|
||||
p->fini ();
|
||||
goto retry;
|
||||
}
|
||||
}
|
||||
return p;
|
||||
}
|
||||
|
||||
inline const T* operator-> (void) const
|
||||
{
|
||||
return get ();
|
||||
}
|
||||
|
||||
private:
|
||||
hb_face_t *face;
|
||||
T *instance;
|
||||
};
|
||||
|
||||
/* Logic is shared between hb_lazy_loader_t and hb_lazy_table_loader_t */
|
||||
template <typename T>
|
||||
struct hb_lazy_table_loader_t
|
||||
{
|
||||
inline void init (hb_face_t *face_)
|
||||
{
|
||||
face = face_;
|
||||
instance = NULL;
|
||||
blob = NULL;
|
||||
}
|
||||
|
||||
inline void fini (void)
|
||||
{
|
||||
hb_blob_destroy (blob);
|
||||
}
|
||||
|
||||
inline const T* get (void) const
|
||||
{
|
||||
retry:
|
||||
T *p = (T *) hb_atomic_ptr_get (&instance);
|
||||
if (unlikely (!p))
|
||||
{
|
||||
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))
|
||||
{
|
||||
hb_blob_destroy (blob_);
|
||||
goto retry;
|
||||
}
|
||||
blob = blob_;
|
||||
}
|
||||
return p;
|
||||
}
|
||||
|
||||
inline const T* operator-> (void) const
|
||||
{
|
||||
return get();
|
||||
}
|
||||
|
||||
private:
|
||||
hb_face_t *face;
|
||||
T *instance;
|
||||
mutable hb_blob_t *blob;
|
||||
};
|
||||
|
||||
|
||||
} /* namespace OT */
|
||||
|
||||
|
||||
|
|
|
@ -0,0 +1,384 @@
|
|||
/*
|
||||
* Copyright © 2016 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): Seigo Nonaka
|
||||
*/
|
||||
|
||||
#ifndef HB_OT_CBDT_TABLE_HH
|
||||
#define HB_OT_CBDT_TABLE_HH
|
||||
|
||||
#include "hb-open-type-private.hh"
|
||||
|
||||
namespace OT {
|
||||
|
||||
struct SmallGlyphMetrics
|
||||
{
|
||||
inline bool sanitize (hb_sanitize_context_t *c) const
|
||||
{
|
||||
TRACE_SANITIZE (this);
|
||||
return_trace (c->check_struct (this));
|
||||
}
|
||||
|
||||
inline void get_extents (hb_glyph_extents_t *extents) const
|
||||
{
|
||||
extents->x_bearing = bearingX;
|
||||
extents->y_bearing = bearingY;
|
||||
extents->width = width;
|
||||
extents->height = -height;
|
||||
}
|
||||
|
||||
BYTE height;
|
||||
BYTE width;
|
||||
CHAR bearingX;
|
||||
CHAR bearingY;
|
||||
BYTE advance;
|
||||
|
||||
DEFINE_SIZE_STATIC(5);
|
||||
};
|
||||
|
||||
struct BigGlyphMetrics : SmallGlyphMetrics
|
||||
{
|
||||
CHAR vertBearingX;
|
||||
CHAR vertBearingY;
|
||||
BYTE vertAdvance;
|
||||
|
||||
DEFINE_SIZE_STATIC(8);
|
||||
};
|
||||
|
||||
struct SBitLineMetrics
|
||||
{
|
||||
inline bool sanitize (hb_sanitize_context_t *c) const
|
||||
{
|
||||
TRACE_SANITIZE (this);
|
||||
return_trace (c->check_struct (this));
|
||||
}
|
||||
|
||||
CHAR ascender;
|
||||
CHAR decender;
|
||||
BYTE widthMax;
|
||||
CHAR caretSlopeNumerator;
|
||||
CHAR caretSlopeDenominator;
|
||||
CHAR caretOffset;
|
||||
CHAR minOriginSB;
|
||||
CHAR minAdvanceSB;
|
||||
CHAR maxBeforeBL;
|
||||
CHAR minAfterBL;
|
||||
CHAR padding1;
|
||||
CHAR padding2;
|
||||
|
||||
DEFINE_SIZE_STATIC(12);
|
||||
};
|
||||
|
||||
|
||||
/*
|
||||
* Index Subtables.
|
||||
*/
|
||||
|
||||
struct IndexSubtableHeader
|
||||
{
|
||||
inline bool sanitize (hb_sanitize_context_t *c) const
|
||||
{
|
||||
TRACE_SANITIZE (this);
|
||||
return_trace (c->check_struct (this));
|
||||
}
|
||||
|
||||
USHORT indexFormat;
|
||||
USHORT imageFormat;
|
||||
ULONG imageDataOffset;
|
||||
|
||||
DEFINE_SIZE_STATIC(8);
|
||||
};
|
||||
|
||||
template <typename OffsetType>
|
||||
struct IndexSubtableFormat1Or3
|
||||
{
|
||||
inline bool sanitize (hb_sanitize_context_t *c, unsigned int glyph_count) const
|
||||
{
|
||||
TRACE_SANITIZE (this);
|
||||
return_trace (c->check_struct (this) &&
|
||||
c->check_array (offsetArrayZ, offsetArrayZ[0].static_size, glyph_count + 1));
|
||||
}
|
||||
|
||||
bool get_image_data (unsigned int idx,
|
||||
unsigned int *offset,
|
||||
unsigned int *length) const
|
||||
{
|
||||
if (unlikely (offsetArrayZ[idx + 1] <= offsetArrayZ[idx]))
|
||||
return false;
|
||||
|
||||
*offset = header.imageDataOffset + offsetArrayZ[idx];
|
||||
*length = offsetArrayZ[idx + 1] - offsetArrayZ[idx];
|
||||
return true;
|
||||
}
|
||||
|
||||
IndexSubtableHeader header;
|
||||
Offset<OffsetType> offsetArrayZ[VAR];
|
||||
|
||||
DEFINE_SIZE_ARRAY(8, offsetArrayZ);
|
||||
};
|
||||
|
||||
struct IndexSubtableFormat1 : IndexSubtableFormat1Or3<ULONG> {};
|
||||
struct IndexSubtableFormat3 : IndexSubtableFormat1Or3<USHORT> {};
|
||||
|
||||
struct IndexSubtable
|
||||
{
|
||||
inline bool sanitize (hb_sanitize_context_t *c, unsigned int glyph_count) const
|
||||
{
|
||||
TRACE_SANITIZE (this);
|
||||
if (!u.header.sanitize (c)) return_trace (false);
|
||||
switch (u.header.indexFormat) {
|
||||
case 1: return_trace (u.format1.sanitize (c, glyph_count));
|
||||
case 3: return_trace (u.format3.sanitize (c, glyph_count));
|
||||
default:return_trace (true);
|
||||
}
|
||||
}
|
||||
|
||||
inline bool get_extents (hb_glyph_extents_t *extents) const
|
||||
{
|
||||
switch (u.header.indexFormat) {
|
||||
case 2: case 5: /* TODO */
|
||||
case 1: case 3: case 4: /* Variable-metrics formats do not have metrics here. */
|
||||
default:return (false);
|
||||
}
|
||||
}
|
||||
|
||||
bool get_image_data (unsigned int idx,
|
||||
unsigned int *offset,
|
||||
unsigned int *length,
|
||||
unsigned int *format) const
|
||||
{
|
||||
*format = u.header.imageFormat;
|
||||
switch (u.header.indexFormat) {
|
||||
case 1: return u.format1.get_image_data (idx, offset, length);
|
||||
case 3: return u.format3.get_image_data (idx, offset, length);
|
||||
default: return false;
|
||||
}
|
||||
}
|
||||
|
||||
protected:
|
||||
union {
|
||||
IndexSubtableHeader header;
|
||||
IndexSubtableFormat1 format1;
|
||||
IndexSubtableFormat3 format3;
|
||||
/* TODO: Format 2, 4, 5. */
|
||||
} u;
|
||||
public:
|
||||
DEFINE_SIZE_UNION (8, header);
|
||||
};
|
||||
|
||||
struct IndexSubtableRecord
|
||||
{
|
||||
inline bool sanitize (hb_sanitize_context_t *c, const void *base) const
|
||||
{
|
||||
TRACE_SANITIZE (this);
|
||||
return_trace (c->check_struct (this) &&
|
||||
firstGlyphIndex <= lastGlyphIndex &&
|
||||
offsetToSubtable.sanitize (c, this, lastGlyphIndex - firstGlyphIndex + 1));
|
||||
}
|
||||
|
||||
inline bool get_extents (hb_glyph_extents_t *extents) const
|
||||
{
|
||||
return (this+offsetToSubtable).get_extents (extents);
|
||||
}
|
||||
|
||||
bool get_image_data (unsigned int gid,
|
||||
unsigned int *offset,
|
||||
unsigned int *length,
|
||||
unsigned int *format) const
|
||||
{
|
||||
if (gid < firstGlyphIndex || gid > lastGlyphIndex)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
return (this+offsetToSubtable).get_image_data (gid - firstGlyphIndex,
|
||||
offset, length, format);
|
||||
}
|
||||
|
||||
USHORT firstGlyphIndex;
|
||||
USHORT lastGlyphIndex;
|
||||
LOffsetTo<IndexSubtable> offsetToSubtable;
|
||||
|
||||
DEFINE_SIZE_STATIC(8);
|
||||
};
|
||||
|
||||
struct IndexSubtableArray
|
||||
{
|
||||
inline bool sanitize (hb_sanitize_context_t *c, unsigned int count) const
|
||||
{
|
||||
TRACE_SANITIZE (this);
|
||||
if (unlikely (!c->check_array (&indexSubtablesZ, indexSubtablesZ[0].static_size, count)))
|
||||
return_trace (false);
|
||||
for (unsigned int i = 0; i < count; i++)
|
||||
if (unlikely (!indexSubtablesZ[i].sanitize (c, this)))
|
||||
return_trace (false);
|
||||
return_trace (true);
|
||||
}
|
||||
|
||||
public:
|
||||
const IndexSubtableRecord* find_table (hb_codepoint_t glyph, unsigned int numTables) const
|
||||
{
|
||||
for (unsigned int i = 0; i < numTables; ++i)
|
||||
{
|
||||
unsigned int firstGlyphIndex = indexSubtablesZ[i].firstGlyphIndex;
|
||||
unsigned int lastGlyphIndex = indexSubtablesZ[i].lastGlyphIndex;
|
||||
if (firstGlyphIndex <= glyph && glyph <= lastGlyphIndex) {
|
||||
return &indexSubtablesZ[i];
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
protected:
|
||||
IndexSubtableRecord indexSubtablesZ[VAR];
|
||||
|
||||
public:
|
||||
DEFINE_SIZE_ARRAY(0, indexSubtablesZ);
|
||||
};
|
||||
|
||||
struct BitmapSizeTable
|
||||
{
|
||||
friend struct CBLC;
|
||||
|
||||
inline bool sanitize (hb_sanitize_context_t *c, const void *base) const
|
||||
{
|
||||
TRACE_SANITIZE (this);
|
||||
return_trace (c->check_struct (this) &&
|
||||
indexSubtableArrayOffset.sanitize (c, base, numberOfIndexSubtables) &&
|
||||
c->check_range (&(base+indexSubtableArrayOffset), indexTablesSize) &&
|
||||
horizontal.sanitize (c) &&
|
||||
vertical.sanitize (c));
|
||||
}
|
||||
|
||||
const IndexSubtableRecord *find_table (hb_codepoint_t glyph, const void *base) const
|
||||
{
|
||||
return (base+indexSubtableArrayOffset).find_table (glyph, numberOfIndexSubtables);
|
||||
}
|
||||
|
||||
protected:
|
||||
LOffsetTo<IndexSubtableArray> indexSubtableArrayOffset;
|
||||
ULONG indexTablesSize;
|
||||
ULONG numberOfIndexSubtables;
|
||||
ULONG colorRef;
|
||||
SBitLineMetrics horizontal;
|
||||
SBitLineMetrics vertical;
|
||||
USHORT startGlyphIndex;
|
||||
USHORT endGlyphIndex;
|
||||
BYTE ppemX;
|
||||
BYTE ppemY;
|
||||
BYTE bitDepth;
|
||||
CHAR flags;
|
||||
|
||||
public:
|
||||
DEFINE_SIZE_STATIC(48);
|
||||
};
|
||||
|
||||
|
||||
/*
|
||||
* Glyph Bitmap Data Formats.
|
||||
*/
|
||||
|
||||
struct GlyphBitmapDataFormat17
|
||||
{
|
||||
SmallGlyphMetrics glyphMetrics;
|
||||
ULONG dataLen;
|
||||
BYTE dataZ[VAR];
|
||||
|
||||
DEFINE_SIZE_ARRAY(9, dataZ);
|
||||
};
|
||||
|
||||
|
||||
/*
|
||||
* CBLC -- Color Bitmap Location Table
|
||||
*/
|
||||
|
||||
#define HB_OT_TAG_CBLC HB_TAG('C','B','L','C')
|
||||
|
||||
struct CBLC
|
||||
{
|
||||
static const hb_tag_t tableTag = HB_OT_TAG_CBLC;
|
||||
|
||||
inline bool sanitize (hb_sanitize_context_t *c) const
|
||||
{
|
||||
TRACE_SANITIZE (this);
|
||||
return_trace (c->check_struct (this) &&
|
||||
likely (version.major == 2 || version.major == 3) &&
|
||||
sizeTables.sanitize (c, this));
|
||||
}
|
||||
|
||||
public:
|
||||
const IndexSubtableRecord *find_table (hb_codepoint_t glyph,
|
||||
unsigned int *x_ppem, unsigned int *y_ppem) const
|
||||
{
|
||||
/* TODO: Make it possible to select strike. */
|
||||
|
||||
unsigned int count = sizeTables.len;
|
||||
for (uint32_t i = 0; i < count; ++i)
|
||||
{
|
||||
unsigned int startGlyphIndex = sizeTables.array[i].startGlyphIndex;
|
||||
unsigned int endGlyphIndex = sizeTables.array[i].endGlyphIndex;
|
||||
if (startGlyphIndex <= glyph && glyph <= endGlyphIndex)
|
||||
{
|
||||
*x_ppem = sizeTables[i].ppemX;
|
||||
*y_ppem = sizeTables[i].ppemY;
|
||||
return sizeTables[i].find_table (glyph, this);
|
||||
}
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
protected:
|
||||
FixedVersion<> version;
|
||||
LArrayOf<BitmapSizeTable> sizeTables;
|
||||
|
||||
public:
|
||||
DEFINE_SIZE_ARRAY(8, sizeTables);
|
||||
};
|
||||
|
||||
/*
|
||||
* CBDT -- Color Bitmap Data Table
|
||||
*/
|
||||
#define HB_OT_TAG_CBDT HB_TAG('C','B','D','T')
|
||||
|
||||
struct CBDT
|
||||
{
|
||||
static const hb_tag_t tableTag = HB_OT_TAG_CBDT;
|
||||
|
||||
inline bool sanitize (hb_sanitize_context_t *c) const
|
||||
{
|
||||
TRACE_SANITIZE (this);
|
||||
return_trace (c->check_struct (this) &&
|
||||
likely (version.major == 2 || version.major == 3));
|
||||
}
|
||||
|
||||
protected:
|
||||
FixedVersion<>version;
|
||||
BYTE dataZ[VAR];
|
||||
|
||||
public:
|
||||
DEFINE_SIZE_ARRAY(4, dataZ);
|
||||
};
|
||||
|
||||
} /* namespace OT */
|
||||
|
||||
#endif /* HB_OT_CBDT_TABLE_HH */
|
|
@ -69,61 +69,78 @@ struct CmapSubtableFormat0
|
|||
|
||||
struct CmapSubtableFormat4
|
||||
{
|
||||
inline bool get_glyph (hb_codepoint_t codepoint, hb_codepoint_t *glyph) const
|
||||
struct accelerator_t
|
||||
{
|
||||
unsigned int segCount;
|
||||
inline void init (const CmapSubtableFormat4 *subtable)
|
||||
{
|
||||
segCount = subtable->segCountX2 / 2;
|
||||
endCount = subtable->values;
|
||||
startCount = endCount + segCount + 1;
|
||||
idDelta = startCount + segCount;
|
||||
idRangeOffset = idDelta + segCount;
|
||||
glyphIdArray = idRangeOffset + segCount;
|
||||
glyphIdArrayLength = (subtable->length - 16 - 8 * segCount) / 2;
|
||||
}
|
||||
|
||||
static inline bool get_glyph_func (const void *obj, hb_codepoint_t codepoint, hb_codepoint_t *glyph)
|
||||
{
|
||||
const accelerator_t *thiz = (const accelerator_t *) obj;
|
||||
|
||||
/* Custom two-array bsearch. */
|
||||
int min = 0, max = (int) thiz->segCount - 1;
|
||||
const USHORT *startCount = thiz->startCount;
|
||||
const USHORT *endCount = thiz->endCount;
|
||||
unsigned int i;
|
||||
while (min <= max)
|
||||
{
|
||||
int mid = (min + max) / 2;
|
||||
if (codepoint < startCount[mid])
|
||||
max = mid - 1;
|
||||
else if (codepoint > endCount[mid])
|
||||
min = mid + 1;
|
||||
else
|
||||
{
|
||||
i = mid;
|
||||
goto found;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
|
||||
found:
|
||||
hb_codepoint_t gid;
|
||||
unsigned int rangeOffset = thiz->idRangeOffset[i];
|
||||
if (rangeOffset == 0)
|
||||
gid = codepoint + thiz->idDelta[i];
|
||||
else
|
||||
{
|
||||
/* Somebody has been smoking... */
|
||||
unsigned int index = rangeOffset / 2 + (codepoint - thiz->startCount[i]) + i - thiz->segCount;
|
||||
if (unlikely (index >= thiz->glyphIdArrayLength))
|
||||
return false;
|
||||
gid = thiz->glyphIdArray[index];
|
||||
if (unlikely (!gid))
|
||||
return false;
|
||||
gid += thiz->idDelta[i];
|
||||
}
|
||||
|
||||
*glyph = gid & 0xFFFFu;
|
||||
return true;
|
||||
}
|
||||
|
||||
const USHORT *endCount;
|
||||
const USHORT *startCount;
|
||||
const USHORT *idDelta;
|
||||
const USHORT *idRangeOffset;
|
||||
const USHORT *glyphIdArray;
|
||||
unsigned int segCount;
|
||||
unsigned int glyphIdArrayLength;
|
||||
};
|
||||
|
||||
segCount = this->segCountX2 / 2;
|
||||
endCount = this->values;
|
||||
startCount = endCount + segCount + 1;
|
||||
idDelta = startCount + segCount;
|
||||
idRangeOffset = idDelta + segCount;
|
||||
glyphIdArray = idRangeOffset + segCount;
|
||||
glyphIdArrayLength = (this->length - 16 - 8 * segCount) / 2;
|
||||
|
||||
/* Custom two-array bsearch. */
|
||||
int min = 0, max = (int) segCount - 1;
|
||||
unsigned int i;
|
||||
while (min <= max)
|
||||
{
|
||||
int mid = (min + max) / 2;
|
||||
if (codepoint < startCount[mid])
|
||||
max = mid - 1;
|
||||
else if (codepoint > endCount[mid])
|
||||
min = mid + 1;
|
||||
else
|
||||
{
|
||||
i = mid;
|
||||
goto found;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
|
||||
found:
|
||||
hb_codepoint_t gid;
|
||||
unsigned int rangeOffset = idRangeOffset[i];
|
||||
if (rangeOffset == 0)
|
||||
gid = codepoint + idDelta[i];
|
||||
else
|
||||
{
|
||||
/* Somebody has been smoking... */
|
||||
unsigned int index = rangeOffset / 2 + (codepoint - startCount[i]) + i - segCount;
|
||||
if (unlikely (index >= glyphIdArrayLength))
|
||||
return false;
|
||||
gid = glyphIdArray[index];
|
||||
if (unlikely (!gid))
|
||||
return false;
|
||||
gid += idDelta[i];
|
||||
}
|
||||
|
||||
*glyph = gid & 0xFFFFu;
|
||||
return true;
|
||||
inline bool get_glyph (hb_codepoint_t codepoint, hb_codepoint_t *glyph) const
|
||||
{
|
||||
accelerator_t accel;
|
||||
accel.init (this);
|
||||
return accel.get_glyph_func (&accel, codepoint, glyph);
|
||||
}
|
||||
|
||||
inline bool sanitize (hb_sanitize_context_t *c) const
|
||||
|
@ -363,9 +380,9 @@ struct VariationSelectorRecord
|
|||
}
|
||||
|
||||
UINT24 varSelector; /* Variation selector. */
|
||||
OffsetTo<DefaultUVS, ULONG>
|
||||
LOffsetTo<DefaultUVS>
|
||||
defaultUVS; /* Offset to Default UVS Table. May be 0. */
|
||||
OffsetTo<NonDefaultUVS, ULONG>
|
||||
LOffsetTo<NonDefaultUVS>
|
||||
nonDefaultUVS; /* Offset to Non-Default UVS Table. May be 0. */
|
||||
public:
|
||||
DEFINE_SIZE_STATIC (11);
|
||||
|
@ -388,7 +405,7 @@ struct CmapSubtableFormat14
|
|||
}
|
||||
|
||||
protected:
|
||||
USHORT format; /* Format number is set to 0. */
|
||||
USHORT format; /* Format number is set to 14. */
|
||||
ULONG lengthZ; /* Byte length of this subtable. */
|
||||
SortedArrayOf<VariationSelectorRecord, ULONG>
|
||||
record; /* Variation selector records; sorted
|
||||
|
@ -416,16 +433,6 @@ struct CmapSubtable
|
|||
}
|
||||
}
|
||||
|
||||
inline glyph_variant_t get_glyph_variant (hb_codepoint_t codepoint,
|
||||
hb_codepoint_t variation_selector,
|
||||
hb_codepoint_t *glyph) const
|
||||
{
|
||||
switch (u.format) {
|
||||
case 14: return u.format14.get_glyph_variant(codepoint, variation_selector, glyph);
|
||||
default: return GLYPH_VARIANT_NOT_FOUND;
|
||||
}
|
||||
}
|
||||
|
||||
inline bool sanitize (hb_sanitize_context_t *c) const
|
||||
{
|
||||
TRACE_SANITIZE (this);
|
||||
|
@ -442,7 +449,7 @@ struct CmapSubtable
|
|||
}
|
||||
}
|
||||
|
||||
protected:
|
||||
public:
|
||||
union {
|
||||
USHORT format; /* Format identifier */
|
||||
CmapSubtableFormat0 format0;
|
||||
|
@ -479,7 +486,7 @@ struct EncodingRecord
|
|||
|
||||
USHORT platformID; /* Platform ID. */
|
||||
USHORT encodingID; /* Platform-specific encoding ID. */
|
||||
OffsetTo<CmapSubtable, ULONG>
|
||||
LOffsetTo<CmapSubtable>
|
||||
subtable; /* Byte offset from beginning of table to the subtable for this encoding. */
|
||||
public:
|
||||
DEFINE_SIZE_STATIC (8);
|
||||
|
|
|
@ -31,10 +31,14 @@
|
|||
#include "hb-font-private.hh"
|
||||
|
||||
#include "hb-ot-cmap-table.hh"
|
||||
#include "hb-ot-cbdt-table.hh"
|
||||
#include "hb-ot-glyf-table.hh"
|
||||
#include "hb-ot-head-table.hh"
|
||||
#include "hb-ot-hhea-table.hh"
|
||||
#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"
|
||||
|
||||
|
||||
struct hb_ot_face_metrics_accelerator_t
|
||||
|
@ -42,20 +46,57 @@ struct hb_ot_face_metrics_accelerator_t
|
|||
unsigned int num_metrics;
|
||||
unsigned int num_advances;
|
||||
unsigned int default_advance;
|
||||
const OT::_mtx *table;
|
||||
unsigned short ascender;
|
||||
unsigned short descender;
|
||||
unsigned short line_gap;
|
||||
bool has_font_extents;
|
||||
|
||||
const OT::hmtxvmtx *table;
|
||||
hb_blob_t *blob;
|
||||
|
||||
const OT::HVARVVAR *var;
|
||||
hb_blob_t *var_blob;
|
||||
|
||||
inline void init (hb_face_t *face,
|
||||
hb_tag_t _hea_tag, hb_tag_t _mtx_tag)
|
||||
hb_tag_t _hea_tag,
|
||||
hb_tag_t _mtx_tag,
|
||||
hb_tag_t _var_tag,
|
||||
hb_tag_t os2_tag,
|
||||
unsigned int default_advance = 0)
|
||||
{
|
||||
this->default_advance = face->get_upem ();
|
||||
this->default_advance = default_advance ? default_advance : face->get_upem ();
|
||||
|
||||
bool got_font_extents = false;
|
||||
if (os2_tag)
|
||||
{
|
||||
hb_blob_t *os2_blob = OT::Sanitizer<OT::os2>::sanitize (face->reference_table (os2_tag));
|
||||
const OT::os2 *os2 = OT::Sanitizer<OT::os2>::lock_instance (os2_blob);
|
||||
#define USE_TYPO_METRICS (1u<<7)
|
||||
if (0 != (os2->fsSelection & USE_TYPO_METRICS))
|
||||
{
|
||||
this->ascender = os2->sTypoAscender;
|
||||
this->descender = os2->sTypoDescender;
|
||||
this->line_gap = os2->sTypoLineGap;
|
||||
got_font_extents = (this->ascender | this->descender) != 0;
|
||||
}
|
||||
hb_blob_destroy (os2_blob);
|
||||
}
|
||||
|
||||
hb_blob_t *_hea_blob = OT::Sanitizer<OT::_hea>::sanitize (face->reference_table (_hea_tag));
|
||||
const OT::_hea *_hea = OT::Sanitizer<OT::_hea>::lock_instance (_hea_blob);
|
||||
this->num_advances = _hea->numberOfLongMetrics;
|
||||
if (!got_font_extents)
|
||||
{
|
||||
this->ascender = _hea->ascender;
|
||||
this->descender = _hea->descender;
|
||||
this->line_gap = _hea->lineGap;
|
||||
got_font_extents = (this->ascender | this->descender) != 0;
|
||||
}
|
||||
hb_blob_destroy (_hea_blob);
|
||||
|
||||
this->blob = OT::Sanitizer<OT::_mtx>::sanitize (face->reference_table (_mtx_tag));
|
||||
this->has_font_extents = got_font_extents;
|
||||
|
||||
this->blob = OT::Sanitizer<OT::hmtxvmtx>::sanitize (face->reference_table (_mtx_tag));
|
||||
|
||||
/* Cap num_metrics() and num_advances() based on table length. */
|
||||
unsigned int len = hb_blob_get_length (this->blob);
|
||||
|
@ -71,15 +112,20 @@ struct hb_ot_face_metrics_accelerator_t
|
|||
hb_blob_destroy (this->blob);
|
||||
this->blob = hb_blob_get_empty ();
|
||||
}
|
||||
this->table = OT::Sanitizer<OT::_mtx>::lock_instance (this->blob);
|
||||
this->table = OT::Sanitizer<OT::hmtxvmtx>::lock_instance (this->blob);
|
||||
|
||||
this->var_blob = OT::Sanitizer<OT::HVARVVAR>::sanitize (face->reference_table (_var_tag));
|
||||
this->var = OT::Sanitizer<OT::HVARVVAR>::lock_instance (this->var_blob);
|
||||
}
|
||||
|
||||
inline void fini (void)
|
||||
{
|
||||
hb_blob_destroy (this->blob);
|
||||
hb_blob_destroy (this->var_blob);
|
||||
}
|
||||
|
||||
inline unsigned int get_advance (hb_codepoint_t glyph) const
|
||||
inline unsigned int get_advance (hb_codepoint_t glyph,
|
||||
hb_font_t *font) const
|
||||
{
|
||||
if (unlikely (glyph >= this->num_metrics))
|
||||
{
|
||||
|
@ -92,10 +138,8 @@ struct hb_ot_face_metrics_accelerator_t
|
|||
return this->default_advance;
|
||||
}
|
||||
|
||||
if (glyph >= this->num_advances)
|
||||
glyph = this->num_advances - 1;
|
||||
|
||||
return this->table->longMetric[glyph].advance;
|
||||
return this->table->longMetric[MIN (glyph, (uint32_t) this->num_advances - 1)].advance
|
||||
+ this->var->get_advance_var (glyph, font->coords, font->num_coords); // TODO Optimize?!
|
||||
}
|
||||
};
|
||||
|
||||
|
@ -172,10 +216,133 @@ struct hb_ot_face_glyf_accelerator_t
|
|||
}
|
||||
};
|
||||
|
||||
struct hb_ot_face_cbdt_accelerator_t
|
||||
{
|
||||
hb_blob_t *cblc_blob;
|
||||
hb_blob_t *cbdt_blob;
|
||||
const OT::CBLC *cblc;
|
||||
const OT::CBDT *cbdt;
|
||||
|
||||
unsigned int cbdt_len;
|
||||
unsigned int upem;
|
||||
|
||||
inline void init (hb_face_t *face)
|
||||
{
|
||||
upem = face->get_upem();
|
||||
|
||||
cblc_blob = OT::Sanitizer<OT::CBLC>::sanitize (face->reference_table (HB_OT_TAG_CBLC));
|
||||
cbdt_blob = OT::Sanitizer<OT::CBDT>::sanitize (face->reference_table (HB_OT_TAG_CBDT));
|
||||
cbdt_len = hb_blob_get_length (cbdt_blob);
|
||||
|
||||
if (hb_blob_get_length (cblc_blob) == 0) {
|
||||
cblc = NULL;
|
||||
cbdt = NULL;
|
||||
return; /* Not a bitmap font. */
|
||||
}
|
||||
cblc = OT::Sanitizer<OT::CBLC>::lock_instance (cblc_blob);
|
||||
cbdt = OT::Sanitizer<OT::CBDT>::lock_instance (cbdt_blob);
|
||||
|
||||
}
|
||||
|
||||
inline void fini (void)
|
||||
{
|
||||
hb_blob_destroy (this->cblc_blob);
|
||||
hb_blob_destroy (this->cbdt_blob);
|
||||
}
|
||||
|
||||
inline bool get_extents (hb_codepoint_t glyph, hb_glyph_extents_t *extents) const
|
||||
{
|
||||
unsigned int x_ppem = upem, y_ppem = upem; /* TODO Use font ppem if available. */
|
||||
|
||||
if (!cblc)
|
||||
return false; // Not a color bitmap font.
|
||||
|
||||
const OT::IndexSubtableRecord *subtable_record = this->cblc->find_table(glyph, &x_ppem, &y_ppem);
|
||||
if (!subtable_record || !x_ppem || !y_ppem)
|
||||
return false;
|
||||
|
||||
if (subtable_record->get_extents (extents))
|
||||
return true;
|
||||
|
||||
unsigned int image_offset = 0, image_length = 0, image_format = 0;
|
||||
if (!subtable_record->get_image_data (glyph, &image_offset, &image_length, &image_format))
|
||||
return false;
|
||||
|
||||
{
|
||||
/* TODO Move the following into CBDT struct when adding more formats. */
|
||||
|
||||
if (unlikely (image_offset > cbdt_len || cbdt_len - image_offset < image_length))
|
||||
return false;
|
||||
|
||||
switch (image_format)
|
||||
{
|
||||
case 17: {
|
||||
if (unlikely (image_length < OT::GlyphBitmapDataFormat17::min_size))
|
||||
return false;
|
||||
|
||||
const OT::GlyphBitmapDataFormat17& glyphFormat17 =
|
||||
OT::StructAtOffset<OT::GlyphBitmapDataFormat17> (this->cbdt, image_offset);
|
||||
glyphFormat17.glyphMetrics.get_extents (extents);
|
||||
}
|
||||
break;
|
||||
default:
|
||||
// TODO: Support other image formats.
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/* Convert to the font units. */
|
||||
extents->x_bearing *= upem / (float) x_ppem;
|
||||
extents->y_bearing *= upem / (float) y_ppem;
|
||||
extents->width *= upem / (float) x_ppem;
|
||||
extents->height *= upem / (float) y_ppem;
|
||||
|
||||
return true;
|
||||
}
|
||||
};
|
||||
|
||||
typedef bool (*hb_cmap_get_glyph_func_t) (const void *obj,
|
||||
hb_codepoint_t codepoint,
|
||||
hb_codepoint_t *glyph);
|
||||
|
||||
template <typename Type>
|
||||
static inline bool get_glyph_from (const void *obj,
|
||||
hb_codepoint_t codepoint,
|
||||
hb_codepoint_t *glyph)
|
||||
{
|
||||
const Type *typed_obj = (const Type *) obj;
|
||||
return typed_obj->get_glyph (codepoint, glyph);
|
||||
}
|
||||
|
||||
template <typename Type>
|
||||
static inline bool get_glyph_from_symbol (const void *obj,
|
||||
hb_codepoint_t codepoint,
|
||||
hb_codepoint_t *glyph)
|
||||
{
|
||||
const Type *typed_obj = (const Type *) obj;
|
||||
if (likely (typed_obj->get_glyph (codepoint, glyph)))
|
||||
return true;
|
||||
|
||||
if (codepoint <= 0x00FFu)
|
||||
{
|
||||
/* For symbol-encoded OpenType fonts, we duplicate the
|
||||
* U+F000..F0FF range at U+0000..U+00FF. That's what
|
||||
* Windows seems to do, and that's hinted about at:
|
||||
* http://www.microsoft.com/typography/otspec/recom.htm
|
||||
* under "Non-Standard (Symbol) Fonts". */
|
||||
return typed_obj->get_glyph (0xF000u + codepoint, glyph);
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
struct hb_ot_face_cmap_accelerator_t
|
||||
{
|
||||
const OT::CmapSubtable *table;
|
||||
const OT::CmapSubtable *uvs_table;
|
||||
hb_cmap_get_glyph_func_t get_glyph_func;
|
||||
const void *get_glyph_data;
|
||||
OT::CmapSubtableFormat4::accelerator_t format4_accel;
|
||||
|
||||
const OT::CmapSubtableFormat14 *uvs_table;
|
||||
hb_blob_t *blob;
|
||||
|
||||
inline void init (hb_face_t *face)
|
||||
|
@ -183,8 +350,9 @@ 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::CmapSubtable *subtable_uvs = NULL;
|
||||
const OT::CmapSubtableFormat14 *subtable_uvs = NULL;
|
||||
|
||||
bool symbol = false;
|
||||
/* 32-bit subtables. */
|
||||
if (!subtable) subtable = cmap->find_subtable (3, 10);
|
||||
if (!subtable) subtable = cmap->find_subtable (0, 6);
|
||||
|
@ -195,17 +363,42 @@ struct hb_ot_face_cmap_accelerator_t
|
|||
if (!subtable) subtable = cmap->find_subtable (0, 2);
|
||||
if (!subtable) subtable = cmap->find_subtable (0, 1);
|
||||
if (!subtable) subtable = cmap->find_subtable (0, 0);
|
||||
if (!subtable) subtable = cmap->find_subtable (3, 0);
|
||||
if (!subtable)
|
||||
{
|
||||
subtable = cmap->find_subtable (3, 0);
|
||||
if (subtable) symbol = true;
|
||||
}
|
||||
/* Meh. */
|
||||
if (!subtable) subtable = &OT::Null(OT::CmapSubtable);
|
||||
|
||||
/* UVS subtable. */
|
||||
if (!subtable_uvs) subtable_uvs = cmap->find_subtable (0, 5);
|
||||
if (!subtable_uvs)
|
||||
{
|
||||
const OT::CmapSubtable *st = cmap->find_subtable (0, 5);
|
||||
if (st && st->u.format == 14)
|
||||
subtable_uvs = &st->u.format14;
|
||||
}
|
||||
/* Meh. */
|
||||
if (!subtable_uvs) subtable_uvs = &OT::Null(OT::CmapSubtable);
|
||||
if (!subtable_uvs) subtable_uvs = &OT::Null(OT::CmapSubtableFormat14);
|
||||
|
||||
this->table = subtable;
|
||||
this->uvs_table = subtable_uvs;
|
||||
|
||||
this->get_glyph_data = subtable;
|
||||
if (unlikely (symbol))
|
||||
this->get_glyph_func = get_glyph_from_symbol<OT::CmapSubtable>;
|
||||
else
|
||||
switch (subtable->u.format) {
|
||||
/* Accelerate format 4 and format 12. */
|
||||
default: this->get_glyph_func = get_glyph_from<OT::CmapSubtable>; break;
|
||||
case 12: this->get_glyph_func = get_glyph_from<OT::CmapSubtableFormat12>; break;
|
||||
case 4:
|
||||
{
|
||||
this->format4_accel.init (&subtable->u.format4);
|
||||
this->get_glyph_data = &this->format4_accel;
|
||||
this->get_glyph_func = this->format4_accel.get_glyph_func;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
inline void fini (void)
|
||||
|
@ -213,33 +406,36 @@ struct hb_ot_face_cmap_accelerator_t
|
|||
hb_blob_destroy (this->blob);
|
||||
}
|
||||
|
||||
inline bool get_glyph (hb_codepoint_t unicode,
|
||||
hb_codepoint_t variation_selector,
|
||||
hb_codepoint_t *glyph) const
|
||||
inline bool get_nominal_glyph (hb_codepoint_t unicode,
|
||||
hb_codepoint_t *glyph) const
|
||||
{
|
||||
if (unlikely (variation_selector))
|
||||
return this->get_glyph_func (this->get_glyph_data, unicode, glyph);
|
||||
}
|
||||
|
||||
inline bool get_variation_glyph (hb_codepoint_t unicode,
|
||||
hb_codepoint_t variation_selector,
|
||||
hb_codepoint_t *glyph) const
|
||||
{
|
||||
switch (this->uvs_table->get_glyph_variant (unicode,
|
||||
variation_selector,
|
||||
glyph))
|
||||
{
|
||||
switch (this->uvs_table->get_glyph_variant (unicode,
|
||||
variation_selector,
|
||||
glyph))
|
||||
{
|
||||
case OT::GLYPH_VARIANT_NOT_FOUND: return false;
|
||||
case OT::GLYPH_VARIANT_FOUND: return true;
|
||||
case OT::GLYPH_VARIANT_USE_DEFAULT: break;
|
||||
}
|
||||
case OT::GLYPH_VARIANT_NOT_FOUND: return false;
|
||||
case OT::GLYPH_VARIANT_FOUND: return true;
|
||||
case OT::GLYPH_VARIANT_USE_DEFAULT: break;
|
||||
}
|
||||
|
||||
return this->table->get_glyph (unicode, glyph);
|
||||
return get_nominal_glyph (unicode, glyph);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
struct hb_ot_font_t
|
||||
{
|
||||
hb_ot_face_cmap_accelerator_t cmap;
|
||||
hb_ot_face_metrics_accelerator_t h_metrics;
|
||||
hb_ot_face_metrics_accelerator_t v_metrics;
|
||||
hb_ot_face_glyf_accelerator_t glyf;
|
||||
OT::hb_lazy_loader_t<hb_ot_face_glyf_accelerator_t> glyf;
|
||||
OT::hb_lazy_loader_t<hb_ot_face_cbdt_accelerator_t> cbdt;
|
||||
};
|
||||
|
||||
|
||||
|
@ -252,9 +448,11 @@ _hb_ot_font_create (hb_face_t *face)
|
|||
return NULL;
|
||||
|
||||
ot_font->cmap.init (face);
|
||||
ot_font->h_metrics.init (face, HB_OT_TAG_hhea, HB_OT_TAG_hmtx);
|
||||
ot_font->v_metrics.init (face, HB_OT_TAG_vhea, HB_OT_TAG_vmtx); /* TODO Can we do this lazily? */
|
||||
ot_font->h_metrics.init (face, HB_OT_TAG_hhea, HB_OT_TAG_hmtx, HB_OT_TAG_HVAR, HB_OT_TAG_os2);
|
||||
ot_font->v_metrics.init (face, HB_OT_TAG_vhea, HB_OT_TAG_vmtx, HB_OT_TAG_VVAR, HB_TAG_NONE,
|
||||
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);
|
||||
|
||||
return ot_font;
|
||||
}
|
||||
|
@ -266,42 +464,54 @@ _hb_ot_font_destroy (hb_ot_font_t *ot_font)
|
|||
ot_font->h_metrics.fini ();
|
||||
ot_font->v_metrics.fini ();
|
||||
ot_font->glyf.fini ();
|
||||
ot_font->cbdt.fini ();
|
||||
|
||||
free (ot_font);
|
||||
}
|
||||
|
||||
|
||||
static hb_bool_t
|
||||
hb_ot_get_glyph (hb_font_t *font HB_UNUSED,
|
||||
void *font_data,
|
||||
hb_codepoint_t unicode,
|
||||
hb_codepoint_t variation_selector,
|
||||
hb_codepoint_t *glyph,
|
||||
void *user_data HB_UNUSED)
|
||||
hb_ot_get_nominal_glyph (hb_font_t *font HB_UNUSED,
|
||||
void *font_data,
|
||||
hb_codepoint_t unicode,
|
||||
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->cmap.get_glyph (unicode, variation_selector, glyph);
|
||||
return ot_font->cmap.get_nominal_glyph (unicode, glyph);
|
||||
}
|
||||
|
||||
static hb_bool_t
|
||||
hb_ot_get_variation_glyph (hb_font_t *font HB_UNUSED,
|
||||
void *font_data,
|
||||
hb_codepoint_t unicode,
|
||||
hb_codepoint_t variation_selector,
|
||||
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->cmap.get_variation_glyph (unicode, variation_selector, glyph);
|
||||
}
|
||||
|
||||
static hb_position_t
|
||||
hb_ot_get_glyph_h_advance (hb_font_t *font HB_UNUSED,
|
||||
hb_ot_get_glyph_h_advance (hb_font_t *font,
|
||||
void *font_data,
|
||||
hb_codepoint_t glyph,
|
||||
void *user_data HB_UNUSED)
|
||||
{
|
||||
const hb_ot_font_t *ot_font = (const hb_ot_font_t *) font_data;
|
||||
return font->em_scale_x (ot_font->h_metrics.get_advance (glyph));
|
||||
return font->em_scale_x (ot_font->h_metrics.get_advance (glyph, font));
|
||||
}
|
||||
|
||||
static hb_position_t
|
||||
hb_ot_get_glyph_v_advance (hb_font_t *font HB_UNUSED,
|
||||
hb_ot_get_glyph_v_advance (hb_font_t *font,
|
||||
void *font_data,
|
||||
hb_codepoint_t glyph,
|
||||
void *user_data HB_UNUSED)
|
||||
{
|
||||
const hb_ot_font_t *ot_font = (const hb_ot_font_t *) font_data;
|
||||
return font->em_scale_y (-(int) ot_font->v_metrics.get_advance (glyph));
|
||||
return font->em_scale_y (-(int) ot_font->v_metrics.get_advance (glyph, font));
|
||||
}
|
||||
|
||||
static hb_bool_t
|
||||
|
@ -312,7 +522,10 @@ hb_ot_get_glyph_extents (hb_font_t *font HB_UNUSED,
|
|||
void *user_data HB_UNUSED)
|
||||
{
|
||||
const hb_ot_font_t *ot_font = (const hb_ot_font_t *) font_data;
|
||||
bool ret = ot_font->glyf.get_extents (glyph, extents);
|
||||
bool ret = ot_font->glyf->get_extents (glyph, extents);
|
||||
if (!ret)
|
||||
ret = ot_font->cbdt->get_extents (glyph, extents);
|
||||
// TODO Hook up side-bearings variations.
|
||||
extents->x_bearing = font->em_scale_x (extents->x_bearing);
|
||||
extents->y_bearing = font->em_scale_y (extents->y_bearing);
|
||||
extents->width = font->em_scale_x (extents->width);
|
||||
|
@ -320,6 +533,33 @@ hb_ot_get_glyph_extents (hb_font_t *font HB_UNUSED,
|
|||
return ret;
|
||||
}
|
||||
|
||||
static hb_bool_t
|
||||
hb_ot_get_font_h_extents (hb_font_t *font HB_UNUSED,
|
||||
void *font_data,
|
||||
hb_font_extents_t *metrics,
|
||||
void *user_data HB_UNUSED)
|
||||
{
|
||||
const hb_ot_font_t *ot_font = (const hb_ot_font_t *) font_data;
|
||||
metrics->ascender = font->em_scale_y (ot_font->h_metrics.ascender);
|
||||
metrics->descender = font->em_scale_y (ot_font->h_metrics.descender);
|
||||
metrics->line_gap = font->em_scale_y (ot_font->h_metrics.line_gap);
|
||||
// TODO Hook up variations.
|
||||
return ot_font->h_metrics.has_font_extents;
|
||||
}
|
||||
|
||||
static hb_bool_t
|
||||
hb_ot_get_font_v_extents (hb_font_t *font HB_UNUSED,
|
||||
void *font_data,
|
||||
hb_font_extents_t *metrics,
|
||||
void *user_data HB_UNUSED)
|
||||
{
|
||||
const hb_ot_font_t *ot_font = (const hb_ot_font_t *) font_data;
|
||||
metrics->ascender = font->em_scale_x (ot_font->v_metrics.ascender);
|
||||
metrics->descender = font->em_scale_x (ot_font->v_metrics.descender);
|
||||
metrics->line_gap = font->em_scale_x (ot_font->v_metrics.line_gap);
|
||||
// TODO Hook up variations.
|
||||
return ot_font->v_metrics.has_font_extents;
|
||||
}
|
||||
|
||||
static hb_font_funcs_t *static_ot_funcs = NULL;
|
||||
|
||||
|
@ -341,7 +581,10 @@ retry:
|
|||
{
|
||||
funcs = hb_font_funcs_create ();
|
||||
|
||||
hb_font_funcs_set_glyph_func (funcs, hb_ot_get_glyph, NULL, NULL);
|
||||
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);
|
||||
|
@ -370,6 +613,8 @@ retry:
|
|||
|
||||
|
||||
/**
|
||||
* hb_ot_font_set_funcs:
|
||||
*
|
||||
* Since: 0.9.28
|
||||
**/
|
||||
void
|
||||
|
|
|
@ -36,7 +36,7 @@
|
|||
HB_BEGIN_DECLS
|
||||
|
||||
|
||||
void
|
||||
HB_EXTERN void
|
||||
hb_ot_font_set_funcs (hb_font_t *font);
|
||||
|
||||
|
||||
|
|
|
@ -90,10 +90,10 @@ struct glyfGlyphHeader
|
|||
* greater than or equal to zero,
|
||||
* this is a simple glyph; if negative,
|
||||
* this is a composite glyph. */
|
||||
SHORT xMin; /* Minimum x for coordinate data. */
|
||||
SHORT yMin; /* Minimum y for coordinate data. */
|
||||
SHORT xMax; /* Maximum x for coordinate data. */
|
||||
SHORT yMax; /* Maximum y for coordinate data. */
|
||||
FWORD xMin; /* Minimum x for coordinate data. */
|
||||
FWORD yMin; /* Minimum y for coordinate data. */
|
||||
FWORD xMax; /* Maximum x for coordinate data. */
|
||||
FWORD yMax; /* Maximum y for coordinate data. */
|
||||
|
||||
DEFINE_SIZE_STATIC (10);
|
||||
};
|
||||
|
|
|
@ -55,13 +55,15 @@ struct head
|
|||
inline bool sanitize (hb_sanitize_context_t *c) const
|
||||
{
|
||||
TRACE_SANITIZE (this);
|
||||
return_trace (c->check_struct (this) && likely (version.major == 1));
|
||||
return_trace (c->check_struct (this) &&
|
||||
version.major == 1 &&
|
||||
magicNumber == 0x5F0F3CF5u);
|
||||
}
|
||||
|
||||
protected:
|
||||
FixedVersion version; /* Version of the head table--currently
|
||||
FixedVersion<>version; /* Version of the head table--currently
|
||||
* 0x00010000u for version 1.0. */
|
||||
FixedVersion fontRevision; /* Set by font manufacturer. */
|
||||
FixedVersion<>fontRevision; /* Set by font manufacturer. */
|
||||
ULONG checkSumAdjustment; /* To compute: set it to 0, sum the
|
||||
* entire font as ULONG, then store
|
||||
* 0xB1B0AFBAu - sum. */
|
||||
|
|
|
@ -56,7 +56,7 @@ struct _hea
|
|||
}
|
||||
|
||||
public:
|
||||
FixedVersion version; /* 0x00010000u for version 1.0. */
|
||||
FixedVersion<>version; /* 0x00010000u for version 1.0. */
|
||||
FWORD ascender; /* Typographic ascent. */
|
||||
FWORD descender; /* Typographic descent. */
|
||||
FWORD lineGap; /* Typographic line gap. */
|
||||
|
|
|
@ -44,16 +44,14 @@ namespace OT {
|
|||
|
||||
struct LongMetric
|
||||
{
|
||||
USHORT advance; /* Advance width/height. */
|
||||
SHORT lsb; /* Leading (left/top) side bearing. */
|
||||
UFWORD advance; /* Advance width/height. */
|
||||
FWORD lsb; /* Leading (left/top) side bearing. */
|
||||
public:
|
||||
DEFINE_SIZE_STATIC (4);
|
||||
};
|
||||
|
||||
struct _mtx
|
||||
struct hmtxvmtx
|
||||
{
|
||||
static const hb_tag_t tableTag = HB_TAG('_','m','t','x');
|
||||
|
||||
static const hb_tag_t hmtxTag = HB_OT_TAG_hmtx;
|
||||
static const hb_tag_t vmtxTag = HB_OT_TAG_vmtx;
|
||||
|
||||
|
@ -74,7 +72,7 @@ struct _mtx
|
|||
* be in the array, but that entry is
|
||||
* required. The last entry applies to
|
||||
* all subsequent glyphs. */
|
||||
SHORT leadingBearingX[VAR]; /* Here the advance is assumed
|
||||
FWORD leadingBearingX[VAR]; /* Here the advance is assumed
|
||||
* to be the same as the advance
|
||||
* for the last entry above. The
|
||||
* number of entries in this array is
|
||||
|
@ -91,10 +89,10 @@ struct _mtx
|
|||
DEFINE_SIZE_ARRAY2 (0, longMetric, leadingBearingX);
|
||||
};
|
||||
|
||||
struct hmtx : _mtx {
|
||||
struct hmtx : hmtxvmtx {
|
||||
static const hb_tag_t tableTag = HB_OT_TAG_hmtx;
|
||||
};
|
||||
struct vmtx : _mtx {
|
||||
struct vmtx : hmtxvmtx {
|
||||
static const hb_tag_t tableTag = HB_OT_TAG_vmtx;
|
||||
};
|
||||
|
||||
|
|
|
@ -507,7 +507,7 @@ struct Feature
|
|||
{ return this+featureParams; }
|
||||
|
||||
inline bool sanitize (hb_sanitize_context_t *c,
|
||||
const Record<Feature>::sanitize_closure_t *closure) const
|
||||
const Record<Feature>::sanitize_closure_t *closure = NULL) const
|
||||
{
|
||||
TRACE_SANITIZE (this);
|
||||
if (unlikely (!(c->check_struct (this) && lookupIndex.sanitize (c))))
|
||||
|
@ -545,6 +545,9 @@ struct Feature
|
|||
c->try_set (&featureParams, new_offset) &&
|
||||
!featureParams.sanitize (c, this, closure ? closure->tag : HB_TAG_NONE))
|
||||
return_trace (false);
|
||||
|
||||
if (c->edit_count > 1)
|
||||
c->edit_count--; /* This was a "legitimate" edit; don't contribute to error count. */
|
||||
}
|
||||
|
||||
return_trace (true);
|
||||
|
@ -728,8 +731,8 @@ struct CoverageFormat1
|
|||
inline void init (const struct CoverageFormat1 &c_) { c = &c_; i = 0; };
|
||||
inline bool more (void) { return i < c->glyphArray.len; }
|
||||
inline void next (void) { i++; }
|
||||
inline uint16_t get_glyph (void) { return c->glyphArray[i]; }
|
||||
inline uint16_t get_coverage (void) { return i; }
|
||||
inline hb_codepoint_t get_glyph (void) { return c->glyphArray[i]; }
|
||||
inline unsigned int get_coverage (void) { return i; }
|
||||
|
||||
private:
|
||||
const struct CoverageFormat1 *c;
|
||||
|
@ -767,7 +770,11 @@ struct CoverageFormat2
|
|||
TRACE_SERIALIZE (this);
|
||||
if (unlikely (!c->extend_min (*this))) return_trace (false);
|
||||
|
||||
if (unlikely (!num_glyphs)) return_trace (true);
|
||||
if (unlikely (!num_glyphs))
|
||||
{
|
||||
rangeRecord.len.set (0);
|
||||
return_trace (true);
|
||||
}
|
||||
|
||||
unsigned int num_ranges = 1;
|
||||
for (unsigned int i = 1; i < num_glyphs; i++)
|
||||
|
@ -822,26 +829,33 @@ struct CoverageFormat2
|
|||
|
||||
public:
|
||||
/* Older compilers need this to be public. */
|
||||
struct Iter {
|
||||
inline void init (const CoverageFormat2 &c_) {
|
||||
struct Iter
|
||||
{
|
||||
inline void init (const CoverageFormat2 &c_)
|
||||
{
|
||||
c = &c_;
|
||||
coverage = 0;
|
||||
i = 0;
|
||||
j = c->rangeRecord.len ? c_.rangeRecord[0].start : 0;
|
||||
}
|
||||
inline bool more (void) { return i < c->rangeRecord.len; }
|
||||
inline void next (void) {
|
||||
coverage++;
|
||||
if (j == c->rangeRecord[i].end) {
|
||||
inline void next (void)
|
||||
{
|
||||
if (j >= c->rangeRecord[i].end)
|
||||
{
|
||||
i++;
|
||||
if (more ())
|
||||
{
|
||||
j = c->rangeRecord[i].start;
|
||||
coverage = c->rangeRecord[i].value;
|
||||
}
|
||||
return;
|
||||
}
|
||||
coverage++;
|
||||
j++;
|
||||
}
|
||||
inline uint16_t get_glyph (void) { return j; }
|
||||
inline uint16_t get_coverage (void) { return coverage; }
|
||||
inline hb_codepoint_t get_glyph (void) { return j; }
|
||||
inline unsigned int get_coverage (void) { return coverage; }
|
||||
|
||||
private:
|
||||
const struct CoverageFormat2 *c;
|
||||
|
@ -927,7 +941,7 @@ struct Coverage
|
|||
}
|
||||
|
||||
struct Iter {
|
||||
Iter (void) : format (0) {};
|
||||
Iter (void) : format (0), u () {};
|
||||
inline void init (const Coverage &c_) {
|
||||
format = c_.u.format;
|
||||
switch (format) {
|
||||
|
@ -950,14 +964,14 @@ struct Coverage
|
|||
default: break;
|
||||
}
|
||||
}
|
||||
inline uint16_t get_glyph (void) {
|
||||
inline hb_codepoint_t get_glyph (void) {
|
||||
switch (format) {
|
||||
case 1: return u.format1.get_glyph ();
|
||||
case 2: return u.format2.get_glyph ();
|
||||
default:return 0;
|
||||
}
|
||||
}
|
||||
inline uint16_t get_coverage (void) {
|
||||
inline unsigned int get_coverage (void) {
|
||||
switch (format) {
|
||||
case 1: return u.format1.get_coverage ();
|
||||
case 2: return u.format2.get_coverage ();
|
||||
|
@ -968,8 +982,8 @@ struct Coverage
|
|||
private:
|
||||
unsigned int format;
|
||||
union {
|
||||
CoverageFormat2::Iter format2; /* Put this one first since it's larger; helps shut up compiler. */
|
||||
CoverageFormat1::Iter format1;
|
||||
CoverageFormat2::Iter format2;
|
||||
} u;
|
||||
};
|
||||
|
||||
|
@ -1154,12 +1168,389 @@ struct ClassDef
|
|||
};
|
||||
|
||||
|
||||
/*
|
||||
* Item Variation Store
|
||||
*/
|
||||
|
||||
struct VarRegionAxis
|
||||
{
|
||||
inline float evaluate (int coord) const
|
||||
{
|
||||
int start = startCoord, peak = peakCoord, end = endCoord;
|
||||
|
||||
/* TODO Move these to sanitize(). */
|
||||
if (unlikely (start > peak || peak > end))
|
||||
return 1.;
|
||||
if (unlikely (start < 0 && end > 0 && peak != 0))
|
||||
return 1.;
|
||||
|
||||
if (peak == 0 || coord == peak)
|
||||
return 1.;
|
||||
|
||||
if (coord <= start || end <= coord)
|
||||
return 0.;
|
||||
|
||||
/* Interpolate */
|
||||
if (coord < peak)
|
||||
return float (coord - start) / (peak - start);
|
||||
else
|
||||
return float (end - coord) / (end - peak);
|
||||
}
|
||||
|
||||
inline bool sanitize (hb_sanitize_context_t *c) const
|
||||
{
|
||||
TRACE_SANITIZE (this);
|
||||
return_trace (c->check_struct (this));
|
||||
/* TODO Handle invalid start/peak/end configs, so we don't
|
||||
* have to do that at runtime. */
|
||||
}
|
||||
|
||||
public:
|
||||
F2DOT14 startCoord;
|
||||
F2DOT14 peakCoord;
|
||||
F2DOT14 endCoord;
|
||||
public:
|
||||
DEFINE_SIZE_STATIC (6);
|
||||
};
|
||||
|
||||
struct VarRegionList
|
||||
{
|
||||
inline float evaluate (unsigned int region_index,
|
||||
int *coords, unsigned int coord_len) const
|
||||
{
|
||||
if (unlikely (region_index >= regionCount))
|
||||
return 0.;
|
||||
|
||||
const VarRegionAxis *axes = axesZ + (region_index * axisCount);
|
||||
|
||||
float v = 1.;
|
||||
unsigned int count = MIN (coord_len, (unsigned int) axisCount);
|
||||
for (unsigned int i = 0; i < count; i++)
|
||||
{
|
||||
float factor = axes[i].evaluate (coords[i]);
|
||||
if (factor == 0.)
|
||||
return 0.;
|
||||
v *= factor;
|
||||
}
|
||||
return v;
|
||||
}
|
||||
|
||||
inline bool sanitize (hb_sanitize_context_t *c) const
|
||||
{
|
||||
TRACE_SANITIZE (this);
|
||||
return_trace (c->check_struct (this) &&
|
||||
c->check_array (axesZ, axesZ[0].static_size,
|
||||
(unsigned int) axisCount * (unsigned int) regionCount));
|
||||
}
|
||||
|
||||
protected:
|
||||
USHORT axisCount;
|
||||
USHORT regionCount;
|
||||
VarRegionAxis axesZ[VAR];
|
||||
public:
|
||||
DEFINE_SIZE_ARRAY (4, axesZ);
|
||||
};
|
||||
|
||||
struct VarData
|
||||
{
|
||||
inline unsigned int get_row_size (void) const
|
||||
{ return shortCount + regionIndices.len; }
|
||||
|
||||
inline unsigned int get_size (void) const
|
||||
{ return itemCount * get_row_size (); }
|
||||
|
||||
inline float get_delta (unsigned int inner,
|
||||
int *coords, unsigned int coord_count,
|
||||
const VarRegionList ®ions) const
|
||||
{
|
||||
if (unlikely (inner >= itemCount))
|
||||
return 0.;
|
||||
|
||||
unsigned int count = regionIndices.len;
|
||||
unsigned int scount = shortCount;
|
||||
|
||||
const BYTE *bytes = &StructAfter<BYTE> (regionIndices);
|
||||
const BYTE *row = bytes + inner * (scount + count);
|
||||
|
||||
float delta = 0.;
|
||||
unsigned int i = 0;
|
||||
|
||||
const SHORT *scursor = reinterpret_cast<const SHORT *> (row);
|
||||
for (; i < scount; i++)
|
||||
{
|
||||
float scalar = regions.evaluate (regionIndices.array[i], coords, coord_count);
|
||||
delta += scalar * *scursor++;
|
||||
}
|
||||
const INT8 *bcursor = reinterpret_cast<const INT8 *> (scursor);
|
||||
for (; i < count; i++)
|
||||
{
|
||||
float scalar = regions.evaluate (regionIndices.array[i], coords, coord_count);
|
||||
delta += scalar * *bcursor++;
|
||||
}
|
||||
|
||||
return delta;
|
||||
}
|
||||
|
||||
inline bool sanitize (hb_sanitize_context_t *c) const
|
||||
{
|
||||
TRACE_SANITIZE (this);
|
||||
return_trace (c->check_struct (this) &&
|
||||
regionIndices.sanitize(c) &&
|
||||
shortCount <= regionIndices.len &&
|
||||
c->check_array (&StructAfter<BYTE> (regionIndices),
|
||||
get_row_size (), itemCount));
|
||||
}
|
||||
|
||||
protected:
|
||||
USHORT itemCount;
|
||||
USHORT shortCount;
|
||||
ArrayOf<USHORT> regionIndices;
|
||||
BYTE bytesX[VAR];
|
||||
public:
|
||||
DEFINE_SIZE_ARRAY2 (6, regionIndices, bytesX);
|
||||
};
|
||||
|
||||
struct VariationStore
|
||||
{
|
||||
inline float get_delta (unsigned int outer, unsigned int inner,
|
||||
int *coords, unsigned int coord_count) const
|
||||
{
|
||||
if (unlikely (outer >= dataSets.len))
|
||||
return 0.;
|
||||
|
||||
return (this+dataSets[outer]).get_delta (inner,
|
||||
coords, coord_count,
|
||||
this+regions);
|
||||
}
|
||||
|
||||
inline float get_delta (unsigned int index,
|
||||
int *coords, unsigned int coord_count) const
|
||||
{
|
||||
unsigned int outer = index >> 16;
|
||||
unsigned int inner = index & 0xFFFF;
|
||||
return get_delta (outer, inner, coords, coord_count);
|
||||
}
|
||||
|
||||
inline bool sanitize (hb_sanitize_context_t *c) const
|
||||
{
|
||||
TRACE_SANITIZE (this);
|
||||
return_trace (c->check_struct (this) &&
|
||||
format == 1 &&
|
||||
regions.sanitize (c, this) &&
|
||||
dataSets.sanitize (c, this));
|
||||
}
|
||||
|
||||
protected:
|
||||
USHORT format;
|
||||
LOffsetTo<VarRegionList> regions;
|
||||
OffsetArrayOf<VarData, ULONG> dataSets;
|
||||
public:
|
||||
DEFINE_SIZE_ARRAY (8, dataSets);
|
||||
};
|
||||
|
||||
/*
|
||||
* Feature Variations
|
||||
*/
|
||||
|
||||
struct ConditionFormat1
|
||||
{
|
||||
friend struct Condition;
|
||||
|
||||
private:
|
||||
inline bool evaluate (const int *coords, unsigned int coord_len) const
|
||||
{
|
||||
int coord = axisIndex < coord_len ? coords[axisIndex] : 0;
|
||||
return filterRangeMinValue <= coord && coord <= filterRangeMaxValue;
|
||||
}
|
||||
|
||||
inline bool sanitize (hb_sanitize_context_t *c) const
|
||||
{
|
||||
TRACE_SANITIZE (this);
|
||||
return_trace (c->check_struct (this));
|
||||
}
|
||||
|
||||
protected:
|
||||
USHORT format; /* Format identifier--format = 1 */
|
||||
USHORT axisIndex;
|
||||
F2DOT14 filterRangeMinValue;
|
||||
F2DOT14 filterRangeMaxValue;
|
||||
public:
|
||||
DEFINE_SIZE_STATIC (8);
|
||||
};
|
||||
|
||||
struct Condition
|
||||
{
|
||||
inline bool evaluate (const int *coords, unsigned int coord_len) const
|
||||
{
|
||||
switch (u.format) {
|
||||
case 1: return u.format1.evaluate (coords, coord_len);
|
||||
default:return false;
|
||||
}
|
||||
}
|
||||
|
||||
inline bool sanitize (hb_sanitize_context_t *c) const
|
||||
{
|
||||
TRACE_SANITIZE (this);
|
||||
if (!u.format.sanitize (c)) return_trace (false);
|
||||
switch (u.format) {
|
||||
case 1: return_trace (u.format1.sanitize (c));
|
||||
default:return_trace (true);
|
||||
}
|
||||
}
|
||||
|
||||
protected:
|
||||
union {
|
||||
USHORT format; /* Format identifier */
|
||||
ConditionFormat1 format1;
|
||||
} u;
|
||||
public:
|
||||
DEFINE_SIZE_UNION (2, format);
|
||||
};
|
||||
|
||||
struct ConditionSet
|
||||
{
|
||||
inline bool evaluate (const int *coords, unsigned int coord_len) const
|
||||
{
|
||||
unsigned int count = conditions.len;
|
||||
for (unsigned int i = 0; i < count; i++)
|
||||
if (!(this+conditions.array[i]).evaluate (coords, coord_len))
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
inline bool sanitize (hb_sanitize_context_t *c) const
|
||||
{
|
||||
TRACE_SANITIZE (this);
|
||||
return_trace (conditions.sanitize (c, this));
|
||||
}
|
||||
|
||||
protected:
|
||||
OffsetArrayOf<Condition, ULONG> conditions;
|
||||
public:
|
||||
DEFINE_SIZE_ARRAY (2, conditions);
|
||||
};
|
||||
|
||||
struct FeatureTableSubstitutionRecord
|
||||
{
|
||||
friend struct FeatureTableSubstitution;
|
||||
|
||||
inline bool sanitize (hb_sanitize_context_t *c, const void *base) const
|
||||
{
|
||||
TRACE_SANITIZE (this);
|
||||
return_trace (c->check_struct (this) && feature.sanitize (c, base));
|
||||
}
|
||||
|
||||
protected:
|
||||
USHORT featureIndex;
|
||||
LOffsetTo<Feature> feature;
|
||||
public:
|
||||
DEFINE_SIZE_STATIC (6);
|
||||
};
|
||||
|
||||
struct FeatureTableSubstitution
|
||||
{
|
||||
inline const Feature *find_substitute (unsigned int feature_index) const
|
||||
{
|
||||
unsigned int count = substitutions.len;
|
||||
for (unsigned int i = 0; i < count; i++)
|
||||
{
|
||||
const FeatureTableSubstitutionRecord &record = substitutions.array[i];
|
||||
if (record.featureIndex == feature_index)
|
||||
return &(this+record.feature);
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
inline bool sanitize (hb_sanitize_context_t *c) const
|
||||
{
|
||||
TRACE_SANITIZE (this);
|
||||
return_trace (version.sanitize (c) &&
|
||||
likely (version.major == 1) &&
|
||||
substitutions.sanitize (c, this));
|
||||
}
|
||||
|
||||
protected:
|
||||
FixedVersion<> version; /* Version--0x00010000u */
|
||||
ArrayOf<FeatureTableSubstitutionRecord>
|
||||
substitutions;
|
||||
public:
|
||||
DEFINE_SIZE_ARRAY (6, substitutions);
|
||||
};
|
||||
|
||||
struct FeatureVariationRecord
|
||||
{
|
||||
friend struct FeatureVariations;
|
||||
|
||||
inline bool sanitize (hb_sanitize_context_t *c, const void *base) const
|
||||
{
|
||||
TRACE_SANITIZE (this);
|
||||
return_trace (conditions.sanitize (c, base) &&
|
||||
substitutions.sanitize (c, base));
|
||||
}
|
||||
|
||||
protected:
|
||||
LOffsetTo<ConditionSet>
|
||||
conditions;
|
||||
LOffsetTo<FeatureTableSubstitution>
|
||||
substitutions;
|
||||
public:
|
||||
DEFINE_SIZE_STATIC (8);
|
||||
};
|
||||
|
||||
struct FeatureVariations
|
||||
{
|
||||
static const unsigned int NOT_FOUND_INDEX = 0xFFFFFFFFu;
|
||||
|
||||
inline bool find_index (const int *coords, unsigned int coord_len,
|
||||
unsigned int *index) const
|
||||
{
|
||||
unsigned int count = varRecords.len;
|
||||
for (unsigned int i = 0; i < count; i++)
|
||||
{
|
||||
const FeatureVariationRecord &record = varRecords.array[i];
|
||||
if ((this+record.conditions).evaluate (coords, coord_len))
|
||||
{
|
||||
*index = i;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
*index = NOT_FOUND_INDEX;
|
||||
return false;
|
||||
}
|
||||
|
||||
inline const Feature *find_substitute (unsigned int variations_index,
|
||||
unsigned int feature_index) const
|
||||
{
|
||||
const FeatureVariationRecord &record = varRecords[variations_index];
|
||||
return (this+record.substitutions).find_substitute (feature_index);
|
||||
}
|
||||
|
||||
inline bool sanitize (hb_sanitize_context_t *c) const
|
||||
{
|
||||
TRACE_SANITIZE (this);
|
||||
return_trace (version.sanitize (c) &&
|
||||
likely (version.major == 1) &&
|
||||
varRecords.sanitize (c, this));
|
||||
}
|
||||
|
||||
protected:
|
||||
FixedVersion<> version; /* Version--0x00010000u */
|
||||
LArrayOf<FeatureVariationRecord>
|
||||
varRecords;
|
||||
public:
|
||||
DEFINE_SIZE_ARRAY (8, varRecords);
|
||||
};
|
||||
|
||||
|
||||
/*
|
||||
* Device Tables
|
||||
*/
|
||||
|
||||
struct Device
|
||||
struct HintingDevice
|
||||
{
|
||||
friend struct Device;
|
||||
|
||||
private:
|
||||
|
||||
inline hb_position_t get_x_delta (hb_font_t *font) const
|
||||
{ return get_delta (font->x_ppem, font->x_scale); }
|
||||
|
@ -1167,6 +1558,21 @@ struct Device
|
|||
inline hb_position_t get_y_delta (hb_font_t *font) const
|
||||
{ return get_delta (font->y_ppem, font->y_scale); }
|
||||
|
||||
inline unsigned int get_size (void) const
|
||||
{
|
||||
unsigned int f = deltaFormat;
|
||||
if (unlikely (f < 1 || f > 3 || startSize > endSize)) return 3 * USHORT::static_size;
|
||||
return USHORT::static_size * (4 + ((endSize - startSize) >> (4 - f)));
|
||||
}
|
||||
|
||||
inline bool sanitize (hb_sanitize_context_t *c) const
|
||||
{
|
||||
TRACE_SANITIZE (this);
|
||||
return_trace (c->check_struct (this) && c->check_range (this, this->get_size ()));
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
inline int get_delta (unsigned int ppem, int scale) const
|
||||
{
|
||||
if (!ppem) return 0;
|
||||
|
@ -1177,8 +1583,6 @@ struct Device
|
|||
|
||||
return (int) (pixels * (int64_t) scale / ppem);
|
||||
}
|
||||
|
||||
|
||||
inline int get_delta_pixels (unsigned int ppem_size) const
|
||||
{
|
||||
unsigned int f = deltaFormat;
|
||||
|
@ -1202,19 +1606,6 @@ struct Device
|
|||
return delta;
|
||||
}
|
||||
|
||||
inline unsigned int get_size (void) const
|
||||
{
|
||||
unsigned int f = deltaFormat;
|
||||
if (unlikely (f < 1 || f > 3 || startSize > endSize)) return 3 * USHORT::static_size;
|
||||
return USHORT::static_size * (4 + ((endSize - startSize) >> (4 - f)));
|
||||
}
|
||||
|
||||
inline bool sanitize (hb_sanitize_context_t *c) const
|
||||
{
|
||||
TRACE_SANITIZE (this);
|
||||
return_trace (c->check_struct (this) && c->check_range (this, this->get_size ()));
|
||||
}
|
||||
|
||||
protected:
|
||||
USHORT startSize; /* Smallest size to correct--in ppem */
|
||||
USHORT endSize; /* Largest size to correct--in ppem */
|
||||
|
@ -1228,6 +1619,101 @@ struct Device
|
|||
DEFINE_SIZE_ARRAY (6, deltaValue);
|
||||
};
|
||||
|
||||
struct VariationDevice
|
||||
{
|
||||
friend struct Device;
|
||||
|
||||
private:
|
||||
|
||||
inline hb_position_t get_x_delta (hb_font_t *font, const VariationStore &store) const
|
||||
{ return font->em_scalef_x (get_delta (font, store)); }
|
||||
|
||||
inline hb_position_t get_y_delta (hb_font_t *font, const VariationStore &store) const
|
||||
{ return font->em_scalef_y (get_delta (font, store)); }
|
||||
|
||||
inline bool sanitize (hb_sanitize_context_t *c) const
|
||||
{
|
||||
TRACE_SANITIZE (this);
|
||||
return_trace (c->check_struct (this));
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
inline float get_delta (hb_font_t *font, const VariationStore &store) const
|
||||
{
|
||||
return store.get_delta (outerIndex, innerIndex, font->coords, font->num_coords);
|
||||
}
|
||||
|
||||
protected:
|
||||
USHORT outerIndex;
|
||||
USHORT innerIndex;
|
||||
USHORT deltaFormat; /* Format identifier for this table: 0x0x8000 */
|
||||
public:
|
||||
DEFINE_SIZE_STATIC (6);
|
||||
};
|
||||
|
||||
struct DeviceHeader
|
||||
{
|
||||
protected:
|
||||
USHORT reserved1;
|
||||
USHORT reserved2;
|
||||
public:
|
||||
USHORT format; /* Format identifier */
|
||||
public:
|
||||
DEFINE_SIZE_STATIC (6);
|
||||
};
|
||||
|
||||
struct Device
|
||||
{
|
||||
inline hb_position_t get_x_delta (hb_font_t *font, const VariationStore &store=Null(VariationStore)) const
|
||||
{
|
||||
switch (u.b.format)
|
||||
{
|
||||
case 1: case 2: case 3:
|
||||
return u.hinting.get_x_delta (font);
|
||||
case 0x8000:
|
||||
return u.variation.get_x_delta (font, store);
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
inline hb_position_t get_y_delta (hb_font_t *font, const VariationStore &store=Null(VariationStore)) const
|
||||
{
|
||||
switch (u.b.format)
|
||||
{
|
||||
case 1: case 2: case 3:
|
||||
return u.hinting.get_y_delta (font);
|
||||
case 0x8000:
|
||||
return u.variation.get_y_delta (font, store);
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
inline bool sanitize (hb_sanitize_context_t *c) const
|
||||
{
|
||||
TRACE_SANITIZE (this);
|
||||
if (!u.b.format.sanitize (c)) return_trace (false);
|
||||
switch (u.b.format) {
|
||||
case 1: case 2: case 3:
|
||||
return_trace (u.hinting.sanitize (c));
|
||||
case 0x8000:
|
||||
return_trace (u.variation.sanitize (c));
|
||||
default:
|
||||
return_trace (true);
|
||||
}
|
||||
}
|
||||
|
||||
protected:
|
||||
union {
|
||||
DeviceHeader b;
|
||||
HintingDevice hinting;
|
||||
VariationDevice variation;
|
||||
} u;
|
||||
public:
|
||||
DEFINE_SIZE_UNION (6, b);
|
||||
};
|
||||
|
||||
|
||||
} /* namespace OT */
|
||||
|
||||
|
|
|
@ -97,7 +97,7 @@ struct CaretValueFormat1
|
|||
friend struct CaretValue;
|
||||
|
||||
private:
|
||||
inline hb_position_t get_caret_value (hb_font_t *font, hb_direction_t direction, hb_codepoint_t glyph_id HB_UNUSED) const
|
||||
inline hb_position_t get_caret_value (hb_font_t *font, hb_direction_t direction) const
|
||||
{
|
||||
return HB_DIRECTION_IS_HORIZONTAL (direction) ? font->em_scale_x (coordinate) : font->em_scale_y (coordinate);
|
||||
}
|
||||
|
@ -146,11 +146,11 @@ struct CaretValueFormat3
|
|||
{
|
||||
friend struct CaretValue;
|
||||
|
||||
inline hb_position_t get_caret_value (hb_font_t *font, hb_direction_t direction, hb_codepoint_t glyph_id HB_UNUSED) const
|
||||
inline hb_position_t get_caret_value (hb_font_t *font, hb_direction_t direction, const VariationStore &var_store) const
|
||||
{
|
||||
return HB_DIRECTION_IS_HORIZONTAL (direction) ?
|
||||
font->em_scale_x (coordinate) + (this+deviceTable).get_x_delta (font) :
|
||||
font->em_scale_y (coordinate) + (this+deviceTable).get_y_delta (font);
|
||||
font->em_scale_x (coordinate) + (this+deviceTable).get_x_delta (font, var_store) :
|
||||
font->em_scale_y (coordinate) + (this+deviceTable).get_y_delta (font, var_store);
|
||||
}
|
||||
|
||||
inline bool sanitize (hb_sanitize_context_t *c) const
|
||||
|
@ -172,12 +172,15 @@ struct CaretValueFormat3
|
|||
|
||||
struct CaretValue
|
||||
{
|
||||
inline hb_position_t get_caret_value (hb_font_t *font, hb_direction_t direction, hb_codepoint_t glyph_id) const
|
||||
inline hb_position_t get_caret_value (hb_font_t *font,
|
||||
hb_direction_t direction,
|
||||
hb_codepoint_t glyph_id,
|
||||
const VariationStore &var_store) const
|
||||
{
|
||||
switch (u.format) {
|
||||
case 1: return u.format1.get_caret_value (font, direction, glyph_id);
|
||||
case 1: return u.format1.get_caret_value (font, direction);
|
||||
case 2: return u.format2.get_caret_value (font, direction, glyph_id);
|
||||
case 3: return u.format3.get_caret_value (font, direction, glyph_id);
|
||||
case 3: return u.format3.get_caret_value (font, direction, var_store);
|
||||
default:return 0;
|
||||
}
|
||||
}
|
||||
|
@ -210,6 +213,7 @@ struct LigGlyph
|
|||
inline unsigned int get_lig_carets (hb_font_t *font,
|
||||
hb_direction_t direction,
|
||||
hb_codepoint_t glyph_id,
|
||||
const VariationStore &var_store,
|
||||
unsigned int start_offset,
|
||||
unsigned int *caret_count /* IN/OUT */,
|
||||
hb_position_t *caret_array /* OUT */) const
|
||||
|
@ -218,7 +222,7 @@ struct LigGlyph
|
|||
const OffsetTo<CaretValue> *array = carets.sub_array (start_offset, caret_count);
|
||||
unsigned int count = *caret_count;
|
||||
for (unsigned int i = 0; i < count; i++)
|
||||
caret_array[i] = (this+array[i]).get_caret_value (font, direction, glyph_id);
|
||||
caret_array[i] = (this+array[i]).get_caret_value (font, direction, glyph_id, var_store);
|
||||
}
|
||||
|
||||
return carets.len;
|
||||
|
@ -244,6 +248,7 @@ struct LigCaretList
|
|||
inline unsigned int get_lig_carets (hb_font_t *font,
|
||||
hb_direction_t direction,
|
||||
hb_codepoint_t glyph_id,
|
||||
const VariationStore &var_store,
|
||||
unsigned int start_offset,
|
||||
unsigned int *caret_count /* IN/OUT */,
|
||||
hb_position_t *caret_array /* OUT */) const
|
||||
|
@ -256,7 +261,7 @@ struct LigCaretList
|
|||
return 0;
|
||||
}
|
||||
const LigGlyph &lig_glyph = this+ligGlyph[index];
|
||||
return lig_glyph.get_lig_carets (font, direction, glyph_id, start_offset, caret_count, caret_array);
|
||||
return lig_glyph.get_lig_carets (font, direction, glyph_id, var_store, start_offset, caret_count, caret_array);
|
||||
}
|
||||
|
||||
inline bool sanitize (hb_sanitize_context_t *c) const
|
||||
|
@ -290,7 +295,7 @@ struct MarkGlyphSetsFormat1
|
|||
|
||||
protected:
|
||||
USHORT format; /* Format identifier--format = 1 */
|
||||
ArrayOf<OffsetTo<Coverage, ULONG> >
|
||||
ArrayOf<LOffsetTo<Coverage> >
|
||||
coverage; /* Array of long offsets to mark set
|
||||
* coverage tables */
|
||||
public:
|
||||
|
@ -367,11 +372,17 @@ struct GDEF
|
|||
unsigned int start_offset,
|
||||
unsigned int *caret_count /* IN/OUT */,
|
||||
hb_position_t *caret_array /* OUT */) const
|
||||
{ return (this+ligCaretList).get_lig_carets (font, direction, glyph_id, start_offset, caret_count, caret_array); }
|
||||
{ return (this+ligCaretList).get_lig_carets (font,
|
||||
direction, glyph_id, get_var_store(),
|
||||
start_offset, caret_count, caret_array); }
|
||||
|
||||
inline bool has_mark_sets (void) const { return version.to_int () >= 0x00010002u && markGlyphSetsDef[0] != 0; }
|
||||
inline bool has_mark_sets (void) const { return version.to_int () >= 0x00010002u && markGlyphSetsDef != 0; }
|
||||
inline bool mark_set_covers (unsigned int set_index, hb_codepoint_t glyph_id) const
|
||||
{ return version.to_int () >= 0x00010002u && (this+markGlyphSetsDef[0]).covers (set_index, glyph_id); }
|
||||
{ return version.to_int () >= 0x00010002u && (this+markGlyphSetsDef).covers (set_index, glyph_id); }
|
||||
|
||||
inline bool has_var_store (void) const { return version.to_int () >= 0x00010003u && varStore != 0; }
|
||||
inline const VariationStore &get_var_store (void) const
|
||||
{ return version.to_int () >= 0x00010003u ? this+varStore : Null(VariationStore); }
|
||||
|
||||
inline bool sanitize (hb_sanitize_context_t *c) const
|
||||
{
|
||||
|
@ -382,10 +393,10 @@ struct GDEF
|
|||
attachList.sanitize (c, this) &&
|
||||
ligCaretList.sanitize (c, this) &&
|
||||
markAttachClassDef.sanitize (c, this) &&
|
||||
(version.to_int () < 0x00010002u || markGlyphSetsDef[0].sanitize (c, this)));
|
||||
(version.to_int () < 0x00010002u || markGlyphSetsDef.sanitize (c, this)) &&
|
||||
(version.to_int () < 0x00010003u || varStore.sanitize (c, this)));
|
||||
}
|
||||
|
||||
|
||||
/* glyph_props is a 16-bit integer where the lower 8-bit have bits representing
|
||||
* glyph class and other bits, and high 8-bit gthe mark attachment type (if any).
|
||||
* Not to be confused with lookup_props which is very similar. */
|
||||
|
@ -409,8 +420,8 @@ struct GDEF
|
|||
|
||||
|
||||
protected:
|
||||
FixedVersion version; /* Version of the GDEF table--currently
|
||||
* 0x00010002u */
|
||||
FixedVersion<>version; /* Version of the GDEF table--currently
|
||||
* 0x00010003u */
|
||||
OffsetTo<ClassDef>
|
||||
glyphClassDef; /* Offset to class definition table
|
||||
* for glyph type--from beginning of
|
||||
|
@ -428,12 +439,17 @@ struct GDEF
|
|||
* mark attachment type--from beginning
|
||||
* of GDEF header (may be Null) */
|
||||
OffsetTo<MarkGlyphSets>
|
||||
markGlyphSetsDef[VAR]; /* Offset to the table of mark set
|
||||
markGlyphSetsDef; /* Offset to the table of mark set
|
||||
* definitions--from beginning of GDEF
|
||||
* header (may be NULL). Introduced
|
||||
* in version 00010002. */
|
||||
* in version 0x00010002. */
|
||||
LOffsetTo<VariationStore>
|
||||
varStore; /* Offset to the table of Item Variation
|
||||
* Store--from beginning of GDEF
|
||||
* header (may be NULL). Introduced
|
||||
* in version 0x00010003. */
|
||||
public:
|
||||
DEFINE_SIZE_ARRAY (12, markGlyphSetsDef);
|
||||
DEFINE_SIZE_MIN (12);
|
||||
};
|
||||
|
||||
|
||||
|
|
|
@ -36,8 +36,17 @@ namespace OT {
|
|||
|
||||
|
||||
/* buffer **position** var allocations */
|
||||
#define attach_lookback() var.u16[0] /* number of glyphs to go back to attach this glyph to its base */
|
||||
#define cursive_chain() var.i16[1] /* character to which this connects, may be positive or negative */
|
||||
#define attach_chain() var.i16[0] /* glyph to which this attaches to, relative to current glyphs; negative for going back, positive for forward. */
|
||||
#define attach_type() var.u8[2] /* attachment type */
|
||||
/* Note! if attach_chain() is zero, the value of attach_type() is irrelevant. */
|
||||
|
||||
enum attach_type_t {
|
||||
ATTACH_TYPE_NONE = 0X00,
|
||||
|
||||
/* Each attachment should be either a mark or a cursive; can't be both. */
|
||||
ATTACH_TYPE_MARK = 0X01,
|
||||
ATTACH_TYPE_CURSIVE = 0X02,
|
||||
};
|
||||
|
||||
|
||||
/* Shared Tables: ValueRecord, Anchor Table, and MarkArray */
|
||||
|
@ -94,18 +103,17 @@ struct ValueFormat : USHORT
|
|||
inline unsigned int get_size (void) const
|
||||
{ return get_len () * Value::static_size; }
|
||||
|
||||
void apply_value (hb_font_t *font,
|
||||
hb_direction_t direction,
|
||||
void apply_value (hb_apply_context_t *c,
|
||||
const void *base,
|
||||
const Value *values,
|
||||
hb_glyph_position_t &glyph_pos) const
|
||||
{
|
||||
unsigned int x_ppem, y_ppem;
|
||||
unsigned int format = *this;
|
||||
hb_bool_t horizontal = HB_DIRECTION_IS_HORIZONTAL (direction);
|
||||
|
||||
if (!format) return;
|
||||
|
||||
hb_font_t *font = c->font;
|
||||
hb_bool_t horizontal = HB_DIRECTION_IS_HORIZONTAL (c->direction);
|
||||
|
||||
if (format & xPlacement) glyph_pos.x_offset += font->em_scale_x (get_short (values++));
|
||||
if (format & yPlacement) glyph_pos.y_offset += font->em_scale_y (get_short (values++));
|
||||
if (format & xAdvance) {
|
||||
|
@ -120,27 +128,29 @@ struct ValueFormat : USHORT
|
|||
|
||||
if (!has_device ()) return;
|
||||
|
||||
x_ppem = font->x_ppem;
|
||||
y_ppem = font->y_ppem;
|
||||
bool use_x_device = font->x_ppem || font->num_coords;
|
||||
bool use_y_device = font->y_ppem || font->num_coords;
|
||||
|
||||
if (!x_ppem && !y_ppem) return;
|
||||
if (!use_x_device && !use_y_device) return;
|
||||
|
||||
const VariationStore &store = c->var_store;
|
||||
|
||||
/* pixel -> fractional pixel */
|
||||
if (format & xPlaDevice) {
|
||||
if (x_ppem) glyph_pos.x_offset += (base + get_device (values)).get_x_delta (font);
|
||||
if (use_x_device) glyph_pos.x_offset += (base + get_device (values)).get_x_delta (font, store);
|
||||
values++;
|
||||
}
|
||||
if (format & yPlaDevice) {
|
||||
if (y_ppem) glyph_pos.y_offset += (base + get_device (values)).get_y_delta (font);
|
||||
if (use_y_device) glyph_pos.y_offset += (base + get_device (values)).get_y_delta (font, store);
|
||||
values++;
|
||||
}
|
||||
if (format & xAdvDevice) {
|
||||
if (horizontal && x_ppem) glyph_pos.x_advance += (base + get_device (values)).get_x_delta (font);
|
||||
if (horizontal && use_x_device) glyph_pos.x_advance += (base + get_device (values)).get_x_delta (font, store);
|
||||
values++;
|
||||
}
|
||||
if (format & yAdvDevice) {
|
||||
/* y_advance values grow downward but font-space grows upward, hence negation */
|
||||
if (!horizontal && y_ppem) glyph_pos.y_advance -= (base + get_device (values)).get_y_delta (font);
|
||||
if (!horizontal && use_y_device) glyph_pos.y_advance -= (base + get_device (values)).get_y_delta (font, store);
|
||||
values++;
|
||||
}
|
||||
}
|
||||
|
@ -222,11 +232,12 @@ struct ValueFormat : USHORT
|
|||
|
||||
struct AnchorFormat1
|
||||
{
|
||||
inline void get_anchor (hb_font_t *font, hb_codepoint_t glyph_id HB_UNUSED,
|
||||
inline void get_anchor (hb_apply_context_t *c, hb_codepoint_t glyph_id HB_UNUSED,
|
||||
hb_position_t *x, hb_position_t *y) const
|
||||
{
|
||||
*x = font->em_scale_x (xCoordinate);
|
||||
*y = font->em_scale_y (yCoordinate);
|
||||
hb_font_t *font = c->font;
|
||||
*x = font->em_scale_x (xCoordinate);
|
||||
*y = font->em_scale_y (yCoordinate);
|
||||
}
|
||||
|
||||
inline bool sanitize (hb_sanitize_context_t *c) const
|
||||
|
@ -245,18 +256,19 @@ struct AnchorFormat1
|
|||
|
||||
struct AnchorFormat2
|
||||
{
|
||||
inline void get_anchor (hb_font_t *font, hb_codepoint_t glyph_id,
|
||||
inline void get_anchor (hb_apply_context_t *c, hb_codepoint_t glyph_id,
|
||||
hb_position_t *x, hb_position_t *y) const
|
||||
{
|
||||
unsigned int x_ppem = font->x_ppem;
|
||||
unsigned int y_ppem = font->y_ppem;
|
||||
hb_position_t cx, cy;
|
||||
hb_bool_t ret;
|
||||
hb_font_t *font = c->font;
|
||||
unsigned int x_ppem = font->x_ppem;
|
||||
unsigned int y_ppem = font->y_ppem;
|
||||
hb_position_t cx, cy;
|
||||
hb_bool_t ret;
|
||||
|
||||
ret = (x_ppem || y_ppem) &&
|
||||
font->get_glyph_contour_point_for_origin (glyph_id, anchorPoint, HB_DIRECTION_LTR, &cx, &cy);
|
||||
*x = ret && x_ppem ? cx : font->em_scale_x (xCoordinate);
|
||||
*y = ret && y_ppem ? cy : font->em_scale_y (yCoordinate);
|
||||
ret = (x_ppem || y_ppem) &&
|
||||
font->get_glyph_contour_point_for_origin (glyph_id, anchorPoint, HB_DIRECTION_LTR, &cx, &cy);
|
||||
*x = ret && x_ppem ? cx : font->em_scale_x (xCoordinate);
|
||||
*y = ret && y_ppem ? cy : font->em_scale_y (yCoordinate);
|
||||
}
|
||||
|
||||
inline bool sanitize (hb_sanitize_context_t *c) const
|
||||
|
@ -276,16 +288,17 @@ struct AnchorFormat2
|
|||
|
||||
struct AnchorFormat3
|
||||
{
|
||||
inline void get_anchor (hb_font_t *font, hb_codepoint_t glyph_id HB_UNUSED,
|
||||
inline void get_anchor (hb_apply_context_t *c, hb_codepoint_t glyph_id HB_UNUSED,
|
||||
hb_position_t *x, hb_position_t *y) const
|
||||
{
|
||||
*x = font->em_scale_x (xCoordinate);
|
||||
*y = font->em_scale_y (yCoordinate);
|
||||
hb_font_t *font = c->font;
|
||||
*x = font->em_scale_x (xCoordinate);
|
||||
*y = font->em_scale_y (yCoordinate);
|
||||
|
||||
if (font->x_ppem)
|
||||
*x += (this+xDeviceTable).get_x_delta (font);
|
||||
if (font->y_ppem)
|
||||
*y += (this+yDeviceTable).get_x_delta (font);
|
||||
if (font->x_ppem || font->num_coords)
|
||||
*x += (this+xDeviceTable).get_x_delta (font, c->var_store);
|
||||
if (font->y_ppem || font->num_coords)
|
||||
*y += (this+yDeviceTable).get_y_delta (font, c->var_store);
|
||||
}
|
||||
|
||||
inline bool sanitize (hb_sanitize_context_t *c) const
|
||||
|
@ -312,14 +325,14 @@ struct AnchorFormat3
|
|||
|
||||
struct Anchor
|
||||
{
|
||||
inline void get_anchor (hb_font_t *font, hb_codepoint_t glyph_id,
|
||||
inline void get_anchor (hb_apply_context_t *c, hb_codepoint_t glyph_id,
|
||||
hb_position_t *x, hb_position_t *y) const
|
||||
{
|
||||
*x = *y = 0;
|
||||
switch (u.format) {
|
||||
case 1: u.format1.get_anchor (font, glyph_id, x, y); return;
|
||||
case 2: u.format2.get_anchor (font, glyph_id, x, y); return;
|
||||
case 3: u.format3.get_anchor (font, glyph_id, x, y); return;
|
||||
case 1: u.format1.get_anchor (c, glyph_id, x, y); return;
|
||||
case 2: u.format2.get_anchor (c, glyph_id, x, y); return;
|
||||
case 3: u.format3.get_anchor (c, glyph_id, x, y); return;
|
||||
default: return;
|
||||
}
|
||||
}
|
||||
|
@ -361,7 +374,7 @@ struct AnchorMatrix
|
|||
{
|
||||
TRACE_SANITIZE (this);
|
||||
if (!c->check_struct (this)) return_trace (false);
|
||||
if (unlikely (rows > 0 && cols >= ((unsigned int) -1) / rows)) return_trace (false);
|
||||
if (unlikely (_hb_unsigned_int_mul_overflows (rows, cols))) return_trace (false);
|
||||
unsigned int count = rows * cols;
|
||||
if (!c->check_array (matrixZ, matrixZ[0].static_size, count)) return_trace (false);
|
||||
for (unsigned int i = 0; i < count; i++)
|
||||
|
@ -419,13 +432,15 @@ struct MarkArray : ArrayOf<MarkRecord> /* Array of MarkRecords--in Coverage orde
|
|||
|
||||
hb_position_t mark_x, mark_y, base_x, base_y;
|
||||
|
||||
mark_anchor.get_anchor (c->font, buffer->cur().codepoint, &mark_x, &mark_y);
|
||||
glyph_anchor.get_anchor (c->font, buffer->info[glyph_pos].codepoint, &base_x, &base_y);
|
||||
buffer->unsafe_to_break (glyph_pos, buffer->idx);
|
||||
mark_anchor.get_anchor (c, buffer->cur().codepoint, &mark_x, &mark_y);
|
||||
glyph_anchor.get_anchor (c, buffer->info[glyph_pos].codepoint, &base_x, &base_y);
|
||||
|
||||
hb_glyph_position_t &o = buffer->cur_pos();
|
||||
o.x_offset = base_x - mark_x;
|
||||
o.y_offset = base_y - mark_y;
|
||||
o.attach_lookback() = buffer->idx - glyph_pos;
|
||||
o.attach_type() = ATTACH_TYPE_MARK;
|
||||
o.attach_chain() = (int) glyph_pos - (int) buffer->idx;
|
||||
buffer->scratch_flags |= HB_BUFFER_SCRATCH_FLAG_HAS_GPOS_ATTACHMENT;
|
||||
|
||||
buffer->idx++;
|
||||
|
@ -462,8 +477,7 @@ struct SinglePosFormat1
|
|||
unsigned int index = (this+coverage).get_coverage (buffer->cur().codepoint);
|
||||
if (likely (index == NOT_COVERED)) return_trace (false);
|
||||
|
||||
valueFormat.apply_value (c->font, c->direction, this,
|
||||
values, buffer->cur_pos());
|
||||
valueFormat.apply_value (c, this, values, buffer->cur_pos());
|
||||
|
||||
buffer->idx++;
|
||||
return_trace (true);
|
||||
|
@ -513,7 +527,7 @@ struct SinglePosFormat2
|
|||
|
||||
if (likely (index >= valueCount)) return_trace (false);
|
||||
|
||||
valueFormat.apply_value (c->font, c->direction, this,
|
||||
valueFormat.apply_value (c, this,
|
||||
&values[index * valueFormat.get_len ()],
|
||||
buffer->cur_pos());
|
||||
|
||||
|
@ -630,10 +644,9 @@ struct PairSet
|
|||
min = mid + 1;
|
||||
else
|
||||
{
|
||||
valueFormats[0].apply_value (c->font, c->direction, this,
|
||||
&record->values[0], buffer->cur_pos());
|
||||
valueFormats[1].apply_value (c->font, c->direction, this,
|
||||
&record->values[len1], buffer->pos[pos]);
|
||||
buffer->unsafe_to_break (buffer->idx, pos + 1);
|
||||
valueFormats[0].apply_value (c, this, &record->values[0], buffer->cur_pos());
|
||||
valueFormats[1].apply_value (c, this, &record->values[len1], buffer->pos[pos]);
|
||||
if (len2)
|
||||
pos++;
|
||||
buffer->idx = pos;
|
||||
|
@ -679,7 +692,7 @@ struct PairPosFormat1
|
|||
(this+coverage).add_coverage (c->input);
|
||||
unsigned int count = pairSet.len;
|
||||
for (unsigned int i = 0; i < count; i++)
|
||||
(this+pairSet[i]).collect_glyphs (c, &valueFormat1);
|
||||
(this+pairSet[i]).collect_glyphs (c, valueFormat);
|
||||
}
|
||||
|
||||
inline const Coverage &get_coverage (void) const
|
||||
|
@ -698,7 +711,7 @@ struct PairPosFormat1
|
|||
skippy_iter.reset (buffer->idx, 1);
|
||||
if (!skippy_iter.next ()) return_trace (false);
|
||||
|
||||
return_trace ((this+pairSet[index]).apply (c, &valueFormat1, skippy_iter.idx));
|
||||
return_trace ((this+pairSet[index]).apply (c, valueFormat, skippy_iter.idx));
|
||||
}
|
||||
|
||||
inline bool sanitize (hb_sanitize_context_t *c) const
|
||||
|
@ -707,11 +720,11 @@ struct PairPosFormat1
|
|||
|
||||
if (!c->check_struct (this)) return_trace (false);
|
||||
|
||||
unsigned int len1 = valueFormat1.get_len ();
|
||||
unsigned int len2 = valueFormat2.get_len ();
|
||||
unsigned int len1 = valueFormat[0].get_len ();
|
||||
unsigned int len2 = valueFormat[1].get_len ();
|
||||
PairSet::sanitize_closure_t closure = {
|
||||
this,
|
||||
&valueFormat1,
|
||||
valueFormat,
|
||||
len1,
|
||||
1 + len1 + len2
|
||||
};
|
||||
|
@ -724,10 +737,10 @@ struct PairPosFormat1
|
|||
OffsetTo<Coverage>
|
||||
coverage; /* Offset to Coverage table--from
|
||||
* beginning of subtable */
|
||||
ValueFormat valueFormat1; /* Defines the types of data in
|
||||
ValueFormat valueFormat[2]; /* [0] Defines the types of data in
|
||||
* ValueRecord1--for the first glyph
|
||||
* in the pair--may be zero (0) */
|
||||
ValueFormat valueFormat2; /* Defines the types of data in
|
||||
/* [1] Defines the types of data in
|
||||
* ValueRecord2--for the second glyph
|
||||
* in the pair--may be zero (0) */
|
||||
OffsetArrayOf<PairSet>
|
||||
|
@ -742,7 +755,7 @@ struct PairPosFormat2
|
|||
inline void collect_glyphs (hb_collect_glyphs_context_t *c) const
|
||||
{
|
||||
TRACE_COLLECT_GLYPHS (this);
|
||||
/* (this+coverage).add_coverage (c->input); // Don't need this. */
|
||||
(this+coverage).add_coverage (c->input);
|
||||
|
||||
unsigned int count1 = class1Count;
|
||||
const ClassDef &klass1 = this+classDef1;
|
||||
|
@ -779,11 +792,10 @@ struct PairPosFormat2
|
|||
unsigned int klass2 = (this+classDef2).get_class (buffer->info[skippy_iter.idx].codepoint);
|
||||
if (unlikely (klass1 >= class1Count || klass2 >= class2Count)) return_trace (false);
|
||||
|
||||
buffer->unsafe_to_break (buffer->idx, skippy_iter.idx + 1);
|
||||
const Value *v = &values[record_len * (klass1 * class2Count + klass2)];
|
||||
valueFormat1.apply_value (c->font, c->direction, this,
|
||||
v, buffer->cur_pos());
|
||||
valueFormat2.apply_value (c->font, c->direction, this,
|
||||
v + len1, buffer->pos[skippy_iter.idx]);
|
||||
valueFormat1.apply_value (c, this, v, buffer->cur_pos());
|
||||
valueFormat2.apply_value (c, this, v + len1, buffer->pos[skippy_iter.idx]);
|
||||
|
||||
buffer->idx = skippy_iter.idx;
|
||||
if (len2)
|
||||
|
@ -907,9 +919,6 @@ struct CursivePosFormat1
|
|||
TRACE_APPLY (this);
|
||||
hb_buffer_t *buffer = c->buffer;
|
||||
|
||||
/* We don't handle mark glyphs here. */
|
||||
if (unlikely (_hb_glyph_info_is_mark (&buffer->cur()))) return_trace (false);
|
||||
|
||||
const EntryExitRecord &this_record = entryExitRecord[(this+coverage).get_coverage (buffer->cur().codepoint)];
|
||||
if (!this_record.exitAnchor) return_trace (false);
|
||||
|
||||
|
@ -923,9 +932,10 @@ struct CursivePosFormat1
|
|||
unsigned int i = buffer->idx;
|
||||
unsigned int j = skippy_iter.idx;
|
||||
|
||||
buffer->unsafe_to_break (i, j);
|
||||
hb_position_t entry_x, entry_y, exit_x, exit_y;
|
||||
(this+this_record.exitAnchor).get_anchor (c->font, buffer->info[i].codepoint, &exit_x, &exit_y);
|
||||
(this+next_record.entryAnchor).get_anchor (c->font, buffer->info[j].codepoint, &entry_x, &entry_y);
|
||||
(this+this_record.exitAnchor).get_anchor (c, buffer->info[i].codepoint, &exit_x, &exit_y);
|
||||
(this+next_record.entryAnchor).get_anchor (c, buffer->info[j].codepoint, &entry_x, &entry_y);
|
||||
|
||||
hb_glyph_position_t *pos = buffer->pos;
|
||||
|
||||
|
@ -993,8 +1003,9 @@ struct CursivePosFormat1
|
|||
*/
|
||||
reverse_cursive_minor_offset (pos, child, c->direction, parent);
|
||||
|
||||
pos[child].cursive_chain() = parent - child;
|
||||
buffer->scratch_flags |= HB_BUFFER_SCRATCH_FLAG_HAS_GPOS_CURSIVE;
|
||||
pos[child].attach_type() = ATTACH_TYPE_CURSIVE;
|
||||
pos[child].attach_chain() = (int) parent - (int) child;
|
||||
buffer->scratch_flags |= HB_BUFFER_SCRATCH_FLAG_HAS_GPOS_ATTACHMENT;
|
||||
if (likely (HB_DIRECTION_IS_HORIZONTAL (c->direction)))
|
||||
pos[child].y_offset = y_offset;
|
||||
else
|
||||
|
@ -1069,7 +1080,7 @@ struct MarkBasePosFormat1
|
|||
unsigned int mark_index = (this+markCoverage).get_coverage (buffer->cur().codepoint);
|
||||
if (likely (mark_index == NOT_COVERED)) return_trace (false);
|
||||
|
||||
/* now we search backwards for a non-mark glyph */
|
||||
/* Now we search backwards for a non-mark glyph */
|
||||
hb_apply_context_t::skipping_iterator_t &skippy_iter = c->iter_input;
|
||||
skippy_iter.reset (buffer->idx, 1);
|
||||
skippy_iter.set_lookup_props (LookupFlag::IgnoreMarks);
|
||||
|
@ -1081,7 +1092,7 @@ struct MarkBasePosFormat1
|
|||
} while (1);
|
||||
|
||||
/* Checking that matched glyph is actually a base glyph by GDEF is too strong; disabled */
|
||||
if (!_hb_glyph_info_is_base_glyph (&buffer->info[skippy_iter.idx])) { /*return_trace (false);*/ }
|
||||
//if (!_hb_glyph_info_is_base_glyph (&buffer->info[skippy_iter.idx])) { return_trace (false); }
|
||||
|
||||
unsigned int base_index = (this+baseCoverage).get_coverage (buffer->info[skippy_iter.idx].codepoint);
|
||||
if (base_index == NOT_COVERED) return_trace (false);
|
||||
|
@ -1170,14 +1181,14 @@ struct MarkLigPosFormat1
|
|||
unsigned int mark_index = (this+markCoverage).get_coverage (buffer->cur().codepoint);
|
||||
if (likely (mark_index == NOT_COVERED)) return_trace (false);
|
||||
|
||||
/* now we search backwards for a non-mark glyph */
|
||||
/* Now we search backwards for a non-mark glyph */
|
||||
hb_apply_context_t::skipping_iterator_t &skippy_iter = c->iter_input;
|
||||
skippy_iter.reset (buffer->idx, 1);
|
||||
skippy_iter.set_lookup_props (LookupFlag::IgnoreMarks);
|
||||
if (!skippy_iter.prev ()) return_trace (false);
|
||||
|
||||
/* Checking that matched glyph is actually a ligature by GDEF is too strong; disabled */
|
||||
if (!_hb_glyph_info_is_ligature (&buffer->info[skippy_iter.idx])) { /*return_trace (false);*/ }
|
||||
//if (!_hb_glyph_info_is_ligature (&buffer->info[skippy_iter.idx])) { return_trace (false); }
|
||||
|
||||
unsigned int j = skippy_iter.idx;
|
||||
unsigned int lig_index = (this+ligatureCoverage).get_coverage (buffer->info[j].codepoint);
|
||||
|
@ -1501,7 +1512,8 @@ struct GPOS : GSUBGPOS
|
|||
{ return CastR<PosLookup> (GSUBGPOS::get_lookup (i)); }
|
||||
|
||||
static inline void position_start (hb_font_t *font, hb_buffer_t *buffer);
|
||||
static inline void position_finish (hb_font_t *font, hb_buffer_t *buffer);
|
||||
static inline void position_finish_advances (hb_font_t *font, hb_buffer_t *buffer);
|
||||
static inline void position_finish_offsets (hb_font_t *font, hb_buffer_t *buffer);
|
||||
|
||||
inline bool sanitize (hb_sanitize_context_t *c) const
|
||||
{
|
||||
|
@ -1510,21 +1522,19 @@ struct GPOS : GSUBGPOS
|
|||
const OffsetTo<PosLookupList> &list = CastR<OffsetTo<PosLookupList> > (lookupList);
|
||||
return_trace (list.sanitize (c, this));
|
||||
}
|
||||
public:
|
||||
DEFINE_SIZE_STATIC (10);
|
||||
};
|
||||
|
||||
|
||||
static void
|
||||
reverse_cursive_minor_offset (hb_glyph_position_t *pos, unsigned int i, hb_direction_t direction, unsigned int new_parent)
|
||||
{
|
||||
unsigned int j = pos[i].cursive_chain();
|
||||
if (likely (!j))
|
||||
int chain = pos[i].attach_chain(), type = pos[i].attach_type();
|
||||
if (likely (!chain || 0 == (type & ATTACH_TYPE_CURSIVE)))
|
||||
return;
|
||||
|
||||
j += i;
|
||||
pos[i].attach_chain() = 0;
|
||||
|
||||
pos[i].cursive_chain() = 0;
|
||||
unsigned int j = (int) i + chain;
|
||||
|
||||
/* Stop if we see new parent in the chain. */
|
||||
if (j == new_parent)
|
||||
|
@ -1537,62 +1547,68 @@ reverse_cursive_minor_offset (hb_glyph_position_t *pos, unsigned int i, hb_direc
|
|||
else
|
||||
pos[j].x_offset = -pos[i].x_offset;
|
||||
|
||||
pos[j].cursive_chain() = i - j;
|
||||
pos[j].attach_chain() = -chain;
|
||||
pos[j].attach_type() = type;
|
||||
}
|
||||
static void
|
||||
fix_cursive_minor_offset (hb_glyph_position_t *pos, unsigned int i, hb_direction_t direction)
|
||||
propagate_attachment_offsets (hb_glyph_position_t *pos, unsigned int i, hb_direction_t direction)
|
||||
{
|
||||
unsigned int j = pos[i].cursive_chain();
|
||||
if (likely (!j))
|
||||
/* Adjusts offsets of attached glyphs (both cursive and mark) to accumulate
|
||||
* offset of glyph they are attached to. */
|
||||
int chain = pos[i].attach_chain(), type = pos[i].attach_type();
|
||||
if (likely (!chain))
|
||||
return;
|
||||
|
||||
j += i;
|
||||
unsigned int j = (int) i + chain;
|
||||
|
||||
pos[i].cursive_chain() = 0;
|
||||
pos[i].attach_chain() = 0;
|
||||
|
||||
fix_cursive_minor_offset (pos, j, direction);
|
||||
propagate_attachment_offsets (pos, j, direction);
|
||||
|
||||
if (HB_DIRECTION_IS_HORIZONTAL (direction))
|
||||
pos[i].y_offset += pos[j].y_offset;
|
||||
else
|
||||
assert (!!(type & ATTACH_TYPE_MARK) ^ !!(type & ATTACH_TYPE_CURSIVE));
|
||||
|
||||
if (type & ATTACH_TYPE_CURSIVE)
|
||||
{
|
||||
if (HB_DIRECTION_IS_HORIZONTAL (direction))
|
||||
pos[i].y_offset += pos[j].y_offset;
|
||||
else
|
||||
pos[i].x_offset += pos[j].x_offset;
|
||||
}
|
||||
else /*if (type & ATTACH_TYPE_MARK)*/
|
||||
{
|
||||
pos[i].x_offset += pos[j].x_offset;
|
||||
}
|
||||
pos[i].y_offset += pos[j].y_offset;
|
||||
|
||||
static void
|
||||
fix_mark_attachment (hb_glyph_position_t *pos, unsigned int i, hb_direction_t direction)
|
||||
{
|
||||
if (likely (!(pos[i].attach_lookback())))
|
||||
return;
|
||||
|
||||
unsigned int j = i - pos[i].attach_lookback();
|
||||
|
||||
pos[i].x_offset += pos[j].x_offset;
|
||||
pos[i].y_offset += pos[j].y_offset;
|
||||
|
||||
if (HB_DIRECTION_IS_FORWARD (direction))
|
||||
for (unsigned int k = j; k < i; k++) {
|
||||
pos[i].x_offset -= pos[k].x_advance;
|
||||
pos[i].y_offset -= pos[k].y_advance;
|
||||
}
|
||||
else
|
||||
for (unsigned int k = j + 1; k < i + 1; k++) {
|
||||
pos[i].x_offset += pos[k].x_advance;
|
||||
pos[i].y_offset += pos[k].y_advance;
|
||||
}
|
||||
assert (j < i);
|
||||
if (HB_DIRECTION_IS_FORWARD (direction))
|
||||
for (unsigned int k = j; k < i; k++) {
|
||||
pos[i].x_offset -= pos[k].x_advance;
|
||||
pos[i].y_offset -= pos[k].y_advance;
|
||||
}
|
||||
else
|
||||
for (unsigned int k = j + 1; k < i + 1; k++) {
|
||||
pos[i].x_offset += pos[k].x_advance;
|
||||
pos[i].y_offset += pos[k].y_advance;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
GPOS::position_start (hb_font_t *font HB_UNUSED, hb_buffer_t *buffer)
|
||||
{
|
||||
buffer->clear_positions ();
|
||||
|
||||
unsigned int count = buffer->len;
|
||||
for (unsigned int i = 0; i < count; i++)
|
||||
buffer->pos[i].attach_lookback() = buffer->pos[i].cursive_chain() = 0;
|
||||
buffer->pos[i].attach_chain() = buffer->pos[i].attach_type() = 0;
|
||||
}
|
||||
|
||||
void
|
||||
GPOS::position_finish (hb_font_t *font HB_UNUSED, hb_buffer_t *buffer)
|
||||
GPOS::position_finish_advances (hb_font_t *font HB_UNUSED, hb_buffer_t *buffer)
|
||||
{
|
||||
//_hb_buffer_assert_gsubgpos_vars (buffer);
|
||||
}
|
||||
|
||||
void
|
||||
GPOS::position_finish_offsets (hb_font_t *font HB_UNUSED, hb_buffer_t *buffer)
|
||||
{
|
||||
_hb_buffer_assert_gsubgpos_vars (buffer);
|
||||
|
||||
|
@ -1600,15 +1616,10 @@ GPOS::position_finish (hb_font_t *font HB_UNUSED, hb_buffer_t *buffer)
|
|||
hb_glyph_position_t *pos = hb_buffer_get_glyph_positions (buffer, &len);
|
||||
hb_direction_t direction = buffer->props.direction;
|
||||
|
||||
/* Handle cursive connections */
|
||||
if (buffer->scratch_flags & HB_BUFFER_SCRATCH_FLAG_HAS_GPOS_CURSIVE)
|
||||
for (unsigned int i = 0; i < len; i++)
|
||||
fix_cursive_minor_offset (pos, i, direction);
|
||||
|
||||
/* Handle attachments */
|
||||
if (buffer->scratch_flags & HB_BUFFER_SCRATCH_FLAG_HAS_GPOS_ATTACHMENT)
|
||||
for (unsigned int i = 0; i < len; i++)
|
||||
fix_mark_attachment (pos, i, direction);
|
||||
propagate_attachment_offsets (pos, i, direction);
|
||||
}
|
||||
|
||||
|
||||
|
@ -1637,8 +1648,8 @@ template <typename context_t>
|
|||
}
|
||||
|
||||
|
||||
#undef attach_lookback
|
||||
#undef cursive_chain
|
||||
#undef attach_chain
|
||||
#undef attach_type
|
||||
|
||||
|
||||
} /* namespace OT */
|
||||
|
|
|
@ -41,7 +41,10 @@ struct SingleSubstFormat1
|
|||
{
|
||||
TRACE_CLOSURE (this);
|
||||
Coverage::Iter iter;
|
||||
for (iter.init (this+coverage); iter.more (); iter.next ()) {
|
||||
for (iter.init (this+coverage); iter.more (); iter.next ())
|
||||
{
|
||||
/* TODO Switch to range-based API to work around malicious fonts.
|
||||
* https://github.com/behdad/harfbuzz/issues/363 */
|
||||
hb_codepoint_t glyph_id = iter.get_glyph ();
|
||||
if (c->glyphs->has (glyph_id))
|
||||
c->glyphs->add ((glyph_id + deltaGlyphID) & 0xFFFFu);
|
||||
|
@ -52,7 +55,10 @@ struct SingleSubstFormat1
|
|||
{
|
||||
TRACE_COLLECT_GLYPHS (this);
|
||||
Coverage::Iter iter;
|
||||
for (iter.init (this+coverage); iter.more (); iter.next ()) {
|
||||
for (iter.init (this+coverage); iter.more (); iter.next ())
|
||||
{
|
||||
/* TODO Switch to range-based API to work around malicious fonts.
|
||||
* https://github.com/behdad/harfbuzz/issues/363 */
|
||||
hb_codepoint_t glyph_id = iter.get_glyph ();
|
||||
c->input->add (glyph_id);
|
||||
c->output->add ((glyph_id + deltaGlyphID) & 0xFFFFu);
|
||||
|
@ -120,7 +126,11 @@ struct SingleSubstFormat2
|
|||
{
|
||||
TRACE_CLOSURE (this);
|
||||
Coverage::Iter iter;
|
||||
for (iter.init (this+coverage); iter.more (); iter.next ()) {
|
||||
unsigned int count = substitute.len;
|
||||
for (iter.init (this+coverage); iter.more (); iter.next ())
|
||||
{
|
||||
if (unlikely (iter.get_coverage () >= count))
|
||||
break; /* Work around malicious fonts. https://github.com/behdad/harfbuzz/issues/363 */
|
||||
if (c->glyphs->has (iter.get_glyph ()))
|
||||
c->glyphs->add (substitute[iter.get_coverage ()]);
|
||||
}
|
||||
|
@ -130,7 +140,11 @@ struct SingleSubstFormat2
|
|||
{
|
||||
TRACE_COLLECT_GLYPHS (this);
|
||||
Coverage::Iter iter;
|
||||
for (iter.init (this+coverage); iter.more (); iter.next ()) {
|
||||
unsigned int count = substitute.len;
|
||||
for (iter.init (this+coverage); iter.more (); iter.next ())
|
||||
{
|
||||
if (unlikely (iter.get_coverage () >= count))
|
||||
break; /* Work around malicious fonts. https://github.com/behdad/harfbuzz/issues/363 */
|
||||
c->input->add (iter.get_glyph ());
|
||||
c->output->add (substitute[iter.get_coverage ()]);
|
||||
}
|
||||
|
@ -265,16 +279,6 @@ struct Sequence
|
|||
TRACE_APPLY (this);
|
||||
unsigned int count = substitute.len;
|
||||
|
||||
/* TODO:
|
||||
* Testing shows that Uniscribe actually allows zero-len susbstitute,
|
||||
* which essentially deletes a glyph. We don't allow for now. It
|
||||
* can be confusing to the client since the cluster from the deleted
|
||||
* glyph won't be merged with any output cluster... Also, currently
|
||||
* buffer->move_to() makes assumptions about this too. Perhaps fix
|
||||
* in the future after figuring out what to do with the clusters.
|
||||
*/
|
||||
if (unlikely (!count)) return_trace (false);
|
||||
|
||||
/* Special-case to make it in-place and not consider this
|
||||
* as a "multiplied" substitution. */
|
||||
if (unlikely (count == 1))
|
||||
|
@ -282,6 +286,13 @@ struct Sequence
|
|||
c->replace_glyph (substitute.array[0]);
|
||||
return_trace (true);
|
||||
}
|
||||
/* Spec disallows this, but Uniscribe allows it.
|
||||
* https://github.com/behdad/harfbuzz/issues/253 */
|
||||
else if (unlikely (count == 0))
|
||||
{
|
||||
c->buffer->delete_glyph ();
|
||||
return_trace (true);
|
||||
}
|
||||
|
||||
unsigned int klass = _hb_glyph_info_is_ligature (&c->buffer->cur()) ?
|
||||
HB_OT_LAYOUT_GLYPH_PROPS_BASE_GLYPH : 0;
|
||||
|
@ -324,7 +335,11 @@ struct MultipleSubstFormat1
|
|||
{
|
||||
TRACE_CLOSURE (this);
|
||||
Coverage::Iter iter;
|
||||
for (iter.init (this+coverage); iter.more (); iter.next ()) {
|
||||
unsigned int count = sequence.len;
|
||||
for (iter.init (this+coverage); iter.more (); iter.next ())
|
||||
{
|
||||
if (unlikely (iter.get_coverage () >= count))
|
||||
break; /* Work around malicious fonts. https://github.com/behdad/harfbuzz/issues/363 */
|
||||
if (c->glyphs->has (iter.get_glyph ()))
|
||||
(this+sequence[iter.get_coverage ()]).closure (c);
|
||||
}
|
||||
|
@ -442,7 +457,11 @@ struct AlternateSubstFormat1
|
|||
{
|
||||
TRACE_CLOSURE (this);
|
||||
Coverage::Iter iter;
|
||||
for (iter.init (this+coverage); iter.more (); iter.next ()) {
|
||||
unsigned int count = alternateSet.len;
|
||||
for (iter.init (this+coverage); iter.more (); iter.next ())
|
||||
{
|
||||
if (unlikely (iter.get_coverage () >= count))
|
||||
break; /* Work around malicious fonts. https://github.com/behdad/harfbuzz/issues/363 */
|
||||
if (c->glyphs->has (iter.get_glyph ())) {
|
||||
const AlternateSet &alt_set = this+alternateSet[iter.get_coverage ()];
|
||||
unsigned int count = alt_set.len;
|
||||
|
@ -456,7 +475,11 @@ struct AlternateSubstFormat1
|
|||
{
|
||||
TRACE_COLLECT_GLYPHS (this);
|
||||
Coverage::Iter iter;
|
||||
for (iter.init (this+coverage); iter.more (); iter.next ()) {
|
||||
unsigned int count = alternateSet.len;
|
||||
for (iter.init (this+coverage); iter.more (); iter.next ())
|
||||
{
|
||||
if (unlikely (iter.get_coverage () >= count))
|
||||
break; /* Work around malicious fonts. https://github.com/behdad/harfbuzz/issues/363 */
|
||||
c->input->add (iter.get_glyph ());
|
||||
const AlternateSet &alt_set = this+alternateSet[iter.get_coverage ()];
|
||||
unsigned int count = alt_set.len;
|
||||
|
@ -765,7 +788,11 @@ struct LigatureSubstFormat1
|
|||
{
|
||||
TRACE_CLOSURE (this);
|
||||
Coverage::Iter iter;
|
||||
for (iter.init (this+coverage); iter.more (); iter.next ()) {
|
||||
unsigned int count = ligatureSet.len;
|
||||
for (iter.init (this+coverage); iter.more (); iter.next ())
|
||||
{
|
||||
if (unlikely (iter.get_coverage () >= count))
|
||||
break; /* Work around malicious fonts. https://github.com/behdad/harfbuzz/issues/363 */
|
||||
if (c->glyphs->has (iter.get_glyph ()))
|
||||
(this+ligatureSet[iter.get_coverage ()]).closure (c);
|
||||
}
|
||||
|
@ -775,7 +802,11 @@ struct LigatureSubstFormat1
|
|||
{
|
||||
TRACE_COLLECT_GLYPHS (this);
|
||||
Coverage::Iter iter;
|
||||
for (iter.init (this+coverage); iter.more (); iter.next ()) {
|
||||
unsigned int count = ligatureSet.len;
|
||||
for (iter.init (this+coverage); iter.more (); iter.next ())
|
||||
{
|
||||
if (unlikely (iter.get_coverage () >= count))
|
||||
break; /* Work around malicious fonts. https://github.com/behdad/harfbuzz/issues/363 */
|
||||
c->input->add (iter.get_glyph ());
|
||||
(this+ligatureSet[iter.get_coverage ()]).collect_glyphs (c);
|
||||
}
|
||||
|
@ -926,7 +957,11 @@ struct ReverseChainSingleSubstFormat1
|
|||
|
||||
const ArrayOf<GlyphID> &substitute = StructAfter<ArrayOf<GlyphID> > (lookahead);
|
||||
Coverage::Iter iter;
|
||||
for (iter.init (this+coverage); iter.more (); iter.next ()) {
|
||||
count = substitute.len;
|
||||
for (iter.init (this+coverage); iter.more (); iter.next ())
|
||||
{
|
||||
if (unlikely (iter.get_coverage () >= count))
|
||||
break; /* Work around malicious fonts. https://github.com/behdad/harfbuzz/issues/363 */
|
||||
if (c->glyphs->has (iter.get_glyph ()))
|
||||
c->glyphs->add (substitute[iter.get_coverage ()]);
|
||||
}
|
||||
|
@ -979,14 +1014,17 @@ struct ReverseChainSingleSubstFormat1
|
|||
const OffsetArrayOf<Coverage> &lookahead = StructAfter<OffsetArrayOf<Coverage> > (backtrack);
|
||||
const ArrayOf<GlyphID> &substitute = StructAfter<ArrayOf<GlyphID> > (lookahead);
|
||||
|
||||
unsigned int start_index = 0, end_index = 0;
|
||||
if (match_backtrack (c,
|
||||
backtrack.len, (USHORT *) backtrack.array,
|
||||
match_coverage, this) &&
|
||||
match_coverage, this,
|
||||
&start_index) &&
|
||||
match_lookahead (c,
|
||||
lookahead.len, (USHORT *) lookahead.array,
|
||||
match_coverage, this,
|
||||
1))
|
||||
1, &end_index))
|
||||
{
|
||||
c->buffer->unsafe_to_break_from_outbuffer (start_index, end_index);
|
||||
c->replace_glyph_inplace (substitute[index]);
|
||||
/* Note: We DON'T decrease buffer->idx. The main loop does it
|
||||
* for us. This is useful for preventing surprises if someone
|
||||
|
@ -1268,7 +1306,6 @@ struct GSUB : GSUBGPOS
|
|||
{ return CastR<SubstLookup> (GSUBGPOS::get_lookup (i)); }
|
||||
|
||||
static inline void substitute_start (hb_font_t *font, hb_buffer_t *buffer);
|
||||
static inline void substitute_finish (hb_font_t *font, hb_buffer_t *buffer);
|
||||
|
||||
inline bool sanitize (hb_sanitize_context_t *c) const
|
||||
{
|
||||
|
@ -1277,8 +1314,6 @@ struct GSUB : GSUBGPOS
|
|||
const OffsetTo<SubstLookupList> &list = CastR<OffsetTo<SubstLookupList> > (lookupList);
|
||||
return_trace (list.sanitize (c, this));
|
||||
}
|
||||
public:
|
||||
DEFINE_SIZE_STATIC (10);
|
||||
};
|
||||
|
||||
|
||||
|
@ -1297,11 +1332,6 @@ GSUB::substitute_start (hb_font_t *font, hb_buffer_t *buffer)
|
|||
}
|
||||
}
|
||||
|
||||
void
|
||||
GSUB::substitute_finish (hb_font_t *font HB_UNUSED, hb_buffer_t *buffer HB_UNUSED)
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
/* Out-of-class implementation for methods recursing */
|
||||
|
||||
|
|
|
@ -319,7 +319,7 @@ struct hb_apply_context_t :
|
|||
if (!c->check_glyph_property (&info, lookup_props))
|
||||
return SKIP_YES;
|
||||
|
||||
if (unlikely (_hb_glyph_info_is_default_ignorable (&info) &&
|
||||
if (unlikely (_hb_glyph_info_is_default_ignorable_and_not_hidden (&info) &&
|
||||
(ignore_zwnj || !_hb_glyph_info_is_zwnj (&info)) &&
|
||||
(ignore_zwj || !_hb_glyph_info_is_zwj (&info))))
|
||||
return SKIP_MAYBE;
|
||||
|
@ -342,13 +342,13 @@ struct hb_apply_context_t :
|
|||
inline void init (hb_apply_context_t *c_, bool context_match = false)
|
||||
{
|
||||
c = c_;
|
||||
match_glyph_data = NULL,
|
||||
match_glyph_data = NULL;
|
||||
matcher.set_match_func (NULL, NULL);
|
||||
matcher.set_lookup_props (c->lookup_props);
|
||||
/* Ignore ZWNJ if we are matching GSUB context, or matching GPOS. */
|
||||
matcher.set_ignore_zwnj (context_match || c->table_index == 1);
|
||||
matcher.set_ignore_zwnj (c->table_index == 1 || (context_match && c->auto_zwnj));
|
||||
/* Ignore ZWJ if we are matching GSUB context, or matching GPOS, or if asked to. */
|
||||
matcher.set_ignore_zwj (context_match || c->table_index == 1 || c->auto_zwj);
|
||||
matcher.set_ignore_zwj (c->table_index == 1 || (context_match || c->auto_zwj));
|
||||
matcher.set_mask (context_match ? -1 : c->lookup_mask);
|
||||
}
|
||||
inline void set_lookup_props (unsigned int lookup_props)
|
||||
|
@ -457,43 +457,50 @@ struct hb_apply_context_t :
|
|||
return ret;
|
||||
}
|
||||
|
||||
unsigned int table_index; /* GSUB/GPOS */
|
||||
skipping_iterator_t iter_input, iter_context;
|
||||
|
||||
hb_font_t *font;
|
||||
hb_face_t *face;
|
||||
hb_buffer_t *buffer;
|
||||
recurse_func_t recurse_func;
|
||||
const GDEF &gdef;
|
||||
const VariationStore &var_store;
|
||||
|
||||
hb_direction_t direction;
|
||||
hb_mask_t lookup_mask;
|
||||
bool auto_zwj;
|
||||
recurse_func_t recurse_func;
|
||||
unsigned int nesting_level_left;
|
||||
unsigned int lookup_props;
|
||||
const GDEF &gdef;
|
||||
bool has_glyph_classes;
|
||||
skipping_iterator_t iter_input, iter_context;
|
||||
unsigned int table_index; /* GSUB/GPOS */
|
||||
unsigned int lookup_index;
|
||||
unsigned int lookup_props;
|
||||
unsigned int nesting_level_left;
|
||||
unsigned int debug_depth;
|
||||
|
||||
bool auto_zwnj;
|
||||
bool auto_zwj;
|
||||
bool has_glyph_classes;
|
||||
|
||||
|
||||
hb_apply_context_t (unsigned int table_index_,
|
||||
hb_font_t *font_,
|
||||
hb_buffer_t *buffer_) :
|
||||
table_index (table_index_),
|
||||
iter_input (), iter_context (),
|
||||
font (font_), face (font->face), buffer (buffer_),
|
||||
recurse_func (NULL),
|
||||
gdef (*hb_ot_layout_from_face (face)->gdef),
|
||||
var_store (gdef.get_var_store ()),
|
||||
direction (buffer_->props.direction),
|
||||
lookup_mask (1),
|
||||
auto_zwj (true),
|
||||
recurse_func (NULL),
|
||||
nesting_level_left (HB_MAX_NESTING_LEVEL),
|
||||
lookup_props (0),
|
||||
gdef (*hb_ot_layout_from_face (face)->gdef),
|
||||
has_glyph_classes (gdef.has_glyph_classes ()),
|
||||
iter_input (),
|
||||
iter_context (),
|
||||
table_index (table_index_),
|
||||
lookup_index ((unsigned int) -1),
|
||||
debug_depth (0) {}
|
||||
lookup_props (0),
|
||||
nesting_level_left (HB_MAX_NESTING_LEVEL),
|
||||
debug_depth (0),
|
||||
auto_zwnj (true),
|
||||
auto_zwj (true),
|
||||
has_glyph_classes (gdef.has_glyph_classes ()) {}
|
||||
|
||||
inline void set_lookup_mask (hb_mask_t mask) { lookup_mask = mask; }
|
||||
inline void set_auto_zwj (bool auto_zwj_) { auto_zwj = auto_zwj_; }
|
||||
inline void set_auto_zwnj (bool auto_zwnj_) { auto_zwnj = auto_zwnj_; }
|
||||
inline void set_recurse_func (recurse_func_t func) { recurse_func = func; }
|
||||
inline void set_lookup_index (unsigned int lookup_index_) { lookup_index = lookup_index_; }
|
||||
inline void set_lookup_props (unsigned int lookup_props_)
|
||||
|
@ -845,9 +852,12 @@ static inline bool ligate_input (hb_apply_context_t *c,
|
|||
while (buffer->idx < match_positions[i] && !buffer->in_error)
|
||||
{
|
||||
if (!is_mark_ligature) {
|
||||
unsigned int this_comp = _hb_glyph_info_get_lig_comp (&buffer->cur());
|
||||
if (this_comp == 0)
|
||||
this_comp = last_num_components;
|
||||
unsigned int new_lig_comp = components_so_far - last_num_components +
|
||||
MIN (MAX (_hb_glyph_info_get_lig_comp (&buffer->cur()), 1u), last_num_components);
|
||||
_hb_glyph_info_set_lig_props_for_mark (&buffer->cur(), lig_id, new_lig_comp);
|
||||
MIN (this_comp, last_num_components);
|
||||
_hb_glyph_info_set_lig_props_for_mark (&buffer->cur(), lig_id, new_lig_comp);
|
||||
}
|
||||
buffer->next_glyph ();
|
||||
}
|
||||
|
@ -864,8 +874,11 @@ static inline bool ligate_input (hb_apply_context_t *c,
|
|||
/* Re-adjust components for any marks following. */
|
||||
for (unsigned int i = buffer->idx; i < buffer->len; i++) {
|
||||
if (last_lig_id == _hb_glyph_info_get_lig_id (&buffer->info[i])) {
|
||||
unsigned int this_comp = _hb_glyph_info_get_lig_comp (&buffer->info[i]);
|
||||
if (!this_comp)
|
||||
break;
|
||||
unsigned int new_lig_comp = components_so_far - last_num_components +
|
||||
MIN (MAX (_hb_glyph_info_get_lig_comp (&buffer->info[i]), 1u), last_num_components);
|
||||
MIN (this_comp, last_num_components);
|
||||
_hb_glyph_info_set_lig_props_for_mark (&buffer->info[i], lig_id, new_lig_comp);
|
||||
} else
|
||||
break;
|
||||
|
@ -878,7 +891,8 @@ static inline bool match_backtrack (hb_apply_context_t *c,
|
|||
unsigned int count,
|
||||
const USHORT backtrack[],
|
||||
match_func_t match_func,
|
||||
const void *match_data)
|
||||
const void *match_data,
|
||||
unsigned int *match_start)
|
||||
{
|
||||
TRACE_APPLY (NULL);
|
||||
|
||||
|
@ -890,6 +904,8 @@ static inline bool match_backtrack (hb_apply_context_t *c,
|
|||
if (!skippy_iter.prev ())
|
||||
return_trace (false);
|
||||
|
||||
*match_start = skippy_iter.idx;
|
||||
|
||||
return_trace (true);
|
||||
}
|
||||
|
||||
|
@ -898,7 +914,8 @@ static inline bool match_lookahead (hb_apply_context_t *c,
|
|||
const USHORT lookahead[],
|
||||
match_func_t match_func,
|
||||
const void *match_data,
|
||||
unsigned int offset)
|
||||
unsigned int offset,
|
||||
unsigned int *end_index)
|
||||
{
|
||||
TRACE_APPLY (NULL);
|
||||
|
||||
|
@ -910,6 +927,8 @@ static inline bool match_lookahead (hb_apply_context_t *c,
|
|||
if (!skippy_iter.next ())
|
||||
return_trace (false);
|
||||
|
||||
*end_index = skippy_iter.idx + 1;
|
||||
|
||||
return_trace (true);
|
||||
}
|
||||
|
||||
|
@ -951,7 +970,7 @@ static inline bool apply_lookup (hb_apply_context_t *c,
|
|||
TRACE_APPLY (NULL);
|
||||
|
||||
hb_buffer_t *buffer = c->buffer;
|
||||
unsigned int end;
|
||||
int end;
|
||||
|
||||
/* All positions are distance from beginning of *output* buffer.
|
||||
* Adjust. */
|
||||
|
@ -965,12 +984,17 @@ static inline bool apply_lookup (hb_apply_context_t *c,
|
|||
match_positions[j] += delta;
|
||||
}
|
||||
|
||||
for (unsigned int i = 0; i < lookupCount; i++)
|
||||
for (unsigned int i = 0; i < lookupCount && !buffer->in_error; i++)
|
||||
{
|
||||
unsigned int idx = lookupRecord[i].sequenceIndex;
|
||||
if (idx >= count)
|
||||
continue;
|
||||
|
||||
/* Don't recurse to ourself at same position.
|
||||
* Note that this test is too naive, it doesn't catch longer loops. */
|
||||
if (idx == 0 && lookupRecord[i].lookupListIndex == c->lookup_index)
|
||||
continue;
|
||||
|
||||
buffer->move_to (match_positions[idx]);
|
||||
|
||||
unsigned int orig_len = buffer->backtrack_len () + buffer->lookahead_len ();
|
||||
|
@ -983,12 +1007,41 @@ static inline bool apply_lookup (hb_apply_context_t *c,
|
|||
if (!delta)
|
||||
continue;
|
||||
|
||||
/* Recursed lookup changed buffer len. Adjust. */
|
||||
/* Recursed lookup changed buffer len. Adjust.
|
||||
*
|
||||
* TODO:
|
||||
*
|
||||
* Right now, if buffer length increased by n, we assume n new glyphs
|
||||
* were added right after the current position, and if buffer length
|
||||
* was decreased by n, we assume n match positions after the current
|
||||
* one where removed. The former (buffer length increased) case is
|
||||
* fine, but the decrease case can be improved in at least two ways,
|
||||
* both of which are significant:
|
||||
*
|
||||
* - If recursed-to lookup is MultipleSubst and buffer length
|
||||
* decreased, then it's current match position that was deleted,
|
||||
* NOT the one after it.
|
||||
*
|
||||
* - If buffer length was decreased by n, it does not necessarily
|
||||
* mean that n match positions where removed, as there might
|
||||
* have been marks and default-ignorables in the sequence. We
|
||||
* should instead drop match positions between current-position
|
||||
* and current-position + n instead.
|
||||
*
|
||||
* It should be possible to construct tests for both of these cases.
|
||||
*/
|
||||
|
||||
/* end can't go back past the current match position.
|
||||
* Note: this is only true because we do NOT allow MultipleSubst
|
||||
* with zero sequence len. */
|
||||
end = MAX (MIN((int) match_positions[idx] + 1, (int) new_len), int (end) + delta);
|
||||
end += delta;
|
||||
if (end <= int (match_positions[idx]))
|
||||
{
|
||||
/* End might end up being smaller than match_positions[idx] if the recursed
|
||||
* lookup ended up removing many items, more than we have had matched.
|
||||
* Just never rewind end back and get out of here.
|
||||
* https://bugs.chromium.org/p/chromium/issues/detail?id=659496 */
|
||||
end = match_positions[idx];
|
||||
/* There can't be any further changes. */
|
||||
break;
|
||||
}
|
||||
|
||||
unsigned int next = idx + 1; /* next now is the position after the recursed lookup. */
|
||||
|
||||
|
@ -1098,10 +1151,11 @@ static inline bool context_apply_lookup (hb_apply_context_t *c,
|
|||
inputCount, input,
|
||||
lookup_context.funcs.match, lookup_context.match_data,
|
||||
&match_length, match_positions)
|
||||
&& apply_lookup (c,
|
||||
&& (c->buffer->unsafe_to_break (c->buffer->idx, c->buffer->idx + match_length),
|
||||
apply_lookup (c,
|
||||
inputCount, match_positions,
|
||||
lookupCount, lookupRecord,
|
||||
match_length);
|
||||
match_length));
|
||||
}
|
||||
|
||||
struct Rule
|
||||
|
@ -1619,7 +1673,7 @@ static inline bool chain_context_apply_lookup (hb_apply_context_t *c,
|
|||
const LookupRecord lookupRecord[],
|
||||
ChainContextApplyLookupContext &lookup_context)
|
||||
{
|
||||
unsigned int match_length = 0;
|
||||
unsigned int start_index = 0, match_length = 0, end_index = 0;
|
||||
unsigned int match_positions[HB_MAX_CONTEXT_LENGTH];
|
||||
return match_input (c,
|
||||
inputCount, input,
|
||||
|
@ -1627,15 +1681,17 @@ static inline bool chain_context_apply_lookup (hb_apply_context_t *c,
|
|||
&match_length, match_positions)
|
||||
&& match_backtrack (c,
|
||||
backtrackCount, backtrack,
|
||||
lookup_context.funcs.match, lookup_context.match_data[0])
|
||||
lookup_context.funcs.match, lookup_context.match_data[0],
|
||||
&start_index)
|
||||
&& match_lookahead (c,
|
||||
lookaheadCount, lookahead,
|
||||
lookup_context.funcs.match, lookup_context.match_data[2],
|
||||
match_length)
|
||||
&& apply_lookup (c,
|
||||
match_length, &end_index)
|
||||
&& (c->buffer->unsafe_to_break_from_outbuffer (start_index, end_index),
|
||||
apply_lookup (c,
|
||||
inputCount, match_positions,
|
||||
lookupCount, lookupRecord,
|
||||
match_length);
|
||||
match_length));
|
||||
}
|
||||
|
||||
struct ChainRule
|
||||
|
@ -2255,6 +2311,24 @@ struct GSUBGPOS
|
|||
inline const Lookup& get_lookup (unsigned int i) const
|
||||
{ return (this+lookupList)[i]; }
|
||||
|
||||
inline bool find_variations_index (const int *coords, unsigned int num_coords,
|
||||
unsigned int *index) const
|
||||
{ return (version.to_int () >= 0x00010001u ? this+featureVars : Null(FeatureVariations))
|
||||
.find_index (coords, num_coords, index); }
|
||||
inline const Feature& get_feature_variation (unsigned int feature_index,
|
||||
unsigned int variations_index) const
|
||||
{
|
||||
if (FeatureVariations::NOT_FOUND_INDEX != variations_index &&
|
||||
version.to_int () >= 0x00010001u)
|
||||
{
|
||||
const Feature *feature = (this+featureVars).find_substitute (variations_index,
|
||||
feature_index);
|
||||
if (feature)
|
||||
return *feature;
|
||||
}
|
||||
return get_feature (feature_index);
|
||||
}
|
||||
|
||||
inline bool sanitize (hb_sanitize_context_t *c) const
|
||||
{
|
||||
TRACE_SANITIZE (this);
|
||||
|
@ -2262,11 +2336,12 @@ struct GSUBGPOS
|
|||
likely (version.major == 1) &&
|
||||
scriptList.sanitize (c, this) &&
|
||||
featureList.sanitize (c, this) &&
|
||||
lookupList.sanitize (c, this));
|
||||
lookupList.sanitize (c, this) &&
|
||||
(version.to_int () < 0x00010001u || featureVars.sanitize (c, this)));
|
||||
}
|
||||
|
||||
protected:
|
||||
FixedVersion version; /* Version of the GSUB/GPOS table--initially set
|
||||
FixedVersion<>version; /* Version of the GSUB/GPOS table--initially set
|
||||
* to 0x00010000u */
|
||||
OffsetTo<ScriptList>
|
||||
scriptList; /* ScriptList table */
|
||||
|
@ -2274,8 +2349,13 @@ struct GSUBGPOS
|
|||
featureList; /* FeatureList table */
|
||||
OffsetTo<LookupList>
|
||||
lookupList; /* LookupList table */
|
||||
LOffsetTo<FeatureVariations>
|
||||
featureVars; /* Offset to Feature Variations
|
||||
table--from beginning of table
|
||||
* (may be NULL). Introduced
|
||||
* in version 0x00010001. */
|
||||
public:
|
||||
DEFINE_SIZE_STATIC (10);
|
||||
DEFINE_SIZE_MIN (10);
|
||||
};
|
||||
|
||||
|
||||
|
|
|
@ -218,7 +218,7 @@ struct JSTF
|
|||
}
|
||||
|
||||
protected:
|
||||
FixedVersion version; /* Version of the JSTF table--initially set
|
||||
FixedVersion<>version; /* Version of the JSTF table--initially set
|
||||
* to 0x00010000u */
|
||||
RecordArrayOf<JstfScript>
|
||||
scriptList; /* Array of JstfScripts--listed
|
||||
|
|
|
@ -34,6 +34,7 @@
|
|||
#include "hb-font-private.hh"
|
||||
#include "hb-buffer-private.hh"
|
||||
#include "hb-set-private.hh"
|
||||
#include "hb-open-type-private.hh"
|
||||
|
||||
|
||||
/* Private API corresponding to hb-ot-layout.h: */
|
||||
|
@ -99,21 +100,20 @@ hb_ot_layout_substitute_lookup (OT::hb_apply_context_t *c,
|
|||
const hb_ot_layout_lookup_accelerator_t &accel);
|
||||
|
||||
|
||||
/* Should be called after all the substitute_lookup's are done */
|
||||
HB_INTERNAL void
|
||||
hb_ot_layout_substitute_finish (hb_font_t *font,
|
||||
hb_buffer_t *buffer);
|
||||
|
||||
|
||||
/* Should be called before all the position_lookup's are done. Resets positions to zero. */
|
||||
/* Should be called before all the position_lookup's are done. */
|
||||
HB_INTERNAL void
|
||||
hb_ot_layout_position_start (hb_font_t *font,
|
||||
hb_buffer_t *buffer);
|
||||
|
||||
/* Should be called after all the position_lookup's are done */
|
||||
/* Should be called after all the position_lookup's are done, to finish advances. */
|
||||
HB_INTERNAL void
|
||||
hb_ot_layout_position_finish (hb_font_t *font,
|
||||
hb_buffer_t *buffer);
|
||||
hb_ot_layout_position_finish_advances (hb_font_t *font,
|
||||
hb_buffer_t *buffer);
|
||||
|
||||
/* Should be called after hb_ot_layout_position_finish_advances, to finish offsets. */
|
||||
HB_INTERNAL void
|
||||
hb_ot_layout_position_finish_offsets (hb_font_t *font,
|
||||
hb_buffer_t *buffer);
|
||||
|
||||
|
||||
|
||||
|
@ -125,6 +125,9 @@ namespace OT {
|
|||
struct GDEF;
|
||||
struct GSUB;
|
||||
struct GPOS;
|
||||
struct MATH;
|
||||
struct fvar;
|
||||
struct avar;
|
||||
}
|
||||
|
||||
struct hb_ot_layout_lookup_accelerator_t
|
||||
|
@ -158,6 +161,11 @@ struct hb_ot_layout_t
|
|||
const struct OT::GSUB *gsub;
|
||||
const struct OT::GPOS *gpos;
|
||||
|
||||
/* TODO Move the following out of this struct. */
|
||||
OT::hb_lazy_table_loader_t<struct OT::MATH> math;
|
||||
OT::hb_lazy_table_loader_t<struct OT::fvar> fvar;
|
||||
OT::hb_lazy_table_loader_t<struct OT::avar> avar;
|
||||
|
||||
unsigned int gsub_lookup_count;
|
||||
unsigned int gpos_lookup_count;
|
||||
|
||||
|
@ -189,8 +197,7 @@ _hb_ot_layout_destroy (hb_ot_layout_t *layout);
|
|||
#define syllable() var1.u8[3] /* GSUB/GPOS shaping boundaries */
|
||||
|
||||
|
||||
/* loop over syllables */
|
||||
|
||||
/* Loop over syllables. Based on foreach_cluster(). */
|
||||
#define foreach_syllable(buffer, start, end) \
|
||||
for (unsigned int \
|
||||
_count = buffer->len, \
|
||||
|
@ -219,23 +226,25 @@ _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().
|
||||
* * Is it U+200D ZWJ?
|
||||
* * Is it U+200C ZWNJ?
|
||||
* * Whether it's one of the three Mongolian Free Variation Selectors.
|
||||
* * One free bit right now.
|
||||
*
|
||||
* The high-byte has different meanings, switched by the Gen-Cat:
|
||||
* - For Mn,Mc,Me: the modified Combining_Class.
|
||||
* - For Cf: whether it's ZWJ, ZWNJ, or something else.
|
||||
* - For Ws: index of which space character this is, if space fallback
|
||||
* is needed, ie. we don't set this by default, only if asked to.
|
||||
*
|
||||
* If needed, we can use the ZWJ/ZWNJ to use the high byte as well,
|
||||
* freeing two more bits.
|
||||
*/
|
||||
|
||||
enum hb_unicode_props_flags_t {
|
||||
UPROPS_MASK_ZWJ = 0x20u,
|
||||
UPROPS_MASK_ZWNJ = 0x40u,
|
||||
UPROPS_MASK_IGNORABLE = 0x80u,
|
||||
UPROPS_MASK_GEN_CAT = 0x1Fu
|
||||
UPROPS_MASK_GEN_CAT = 0x001Fu,
|
||||
UPROPS_MASK_IGNORABLE = 0x0020u,
|
||||
UPROPS_MASK_HIDDEN = 0x0040u, /* MONGOLIAN FREE VARIATION SELECTOR 1..3,
|
||||
* or TAG characters */
|
||||
|
||||
/* If GEN_CAT=FORMAT, top byte masks: */
|
||||
UPROPS_MASK_Cf_ZWJ = 0x0100u,
|
||||
UPROPS_MASK_Cf_ZWNJ = 0x0200u
|
||||
};
|
||||
HB_MARK_AS_FLAG_T (hb_unicode_props_flags_t);
|
||||
|
||||
|
@ -254,11 +263,27 @@ _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_ZWNJ;
|
||||
if (u == 0x200Du) props |= UPROPS_MASK_ZWJ;
|
||||
if (u == 0x200Cu) props |= UPROPS_MASK_Cf_ZWNJ;
|
||||
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;
|
||||
/* 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;
|
||||
}
|
||||
else if (unlikely (HB_UNICODE_GENERAL_CATEGORY_IS_NON_ENCLOSING_MARK (gen_cat)))
|
||||
else if (unlikely (HB_UNICODE_GENERAL_CATEGORY_IS_NON_ENCLOSING_MARK_OR_MODIFIER_SYMBOL (gen_cat)))
|
||||
{
|
||||
/* The above check is just an optimization to let in only things we need further
|
||||
* processing on. */
|
||||
|
||||
/* Only Mn and Mc can have non-zero ccc:
|
||||
* http://www.unicode.org/policies/stability_policy.html#Property_Value
|
||||
* """
|
||||
|
@ -273,6 +298,16 @@ _hb_glyph_info_set_unicode_props (hb_glyph_info_t *info, hb_buffer_t *buffer)
|
|||
* the "else if".
|
||||
*/
|
||||
props |= unicode->modified_combining_class (info->codepoint)<<8;
|
||||
|
||||
/* Recategorize emoji skin-tone modifiers as Unicode mark, so they
|
||||
* behave correctly in non-native directionality. They originally
|
||||
* are MODIFIER_SYMBOL. Fixes:
|
||||
* https://github.com/behdad/harfbuzz/issues/169
|
||||
*/
|
||||
if (unlikely (hb_in_range (u, 0x1F3FBu, 0x1F3FFu)))
|
||||
{
|
||||
props = gen_cat = HB_UNICODE_GENERAL_CATEGORY_ENCLOSING_MARK;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -338,25 +373,44 @@ static inline bool _hb_glyph_info_ligated (const hb_glyph_info_t *info);
|
|||
static inline hb_bool_t
|
||||
_hb_glyph_info_is_default_ignorable (const hb_glyph_info_t *info)
|
||||
{
|
||||
return (info->unicode_props() & UPROPS_MASK_IGNORABLE) && !_hb_glyph_info_ligated (info);
|
||||
return (info->unicode_props() & UPROPS_MASK_IGNORABLE) &&
|
||||
!_hb_glyph_info_ligated (info);
|
||||
}
|
||||
static inline hb_bool_t
|
||||
_hb_glyph_info_is_default_ignorable_and_not_hidden (const hb_glyph_info_t *info)
|
||||
{
|
||||
return ((info->unicode_props() & (UPROPS_MASK_IGNORABLE|UPROPS_MASK_HIDDEN))
|
||||
== UPROPS_MASK_IGNORABLE) &&
|
||||
!_hb_glyph_info_ligated (info);
|
||||
}
|
||||
|
||||
static inline bool
|
||||
_hb_glyph_info_is_unicode_format (const hb_glyph_info_t *info)
|
||||
{
|
||||
return _hb_glyph_info_get_general_category (info) ==
|
||||
HB_UNICODE_GENERAL_CATEGORY_FORMAT;
|
||||
}
|
||||
static inline hb_bool_t
|
||||
_hb_glyph_info_is_zwnj (const hb_glyph_info_t *info)
|
||||
{
|
||||
return !!(info->unicode_props() & UPROPS_MASK_ZWNJ);
|
||||
return _hb_glyph_info_is_unicode_format (info) && (info->unicode_props() & UPROPS_MASK_Cf_ZWNJ);
|
||||
}
|
||||
|
||||
static inline hb_bool_t
|
||||
_hb_glyph_info_is_zwj (const hb_glyph_info_t *info)
|
||||
{
|
||||
return !!(info->unicode_props() & UPROPS_MASK_ZWJ);
|
||||
return _hb_glyph_info_is_unicode_format (info) && (info->unicode_props() & UPROPS_MASK_Cf_ZWJ);
|
||||
}
|
||||
static inline hb_bool_t
|
||||
_hb_glyph_info_is_joiner (const hb_glyph_info_t *info)
|
||||
{
|
||||
return _hb_glyph_info_is_unicode_format (info) && (info->unicode_props() & (UPROPS_MASK_Cf_ZWNJ|UPROPS_MASK_Cf_ZWJ));
|
||||
}
|
||||
|
||||
static inline void
|
||||
_hb_glyph_info_flip_joiners (hb_glyph_info_t *info)
|
||||
{
|
||||
info->unicode_props() ^= UPROPS_MASK_ZWNJ | UPROPS_MASK_ZWJ;
|
||||
if (!_hb_glyph_info_is_unicode_format (info))
|
||||
return;
|
||||
info->unicode_props() ^= UPROPS_MASK_Cf_ZWNJ | UPROPS_MASK_Cf_ZWJ;
|
||||
}
|
||||
|
||||
/* lig_props: aka lig_id / lig_comp
|
||||
|
@ -517,11 +571,9 @@ _hb_glyph_info_clear_ligated_and_multiplied (hb_glyph_info_t *info)
|
|||
}
|
||||
|
||||
static inline void
|
||||
_hb_glyph_info_clear_substituted_and_ligated_and_multiplied (hb_glyph_info_t *info)
|
||||
_hb_glyph_info_clear_substituted (hb_glyph_info_t *info)
|
||||
{
|
||||
info->glyph_props() &= ~(HB_OT_LAYOUT_GLYPH_PROPS_SUBSTITUTED |
|
||||
HB_OT_LAYOUT_GLYPH_PROPS_LIGATED |
|
||||
HB_OT_LAYOUT_GLYPH_PROPS_MULTIPLIED);
|
||||
info->glyph_props() &= ~(HB_OT_LAYOUT_GLYPH_PROPS_SUBSTITUTED);
|
||||
}
|
||||
|
||||
|
||||
|
@ -575,5 +627,4 @@ _hb_buffer_assert_gsubgpos_vars (hb_buffer_t *buffer)
|
|||
#undef lig_props
|
||||
#undef glyph_props
|
||||
|
||||
|
||||
#endif /* HB_OT_LAYOUT_PRIVATE_HH */
|
||||
|
|
|
@ -34,15 +34,10 @@
|
|||
#include "hb-ot-layout-gdef-table.hh"
|
||||
#include "hb-ot-layout-gsub-table.hh"
|
||||
#include "hb-ot-layout-gpos-table.hh"
|
||||
#include "hb-ot-layout-jstf-table.hh"
|
||||
#include "hb-ot-layout-jstf-table.hh" // Just so we compile it; unused otherwise.
|
||||
|
||||
#include "hb-ot-map-private.hh"
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
|
||||
HB_SHAPER_DATA_ENSURE_DECLARE(ot, face)
|
||||
|
||||
hb_ot_layout_t *
|
||||
_hb_ot_layout_create (hb_face_t *face)
|
||||
|
@ -60,6 +55,117 @@ _hb_ot_layout_create (hb_face_t *face)
|
|||
layout->gpos_blob = OT::Sanitizer<OT::GPOS>::sanitize (face->reference_table (HB_OT_TAG_GPOS));
|
||||
layout->gpos = OT::Sanitizer<OT::GPOS>::lock_instance (layout->gpos_blob);
|
||||
|
||||
layout->math.init (face);
|
||||
layout->fvar.init (face);
|
||||
layout->avar.init (face);
|
||||
|
||||
{
|
||||
/*
|
||||
* The ugly business of blacklisting individual fonts' tables happen here!
|
||||
* See this thread for why we finally had to bend in and do this:
|
||||
* https://lists.freedesktop.org/archives/harfbuzz/2016-February/005489.html
|
||||
*/
|
||||
unsigned int gdef_len = hb_blob_get_length (layout->gdef_blob);
|
||||
unsigned int gsub_len = hb_blob_get_length (layout->gsub_blob);
|
||||
unsigned int gpos_len = hb_blob_get_length (layout->gpos_blob);
|
||||
if (0
|
||||
/* sha1sum:c5ee92f0bca4bfb7d06c4d03e8cf9f9cf75d2e8a Windows 7? timesi.ttf */
|
||||
|| (442 == gdef_len && 42038 == gpos_len && 2874 == gsub_len)
|
||||
/* sha1sum:37fc8c16a0894ab7b749e35579856c73c840867b Windows 7? timesbi.ttf */
|
||||
|| (430 == gdef_len && 40662 == gpos_len && 2874 == gsub_len)
|
||||
/* sha1sum:19fc45110ea6cd3cdd0a5faca256a3797a069a80 Windows 7 timesi.ttf */
|
||||
|| (442 == gdef_len && 39116 == gpos_len && 2874 == gsub_len)
|
||||
/* sha1sum:6d2d3c9ed5b7de87bc84eae0df95ee5232ecde26 Windows 7 timesbi.ttf */
|
||||
|| (430 == gdef_len && 39374 == gpos_len && 2874 == gsub_len)
|
||||
/* sha1sum:8583225a8b49667c077b3525333f84af08c6bcd8 OS X 10.11.3 Times New Roman Italic.ttf */
|
||||
|| (490 == gdef_len && 41638 == gpos_len && 3046 == gsub_len)
|
||||
/* sha1sum:ec0f5a8751845355b7c3271d11f9918a966cb8c9 OS X 10.11.3 Times New Roman Bold Italic.ttf */
|
||||
|| (478 == gdef_len && 41902 == gpos_len && 3046 == gsub_len)
|
||||
)
|
||||
{
|
||||
/* In certain versions of Times New Roman Italic and Bold Italic,
|
||||
* ASCII double quotation mark U+0022, mapped to glyph 5, has wrong
|
||||
* glyph class 3 (mark) in GDEF. Nuke the GDEF to avoid zero-width
|
||||
* double-quote. See:
|
||||
* https://lists.freedesktop.org/archives/harfbuzz/2016-February/005489.html
|
||||
*/
|
||||
if (3 == layout->gdef->get_glyph_class (5))
|
||||
layout->gdef = &OT::Null(OT::GDEF);
|
||||
}
|
||||
else if (0
|
||||
/* sha1sum:96eda93f7d33e79962451c6c39a6b51ee893ce8c tahoma.ttf from Windows 8 */
|
||||
|| (898 == gdef_len && 46470 == gpos_len && 12554 == gsub_len)
|
||||
/* sha1sum:20928dc06014e0cd120b6fc942d0c3b1a46ac2bc tahomabd.ttf from Windows 8 */
|
||||
|| (910 == gdef_len && 47732 == gpos_len && 12566 == gsub_len)
|
||||
/* sha1sum:4f95b7e4878f60fa3a39ca269618dfde9721a79e tahoma.ttf from Windows 8.1 */
|
||||
|| (928 == gdef_len && 59332 == gpos_len && 23298 == gsub_len)
|
||||
/* sha1sum:6d400781948517c3c0441ba42acb309584b73033 tahomabd.ttf from Windows 8.1 */
|
||||
|| (940 == gdef_len && 60732 == gpos_len && 23310 == gsub_len)
|
||||
/* tahoma.ttf v6.04 from Windows 8.1 x64, see https://bugzilla.mozilla.org/show_bug.cgi?id=1279925 */
|
||||
|| (964 == gdef_len && 60072 == gpos_len && 23836 == gsub_len)
|
||||
/* tahomabd.ttf v6.04 from Windows 8.1 x64, see https://bugzilla.mozilla.org/show_bug.cgi?id=1279925 */
|
||||
|| (976 == gdef_len && 61456 == gpos_len && 23832 == gsub_len)
|
||||
/* sha1sum:e55fa2dfe957a9f7ec26be516a0e30b0c925f846 tahoma.ttf from Windows 10 */
|
||||
|| (994 == gdef_len && 60336 == gpos_len && 24474 == gsub_len)
|
||||
/* sha1sum:7199385abb4c2cc81c83a151a7599b6368e92343 tahomabd.ttf from Windows 10 */
|
||||
|| (1006 == gdef_len && 61740 == gpos_len && 24470 == gsub_len)
|
||||
/* tahoma.ttf v6.91 from Windows 10 x64, see https://bugzilla.mozilla.org/show_bug.cgi?id=1279925 */
|
||||
|| (1006 == gdef_len && 61346 == gpos_len && 24576 == gsub_len)
|
||||
/* tahomabd.ttf v6.91 from Windows 10 x64, see https://bugzilla.mozilla.org/show_bug.cgi?id=1279925 */
|
||||
|| (1018 == gdef_len && 62828 == gpos_len && 24572 == gsub_len)
|
||||
/* sha1sum:b9c84d820c49850d3d27ec498be93955b82772b5 tahoma.ttf from Windows 10 AU */
|
||||
|| (1006 == gdef_len && 61352 == gpos_len && 24576 == gsub_len)
|
||||
/* sha1sum:2bdfaab28174bdadd2f3d4200a30a7ae31db79d2 tahomabd.ttf from Windows 10 AU */
|
||||
|| (1018 == gdef_len && 62834 == gpos_len && 24572 == gsub_len)
|
||||
/* sha1sum:b0d36cf5a2fbe746a3dd277bffc6756a820807a7 Tahoma.ttf from Mac OS X 10.9 */
|
||||
|| (832 == gdef_len && 47162 == gpos_len && 7324 == gsub_len)
|
||||
/* sha1sum:12fc4538e84d461771b30c18b5eb6bd434e30fba Tahoma Bold.ttf from Mac OS X 10.9 */
|
||||
|| (844 == gdef_len && 45474 == gpos_len && 7302 == gsub_len)
|
||||
/* sha1sum:eb8afadd28e9cf963e886b23a30b44ab4fd83acc himalaya.ttf from Windows 7 */
|
||||
|| (180 == gdef_len && 7254 == gpos_len && 13054 == gsub_len)
|
||||
/* sha1sum:73da7f025b238a3f737aa1fde22577a6370f77b0 himalaya.ttf from Windows 8 */
|
||||
|| (192 == gdef_len && 7254 == gpos_len && 12638 == gsub_len)
|
||||
/* sha1sum:6e80fd1c0b059bbee49272401583160dc1e6a427 himalaya.ttf from Windows 8.1 */
|
||||
|| (192 == gdef_len && 7254 == gpos_len && 12690 == gsub_len)
|
||||
/* 8d9267aea9cd2c852ecfb9f12a6e834bfaeafe44 cantarell-fonts-0.0.21/otf/Cantarell-Regular.otf */
|
||||
/* 983988ff7b47439ab79aeaf9a45bd4a2c5b9d371 cantarell-fonts-0.0.21/otf/Cantarell-Oblique.otf */
|
||||
|| (188 == gdef_len && 3852 == gpos_len && 248 == gsub_len)
|
||||
/* 2c0c90c6f6087ffbfea76589c93113a9cbb0e75f cantarell-fonts-0.0.21/otf/Cantarell-Bold.otf */
|
||||
/* 55461f5b853c6da88069ffcdf7f4dd3f8d7e3e6b cantarell-fonts-0.0.21/otf/Cantarell-Bold-Oblique.otf */
|
||||
|| (188 == gdef_len && 3426 == gpos_len && 264 == gsub_len)
|
||||
/* d125afa82a77a6475ac0e74e7c207914af84b37a padauk-2.80/Padauk.ttf RHEL 7.2 */
|
||||
|| (1058 == gdef_len && 11818 == gpos_len && 47032 == gsub_len)
|
||||
/* 0f7b80437227b90a577cc078c0216160ae61b031 padauk-2.80/Padauk-Bold.ttf RHEL 7.2*/
|
||||
|| (1046 == gdef_len && 12600 == gpos_len && 47030 == gsub_len)
|
||||
/* d3dde9aa0a6b7f8f6a89ef1002e9aaa11b882290 padauk-2.80/Padauk.ttf Ubuntu 16.04 */
|
||||
|| (1058 == gdef_len && 16770 == gpos_len && 71796 == gsub_len)
|
||||
/* 5f3c98ccccae8a953be2d122c1b3a77fd805093f padauk-2.80/Padauk-Bold.ttf Ubuntu 16.04 */
|
||||
|| (1046 == gdef_len && 17862 == gpos_len && 71790 == gsub_len)
|
||||
/* 6c93b63b64e8b2c93f5e824e78caca555dc887c7 padauk-2.80/Padauk-book.ttf */
|
||||
|| (1046 == gdef_len && 17112 == gpos_len && 71788 == gsub_len)
|
||||
/* d89b1664058359b8ec82e35d3531931125991fb9 padauk-2.80/Padauk-bookbold.ttf */
|
||||
|| (1058 == gdef_len && 17514 == gpos_len && 71794 == gsub_len)
|
||||
/* 824cfd193aaf6234b2b4dc0cf3c6ef576c0d00ef padauk-3.0/Padauk-book.ttf */
|
||||
|| (1330 == gdef_len && 57938 == gpos_len && 109904 == gsub_len)
|
||||
/* 91fcc10cf15e012d27571e075b3b4dfe31754a8a padauk-3.0/Padauk-bookbold.ttf */
|
||||
|| (1330 == gdef_len && 58972 == gpos_len && 109904 == gsub_len)
|
||||
/* sha1sum: c26e41d567ed821bed997e937bc0c41435689e85 Padauk.ttf
|
||||
* "Padauk Regular" "Version 2.5", see https://crbug.com/681813 */
|
||||
|| (1004 == gdef_len && 14836 == gpos_len && 59092 == gsub_len)
|
||||
)
|
||||
{
|
||||
/* Many versions of Tahoma have bad GDEF tables that incorrectly classify some spacing marks
|
||||
* such as certain IPA symbols as glyph class 3. So do older versions of Microsoft Himalaya,
|
||||
* and the version of Cantarell shipped by Ubuntu 16.04.
|
||||
* Nuke the GDEF tables of these fonts to avoid unwanted width-zeroing.
|
||||
* See https://bugzilla.mozilla.org/show_bug.cgi?id=1279925
|
||||
* https://bugzilla.mozilla.org/show_bug.cgi?id=1279693
|
||||
* https://bugzilla.mozilla.org/show_bug.cgi?id=1279875
|
||||
*/
|
||||
layout->gdef = &OT::Null(OT::GDEF);
|
||||
}
|
||||
}
|
||||
|
||||
layout->gsub_lookup_count = layout->gsub->get_lookup_count ();
|
||||
layout->gpos_lookup_count = layout->gpos->get_lookup_count ();
|
||||
|
||||
|
@ -96,6 +202,10 @@ _hb_ot_layout_destroy (hb_ot_layout_t *layout)
|
|||
hb_blob_destroy (layout->gsub_blob);
|
||||
hb_blob_destroy (layout->gpos_blob);
|
||||
|
||||
layout->math.fini ();
|
||||
layout->fvar.fini ();
|
||||
layout->avar.fini ();
|
||||
|
||||
free (layout);
|
||||
}
|
||||
|
||||
|
@ -118,7 +228,6 @@ _get_gpos (hb_face_t *face)
|
|||
return *hb_ot_layout_from_face (face)->gpos;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* GDEF
|
||||
*/
|
||||
|
@ -130,6 +239,8 @@ hb_ot_layout_has_glyph_classes (hb_face_t *face)
|
|||
}
|
||||
|
||||
/**
|
||||
* hb_ot_layout_get_glyph_class:
|
||||
*
|
||||
* Since: 0.9.7
|
||||
**/
|
||||
hb_ot_layout_glyph_class_t
|
||||
|
@ -140,6 +251,8 @@ hb_ot_layout_get_glyph_class (hb_face_t *face,
|
|||
}
|
||||
|
||||
/**
|
||||
* hb_ot_layout_get_glyphs_in_class:
|
||||
*
|
||||
* Since: 0.9.7
|
||||
**/
|
||||
void
|
||||
|
@ -166,7 +279,7 @@ hb_ot_layout_get_ligature_carets (hb_font_t *font,
|
|||
hb_codepoint_t glyph,
|
||||
unsigned int start_offset,
|
||||
unsigned int *caret_count /* IN/OUT */,
|
||||
int *caret_array /* OUT */)
|
||||
hb_position_t *caret_array /* OUT */)
|
||||
{
|
||||
return _get_gdef (font->face).get_lig_carets (font, direction, glyph, start_offset, caret_count, caret_array);
|
||||
}
|
||||
|
@ -365,6 +478,8 @@ hb_ot_layout_language_get_required_feature_index (hb_face_t *face,
|
|||
}
|
||||
|
||||
/**
|
||||
* hb_ot_layout_language_get_required_feature:
|
||||
*
|
||||
* Since: 0.9.30
|
||||
**/
|
||||
hb_bool_t
|
||||
|
@ -452,6 +567,8 @@ hb_ot_layout_language_find_feature (hb_face_t *face,
|
|||
}
|
||||
|
||||
/**
|
||||
* hb_ot_layout_feature_get_lookups:
|
||||
*
|
||||
* Since: 0.9.7
|
||||
**/
|
||||
unsigned int
|
||||
|
@ -462,13 +579,18 @@ hb_ot_layout_feature_get_lookups (hb_face_t *face,
|
|||
unsigned int *lookup_count /* IN/OUT */,
|
||||
unsigned int *lookup_indexes /* OUT */)
|
||||
{
|
||||
const OT::GSUBGPOS &g = get_gsubgpos_table (face, table_tag);
|
||||
const OT::Feature &f = g.get_feature (feature_index);
|
||||
|
||||
return f.get_lookup_indexes (start_offset, lookup_count, lookup_indexes);
|
||||
return hb_ot_layout_feature_with_variations_get_lookups (face,
|
||||
table_tag,
|
||||
feature_index,
|
||||
HB_OT_LAYOUT_NO_VARIATIONS_INDEX,
|
||||
start_offset,
|
||||
lookup_count,
|
||||
lookup_indexes);
|
||||
}
|
||||
|
||||
/**
|
||||
* hb_ot_layout_table_get_lookup_count:
|
||||
*
|
||||
* Since: 0.9.22
|
||||
**/
|
||||
unsigned int
|
||||
|
@ -629,6 +751,8 @@ _hb_ot_layout_collect_lookups_languages (hb_face_t *face,
|
|||
}
|
||||
|
||||
/**
|
||||
* hb_ot_layout_collect_lookups:
|
||||
*
|
||||
* Since: 0.9.8
|
||||
**/
|
||||
void
|
||||
|
@ -673,6 +797,8 @@ hb_ot_layout_collect_lookups (hb_face_t *face,
|
|||
}
|
||||
|
||||
/**
|
||||
* hb_ot_layout_lookup_collect_glyphs:
|
||||
*
|
||||
* Since: 0.9.7
|
||||
**/
|
||||
void
|
||||
|
@ -710,6 +836,38 @@ hb_ot_layout_lookup_collect_glyphs (hb_face_t *face,
|
|||
}
|
||||
|
||||
|
||||
/* Variations support */
|
||||
|
||||
hb_bool_t
|
||||
hb_ot_layout_table_find_feature_variations (hb_face_t *face,
|
||||
hb_tag_t table_tag,
|
||||
const int *coords,
|
||||
unsigned int num_coords,
|
||||
unsigned int *variations_index /* out */)
|
||||
{
|
||||
const OT::GSUBGPOS &g = get_gsubgpos_table (face, table_tag);
|
||||
|
||||
return g.find_variations_index (coords, num_coords, variations_index);
|
||||
}
|
||||
|
||||
unsigned int
|
||||
hb_ot_layout_feature_with_variations_get_lookups (hb_face_t *face,
|
||||
hb_tag_t table_tag,
|
||||
unsigned int feature_index,
|
||||
unsigned int variations_index,
|
||||
unsigned int start_offset,
|
||||
unsigned int *lookup_count /* IN/OUT */,
|
||||
unsigned int *lookup_indexes /* OUT */)
|
||||
{
|
||||
ASSERT_STATIC (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);
|
||||
|
||||
return f.get_lookup_indexes (start_offset, lookup_count, lookup_indexes);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* OT::GSUB
|
||||
*/
|
||||
|
@ -721,6 +879,8 @@ hb_ot_layout_has_substitution (hb_face_t *face)
|
|||
}
|
||||
|
||||
/**
|
||||
* hb_ot_layout_lookup_would_substitute:
|
||||
*
|
||||
* Since: 0.9.7
|
||||
**/
|
||||
hb_bool_t
|
||||
|
@ -742,7 +902,7 @@ hb_ot_layout_lookup_would_substitute_fast (hb_face_t *face,
|
|||
hb_bool_t zero_context)
|
||||
{
|
||||
if (unlikely (lookup_index >= hb_ot_layout_from_face (face)->gsub_lookup_count)) return false;
|
||||
OT::hb_would_apply_context_t c (face, glyphs, glyphs_length, zero_context);
|
||||
OT::hb_would_apply_context_t c (face, glyphs, glyphs_length, (bool) zero_context);
|
||||
|
||||
const OT::SubstLookup& l = hb_ot_layout_from_face (face)->gsub->get_lookup (lookup_index);
|
||||
|
||||
|
@ -755,13 +915,9 @@ hb_ot_layout_substitute_start (hb_font_t *font, hb_buffer_t *buffer)
|
|||
OT::GSUB::substitute_start (font, buffer);
|
||||
}
|
||||
|
||||
void
|
||||
hb_ot_layout_substitute_finish (hb_font_t *font, hb_buffer_t *buffer)
|
||||
{
|
||||
OT::GSUB::substitute_finish (font, buffer);
|
||||
}
|
||||
|
||||
/**
|
||||
* hb_ot_layout_lookup_substitute_closure:
|
||||
*
|
||||
* Since: 0.9.7
|
||||
**/
|
||||
void
|
||||
|
@ -793,12 +949,20 @@ hb_ot_layout_position_start (hb_font_t *font, hb_buffer_t *buffer)
|
|||
}
|
||||
|
||||
void
|
||||
hb_ot_layout_position_finish (hb_font_t *font, hb_buffer_t *buffer)
|
||||
hb_ot_layout_position_finish_advances (hb_font_t *font, hb_buffer_t *buffer)
|
||||
{
|
||||
OT::GPOS::position_finish (font, buffer);
|
||||
OT::GPOS::position_finish_advances (font, buffer);
|
||||
}
|
||||
|
||||
void
|
||||
hb_ot_layout_position_finish_offsets (hb_font_t *font, hb_buffer_t *buffer)
|
||||
{
|
||||
OT::GPOS::position_finish_offsets (font, buffer);
|
||||
}
|
||||
|
||||
/**
|
||||
* hb_ot_layout_get_size_params:
|
||||
*
|
||||
* Since: 0.9.10
|
||||
**/
|
||||
hb_bool_t
|
||||
|
@ -882,20 +1046,79 @@ struct GPOSProxy
|
|||
};
|
||||
|
||||
|
||||
template <typename Obj>
|
||||
struct hb_get_subtables_context_t :
|
||||
OT::hb_dispatch_context_t<hb_get_subtables_context_t, hb_void_t, HB_DEBUG_APPLY>
|
||||
{
|
||||
template <typename Type>
|
||||
static inline bool apply_to (const void *obj, OT::hb_apply_context_t *c)
|
||||
{
|
||||
const Type *typed_obj = (const Type *) obj;
|
||||
return typed_obj->apply (c);
|
||||
}
|
||||
|
||||
typedef bool (*hb_apply_func_t) (const void *obj, OT::hb_apply_context_t *c);
|
||||
|
||||
struct hb_applicable_t
|
||||
{
|
||||
inline void init (const void *obj_, hb_apply_func_t apply_func_)
|
||||
{
|
||||
obj = obj_;
|
||||
apply_func = apply_func_;
|
||||
}
|
||||
|
||||
inline bool apply (OT::hb_apply_context_t *c) const { return apply_func (obj, c); }
|
||||
|
||||
private:
|
||||
const void *obj;
|
||||
hb_apply_func_t apply_func;
|
||||
};
|
||||
|
||||
typedef hb_auto_array_t<hb_applicable_t> array_t;
|
||||
|
||||
/* Dispatch interface. */
|
||||
inline const char *get_name (void) { return "GET_SUBTABLES"; }
|
||||
template <typename T>
|
||||
inline return_t dispatch (const T &obj)
|
||||
{
|
||||
hb_applicable_t *entry = array.push();
|
||||
if (likely (entry))
|
||||
entry->init (&obj, apply_to<T>);
|
||||
return HB_VOID;
|
||||
}
|
||||
static return_t default_return_value (void) { return HB_VOID; }
|
||||
bool stop_sublookup_iteration (return_t r HB_UNUSED) const { return false; }
|
||||
|
||||
hb_get_subtables_context_t (array_t &array_) :
|
||||
array (array_),
|
||||
debug_depth (0) {}
|
||||
|
||||
array_t &array;
|
||||
unsigned int debug_depth;
|
||||
};
|
||||
|
||||
static inline bool
|
||||
apply_forward (OT::hb_apply_context_t *c,
|
||||
const Obj &obj,
|
||||
const hb_ot_layout_lookup_accelerator_t &accel)
|
||||
const hb_ot_layout_lookup_accelerator_t &accel,
|
||||
const hb_get_subtables_context_t::array_t &subtables)
|
||||
{
|
||||
bool ret = false;
|
||||
hb_buffer_t *buffer = c->buffer;
|
||||
while (buffer->idx < buffer->len && !buffer->in_error)
|
||||
{
|
||||
bool applied = false;
|
||||
if (accel.may_have (buffer->cur().codepoint) &&
|
||||
(buffer->cur().mask & c->lookup_mask) &&
|
||||
c->check_glyph_property (&buffer->cur(), c->lookup_props) &&
|
||||
obj.apply (c))
|
||||
c->check_glyph_property (&buffer->cur(), c->lookup_props))
|
||||
{
|
||||
for (unsigned int i = 0; i < subtables.len; i++)
|
||||
if (subtables[i].apply (c))
|
||||
{
|
||||
applied = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (applied)
|
||||
ret = true;
|
||||
else
|
||||
buffer->next_glyph ();
|
||||
|
@ -903,11 +1126,10 @@ apply_forward (OT::hb_apply_context_t *c,
|
|||
return ret;
|
||||
}
|
||||
|
||||
template <typename Obj>
|
||||
static inline bool
|
||||
apply_backward (OT::hb_apply_context_t *c,
|
||||
const Obj &obj,
|
||||
const hb_ot_layout_lookup_accelerator_t &accel)
|
||||
const hb_ot_layout_lookup_accelerator_t &accel,
|
||||
const hb_get_subtables_context_t::array_t &subtables)
|
||||
{
|
||||
bool ret = false;
|
||||
hb_buffer_t *buffer = c->buffer;
|
||||
|
@ -915,9 +1137,15 @@ apply_backward (OT::hb_apply_context_t *c,
|
|||
{
|
||||
if (accel.may_have (buffer->cur().codepoint) &&
|
||||
(buffer->cur().mask & c->lookup_mask) &&
|
||||
c->check_glyph_property (&buffer->cur(), c->lookup_props) &&
|
||||
obj.apply (c))
|
||||
ret = true;
|
||||
c->check_glyph_property (&buffer->cur(), c->lookup_props))
|
||||
{
|
||||
for (unsigned int i = 0; i < subtables.len; i++)
|
||||
if (subtables[i].apply (c))
|
||||
{
|
||||
ret = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
/* The reverse lookup doesn't "advance" cursor (for good reason). */
|
||||
buffer->idx--;
|
||||
|
||||
|
@ -926,26 +1154,6 @@ apply_backward (OT::hb_apply_context_t *c,
|
|||
return ret;
|
||||
}
|
||||
|
||||
struct hb_apply_forward_context_t :
|
||||
OT::hb_dispatch_context_t<hb_apply_forward_context_t, bool, HB_DEBUG_APPLY>
|
||||
{
|
||||
inline const char *get_name (void) { return "APPLY_FWD"; }
|
||||
template <typename T>
|
||||
inline return_t dispatch (const T &obj) { return apply_forward (c, obj, accel); }
|
||||
static return_t default_return_value (void) { return false; }
|
||||
bool stop_sublookup_iteration (return_t r HB_UNUSED) const { return true; }
|
||||
|
||||
hb_apply_forward_context_t (OT::hb_apply_context_t *c_,
|
||||
const hb_ot_layout_lookup_accelerator_t &accel_) :
|
||||
c (c_),
|
||||
accel (accel_),
|
||||
debug_depth (0) {}
|
||||
|
||||
OT::hb_apply_context_t *c;
|
||||
const hb_ot_layout_lookup_accelerator_t &accel;
|
||||
unsigned int debug_depth;
|
||||
};
|
||||
|
||||
template <typename Proxy>
|
||||
static inline void
|
||||
apply_string (OT::hb_apply_context_t *c,
|
||||
|
@ -959,6 +1167,10 @@ apply_string (OT::hb_apply_context_t *c,
|
|||
|
||||
c->set_lookup_props (lookup.get_props ());
|
||||
|
||||
hb_get_subtables_context_t::array_t subtables;
|
||||
hb_get_subtables_context_t c_get_subtables (subtables);
|
||||
lookup.dispatch (&c_get_subtables);
|
||||
|
||||
if (likely (!lookup.is_reverse ()))
|
||||
{
|
||||
/* in/out forward substitution/positioning */
|
||||
|
@ -967,13 +1179,7 @@ apply_string (OT::hb_apply_context_t *c,
|
|||
buffer->idx = 0;
|
||||
|
||||
bool ret;
|
||||
if (lookup.get_subtable_count () == 1)
|
||||
{
|
||||
hb_apply_forward_context_t c_forward (c, accel);
|
||||
ret = lookup.dispatch (&c_forward);
|
||||
}
|
||||
else
|
||||
ret = apply_forward (c, lookup, accel);
|
||||
ret = apply_forward (c, accel, subtables);
|
||||
if (ret)
|
||||
{
|
||||
if (!Proxy::inplace)
|
||||
|
@ -989,7 +1195,7 @@ apply_string (OT::hb_apply_context_t *c,
|
|||
buffer->remove_output ();
|
||||
buffer->idx = buffer->len - 1;
|
||||
|
||||
apply_backward (c, lookup, accel);
|
||||
apply_backward (c, accel, subtables);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -1008,25 +1214,16 @@ inline void hb_ot_map_t::apply (const Proxy &proxy,
|
|||
const stage_map_t *stage = &stages[table_index][stage_index];
|
||||
for (; i < stage->last_lookup; i++)
|
||||
{
|
||||
#if 0
|
||||
char buf[4096];
|
||||
hb_buffer_serialize_glyphs (buffer, 0, buffer->len,
|
||||
buf, sizeof (buf), NULL,
|
||||
font,
|
||||
HB_BUFFER_SERIALIZE_FORMAT_TEXT,
|
||||
Proxy::table_index == 0 ?
|
||||
HB_BUFFER_SERIALIZE_FLAG_NO_POSITIONS :
|
||||
HB_BUFFER_SERIALIZE_FLAG_DEFAULT);
|
||||
printf ("buf: [%s]\n", buf);
|
||||
#endif
|
||||
|
||||
unsigned int lookup_index = lookups[table_index][i].index;
|
||||
if (!buffer->message (font, "start lookup %d", lookup_index)) continue;
|
||||
c.set_lookup_index (lookup_index);
|
||||
c.set_lookup_mask (lookups[table_index][i].mask);
|
||||
c.set_auto_zwj (lookups[table_index][i].auto_zwj);
|
||||
c.set_auto_zwnj (lookups[table_index][i].auto_zwnj);
|
||||
apply_string<Proxy> (&c,
|
||||
proxy.table.get_lookup (lookup_index),
|
||||
proxy.accels[lookup_index]);
|
||||
(void) buffer->message (font, "end lookup %d", lookup_index);
|
||||
}
|
||||
|
||||
if (stage->pause_func)
|
||||
|
|
|
@ -48,7 +48,7 @@ HB_BEGIN_DECLS
|
|||
* GDEF
|
||||
*/
|
||||
|
||||
hb_bool_t
|
||||
HB_EXTERN hb_bool_t
|
||||
hb_ot_layout_has_glyph_classes (hb_face_t *face);
|
||||
|
||||
typedef enum {
|
||||
|
@ -59,11 +59,11 @@ typedef enum {
|
|||
HB_OT_LAYOUT_GLYPH_CLASS_COMPONENT = 4
|
||||
} hb_ot_layout_glyph_class_t;
|
||||
|
||||
hb_ot_layout_glyph_class_t
|
||||
HB_EXTERN hb_ot_layout_glyph_class_t
|
||||
hb_ot_layout_get_glyph_class (hb_face_t *face,
|
||||
hb_codepoint_t glyph);
|
||||
|
||||
void
|
||||
HB_EXTERN void
|
||||
hb_ot_layout_get_glyphs_in_class (hb_face_t *face,
|
||||
hb_ot_layout_glyph_class_t klass,
|
||||
hb_set_t *glyphs /* OUT */);
|
||||
|
@ -71,7 +71,7 @@ hb_ot_layout_get_glyphs_in_class (hb_face_t *face,
|
|||
|
||||
/* Not that useful. Provides list of attach points for a glyph that a
|
||||
* client may want to cache */
|
||||
unsigned int
|
||||
HB_EXTERN unsigned int
|
||||
hb_ot_layout_get_attach_points (hb_face_t *face,
|
||||
hb_codepoint_t glyph,
|
||||
unsigned int start_offset,
|
||||
|
@ -79,7 +79,7 @@ hb_ot_layout_get_attach_points (hb_face_t *face,
|
|||
unsigned int *point_array /* OUT */);
|
||||
|
||||
/* Ligature caret positions */
|
||||
unsigned int
|
||||
HB_EXTERN unsigned int
|
||||
hb_ot_layout_get_ligature_carets (hb_font_t *font,
|
||||
hb_direction_t direction,
|
||||
hb_codepoint_t glyph,
|
||||
|
@ -95,36 +95,37 @@ hb_ot_layout_get_ligature_carets (hb_font_t *font,
|
|||
#define HB_OT_LAYOUT_NO_SCRIPT_INDEX 0xFFFFu
|
||||
#define HB_OT_LAYOUT_NO_FEATURE_INDEX 0xFFFFu
|
||||
#define HB_OT_LAYOUT_DEFAULT_LANGUAGE_INDEX 0xFFFFu
|
||||
#define HB_OT_LAYOUT_NO_VARIATIONS_INDEX 0xFFFFFFFFu
|
||||
|
||||
unsigned int
|
||||
HB_EXTERN unsigned int
|
||||
hb_ot_layout_table_get_script_tags (hb_face_t *face,
|
||||
hb_tag_t table_tag,
|
||||
unsigned int start_offset,
|
||||
unsigned int *script_count /* IN/OUT */,
|
||||
hb_tag_t *script_tags /* OUT */);
|
||||
|
||||
hb_bool_t
|
||||
HB_EXTERN hb_bool_t
|
||||
hb_ot_layout_table_find_script (hb_face_t *face,
|
||||
hb_tag_t table_tag,
|
||||
hb_tag_t script_tag,
|
||||
unsigned int *script_index);
|
||||
|
||||
/* Like find_script, but takes zero-terminated array of scripts to test */
|
||||
hb_bool_t
|
||||
HB_EXTERN hb_bool_t
|
||||
hb_ot_layout_table_choose_script (hb_face_t *face,
|
||||
hb_tag_t table_tag,
|
||||
const hb_tag_t *script_tags,
|
||||
unsigned int *script_index,
|
||||
hb_tag_t *chosen_script);
|
||||
|
||||
unsigned int
|
||||
HB_EXTERN unsigned int
|
||||
hb_ot_layout_table_get_feature_tags (hb_face_t *face,
|
||||
hb_tag_t table_tag,
|
||||
unsigned int start_offset,
|
||||
unsigned int *feature_count /* IN/OUT */,
|
||||
hb_tag_t *feature_tags /* OUT */);
|
||||
|
||||
unsigned int
|
||||
HB_EXTERN unsigned int
|
||||
hb_ot_layout_script_get_language_tags (hb_face_t *face,
|
||||
hb_tag_t table_tag,
|
||||
unsigned int script_index,
|
||||
|
@ -132,21 +133,21 @@ hb_ot_layout_script_get_language_tags (hb_face_t *face,
|
|||
unsigned int *language_count /* IN/OUT */,
|
||||
hb_tag_t *language_tags /* OUT */);
|
||||
|
||||
hb_bool_t
|
||||
HB_EXTERN hb_bool_t
|
||||
hb_ot_layout_script_find_language (hb_face_t *face,
|
||||
hb_tag_t table_tag,
|
||||
unsigned int script_index,
|
||||
hb_tag_t language_tag,
|
||||
unsigned int *language_index);
|
||||
|
||||
hb_bool_t
|
||||
HB_EXTERN hb_bool_t
|
||||
hb_ot_layout_language_get_required_feature_index (hb_face_t *face,
|
||||
hb_tag_t table_tag,
|
||||
unsigned int script_index,
|
||||
unsigned int language_index,
|
||||
unsigned int *feature_index);
|
||||
|
||||
hb_bool_t
|
||||
HB_EXTERN hb_bool_t
|
||||
hb_ot_layout_language_get_required_feature (hb_face_t *face,
|
||||
hb_tag_t table_tag,
|
||||
unsigned int script_index,
|
||||
|
@ -154,7 +155,7 @@ hb_ot_layout_language_get_required_feature (hb_face_t *face,
|
|||
unsigned int *feature_index,
|
||||
hb_tag_t *feature_tag);
|
||||
|
||||
unsigned int
|
||||
HB_EXTERN unsigned int
|
||||
hb_ot_layout_language_get_feature_indexes (hb_face_t *face,
|
||||
hb_tag_t table_tag,
|
||||
unsigned int script_index,
|
||||
|
@ -163,7 +164,7 @@ hb_ot_layout_language_get_feature_indexes (hb_face_t *face,
|
|||
unsigned int *feature_count /* IN/OUT */,
|
||||
unsigned int *feature_indexes /* OUT */);
|
||||
|
||||
unsigned int
|
||||
HB_EXTERN unsigned int
|
||||
hb_ot_layout_language_get_feature_tags (hb_face_t *face,
|
||||
hb_tag_t table_tag,
|
||||
unsigned int script_index,
|
||||
|
@ -172,7 +173,7 @@ hb_ot_layout_language_get_feature_tags (hb_face_t *face,
|
|||
unsigned int *feature_count /* IN/OUT */,
|
||||
hb_tag_t *feature_tags /* OUT */);
|
||||
|
||||
hb_bool_t
|
||||
HB_EXTERN hb_bool_t
|
||||
hb_ot_layout_language_find_feature (hb_face_t *face,
|
||||
hb_tag_t table_tag,
|
||||
unsigned int script_index,
|
||||
|
@ -180,7 +181,7 @@ hb_ot_layout_language_find_feature (hb_face_t *face,
|
|||
hb_tag_t feature_tag,
|
||||
unsigned int *feature_index);
|
||||
|
||||
unsigned int
|
||||
HB_EXTERN unsigned int
|
||||
hb_ot_layout_feature_get_lookups (hb_face_t *face,
|
||||
hb_tag_t table_tag,
|
||||
unsigned int feature_index,
|
||||
|
@ -188,12 +189,12 @@ hb_ot_layout_feature_get_lookups (hb_face_t *face,
|
|||
unsigned int *lookup_count /* IN/OUT */,
|
||||
unsigned int *lookup_indexes /* OUT */);
|
||||
|
||||
unsigned int
|
||||
HB_EXTERN unsigned int
|
||||
hb_ot_layout_table_get_lookup_count (hb_face_t *face,
|
||||
hb_tag_t table_tag);
|
||||
|
||||
|
||||
void
|
||||
HB_EXTERN void
|
||||
hb_ot_layout_collect_lookups (hb_face_t *face,
|
||||
hb_tag_t table_tag,
|
||||
const hb_tag_t *scripts,
|
||||
|
@ -201,7 +202,7 @@ hb_ot_layout_collect_lookups (hb_face_t *face,
|
|||
const hb_tag_t *features,
|
||||
hb_set_t *lookup_indexes /* OUT */);
|
||||
|
||||
void
|
||||
HB_EXTERN void
|
||||
hb_ot_layout_lookup_collect_glyphs (hb_face_t *face,
|
||||
hb_tag_t table_tag,
|
||||
unsigned int lookup_index,
|
||||
|
@ -228,7 +229,7 @@ typedef hb_bool_t
|
|||
const hb_ot_layout_glyph_sequence_t *sequence,
|
||||
void *user_data);
|
||||
|
||||
void
|
||||
HB_EXTERN void
|
||||
Xhb_ot_layout_lookup_enumerate_sequences (hb_face_t *face,
|
||||
hb_tag_t table_tag,
|
||||
unsigned int lookup_index,
|
||||
|
@ -236,22 +237,40 @@ Xhb_ot_layout_lookup_enumerate_sequences (hb_face_t *face,
|
|||
void *user_data);
|
||||
#endif
|
||||
|
||||
/* Variations support */
|
||||
|
||||
HB_EXTERN hb_bool_t
|
||||
hb_ot_layout_table_find_feature_variations (hb_face_t *face,
|
||||
hb_tag_t table_tag,
|
||||
const int *coords,
|
||||
unsigned int num_coords,
|
||||
unsigned int *variations_index /* out */);
|
||||
|
||||
HB_EXTERN unsigned int
|
||||
hb_ot_layout_feature_with_variations_get_lookups (hb_face_t *face,
|
||||
hb_tag_t table_tag,
|
||||
unsigned int feature_index,
|
||||
unsigned int variations_index,
|
||||
unsigned int start_offset,
|
||||
unsigned int *lookup_count /* IN/OUT */,
|
||||
unsigned int *lookup_indexes /* OUT */);
|
||||
|
||||
|
||||
/*
|
||||
* GSUB
|
||||
*/
|
||||
|
||||
hb_bool_t
|
||||
HB_EXTERN hb_bool_t
|
||||
hb_ot_layout_has_substitution (hb_face_t *face);
|
||||
|
||||
hb_bool_t
|
||||
HB_EXTERN hb_bool_t
|
||||
hb_ot_layout_lookup_would_substitute (hb_face_t *face,
|
||||
unsigned int lookup_index,
|
||||
const hb_codepoint_t *glyphs,
|
||||
unsigned int glyphs_length,
|
||||
hb_bool_t zero_context);
|
||||
|
||||
void
|
||||
HB_EXTERN void
|
||||
hb_ot_layout_lookup_substitute_closure (hb_face_t *face,
|
||||
unsigned int lookup_index,
|
||||
hb_set_t *glyphs
|
||||
|
@ -259,7 +278,7 @@ hb_ot_layout_lookup_substitute_closure (hb_face_t *face,
|
|||
|
||||
#ifdef HB_NOT_IMPLEMENTED
|
||||
/* Note: You better have GDEF when using this API, or marks won't do much. */
|
||||
hb_bool_t
|
||||
HB_EXTERN hb_bool_t
|
||||
Xhb_ot_layout_lookup_substitute (hb_font_t *font,
|
||||
unsigned int lookup_index,
|
||||
const hb_ot_layout_glyph_sequence_t *sequence,
|
||||
|
@ -274,12 +293,12 @@ Xhb_ot_layout_lookup_substitute (hb_font_t *font,
|
|||
* GPOS
|
||||
*/
|
||||
|
||||
hb_bool_t
|
||||
HB_EXTERN hb_bool_t
|
||||
hb_ot_layout_has_positioning (hb_face_t *face);
|
||||
|
||||
#ifdef HB_NOT_IMPLEMENTED
|
||||
/* Note: You better have GDEF when using this API, or marks won't do much. */
|
||||
hb_bool_t
|
||||
HB_EXTERN hb_bool_t
|
||||
Xhb_ot_layout_lookup_position (hb_font_t *font,
|
||||
unsigned int lookup_index,
|
||||
const hb_ot_layout_glyph_sequence_t *sequence,
|
||||
|
@ -288,7 +307,7 @@ Xhb_ot_layout_lookup_position (hb_font_t *font,
|
|||
|
||||
/* Optical 'size' feature info. Returns true if found.
|
||||
* http://www.microsoft.com/typography/otspec/features_pt.htm#size */
|
||||
hb_bool_t
|
||||
HB_EXTERN 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 */
|
||||
|
|
|
@ -50,6 +50,7 @@ struct hb_ot_map_t
|
|||
hb_mask_t mask;
|
||||
hb_mask_t _1_mask; /* mask for value=1, for quick access */
|
||||
unsigned int needs_fallback : 1;
|
||||
unsigned int auto_zwnj : 1;
|
||||
unsigned int auto_zwj : 1;
|
||||
|
||||
static int cmp (const feature_map_t *a, const feature_map_t *b)
|
||||
|
@ -58,6 +59,7 @@ struct hb_ot_map_t
|
|||
|
||||
struct lookup_map_t {
|
||||
unsigned short index;
|
||||
unsigned short auto_zwnj : 1;
|
||||
unsigned short auto_zwj : 1;
|
||||
hb_mask_t mask;
|
||||
|
||||
|
@ -113,7 +115,7 @@ struct hb_ot_map_t
|
|||
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 = &lookups[table_index][start];
|
||||
*plookups = end == start ? NULL : &lookups[table_index][start];
|
||||
*lookup_count = end - start;
|
||||
}
|
||||
|
||||
|
@ -139,12 +141,6 @@ struct hb_ot_map_t
|
|||
|
||||
private:
|
||||
|
||||
HB_INTERNAL void add_lookups (hb_face_t *face,
|
||||
unsigned int table_index,
|
||||
unsigned int feature_index,
|
||||
hb_mask_t mask,
|
||||
bool auto_zwj);
|
||||
|
||||
hb_mask_t global_mask;
|
||||
|
||||
hb_prealloced_array_t<feature_map_t, 8> features;
|
||||
|
@ -156,8 +152,9 @@ enum hb_ot_map_feature_flags_t {
|
|||
F_NONE = 0x0000u,
|
||||
F_GLOBAL = 0x0001u, /* Feature applies to all characters; results in no mask allocated for it. */
|
||||
F_HAS_FALLBACK = 0x0002u, /* Has fallback implementation, so include mask bit even if feature not found. */
|
||||
F_MANUAL_ZWJ = 0x0004u, /* Don't skip over ZWJ when matching. */
|
||||
F_GLOBAL_SEARCH = 0x0008u /* If feature not found in LangSys, look for it in global feature list and pick one. */
|
||||
F_MANUAL_ZWNJ = 0x0004u, /* Don't skip over ZWNJ when matching **context**. */
|
||||
F_MANUAL_ZWJ = 0x0008u, /* Don't skip over ZWJ when matching **input**. */
|
||||
F_GLOBAL_SEARCH = 0x0010u /* If feature not found in LangSys, look for it in global feature list and pick one. */
|
||||
};
|
||||
HB_MARK_AS_FLAG_T (hb_ot_map_feature_flags_t);
|
||||
/* Macro version for where const is desired. */
|
||||
|
@ -182,7 +179,9 @@ struct hb_ot_map_builder_t
|
|||
inline void add_gpos_pause (hb_ot_map_t::pause_func_t pause_func)
|
||||
{ add_pause (1, pause_func); }
|
||||
|
||||
HB_INTERNAL void compile (struct hb_ot_map_t &m);
|
||||
HB_INTERNAL void compile (hb_ot_map_t &m,
|
||||
const int *coords,
|
||||
unsigned int num_coords);
|
||||
|
||||
inline void finish (void) {
|
||||
feature_infos.finish ();
|
||||
|
@ -194,6 +193,15 @@ struct hb_ot_map_builder_t
|
|||
|
||||
private:
|
||||
|
||||
HB_INTERNAL void add_lookups (hb_ot_map_t &m,
|
||||
hb_face_t *face,
|
||||
unsigned int table_index,
|
||||
unsigned int feature_index,
|
||||
unsigned int variations_index,
|
||||
hb_mask_t mask,
|
||||
bool auto_zwnj = true,
|
||||
bool auto_zwj = true);
|
||||
|
||||
struct feature_info_t {
|
||||
hb_tag_t tag;
|
||||
unsigned int seq; /* sequence#, used for stable sorting only */
|
||||
|
@ -203,7 +211,8 @@ struct hb_ot_map_builder_t
|
|||
unsigned int stage[2]; /* GSUB/GPOS */
|
||||
|
||||
static int cmp (const feature_info_t *a, const feature_info_t *b)
|
||||
{ return (a->tag != b->tag) ? (a->tag < b->tag ? -1 : 1) : (a->seq < b->seq ? -1 : 1); }
|
||||
{ return (a->tag != b->tag) ? (a->tag < b->tag ? -1 : 1) :
|
||||
(a->seq < b->seq ? -1 : a->seq > b->seq ? 1 : 0); }
|
||||
};
|
||||
|
||||
struct stage_info_t {
|
||||
|
|
|
@ -31,44 +31,13 @@
|
|||
#include "hb-ot-layout-private.hh"
|
||||
|
||||
|
||||
void
|
||||
hb_ot_map_t::add_lookups (hb_face_t *face,
|
||||
unsigned int table_index,
|
||||
unsigned int feature_index,
|
||||
hb_mask_t mask,
|
||||
bool auto_zwj)
|
||||
void hb_ot_map_t::collect_lookups (unsigned int table_index, hb_set_t *lookups_out) const
|
||||
{
|
||||
unsigned int lookup_indices[32];
|
||||
unsigned int offset, len;
|
||||
unsigned int table_lookup_count;
|
||||
|
||||
table_lookup_count = hb_ot_layout_table_get_lookup_count (face, table_tags[table_index]);
|
||||
|
||||
offset = 0;
|
||||
do {
|
||||
len = ARRAY_LENGTH (lookup_indices);
|
||||
hb_ot_layout_feature_get_lookups (face,
|
||||
table_tags[table_index],
|
||||
feature_index,
|
||||
offset, &len,
|
||||
lookup_indices);
|
||||
|
||||
for (unsigned int i = 0; i < len; i++)
|
||||
{
|
||||
if (lookup_indices[i] >= table_lookup_count)
|
||||
continue;
|
||||
hb_ot_map_t::lookup_map_t *lookup = lookups[table_index].push ();
|
||||
if (unlikely (!lookup))
|
||||
return;
|
||||
lookup->mask = mask;
|
||||
lookup->index = lookup_indices[i];
|
||||
lookup->auto_zwj = auto_zwj;
|
||||
}
|
||||
|
||||
offset += len;
|
||||
} while (len == ARRAY_LENGTH (lookup_indices));
|
||||
for (unsigned int i = 0; i < lookups[table_index].len; i++)
|
||||
hb_set_add (lookups_out, lookups[table_index][i].index);
|
||||
}
|
||||
|
||||
|
||||
hb_ot_map_builder_t::hb_ot_map_builder_t (hb_face_t *face_,
|
||||
const hb_segment_properties_t *props_)
|
||||
{
|
||||
|
@ -89,7 +58,7 @@ hb_ot_map_builder_t::hb_ot_map_builder_t (hb_face_t *face_,
|
|||
|
||||
for (unsigned int table_index = 0; table_index < 2; table_index++) {
|
||||
hb_tag_t table_tag = table_tags[table_index];
|
||||
found_script[table_index] = hb_ot_layout_table_choose_script (face, table_tag, script_tags, &script_index[table_index], &chosen_script[table_index]);
|
||||
found_script[table_index] = (bool) hb_ot_layout_table_choose_script (face, table_tag, script_tags, &script_index[table_index], &chosen_script[table_index]);
|
||||
hb_ot_layout_script_find_language (face, table_tag, script_index[table_index], language_tag, &language_index[table_index]);
|
||||
}
|
||||
}
|
||||
|
@ -109,13 +78,50 @@ void hb_ot_map_builder_t::add_feature (hb_tag_t tag, unsigned int value,
|
|||
info->stage[1] = current_stage[1];
|
||||
}
|
||||
|
||||
|
||||
void hb_ot_map_t::collect_lookups (unsigned int table_index, hb_set_t *lookups_out) const
|
||||
void
|
||||
hb_ot_map_builder_t::add_lookups (hb_ot_map_t &m,
|
||||
hb_face_t *face,
|
||||
unsigned int table_index,
|
||||
unsigned int feature_index,
|
||||
unsigned int variations_index,
|
||||
hb_mask_t mask,
|
||||
bool auto_zwnj,
|
||||
bool auto_zwj)
|
||||
{
|
||||
for (unsigned int i = 0; i < lookups[table_index].len; i++)
|
||||
hb_set_add (lookups_out, lookups[table_index][i].index);
|
||||
unsigned int lookup_indices[32];
|
||||
unsigned int offset, len;
|
||||
unsigned int table_lookup_count;
|
||||
|
||||
table_lookup_count = hb_ot_layout_table_get_lookup_count (face, table_tags[table_index]);
|
||||
|
||||
offset = 0;
|
||||
do {
|
||||
len = ARRAY_LENGTH (lookup_indices);
|
||||
hb_ot_layout_feature_with_variations_get_lookups (face,
|
||||
table_tags[table_index],
|
||||
feature_index,
|
||||
variations_index,
|
||||
offset, &len,
|
||||
lookup_indices);
|
||||
|
||||
for (unsigned int i = 0; i < len; i++)
|
||||
{
|
||||
if (lookup_indices[i] >= table_lookup_count)
|
||||
continue;
|
||||
hb_ot_map_t::lookup_map_t *lookup = m.lookups[table_index].push ();
|
||||
if (unlikely (!lookup))
|
||||
return;
|
||||
lookup->mask = mask;
|
||||
lookup->index = lookup_indices[i];
|
||||
lookup->auto_zwnj = auto_zwnj;
|
||||
lookup->auto_zwj = auto_zwj;
|
||||
}
|
||||
|
||||
offset += len;
|
||||
} while (len == ARRAY_LENGTH (lookup_indices));
|
||||
}
|
||||
|
||||
|
||||
void hb_ot_map_builder_t::add_pause (unsigned int table_index, hb_ot_map_t::pause_func_t pause_func)
|
||||
{
|
||||
stage_info_t *s = stages[table_index].push ();
|
||||
|
@ -128,9 +134,15 @@ void hb_ot_map_builder_t::add_pause (unsigned int table_index, hb_ot_map_t::paus
|
|||
}
|
||||
|
||||
void
|
||||
hb_ot_map_builder_t::compile (hb_ot_map_t &m)
|
||||
hb_ot_map_builder_t::compile (hb_ot_map_t &m,
|
||||
const int *coords,
|
||||
unsigned int num_coords)
|
||||
{
|
||||
m.global_mask = 1;
|
||||
ASSERT_STATIC (!(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);
|
||||
|
||||
m.global_mask = global_bit_mask;
|
||||
|
||||
unsigned int required_feature_index[2];
|
||||
hb_tag_t required_feature_tag[2];
|
||||
|
@ -182,7 +194,8 @@ hb_ot_map_builder_t::compile (hb_ot_map_t &m)
|
|||
|
||||
|
||||
/* Allocate bits now */
|
||||
unsigned int next_bit = 1;
|
||||
unsigned int next_bit = global_bit_shift + 1;
|
||||
|
||||
for (unsigned int i = 0; i < feature_infos.len; i++)
|
||||
{
|
||||
const feature_info_t *info = &feature_infos[i];
|
||||
|
@ -193,7 +206,8 @@ hb_ot_map_builder_t::compile (hb_ot_map_t &m)
|
|||
/* Uses the global bit */
|
||||
bits_needed = 0;
|
||||
else
|
||||
bits_needed = _hb_bit_storage (info->max_value);
|
||||
/* Limit to 8 bits per feature. */
|
||||
bits_needed = MIN(8u, _hb_bit_storage (info->max_value));
|
||||
|
||||
if (!info->max_value || next_bit + bits_needed > 8 * sizeof (hb_mask_t))
|
||||
continue; /* Feature disabled, or not enough bits. */
|
||||
|
@ -204,11 +218,8 @@ hb_ot_map_builder_t::compile (hb_ot_map_t &m)
|
|||
for (unsigned int table_index = 0; table_index < 2; table_index++)
|
||||
{
|
||||
if (required_feature_tag[table_index] == info->tag)
|
||||
{
|
||||
required_feature_stage[table_index] = info->stage[table_index];
|
||||
found = true;
|
||||
continue;
|
||||
}
|
||||
|
||||
found |= hb_ot_layout_language_find_feature (face,
|
||||
table_tags[table_index],
|
||||
script_index[table_index],
|
||||
|
@ -239,18 +250,19 @@ hb_ot_map_builder_t::compile (hb_ot_map_t &m)
|
|||
map->index[1] = feature_index[1];
|
||||
map->stage[0] = info->stage[0];
|
||||
map->stage[1] = info->stage[1];
|
||||
map->auto_zwnj = !(info->flags & F_MANUAL_ZWNJ);
|
||||
map->auto_zwj = !(info->flags & F_MANUAL_ZWJ);
|
||||
if ((info->flags & F_GLOBAL) && info->max_value == 1) {
|
||||
/* Uses the global bit */
|
||||
map->shift = 0;
|
||||
map->mask = 1;
|
||||
map->shift = global_bit_shift;
|
||||
map->mask = global_bit_mask;
|
||||
} else {
|
||||
map->shift = next_bit;
|
||||
map->mask = (1 << (next_bit + bits_needed)) - (1 << next_bit);
|
||||
map->mask = (1u << (next_bit + bits_needed)) - (1u << next_bit);
|
||||
next_bit += bits_needed;
|
||||
m.global_mask |= (info->default_value << map->shift) & map->mask;
|
||||
}
|
||||
map->_1_mask = (1 << map->shift) & map->mask;
|
||||
map->_1_mask = (1u << map->shift) & map->mask;
|
||||
map->needs_fallback = !found;
|
||||
|
||||
}
|
||||
|
@ -264,23 +276,32 @@ hb_ot_map_builder_t::compile (hb_ot_map_t &m)
|
|||
{
|
||||
/* Collect lookup indices for features */
|
||||
|
||||
unsigned int variations_index;
|
||||
hb_ot_layout_table_find_feature_variations (face,
|
||||
table_tags[table_index],
|
||||
coords,
|
||||
num_coords,
|
||||
&variations_index);
|
||||
|
||||
unsigned int stage_index = 0;
|
||||
unsigned int last_num_lookups = 0;
|
||||
for (unsigned stage = 0; stage < current_stage[table_index]; stage++)
|
||||
{
|
||||
if (required_feature_index[table_index] != HB_OT_LAYOUT_NO_FEATURE_INDEX &&
|
||||
required_feature_stage[table_index] == stage)
|
||||
m.add_lookups (face, table_index,
|
||||
required_feature_index[table_index],
|
||||
1 /* mask */,
|
||||
true /* auto_zwj */);
|
||||
add_lookups (m, face, table_index,
|
||||
required_feature_index[table_index],
|
||||
variations_index,
|
||||
global_bit_mask);
|
||||
|
||||
for (unsigned i = 0; i < m.features.len; i++)
|
||||
if (m.features[i].stage[table_index] == stage)
|
||||
m.add_lookups (face, table_index,
|
||||
m.features[i].index[table_index],
|
||||
m.features[i].mask,
|
||||
m.features[i].auto_zwj);
|
||||
add_lookups (m, face, table_index,
|
||||
m.features[i].index[table_index],
|
||||
variations_index,
|
||||
m.features[i].mask,
|
||||
m.features[i].auto_zwnj,
|
||||
m.features[i].auto_zwj);
|
||||
|
||||
/* Sort lookups and merge duplicates */
|
||||
if (last_num_lookups < m.lookups[table_index].len)
|
||||
|
@ -294,6 +315,7 @@ hb_ot_map_builder_t::compile (hb_ot_map_t &m)
|
|||
else
|
||||
{
|
||||
m.lookups[table_index][j].mask |= m.lookups[table_index][i].mask;
|
||||
m.lookups[table_index][j].auto_zwnj &= m.lookups[table_index][i].auto_zwnj;
|
||||
m.lookups[table_index][j].auto_zwj &= m.lookups[table_index][i].auto_zwj;
|
||||
}
|
||||
m.lookups[table_index].shrink (j + 1);
|
||||
|
|
|
@ -0,0 +1,722 @@
|
|||
/*
|
||||
* Copyright © 2016 Igalia S.L.
|
||||
*
|
||||
* 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.
|
||||
*
|
||||
* Igalia Author(s): Frédéric Wang
|
||||
*/
|
||||
|
||||
#ifndef HB_OT_MATH_TABLE_HH
|
||||
#define HB_OT_MATH_TABLE_HH
|
||||
|
||||
#include "hb-open-type-private.hh"
|
||||
#include "hb-ot-layout-common-private.hh"
|
||||
#include "hb-ot-math.h"
|
||||
|
||||
namespace OT {
|
||||
|
||||
|
||||
struct MathValueRecord
|
||||
{
|
||||
inline hb_position_t get_x_value (hb_font_t *font, const void *base) const
|
||||
{ return font->em_scale_x (value) + (base+deviceTable).get_x_delta (font); }
|
||||
inline hb_position_t get_y_value (hb_font_t *font, const void *base) const
|
||||
{ return font->em_scale_y (value) + (base+deviceTable).get_y_delta (font); }
|
||||
|
||||
inline bool sanitize (hb_sanitize_context_t *c, const void *base) const
|
||||
{
|
||||
TRACE_SANITIZE (this);
|
||||
return_trace (c->check_struct (this) && deviceTable.sanitize (c, base));
|
||||
}
|
||||
|
||||
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.
|
||||
* Suggested format for device table is 1. */
|
||||
|
||||
public:
|
||||
DEFINE_SIZE_STATIC (4);
|
||||
};
|
||||
|
||||
struct MathConstants
|
||||
{
|
||||
inline bool sanitize_math_value_records (hb_sanitize_context_t *c) const
|
||||
{
|
||||
TRACE_SANITIZE (this);
|
||||
|
||||
unsigned int count = ARRAY_LENGTH (mathValueRecords);
|
||||
for (unsigned int i = 0; i < count; i++)
|
||||
if (!mathValueRecords[i].sanitize (c, this))
|
||||
return_trace (false);
|
||||
|
||||
return_trace (true);
|
||||
}
|
||||
|
||||
inline bool sanitize (hb_sanitize_context_t *c) const
|
||||
{
|
||||
TRACE_SANITIZE (this);
|
||||
return_trace (c->check_struct (this) && sanitize_math_value_records(c));
|
||||
}
|
||||
|
||||
inline hb_position_t get_value (hb_ot_math_constant_t constant,
|
||||
hb_font_t *font) const
|
||||
{
|
||||
switch (constant) {
|
||||
|
||||
case HB_OT_MATH_CONSTANT_SCRIPT_PERCENT_SCALE_DOWN:
|
||||
case HB_OT_MATH_CONSTANT_SCRIPT_SCRIPT_PERCENT_SCALE_DOWN:
|
||||
return percentScaleDown[constant - HB_OT_MATH_CONSTANT_SCRIPT_PERCENT_SCALE_DOWN];
|
||||
|
||||
case HB_OT_MATH_CONSTANT_DELIMITED_SUB_FORMULA_MIN_HEIGHT:
|
||||
case HB_OT_MATH_CONSTANT_DISPLAY_OPERATOR_MIN_HEIGHT:
|
||||
return font->em_scale_y (minHeight[constant - HB_OT_MATH_CONSTANT_DELIMITED_SUB_FORMULA_MIN_HEIGHT]);
|
||||
|
||||
case HB_OT_MATH_CONSTANT_RADICAL_KERN_AFTER_DEGREE:
|
||||
case HB_OT_MATH_CONSTANT_RADICAL_KERN_BEFORE_DEGREE:
|
||||
case HB_OT_MATH_CONSTANT_SKEWED_FRACTION_HORIZONTAL_GAP:
|
||||
case HB_OT_MATH_CONSTANT_SPACE_AFTER_SCRIPT:
|
||||
return mathValueRecords[constant - HB_OT_MATH_CONSTANT_MATH_LEADING].get_x_value(font, this);
|
||||
|
||||
case HB_OT_MATH_CONSTANT_ACCENT_BASE_HEIGHT:
|
||||
case HB_OT_MATH_CONSTANT_AXIS_HEIGHT:
|
||||
case HB_OT_MATH_CONSTANT_FLATTENED_ACCENT_BASE_HEIGHT:
|
||||
case HB_OT_MATH_CONSTANT_FRACTION_DENOMINATOR_DISPLAY_STYLE_SHIFT_DOWN:
|
||||
case HB_OT_MATH_CONSTANT_FRACTION_DENOMINATOR_GAP_MIN:
|
||||
case HB_OT_MATH_CONSTANT_FRACTION_DENOMINATOR_SHIFT_DOWN:
|
||||
case HB_OT_MATH_CONSTANT_FRACTION_DENOM_DISPLAY_STYLE_GAP_MIN:
|
||||
case HB_OT_MATH_CONSTANT_FRACTION_NUMERATOR_DISPLAY_STYLE_SHIFT_UP:
|
||||
case HB_OT_MATH_CONSTANT_FRACTION_NUMERATOR_GAP_MIN:
|
||||
case HB_OT_MATH_CONSTANT_FRACTION_NUMERATOR_SHIFT_UP:
|
||||
case HB_OT_MATH_CONSTANT_FRACTION_NUM_DISPLAY_STYLE_GAP_MIN:
|
||||
case HB_OT_MATH_CONSTANT_FRACTION_RULE_THICKNESS:
|
||||
case HB_OT_MATH_CONSTANT_LOWER_LIMIT_BASELINE_DROP_MIN:
|
||||
case HB_OT_MATH_CONSTANT_LOWER_LIMIT_GAP_MIN:
|
||||
case HB_OT_MATH_CONSTANT_MATH_LEADING:
|
||||
case HB_OT_MATH_CONSTANT_OVERBAR_EXTRA_ASCENDER:
|
||||
case HB_OT_MATH_CONSTANT_OVERBAR_RULE_THICKNESS:
|
||||
case HB_OT_MATH_CONSTANT_OVERBAR_VERTICAL_GAP:
|
||||
case HB_OT_MATH_CONSTANT_RADICAL_DISPLAY_STYLE_VERTICAL_GAP:
|
||||
case HB_OT_MATH_CONSTANT_RADICAL_EXTRA_ASCENDER:
|
||||
case HB_OT_MATH_CONSTANT_RADICAL_RULE_THICKNESS:
|
||||
case HB_OT_MATH_CONSTANT_RADICAL_VERTICAL_GAP:
|
||||
case HB_OT_MATH_CONSTANT_SKEWED_FRACTION_VERTICAL_GAP:
|
||||
case HB_OT_MATH_CONSTANT_STACK_BOTTOM_DISPLAY_STYLE_SHIFT_DOWN:
|
||||
case HB_OT_MATH_CONSTANT_STACK_BOTTOM_SHIFT_DOWN:
|
||||
case HB_OT_MATH_CONSTANT_STACK_DISPLAY_STYLE_GAP_MIN:
|
||||
case HB_OT_MATH_CONSTANT_STACK_GAP_MIN:
|
||||
case HB_OT_MATH_CONSTANT_STACK_TOP_DISPLAY_STYLE_SHIFT_UP:
|
||||
case HB_OT_MATH_CONSTANT_STACK_TOP_SHIFT_UP:
|
||||
case HB_OT_MATH_CONSTANT_STRETCH_STACK_BOTTOM_SHIFT_DOWN:
|
||||
case HB_OT_MATH_CONSTANT_STRETCH_STACK_GAP_ABOVE_MIN:
|
||||
case HB_OT_MATH_CONSTANT_STRETCH_STACK_GAP_BELOW_MIN:
|
||||
case HB_OT_MATH_CONSTANT_STRETCH_STACK_TOP_SHIFT_UP:
|
||||
case HB_OT_MATH_CONSTANT_SUBSCRIPT_BASELINE_DROP_MIN:
|
||||
case HB_OT_MATH_CONSTANT_SUBSCRIPT_SHIFT_DOWN:
|
||||
case HB_OT_MATH_CONSTANT_SUBSCRIPT_TOP_MAX:
|
||||
case HB_OT_MATH_CONSTANT_SUB_SUPERSCRIPT_GAP_MIN:
|
||||
case HB_OT_MATH_CONSTANT_SUPERSCRIPT_BASELINE_DROP_MAX:
|
||||
case HB_OT_MATH_CONSTANT_SUPERSCRIPT_BOTTOM_MAX_WITH_SUBSCRIPT:
|
||||
case HB_OT_MATH_CONSTANT_SUPERSCRIPT_BOTTOM_MIN:
|
||||
case HB_OT_MATH_CONSTANT_SUPERSCRIPT_SHIFT_UP:
|
||||
case HB_OT_MATH_CONSTANT_SUPERSCRIPT_SHIFT_UP_CRAMPED:
|
||||
case HB_OT_MATH_CONSTANT_UNDERBAR_EXTRA_DESCENDER:
|
||||
case HB_OT_MATH_CONSTANT_UNDERBAR_RULE_THICKNESS:
|
||||
case HB_OT_MATH_CONSTANT_UNDERBAR_VERTICAL_GAP:
|
||||
case HB_OT_MATH_CONSTANT_UPPER_LIMIT_BASELINE_RISE_MIN:
|
||||
case HB_OT_MATH_CONSTANT_UPPER_LIMIT_GAP_MIN:
|
||||
return mathValueRecords[constant - HB_OT_MATH_CONSTANT_MATH_LEADING].get_y_value(font, this);
|
||||
|
||||
case HB_OT_MATH_CONSTANT_RADICAL_DEGREE_BOTTOM_RAISE_PERCENT:
|
||||
return radicalDegreeBottomRaisePercent;
|
||||
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
protected:
|
||||
SHORT percentScaleDown[2];
|
||||
USHORT minHeight[2];
|
||||
MathValueRecord mathValueRecords[51];
|
||||
SHORT radicalDegreeBottomRaisePercent;
|
||||
|
||||
public:
|
||||
DEFINE_SIZE_STATIC (214);
|
||||
};
|
||||
|
||||
struct MathItalicsCorrectionInfo
|
||||
{
|
||||
inline bool sanitize (hb_sanitize_context_t *c) const
|
||||
{
|
||||
TRACE_SANITIZE (this);
|
||||
return_trace (c->check_struct (this) &&
|
||||
coverage.sanitize (c, this) &&
|
||||
italicsCorrection.sanitize (c, this));
|
||||
}
|
||||
|
||||
inline hb_position_t get_value (hb_codepoint_t glyph,
|
||||
hb_font_t *font) const
|
||||
{
|
||||
unsigned int index = (this+coverage).get_coverage (glyph);
|
||||
return italicsCorrection[index].get_x_value (font, this);
|
||||
}
|
||||
|
||||
protected:
|
||||
OffsetTo<Coverage> coverage; /* Offset to Coverage table -
|
||||
* from the beginning of
|
||||
* MathItalicsCorrectionInfo
|
||||
* table. */
|
||||
ArrayOf<MathValueRecord> italicsCorrection; /* Array of MathValueRecords
|
||||
* defining italics correction
|
||||
* values for each
|
||||
* covered glyph. */
|
||||
|
||||
public:
|
||||
DEFINE_SIZE_ARRAY (4, italicsCorrection);
|
||||
};
|
||||
|
||||
struct MathTopAccentAttachment
|
||||
{
|
||||
inline bool sanitize (hb_sanitize_context_t *c) const
|
||||
{
|
||||
TRACE_SANITIZE (this);
|
||||
return_trace (c->check_struct (this) &&
|
||||
topAccentCoverage.sanitize (c, this) &&
|
||||
topAccentAttachment.sanitize (c, this));
|
||||
}
|
||||
|
||||
inline hb_position_t get_value (hb_codepoint_t glyph,
|
||||
hb_font_t *font) const
|
||||
{
|
||||
unsigned int index = (this+topAccentCoverage).get_coverage (glyph);
|
||||
if (index == NOT_COVERED)
|
||||
return font->get_glyph_h_advance (glyph) / 2;
|
||||
return topAccentAttachment[index].get_x_value(font, this);
|
||||
}
|
||||
|
||||
protected:
|
||||
OffsetTo<Coverage> topAccentCoverage; /* Offset to Coverage table -
|
||||
* from the beginning of
|
||||
* MathTopAccentAttachment
|
||||
* table. */
|
||||
ArrayOf<MathValueRecord> topAccentAttachment; /* Array of MathValueRecords
|
||||
* defining top accent
|
||||
* attachment points for each
|
||||
* covered glyph. */
|
||||
|
||||
public:
|
||||
DEFINE_SIZE_ARRAY (2 + 2, topAccentAttachment);
|
||||
};
|
||||
|
||||
struct MathKern
|
||||
{
|
||||
inline bool sanitize_math_value_records (hb_sanitize_context_t *c) const
|
||||
{
|
||||
TRACE_SANITIZE (this);
|
||||
unsigned int count = 2 * heightCount + 1;
|
||||
for (unsigned int i = 0; i < count; i++)
|
||||
if (!mathValueRecords[i].sanitize (c, this)) return_trace (false);
|
||||
return_trace (true);
|
||||
}
|
||||
|
||||
inline bool sanitize (hb_sanitize_context_t *c) const
|
||||
{
|
||||
TRACE_SANITIZE (this);
|
||||
return_trace (c->check_struct (this) &&
|
||||
c->check_array (mathValueRecords,
|
||||
mathValueRecords[0].static_size,
|
||||
2 * heightCount + 1) &&
|
||||
sanitize_math_value_records (c));
|
||||
}
|
||||
|
||||
inline hb_position_t get_value (hb_position_t correction_height, hb_font_t *font) const
|
||||
{
|
||||
const MathValueRecord* correctionHeight = mathValueRecords;
|
||||
const MathValueRecord* kernValue = mathValueRecords + heightCount;
|
||||
int sign = font->y_scale < 0 ? -1 : +1;
|
||||
|
||||
/* The description of the MathKern table is a ambiguous, but interpreting
|
||||
* "between the two heights found at those indexes" for 0 < i < len as
|
||||
*
|
||||
* correctionHeight[i-1] < correction_height <= correctionHeight[i]
|
||||
*
|
||||
* makes the result consistent with the limit cases and we can just use the
|
||||
* binary search algorithm of std::upper_bound:
|
||||
*/
|
||||
unsigned int i = 0;
|
||||
unsigned int count = heightCount;
|
||||
while (count > 0)
|
||||
{
|
||||
unsigned int half = count / 2;
|
||||
hb_position_t height = correctionHeight[i + half].get_y_value(font, this);
|
||||
if (sign * height < sign * correction_height)
|
||||
{
|
||||
i += half + 1;
|
||||
count -= half + 1;
|
||||
} else
|
||||
count = half;
|
||||
}
|
||||
return kernValue[i].get_x_value(font, this);
|
||||
}
|
||||
|
||||
protected:
|
||||
USHORT heightCount;
|
||||
MathValueRecord mathValueRecords[VAR]; /* Array of correction heights at
|
||||
* which the kern value changes.
|
||||
* Sorted by the height value in
|
||||
* design units (heightCount entries),
|
||||
* Followed by:
|
||||
* Array of kern values corresponding
|
||||
* to heights. (heightCount+1 entries).
|
||||
*/
|
||||
|
||||
public:
|
||||
DEFINE_SIZE_ARRAY (2, mathValueRecords);
|
||||
};
|
||||
|
||||
struct MathKernInfoRecord
|
||||
{
|
||||
inline bool sanitize (hb_sanitize_context_t *c, const void *base) const
|
||||
{
|
||||
TRACE_SANITIZE (this);
|
||||
|
||||
unsigned int count = ARRAY_LENGTH (mathKern);
|
||||
for (unsigned int i = 0; i < count; i++)
|
||||
if (unlikely (!mathKern[i].sanitize (c, base)))
|
||||
return_trace (false);
|
||||
|
||||
return_trace (true);
|
||||
}
|
||||
|
||||
inline hb_position_t get_kerning (hb_ot_math_kern_t kern,
|
||||
hb_position_t correction_height,
|
||||
hb_font_t *font,
|
||||
const void *base) const
|
||||
{
|
||||
unsigned int idx = kern;
|
||||
if (unlikely (idx >= ARRAY_LENGTH (mathKern))) return 0;
|
||||
return (base+mathKern[idx]).get_value (correction_height, font);
|
||||
}
|
||||
|
||||
protected:
|
||||
/* Offset to MathKern table for each corner -
|
||||
* from the beginning of MathKernInfo table. May be NULL. */
|
||||
OffsetTo<MathKern> mathKern[4];
|
||||
|
||||
public:
|
||||
DEFINE_SIZE_STATIC (8);
|
||||
};
|
||||
|
||||
struct MathKernInfo
|
||||
{
|
||||
inline bool sanitize (hb_sanitize_context_t *c) const
|
||||
{
|
||||
TRACE_SANITIZE (this);
|
||||
return_trace (c->check_struct (this) &&
|
||||
mathKernCoverage.sanitize (c, this) &&
|
||||
mathKernInfoRecords.sanitize (c, this));
|
||||
}
|
||||
|
||||
inline hb_position_t get_kerning (hb_codepoint_t glyph,
|
||||
hb_ot_math_kern_t kern,
|
||||
hb_position_t correction_height,
|
||||
hb_font_t *font) const
|
||||
{
|
||||
unsigned int index = (this+mathKernCoverage).get_coverage (glyph);
|
||||
return mathKernInfoRecords[index].get_kerning (kern, correction_height, font, this);
|
||||
}
|
||||
|
||||
protected:
|
||||
OffsetTo<Coverage> mathKernCoverage; /* Offset to Coverage table -
|
||||
* from the beginning of the
|
||||
* MathKernInfo table. */
|
||||
ArrayOf<MathKernInfoRecord> mathKernInfoRecords; /* Array of
|
||||
* MathKernInfoRecords,
|
||||
* per-glyph information for
|
||||
* mathematical positioning
|
||||
* of subscripts and
|
||||
* superscripts. */
|
||||
|
||||
public:
|
||||
DEFINE_SIZE_ARRAY (4, mathKernInfoRecords);
|
||||
};
|
||||
|
||||
struct MathGlyphInfo
|
||||
{
|
||||
inline bool sanitize (hb_sanitize_context_t *c) const
|
||||
{
|
||||
TRACE_SANITIZE (this);
|
||||
return_trace (c->check_struct (this) &&
|
||||
mathItalicsCorrectionInfo.sanitize (c, this) &&
|
||||
mathTopAccentAttachment.sanitize (c, this) &&
|
||||
extendedShapeCoverage.sanitize (c, this) &&
|
||||
mathKernInfo.sanitize(c, this));
|
||||
}
|
||||
|
||||
inline hb_position_t
|
||||
get_italics_correction (hb_codepoint_t glyph, hb_font_t *font) const
|
||||
{ return (this+mathItalicsCorrectionInfo).get_value (glyph, font); }
|
||||
|
||||
inline hb_position_t
|
||||
get_top_accent_attachment (hb_codepoint_t glyph, hb_font_t *font) const
|
||||
{ return (this+mathTopAccentAttachment).get_value (glyph, font); }
|
||||
|
||||
inline bool is_extended_shape (hb_codepoint_t glyph) const
|
||||
{ return (this+extendedShapeCoverage).get_coverage (glyph) != NOT_COVERED; }
|
||||
|
||||
inline hb_position_t get_kerning (hb_codepoint_t glyph,
|
||||
hb_ot_math_kern_t kern,
|
||||
hb_position_t correction_height,
|
||||
hb_font_t *font) const
|
||||
{ return (this+mathKernInfo).get_kerning (glyph, kern, correction_height, font); }
|
||||
|
||||
protected:
|
||||
/* Offset to MathItalicsCorrectionInfo table -
|
||||
* from the beginning of MathGlyphInfo table. */
|
||||
OffsetTo<MathItalicsCorrectionInfo> mathItalicsCorrectionInfo;
|
||||
|
||||
/* Offset to MathTopAccentAttachment table -
|
||||
* from the beginning of MathGlyphInfo table. */
|
||||
OffsetTo<MathTopAccentAttachment> mathTopAccentAttachment;
|
||||
|
||||
/* Offset to coverage table for Extended Shape glyphs -
|
||||
* 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.. */
|
||||
OffsetTo<Coverage> extendedShapeCoverage;
|
||||
|
||||
/* Offset to MathKernInfo table -
|
||||
* from the beginning of MathGlyphInfo table. */
|
||||
OffsetTo<MathKernInfo> mathKernInfo;
|
||||
|
||||
public:
|
||||
DEFINE_SIZE_STATIC (8);
|
||||
};
|
||||
|
||||
struct MathGlyphVariantRecord
|
||||
{
|
||||
friend struct MathGlyphConstruction;
|
||||
|
||||
inline bool sanitize (hb_sanitize_context_t *c) const
|
||||
{
|
||||
TRACE_SANITIZE (this);
|
||||
return_trace (c->check_struct (this));
|
||||
}
|
||||
|
||||
protected:
|
||||
GlyphID variantGlyph; /* Glyph ID for the variant. */
|
||||
USHORT advanceMeasurement; /* Advance width/height, in design units, of the
|
||||
* variant, in the direction of requested
|
||||
* glyph extension. */
|
||||
|
||||
public:
|
||||
DEFINE_SIZE_STATIC (4);
|
||||
};
|
||||
|
||||
struct PartFlags : USHORT
|
||||
{
|
||||
enum Flags {
|
||||
Extender = 0x0001u, /* If set, the part can be skipped or repeated. */
|
||||
|
||||
Defined = 0x0001u, /* All defined flags. */
|
||||
};
|
||||
|
||||
public:
|
||||
DEFINE_SIZE_STATIC (2);
|
||||
};
|
||||
|
||||
struct MathGlyphPartRecord
|
||||
{
|
||||
inline bool sanitize (hb_sanitize_context_t *c) const
|
||||
{
|
||||
TRACE_SANITIZE (this);
|
||||
return_trace (c->check_struct (this));
|
||||
}
|
||||
|
||||
inline void extract (hb_ot_math_glyph_part_t &out,
|
||||
int scale,
|
||||
hb_font_t *font) const
|
||||
{
|
||||
out.glyph = glyph;
|
||||
|
||||
out.start_connector_length = font->em_scale (startConnectorLength, scale);
|
||||
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);
|
||||
|
||||
out.flags = (hb_ot_math_glyph_part_flags_t)
|
||||
(unsigned int)
|
||||
(partFlags & PartFlags::Defined);
|
||||
}
|
||||
|
||||
protected:
|
||||
GlyphID glyph; /* Glyph ID for the part. */
|
||||
USHORT startConnectorLength; /* Advance width/ height of the straight bar
|
||||
* connector material, in design units, is at
|
||||
* the beginning of the glyph, in the
|
||||
* direction of the extension. */
|
||||
USHORT endConnectorLength; /* Advance width/ height of the straight bar
|
||||
* connector material, in design units, is at
|
||||
* the end of the glyph, in the direction of
|
||||
* the extension. */
|
||||
USHORT fullAdvance; /* Full advance width/height for this part,
|
||||
* in the direction of the extension.
|
||||
* In design units. */
|
||||
PartFlags partFlags; /* Part qualifiers. */
|
||||
|
||||
public:
|
||||
DEFINE_SIZE_STATIC (10);
|
||||
};
|
||||
|
||||
struct MathGlyphAssembly
|
||||
{
|
||||
inline bool sanitize (hb_sanitize_context_t *c) const
|
||||
{
|
||||
TRACE_SANITIZE (this);
|
||||
return_trace (c->check_struct (this) &&
|
||||
italicsCorrection.sanitize(c, this) &&
|
||||
partRecords.sanitize(c));
|
||||
}
|
||||
|
||||
inline unsigned int get_parts (hb_direction_t direction,
|
||||
hb_font_t *font,
|
||||
unsigned int start_offset,
|
||||
unsigned int *parts_count, /* IN/OUT */
|
||||
hb_ot_math_glyph_part_t *parts /* OUT */,
|
||||
hb_position_t *italics_correction /* OUT */) const
|
||||
{
|
||||
if (parts_count)
|
||||
{
|
||||
int scale = font->dir_scale (direction);
|
||||
const MathGlyphPartRecord *arr =
|
||||
partRecords.sub_array (start_offset, parts_count);
|
||||
unsigned int count = *parts_count;
|
||||
for (unsigned int i = 0; i < count; i++)
|
||||
arr[i].extract (parts[i], scale, font);
|
||||
}
|
||||
|
||||
if (italics_correction)
|
||||
*italics_correction = italicsCorrection.get_x_value (font, this);
|
||||
|
||||
return partRecords.len;
|
||||
}
|
||||
|
||||
protected:
|
||||
MathValueRecord italicsCorrection; /* Italics correction of this
|
||||
* MathGlyphAssembly. Should not
|
||||
* depend on the assembly size. */
|
||||
ArrayOf<MathGlyphPartRecord> partRecords; /* Array of part records, from
|
||||
* left to right and bottom to
|
||||
* top. */
|
||||
|
||||
public:
|
||||
DEFINE_SIZE_ARRAY (6, partRecords);
|
||||
};
|
||||
|
||||
struct MathGlyphConstruction
|
||||
{
|
||||
inline bool sanitize (hb_sanitize_context_t *c) const
|
||||
{
|
||||
TRACE_SANITIZE (this);
|
||||
return_trace (c->check_struct (this) &&
|
||||
glyphAssembly.sanitize(c, this) &&
|
||||
mathGlyphVariantRecord.sanitize(c));
|
||||
}
|
||||
|
||||
inline const MathGlyphAssembly &get_assembly (void) const
|
||||
{ return this+glyphAssembly; }
|
||||
|
||||
inline unsigned int get_variants (hb_direction_t direction,
|
||||
hb_font_t *font,
|
||||
unsigned int start_offset,
|
||||
unsigned int *variants_count, /* IN/OUT */
|
||||
hb_ot_math_glyph_variant_t *variants /* OUT */) const
|
||||
{
|
||||
if (variants_count)
|
||||
{
|
||||
int scale = font->dir_scale (direction);
|
||||
const MathGlyphVariantRecord *arr =
|
||||
mathGlyphVariantRecord.sub_array (start_offset, variants_count);
|
||||
unsigned int count = *variants_count;
|
||||
for (unsigned int i = 0; i < count; i++)
|
||||
{
|
||||
variants[i].glyph = arr[i].variantGlyph;
|
||||
variants[i].advance = font->em_scale (arr[i].advanceMeasurement, scale);
|
||||
}
|
||||
}
|
||||
return mathGlyphVariantRecord.len;
|
||||
}
|
||||
|
||||
protected:
|
||||
/* Offset to MathGlyphAssembly table for this shape - from the beginning of
|
||||
MathGlyphConstruction table. May be NULL. */
|
||||
OffsetTo<MathGlyphAssembly> glyphAssembly;
|
||||
|
||||
/* MathGlyphVariantRecords for alternative variants of the glyphs. */
|
||||
ArrayOf<MathGlyphVariantRecord> mathGlyphVariantRecord;
|
||||
|
||||
public:
|
||||
DEFINE_SIZE_ARRAY (4, mathGlyphVariantRecord);
|
||||
};
|
||||
|
||||
struct MathVariants
|
||||
{
|
||||
inline bool sanitize_offsets (hb_sanitize_context_t *c) const
|
||||
{
|
||||
TRACE_SANITIZE (this);
|
||||
unsigned int count = vertGlyphCount + horizGlyphCount;
|
||||
for (unsigned int i = 0; i < count; i++)
|
||||
if (!glyphConstruction[i].sanitize (c, this)) return_trace (false);
|
||||
return_trace (true);
|
||||
}
|
||||
|
||||
inline bool sanitize (hb_sanitize_context_t *c) const
|
||||
{
|
||||
TRACE_SANITIZE (this);
|
||||
return_trace (c->check_struct (this) &&
|
||||
vertGlyphCoverage.sanitize (c, this) &&
|
||||
horizGlyphCoverage.sanitize (c, this) &&
|
||||
c->check_array (glyphConstruction,
|
||||
glyphConstruction[0].static_size,
|
||||
vertGlyphCount + horizGlyphCount) &&
|
||||
sanitize_offsets (c));
|
||||
}
|
||||
|
||||
inline hb_position_t get_min_connector_overlap (hb_direction_t direction,
|
||||
hb_font_t *font) const
|
||||
{ return font->em_scale_dir (minConnectorOverlap, direction); }
|
||||
|
||||
inline unsigned int get_glyph_variants (hb_codepoint_t glyph,
|
||||
hb_direction_t direction,
|
||||
hb_font_t *font,
|
||||
unsigned int start_offset,
|
||||
unsigned int *variants_count, /* IN/OUT */
|
||||
hb_ot_math_glyph_variant_t *variants /* OUT */) const
|
||||
{ return get_glyph_construction (glyph, direction, font)
|
||||
.get_variants (direction, font, start_offset, variants_count, variants); }
|
||||
|
||||
inline unsigned int get_glyph_parts (hb_codepoint_t glyph,
|
||||
hb_direction_t direction,
|
||||
hb_font_t *font,
|
||||
unsigned int start_offset,
|
||||
unsigned int *parts_count, /* IN/OUT */
|
||||
hb_ot_math_glyph_part_t *parts /* OUT */,
|
||||
hb_position_t *italics_correction /* OUT */) const
|
||||
{ return get_glyph_construction (glyph, direction, font)
|
||||
.get_assembly ()
|
||||
.get_parts (direction, font,
|
||||
start_offset, parts_count, parts,
|
||||
italics_correction); }
|
||||
|
||||
private:
|
||||
inline const MathGlyphConstruction &
|
||||
get_glyph_construction (hb_codepoint_t glyph,
|
||||
hb_direction_t direction,
|
||||
hb_font_t *font) const
|
||||
{
|
||||
bool vertical = HB_DIRECTION_IS_VERTICAL (direction);
|
||||
unsigned int count = vertical ? vertGlyphCount : horizGlyphCount;
|
||||
const OffsetTo<Coverage> &coverage = vertical ? vertGlyphCoverage
|
||||
: horizGlyphCoverage;
|
||||
|
||||
unsigned int index = (this+coverage).get_coverage (glyph);
|
||||
if (unlikely (index >= count)) return Null(MathGlyphConstruction);
|
||||
|
||||
if (!vertical)
|
||||
index += vertGlyphCount;
|
||||
|
||||
return this+glyphConstruction[index];
|
||||
}
|
||||
|
||||
protected:
|
||||
USHORT minConnectorOverlap; /* Minimum overlap of connecting
|
||||
* glyphs during glyph construction,
|
||||
* in design units. */
|
||||
OffsetTo<Coverage> vertGlyphCoverage; /* Offset to Coverage table -
|
||||
* from the beginning of MathVariants
|
||||
* table. */
|
||||
OffsetTo<Coverage> horizGlyphCoverage; /* Offset to Coverage table -
|
||||
* from the beginning of MathVariants
|
||||
* table. */
|
||||
USHORT vertGlyphCount; /* Number of glyphs for which
|
||||
* information is provided for
|
||||
* vertically growing variants. */
|
||||
USHORT horizGlyphCount; /* Number of glyphs for which
|
||||
* information is provided for
|
||||
* horizontally growing variants. */
|
||||
|
||||
/* Array of offsets to MathGlyphConstruction tables - from the beginning of
|
||||
the MathVariants table, for shapes growing in vertical/horizontal
|
||||
direction. */
|
||||
OffsetTo<MathGlyphConstruction> glyphConstruction[VAR];
|
||||
|
||||
public:
|
||||
DEFINE_SIZE_ARRAY (10, glyphConstruction);
|
||||
};
|
||||
|
||||
|
||||
/*
|
||||
* MATH -- The MATH Table
|
||||
*/
|
||||
|
||||
struct MATH
|
||||
{
|
||||
static const hb_tag_t tableTag = HB_OT_TAG_MATH;
|
||||
|
||||
inline bool sanitize (hb_sanitize_context_t *c) const
|
||||
{
|
||||
TRACE_SANITIZE (this);
|
||||
return_trace (version.sanitize (c) &&
|
||||
likely (version.major == 1) &&
|
||||
mathConstants.sanitize (c, this) &&
|
||||
mathGlyphInfo.sanitize (c, this) &&
|
||||
mathVariants.sanitize (c, this));
|
||||
}
|
||||
|
||||
inline hb_position_t get_constant (hb_ot_math_constant_t constant,
|
||||
hb_font_t *font) const
|
||||
{ return (this+mathConstants).get_value (constant, font); }
|
||||
|
||||
inline const MathGlyphInfo &get_math_glyph_info (void) const
|
||||
{ return this+mathGlyphInfo; }
|
||||
|
||||
inline const MathVariants &get_math_variants (void) const
|
||||
{ return this+mathVariants; }
|
||||
|
||||
protected:
|
||||
FixedVersion<>version; /* Version of the MATH table
|
||||
* initially set to 0x00010000u */
|
||||
OffsetTo<MathConstants> mathConstants;/* MathConstants table */
|
||||
OffsetTo<MathGlyphInfo> mathGlyphInfo;/* MathGlyphInfo table */
|
||||
OffsetTo<MathVariants> mathVariants; /* MathVariants table */
|
||||
|
||||
public:
|
||||
DEFINE_SIZE_STATIC (10);
|
||||
};
|
||||
|
||||
} /* namespace OT */
|
||||
|
||||
|
||||
#endif /* HB_OT_MATH_TABLE_HH */
|
|
@ -0,0 +1,253 @@
|
|||
/*
|
||||
* Copyright © 2016 Igalia S.L.
|
||||
*
|
||||
* 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.
|
||||
*
|
||||
* Igalia Author(s): Frédéric Wang
|
||||
*/
|
||||
|
||||
#include "hb-open-type-private.hh"
|
||||
|
||||
#include "hb-ot-layout-private.hh"
|
||||
#include "hb-ot-math-table.hh"
|
||||
|
||||
static inline const OT::MATH&
|
||||
_get_math (hb_face_t *face)
|
||||
{
|
||||
if (unlikely (!hb_ot_shaper_face_data_ensure (face))) return OT::Null(OT::MATH);
|
||||
hb_ot_layout_t * layout = hb_ot_layout_from_face (face);
|
||||
return *(layout->math.get ());
|
||||
}
|
||||
|
||||
/*
|
||||
* OT::MATH
|
||||
*/
|
||||
|
||||
/**
|
||||
* hb_ot_math_has_data:
|
||||
* @face: #hb_face_t to test
|
||||
*
|
||||
* This function allows to verify the presence of an OpenType MATH table on the
|
||||
* face.
|
||||
*
|
||||
* Return value: true if face has a MATH table, false otherwise
|
||||
*
|
||||
* Since: 1.3.3
|
||||
**/
|
||||
hb_bool_t
|
||||
hb_ot_math_has_data (hb_face_t *face)
|
||||
{
|
||||
return &_get_math (face) != &OT::Null(OT::MATH);
|
||||
}
|
||||
|
||||
/**
|
||||
* hb_ot_math_get_constant:
|
||||
* @font: #hb_font_t from which to retrieve the value
|
||||
* @constant: #hb_ot_math_constant_t the constant to retrieve
|
||||
*
|
||||
* This function returns the requested math constants as a #hb_position_t.
|
||||
* If the request constant is HB_OT_MATH_CONSTANT_SCRIPT_PERCENT_SCALE_DOWN,
|
||||
* HB_OT_MATH_CONSTANT_SCRIPT_SCRIPT_PERCENT_SCALE_DOWN or
|
||||
* HB_OT_MATH_CONSTANT_SCRIPT_PERCENT_SCALE_DOWN then the return value is
|
||||
* actually an integer between 0 and 100 representing that percentage.
|
||||
*
|
||||
* Return value: the requested constant or 0
|
||||
*
|
||||
* Since: 1.3.3
|
||||
**/
|
||||
hb_position_t
|
||||
hb_ot_math_get_constant (hb_font_t *font,
|
||||
hb_ot_math_constant_t constant)
|
||||
{
|
||||
const OT::MATH &math = _get_math (font->face);
|
||||
return math.get_constant(constant, font);
|
||||
}
|
||||
|
||||
/**
|
||||
* hb_ot_math_get_glyph_italics_correction:
|
||||
* @font: #hb_font_t from which to retrieve the value
|
||||
* @glyph: glyph index from which to retrieve the value
|
||||
*
|
||||
* Return value: the italics correction of the glyph or 0
|
||||
*
|
||||
* Since: 1.3.3
|
||||
**/
|
||||
hb_position_t
|
||||
hb_ot_math_get_glyph_italics_correction (hb_font_t *font,
|
||||
hb_codepoint_t glyph)
|
||||
{
|
||||
const OT::MATH &math = _get_math (font->face);
|
||||
return math.get_math_glyph_info().get_italics_correction (glyph, font);
|
||||
}
|
||||
|
||||
/**
|
||||
* hb_ot_math_get_glyph_top_accent_attachment:
|
||||
* @font: #hb_font_t from which to retrieve the value
|
||||
* @glyph: glyph index from which to retrieve the value
|
||||
*
|
||||
* Return value: the top accent attachment of the glyph or 0
|
||||
*
|
||||
* Since: 1.3.3
|
||||
**/
|
||||
hb_position_t
|
||||
hb_ot_math_get_glyph_top_accent_attachment (hb_font_t *font,
|
||||
hb_codepoint_t glyph)
|
||||
{
|
||||
const OT::MATH &math = _get_math (font->face);
|
||||
return math.get_math_glyph_info().get_top_accent_attachment (glyph, font);
|
||||
}
|
||||
|
||||
/**
|
||||
* hb_ot_math_is_glyph_extended_shape:
|
||||
* @face: a #hb_face_t to test
|
||||
* @glyph: a glyph index to test
|
||||
*
|
||||
* Return value: true if the glyph is an extended shape, false otherwise
|
||||
*
|
||||
* Since: 1.3.3
|
||||
**/
|
||||
hb_bool_t
|
||||
hb_ot_math_is_glyph_extended_shape (hb_face_t *face,
|
||||
hb_codepoint_t glyph)
|
||||
{
|
||||
const OT::MATH &math = _get_math (face);
|
||||
return math.get_math_glyph_info().is_extended_shape (glyph);
|
||||
}
|
||||
|
||||
/**
|
||||
* hb_ot_math_get_glyph_kerning:
|
||||
* @font: #hb_font_t from which to retrieve the value
|
||||
* @glyph: glyph index from which to retrieve the value
|
||||
* @kern: the #hb_ot_math_kern_t from which to retrieve the value
|
||||
* @correction_height: the correction height to use to determine the kerning.
|
||||
*
|
||||
* This function tries to retrieve the MathKern table for the specified font,
|
||||
* glyph and #hb_ot_math_kern_t. Then it browses the list of heights from the
|
||||
* MathKern table to find one value that is greater or equal to specified
|
||||
* correction_height. If one is found the corresponding value from the list of
|
||||
* kerns is returned and otherwise the last kern value is returned.
|
||||
*
|
||||
* Return value: requested kerning or 0
|
||||
*
|
||||
* Since: 1.3.3
|
||||
**/
|
||||
hb_position_t
|
||||
hb_ot_math_get_glyph_kerning (hb_font_t *font,
|
||||
hb_codepoint_t glyph,
|
||||
hb_ot_math_kern_t kern,
|
||||
hb_position_t correction_height)
|
||||
{
|
||||
const OT::MATH &math = _get_math (font->face);
|
||||
return math.get_math_glyph_info().get_kerning (glyph, kern, correction_height, font);
|
||||
}
|
||||
|
||||
/**
|
||||
* hb_ot_math_get_glyph_variants:
|
||||
* @font: #hb_font_t from which to retrieve the values
|
||||
* @glyph: index of the glyph to stretch
|
||||
* @direction: direction of the stretching
|
||||
* @start_offset: offset of the first variant to retrieve
|
||||
* @variants_count: maximum number of variants to retrieve after start_offset
|
||||
* (IN) and actual number of variants retrieved (OUT)
|
||||
* @variants: array of size at least @variants_count to store the result
|
||||
*
|
||||
* This function tries to retrieve the MathGlyphConstruction for the specified
|
||||
* font, glyph and direction. Note that only the value of
|
||||
* #HB_DIRECTION_IS_HORIZONTAL is considered. It provides the corresponding list
|
||||
* of size variants as an array of hb_ot_math_glyph_variant_t structs.
|
||||
*
|
||||
* Return value: the total number of size variants available or 0
|
||||
*
|
||||
* Since: 1.3.3
|
||||
**/
|
||||
unsigned int
|
||||
hb_ot_math_get_glyph_variants (hb_font_t *font,
|
||||
hb_codepoint_t glyph,
|
||||
hb_direction_t direction,
|
||||
unsigned int start_offset,
|
||||
unsigned int *variants_count, /* IN/OUT */
|
||||
hb_ot_math_glyph_variant_t *variants /* OUT */)
|
||||
{
|
||||
const OT::MATH &math = _get_math (font->face);
|
||||
return math.get_math_variants().get_glyph_variants (glyph, direction, font,
|
||||
start_offset,
|
||||
variants_count,
|
||||
variants);
|
||||
}
|
||||
|
||||
/**
|
||||
* hb_ot_math_get_min_connector_overlap:
|
||||
* @font: #hb_font_t from which to retrieve the value
|
||||
* @direction: direction of the stretching
|
||||
*
|
||||
* This function tries to retrieve the MathVariants table for the specified
|
||||
* font and returns the minimum overlap of connecting glyphs to draw a glyph
|
||||
* assembly in the specified direction. Note that only the value of
|
||||
* #HB_DIRECTION_IS_HORIZONTAL is considered.
|
||||
*
|
||||
* Return value: requested min connector overlap or 0
|
||||
*
|
||||
* Since: 1.3.3
|
||||
**/
|
||||
hb_position_t
|
||||
hb_ot_math_get_min_connector_overlap (hb_font_t *font,
|
||||
hb_direction_t direction)
|
||||
{
|
||||
const OT::MATH &math = _get_math (font->face);
|
||||
return math.get_math_variants().get_min_connector_overlap (direction, font);
|
||||
}
|
||||
|
||||
/**
|
||||
* hb_ot_math_get_glyph_assembly:
|
||||
* @font: #hb_font_t from which to retrieve the values
|
||||
* @glyph: index of the glyph to stretch
|
||||
* @direction: direction of the stretching
|
||||
* @start_offset: offset of the first glyph part to retrieve
|
||||
* @parts_count: maximum number of glyph parts to retrieve after start_offset
|
||||
* (IN) and actual number of parts retrieved (OUT)
|
||||
* @parts: array of size at least @parts_count to store the result
|
||||
* @italics_correction: italic correction of the glyph assembly
|
||||
*
|
||||
* This function tries to retrieve the GlyphAssembly for the specified font,
|
||||
* glyph and direction. Note that only the value of #HB_DIRECTION_IS_HORIZONTAL
|
||||
* is considered. It provides the information necessary to draw the glyph
|
||||
* assembly as an array of #hb_ot_math_glyph_part_t.
|
||||
*
|
||||
* Return value: the total number of parts in the glyph assembly
|
||||
*
|
||||
* Since: 1.3.3
|
||||
**/
|
||||
unsigned int
|
||||
hb_ot_math_get_glyph_assembly (hb_font_t *font,
|
||||
hb_codepoint_t glyph,
|
||||
hb_direction_t direction,
|
||||
unsigned int start_offset,
|
||||
unsigned int *parts_count, /* IN/OUT */
|
||||
hb_ot_math_glyph_part_t *parts, /* OUT */
|
||||
hb_position_t *italics_correction /* OUT */)
|
||||
{
|
||||
const OT::MATH &math = _get_math (font->face);
|
||||
return math.get_math_variants().get_glyph_parts (glyph, direction, font,
|
||||
start_offset,
|
||||
parts_count,
|
||||
parts,
|
||||
italics_correction);
|
||||
}
|
|
@ -0,0 +1,209 @@
|
|||
/*
|
||||
* Copyright © 2016 Igalia S.L.
|
||||
*
|
||||
* 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.
|
||||
*
|
||||
* Igalia Author(s): Frédéric Wang
|
||||
*/
|
||||
|
||||
#ifndef HB_OT_H_IN
|
||||
#error "Include <hb-ot.h> instead."
|
||||
#endif
|
||||
|
||||
#ifndef HB_OT_MATH_H
|
||||
#define HB_OT_MATH_H
|
||||
|
||||
#include "hb.h"
|
||||
|
||||
HB_BEGIN_DECLS
|
||||
|
||||
|
||||
/*
|
||||
* MATH
|
||||
*/
|
||||
|
||||
#define HB_OT_TAG_MATH HB_TAG('M','A','T','H')
|
||||
|
||||
/* Use with hb_buffer_set_script() for math shaping. */
|
||||
#define HB_OT_MATH_SCRIPT HB_TAG('m','a','t','h')
|
||||
|
||||
/* Types */
|
||||
|
||||
/**
|
||||
* hb_ot_math_constant_t:
|
||||
*
|
||||
* Since: 1.3.3
|
||||
*/
|
||||
typedef enum {
|
||||
HB_OT_MATH_CONSTANT_SCRIPT_PERCENT_SCALE_DOWN = 0,
|
||||
HB_OT_MATH_CONSTANT_SCRIPT_SCRIPT_PERCENT_SCALE_DOWN = 1,
|
||||
HB_OT_MATH_CONSTANT_DELIMITED_SUB_FORMULA_MIN_HEIGHT = 2,
|
||||
HB_OT_MATH_CONSTANT_DISPLAY_OPERATOR_MIN_HEIGHT = 3,
|
||||
HB_OT_MATH_CONSTANT_MATH_LEADING = 4,
|
||||
HB_OT_MATH_CONSTANT_AXIS_HEIGHT = 5,
|
||||
HB_OT_MATH_CONSTANT_ACCENT_BASE_HEIGHT = 6,
|
||||
HB_OT_MATH_CONSTANT_FLATTENED_ACCENT_BASE_HEIGHT = 7,
|
||||
HB_OT_MATH_CONSTANT_SUBSCRIPT_SHIFT_DOWN = 8,
|
||||
HB_OT_MATH_CONSTANT_SUBSCRIPT_TOP_MAX = 9,
|
||||
HB_OT_MATH_CONSTANT_SUBSCRIPT_BASELINE_DROP_MIN = 10,
|
||||
HB_OT_MATH_CONSTANT_SUPERSCRIPT_SHIFT_UP = 11,
|
||||
HB_OT_MATH_CONSTANT_SUPERSCRIPT_SHIFT_UP_CRAMPED = 12,
|
||||
HB_OT_MATH_CONSTANT_SUPERSCRIPT_BOTTOM_MIN = 13,
|
||||
HB_OT_MATH_CONSTANT_SUPERSCRIPT_BASELINE_DROP_MAX = 14,
|
||||
HB_OT_MATH_CONSTANT_SUB_SUPERSCRIPT_GAP_MIN = 15,
|
||||
HB_OT_MATH_CONSTANT_SUPERSCRIPT_BOTTOM_MAX_WITH_SUBSCRIPT = 16,
|
||||
HB_OT_MATH_CONSTANT_SPACE_AFTER_SCRIPT = 17,
|
||||
HB_OT_MATH_CONSTANT_UPPER_LIMIT_GAP_MIN = 18,
|
||||
HB_OT_MATH_CONSTANT_UPPER_LIMIT_BASELINE_RISE_MIN = 19,
|
||||
HB_OT_MATH_CONSTANT_LOWER_LIMIT_GAP_MIN = 20,
|
||||
HB_OT_MATH_CONSTANT_LOWER_LIMIT_BASELINE_DROP_MIN = 21,
|
||||
HB_OT_MATH_CONSTANT_STACK_TOP_SHIFT_UP = 22,
|
||||
HB_OT_MATH_CONSTANT_STACK_TOP_DISPLAY_STYLE_SHIFT_UP = 23,
|
||||
HB_OT_MATH_CONSTANT_STACK_BOTTOM_SHIFT_DOWN = 24,
|
||||
HB_OT_MATH_CONSTANT_STACK_BOTTOM_DISPLAY_STYLE_SHIFT_DOWN = 25,
|
||||
HB_OT_MATH_CONSTANT_STACK_GAP_MIN = 26,
|
||||
HB_OT_MATH_CONSTANT_STACK_DISPLAY_STYLE_GAP_MIN = 27,
|
||||
HB_OT_MATH_CONSTANT_STRETCH_STACK_TOP_SHIFT_UP = 28,
|
||||
HB_OT_MATH_CONSTANT_STRETCH_STACK_BOTTOM_SHIFT_DOWN = 29,
|
||||
HB_OT_MATH_CONSTANT_STRETCH_STACK_GAP_ABOVE_MIN = 30,
|
||||
HB_OT_MATH_CONSTANT_STRETCH_STACK_GAP_BELOW_MIN = 31,
|
||||
HB_OT_MATH_CONSTANT_FRACTION_NUMERATOR_SHIFT_UP = 32,
|
||||
HB_OT_MATH_CONSTANT_FRACTION_NUMERATOR_DISPLAY_STYLE_SHIFT_UP = 33,
|
||||
HB_OT_MATH_CONSTANT_FRACTION_DENOMINATOR_SHIFT_DOWN = 34,
|
||||
HB_OT_MATH_CONSTANT_FRACTION_DENOMINATOR_DISPLAY_STYLE_SHIFT_DOWN = 35,
|
||||
HB_OT_MATH_CONSTANT_FRACTION_NUMERATOR_GAP_MIN = 36,
|
||||
HB_OT_MATH_CONSTANT_FRACTION_NUM_DISPLAY_STYLE_GAP_MIN = 37,
|
||||
HB_OT_MATH_CONSTANT_FRACTION_RULE_THICKNESS = 38,
|
||||
HB_OT_MATH_CONSTANT_FRACTION_DENOMINATOR_GAP_MIN = 39,
|
||||
HB_OT_MATH_CONSTANT_FRACTION_DENOM_DISPLAY_STYLE_GAP_MIN = 40,
|
||||
HB_OT_MATH_CONSTANT_SKEWED_FRACTION_HORIZONTAL_GAP = 41,
|
||||
HB_OT_MATH_CONSTANT_SKEWED_FRACTION_VERTICAL_GAP = 42,
|
||||
HB_OT_MATH_CONSTANT_OVERBAR_VERTICAL_GAP = 43,
|
||||
HB_OT_MATH_CONSTANT_OVERBAR_RULE_THICKNESS = 44,
|
||||
HB_OT_MATH_CONSTANT_OVERBAR_EXTRA_ASCENDER = 45,
|
||||
HB_OT_MATH_CONSTANT_UNDERBAR_VERTICAL_GAP = 46,
|
||||
HB_OT_MATH_CONSTANT_UNDERBAR_RULE_THICKNESS = 47,
|
||||
HB_OT_MATH_CONSTANT_UNDERBAR_EXTRA_DESCENDER = 48,
|
||||
HB_OT_MATH_CONSTANT_RADICAL_VERTICAL_GAP = 49,
|
||||
HB_OT_MATH_CONSTANT_RADICAL_DISPLAY_STYLE_VERTICAL_GAP = 50,
|
||||
HB_OT_MATH_CONSTANT_RADICAL_RULE_THICKNESS = 51,
|
||||
HB_OT_MATH_CONSTANT_RADICAL_EXTRA_ASCENDER = 52,
|
||||
HB_OT_MATH_CONSTANT_RADICAL_KERN_BEFORE_DEGREE = 53,
|
||||
HB_OT_MATH_CONSTANT_RADICAL_KERN_AFTER_DEGREE = 54,
|
||||
HB_OT_MATH_CONSTANT_RADICAL_DEGREE_BOTTOM_RAISE_PERCENT = 55
|
||||
} hb_ot_math_constant_t;
|
||||
|
||||
/**
|
||||
* hb_ot_math_kern_t:
|
||||
*
|
||||
* Since: 1.3.3
|
||||
*/
|
||||
typedef enum {
|
||||
HB_OT_MATH_KERN_TOP_RIGHT = 0,
|
||||
HB_OT_MATH_KERN_TOP_LEFT = 1,
|
||||
HB_OT_MATH_KERN_BOTTOM_RIGHT = 2,
|
||||
HB_OT_MATH_KERN_BOTTOM_LEFT = 3
|
||||
} hb_ot_math_kern_t;
|
||||
|
||||
/**
|
||||
* hb_ot_math_glyph_variant_t:
|
||||
*
|
||||
* Since: 1.3.3
|
||||
*/
|
||||
typedef struct hb_ot_math_glyph_variant_t {
|
||||
hb_codepoint_t glyph;
|
||||
hb_position_t advance;
|
||||
} hb_ot_math_glyph_variant_t;
|
||||
|
||||
/**
|
||||
* hb_ot_math_glyph_part_flags_t:
|
||||
*
|
||||
* Since: 1.3.3
|
||||
*/
|
||||
typedef enum { /*< flags >*/
|
||||
HB_MATH_GLYPH_PART_FLAG_EXTENDER = 0x00000001u /* Extender glyph */
|
||||
} hb_ot_math_glyph_part_flags_t;
|
||||
|
||||
/**
|
||||
* hb_ot_math_glyph_part_t:
|
||||
*
|
||||
* Since: 1.3.3
|
||||
*/
|
||||
typedef struct hb_ot_math_glyph_part_t {
|
||||
hb_codepoint_t glyph;
|
||||
hb_position_t start_connector_length;
|
||||
hb_position_t end_connector_length;
|
||||
hb_position_t full_advance;
|
||||
hb_ot_math_glyph_part_flags_t flags;
|
||||
} hb_ot_math_glyph_part_t;
|
||||
|
||||
/* Methods */
|
||||
|
||||
HB_EXTERN hb_bool_t
|
||||
hb_ot_math_has_data (hb_face_t *face);
|
||||
|
||||
HB_EXTERN hb_position_t
|
||||
hb_ot_math_get_constant (hb_font_t *font,
|
||||
hb_ot_math_constant_t constant);
|
||||
|
||||
HB_EXTERN hb_position_t
|
||||
hb_ot_math_get_glyph_italics_correction (hb_font_t *font,
|
||||
hb_codepoint_t glyph);
|
||||
|
||||
HB_EXTERN hb_position_t
|
||||
hb_ot_math_get_glyph_top_accent_attachment (hb_font_t *font,
|
||||
hb_codepoint_t glyph);
|
||||
|
||||
HB_EXTERN hb_bool_t
|
||||
hb_ot_math_is_glyph_extended_shape (hb_face_t *face,
|
||||
hb_codepoint_t glyph);
|
||||
|
||||
HB_EXTERN hb_position_t
|
||||
hb_ot_math_get_glyph_kerning (hb_font_t *font,
|
||||
hb_codepoint_t glyph,
|
||||
hb_ot_math_kern_t kern,
|
||||
hb_position_t correction_height);
|
||||
|
||||
HB_EXTERN unsigned int
|
||||
hb_ot_math_get_glyph_variants (hb_font_t *font,
|
||||
hb_codepoint_t glyph,
|
||||
hb_direction_t direction,
|
||||
unsigned int start_offset,
|
||||
unsigned int *variants_count, /* IN/OUT */
|
||||
hb_ot_math_glyph_variant_t *variants /* OUT */);
|
||||
|
||||
HB_EXTERN hb_position_t
|
||||
hb_ot_math_get_min_connector_overlap (hb_font_t *font,
|
||||
hb_direction_t direction);
|
||||
|
||||
HB_EXTERN unsigned int
|
||||
hb_ot_math_get_glyph_assembly (hb_font_t *font,
|
||||
hb_codepoint_t glyph,
|
||||
hb_direction_t direction,
|
||||
unsigned int start_offset,
|
||||
unsigned int *parts_count, /* IN/OUT */
|
||||
hb_ot_math_glyph_part_t *parts, /* OUT */
|
||||
hb_position_t *italics_correction /* OUT */);
|
||||
|
||||
|
||||
HB_END_DECLS
|
||||
|
||||
#endif /* HB_OT_MATH_H */
|
|
@ -58,7 +58,7 @@ struct maxp
|
|||
|
||||
/* We only implement version 0.5 as none of the extra fields in version 1.0 are useful. */
|
||||
protected:
|
||||
FixedVersion version; /* Version of the maxp table (0.5 or 1.0),
|
||||
FixedVersion<>version; /* Version of the maxp table (0.5 or 1.0),
|
||||
* 0x00005000u or 0x00010000u. */
|
||||
USHORT numGlyphs; /* The number of glyphs in the font. */
|
||||
public:
|
||||
|
|
|
@ -0,0 +1,105 @@
|
|||
/*
|
||||
* Copyright © 2011,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_OT_OS2_TABLE_HH
|
||||
#define HB_OT_OS2_TABLE_HH
|
||||
|
||||
#include "hb-open-type-private.hh"
|
||||
|
||||
|
||||
namespace OT {
|
||||
|
||||
/*
|
||||
* OS/2 and Windows Metrics
|
||||
* http://www.microsoft.com/typography/otspec/os2.htm
|
||||
*/
|
||||
|
||||
#define HB_OT_TAG_os2 HB_TAG('O','S','/','2')
|
||||
|
||||
struct os2
|
||||
{
|
||||
static const hb_tag_t tableTag = HB_OT_TAG_os2;
|
||||
|
||||
inline bool sanitize (hb_sanitize_context_t *c) const
|
||||
{
|
||||
TRACE_SANITIZE (this);
|
||||
return_trace (c->check_struct (this));
|
||||
}
|
||||
|
||||
public:
|
||||
USHORT version;
|
||||
|
||||
/* Version 0 */
|
||||
SHORT xAvgCharWidth;
|
||||
USHORT usWeightClass;
|
||||
USHORT usWidthClass;
|
||||
USHORT fsType;
|
||||
SHORT ySubscriptXSize;
|
||||
SHORT ySubscriptYSize;
|
||||
SHORT ySubscriptXOffset;
|
||||
SHORT ySubscriptYOffset;
|
||||
SHORT ySuperscriptXSize;
|
||||
SHORT ySuperscriptYSize;
|
||||
SHORT ySuperscriptXOffset;
|
||||
SHORT ySuperscriptYOffset;
|
||||
SHORT yStrikeoutSize;
|
||||
SHORT yStrikeoutPosition;
|
||||
SHORT sFamilyClass;
|
||||
BYTE panose[10];
|
||||
ULONG ulUnicodeRange[4];
|
||||
Tag achVendID;
|
||||
USHORT fsSelection;
|
||||
USHORT usFirstCharIndex;
|
||||
USHORT usLastCharIndex;
|
||||
SHORT sTypoAscender;
|
||||
SHORT sTypoDescender;
|
||||
SHORT sTypoLineGap;
|
||||
USHORT usWinAscent;
|
||||
USHORT usWinDescent;
|
||||
|
||||
/* Version 1 */
|
||||
//ULONG ulCodePageRange1;
|
||||
//ULONG ulCodePageRange2;
|
||||
|
||||
/* Version 2 */
|
||||
//SHORT sxHeight;
|
||||
//SHORT sCapHeight;
|
||||
//USHORT usDefaultChar;
|
||||
//USHORT usBreakChar;
|
||||
//USHORT usMaxContext;
|
||||
|
||||
/* Version 5 */
|
||||
//USHORT usLowerOpticalPointSize;
|
||||
//USHORT usUpperOpticalPointSize;
|
||||
|
||||
public:
|
||||
DEFINE_SIZE_STATIC (78);
|
||||
};
|
||||
|
||||
} /* namespace OT */
|
||||
|
||||
|
||||
#endif /* HB_OT_OS2_TABLE_HH */
|
|
@ -0,0 +1,119 @@
|
|||
/*
|
||||
* Copyright © 2016 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_OT_POST_TABLE_HH
|
||||
#define HB_OT_POST_TABLE_HH
|
||||
|
||||
#include "hb-open-type-private.hh"
|
||||
|
||||
|
||||
namespace OT {
|
||||
|
||||
|
||||
/*
|
||||
* post -- PostScript
|
||||
*/
|
||||
|
||||
#define HB_OT_TAG_post HB_TAG('p','o','s','t')
|
||||
|
||||
|
||||
struct postV2Tail
|
||||
{
|
||||
inline bool sanitize (hb_sanitize_context_t *c) const
|
||||
{
|
||||
TRACE_SANITIZE (this);
|
||||
return_trace (numberOfGlyphs.sanitize (c) &&
|
||||
c->check_array (glyphNameIndex, sizeof (USHORT), numberOfGlyphs));
|
||||
}
|
||||
|
||||
USHORT numberOfGlyphs; /* Number of glyphs (this should be the
|
||||
* same as numGlyphs in 'maxp' table). */
|
||||
USHORT glyphNameIndex[VAR]; /* This is not an offset, but is the
|
||||
* ordinal number of the glyph in 'post'
|
||||
* string tables. */
|
||||
BYTE namesX[VAR]; /* Glyph names with length bytes [variable]
|
||||
* (a Pascal string). */
|
||||
|
||||
DEFINE_SIZE_ARRAY2 (2, glyphNameIndex, namesX);
|
||||
};
|
||||
|
||||
struct post
|
||||
{
|
||||
static const hb_tag_t tableTag = HB_OT_TAG_post;
|
||||
|
||||
inline bool sanitize (hb_sanitize_context_t *c) const
|
||||
{
|
||||
TRACE_SANITIZE (this);
|
||||
if (unlikely (!c->check_struct (this)))
|
||||
return_trace (false);
|
||||
if (version.to_int () == 0x00020000)
|
||||
{
|
||||
const postV2Tail &v2 = StructAfter<postV2Tail>(*this);
|
||||
return_trace (v2.sanitize (c));
|
||||
}
|
||||
return_trace (true);
|
||||
}
|
||||
|
||||
public:
|
||||
FixedVersion<>version; /* 0x00010000 for version 1.0
|
||||
* 0x00020000 for version 2.0
|
||||
* 0x00025000 for version 2.5 (deprecated)
|
||||
* 0x00030000 for version 3.0 */
|
||||
Fixed italicAngle; /* Italic angle in counter-clockwise degrees
|
||||
* from the vertical. Zero for upright text,
|
||||
* negative for text that leans to the right
|
||||
* (forward). */
|
||||
FWORD underlinePosition; /* This is the suggested distance of the top
|
||||
* of the underline from the baseline
|
||||
* (negative values indicate below baseline).
|
||||
* The PostScript definition of this FontInfo
|
||||
* dictionary key (the y coordinate of the
|
||||
* center of the stroke) is not used for
|
||||
* historical reasons. The value of the
|
||||
* PostScript key may be calculated by
|
||||
* subtracting half the underlineThickness
|
||||
* from the value of this field. */
|
||||
FWORD underlineThickness; /* Suggested values for the underline
|
||||
thickness. */
|
||||
ULONG isFixedPitch; /* Set to 0 if the font is proportionally
|
||||
* spaced, non-zero if the font is not
|
||||
* proportionally spaced (i.e. monospaced). */
|
||||
ULONG minMemType42; /* Minimum memory usage when an OpenType font
|
||||
* is downloaded. */
|
||||
ULONG maxMemType42; /* Maximum memory usage when an OpenType font
|
||||
* is downloaded. */
|
||||
ULONG minMemType1; /* Minimum memory usage when an OpenType font
|
||||
* is downloaded as a Type 1 font. */
|
||||
ULONG maxMemType1; /* Maximum memory usage when an OpenType font
|
||||
* is downloaded as a Type 1 font. */
|
||||
/*postV2Tail v2[VAR];*/
|
||||
DEFINE_SIZE_STATIC (32);
|
||||
};
|
||||
|
||||
} /* namespace OT */
|
||||
|
||||
|
||||
#endif /* HB_OT_POST_TABLE_HH */
|
|
@ -6,10 +6,10 @@
|
|||
*
|
||||
* on files with these headers:
|
||||
*
|
||||
* # ArabicShaping-8.0.0.txt
|
||||
* # Date: 2015-02-17, 23:33:00 GMT [RP]
|
||||
* # Blocks-8.0.0.txt
|
||||
* # Date: 2014-11-10, 23:04:00 GMT [KW]
|
||||
* # ArabicShaping-9.0.0.txt
|
||||
* # Date: 2016-02-24, 22:25:00 GMT [RP]
|
||||
* # Blocks-9.0.0.txt
|
||||
* # Date: 2016-02-05, 23:48:00 GMT [KW]
|
||||
* UnicodeData.txt does not have a header.
|
||||
*/
|
||||
|
||||
|
@ -19,6 +19,7 @@
|
|||
|
||||
#define X JOINING_TYPE_X
|
||||
#define R JOINING_TYPE_R
|
||||
#define T JOINING_TYPE_T
|
||||
#define U JOINING_TYPE_U
|
||||
#define A JOINING_GROUP_ALAPH
|
||||
#define DR JOINING_GROUP_DALATH_RISH
|
||||
|
@ -76,9 +77,11 @@ static const uint8_t joining_table[] =
|
|||
|
||||
/* Arabic Extended-A */
|
||||
|
||||
/* 08A0 */ D,D,D,D,D,D,D,D,D,D,R,R,R,U,R,D,D,R,R,D,D,
|
||||
/* 08A0 */ D,D,D,D,D,D,D,D,D,D,R,R,R,U,R,D,D,R,R,D,D,X,D,D,D,R,D,D,D,D,X,X,
|
||||
/* 08C0 */ X,X,X,X,X,X,X,X,X,X,X,X,X,X,X,X,X,X,X,X,X,X,X,X,X,X,X,X,X,X,X,X,
|
||||
/* 08E0 */ X,X,U,
|
||||
|
||||
#define joining_offset_0x1806u 693
|
||||
#define joining_offset_0x1806u 739
|
||||
|
||||
/* Mongolian */
|
||||
|
||||
|
@ -86,43 +89,48 @@ static const uint8_t joining_table[] =
|
|||
/* 1820 */ D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,
|
||||
/* 1840 */ D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,
|
||||
/* 1860 */ D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,X,X,X,X,X,X,X,X,
|
||||
/* 1880 */ U,U,U,U,U,U,U,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,
|
||||
/* 1880 */ U,U,U,U,U,T,T,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,
|
||||
/* 18A0 */ D,D,D,D,D,D,D,D,D,X,D,
|
||||
|
||||
#define joining_offset_0x200cu 858
|
||||
#define joining_offset_0x200cu 904
|
||||
|
||||
/* General Punctuation */
|
||||
|
||||
/* 2000 */ U,C,
|
||||
/* 2000 */ U,C,X,X,X,X,X,X,X,X,X,X,X,X,X,X,X,X,X,X,
|
||||
/* 2020 */ X,X,X,X,X,X,X,X,X,X,X,X,X,X,X,U,X,X,X,X,X,X,X,X,X,X,X,X,X,X,X,X,
|
||||
/* 2040 */ X,X,X,X,X,X,X,X,X,X,X,X,X,X,X,X,X,X,X,X,X,X,X,X,X,X,X,X,X,X,X,X,
|
||||
/* 2060 */ X,X,X,X,X,X,U,U,U,U,
|
||||
|
||||
#define joining_offset_0x2066u 860
|
||||
|
||||
/* General Punctuation */
|
||||
|
||||
/* 2060 */ U,U,U,U,
|
||||
|
||||
#define joining_offset_0xa840u 864
|
||||
#define joining_offset_0xa840u 998
|
||||
|
||||
/* Phags-pa */
|
||||
|
||||
/* A840 */ D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,
|
||||
/* A860 */ D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,L,U,
|
||||
|
||||
#define joining_offset_0x10ac0u 916
|
||||
#define joining_offset_0x10ac0u 1050
|
||||
|
||||
/* Manichaean */
|
||||
|
||||
/* 10AC0 */ D,D,D,D,D,R,U,R,U,R,R,U,U,L,R,R,R,R,R,D,D,D,D,L,D,D,D,D,D,R,D,D,
|
||||
/* 10AE0 */ D,R,U,U,R,X,X,X,X,X,X,D,D,D,D,R,
|
||||
|
||||
#define joining_offset_0x10b80u 964
|
||||
#define joining_offset_0x10b80u 1098
|
||||
|
||||
/* Psalter Pahlavi */
|
||||
|
||||
/* 10B80 */ D,R,D,R,R,R,D,D,D,R,D,D,R,D,R,R,D,R,X,X,X,X,X,X,X,X,X,X,X,X,X,X,
|
||||
/* 10BA0 */ X,X,X,X,X,X,X,X,X,R,R,R,R,D,D,U,
|
||||
|
||||
}; /* Table items: 1012; occupancy: 57% */
|
||||
#define joining_offset_0x1e900u 1146
|
||||
|
||||
/* Adlam */
|
||||
|
||||
/* 1E900 */ D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,
|
||||
/* 1E920 */ D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,D,
|
||||
/* 1E940 */ D,D,D,D,
|
||||
|
||||
}; /* Table items: 1214; occupancy: 54% */
|
||||
|
||||
|
||||
static unsigned int
|
||||
|
@ -131,25 +139,28 @@ joining_type (hb_codepoint_t u)
|
|||
switch (u >> 12)
|
||||
{
|
||||
case 0x0u:
|
||||
if (hb_in_range (u, 0x0600u, 0x08B4u)) return joining_table[u - 0x0600u + joining_offset_0x0600u];
|
||||
if (hb_in_range<hb_codepoint_t> (u, 0x0600u, 0x08E2u)) return joining_table[u - 0x0600u + joining_offset_0x0600u];
|
||||
break;
|
||||
|
||||
case 0x1u:
|
||||
if (hb_in_range (u, 0x1806u, 0x18AAu)) return joining_table[u - 0x1806u + joining_offset_0x1806u];
|
||||
if (hb_in_range<hb_codepoint_t> (u, 0x1806u, 0x18AAu)) return joining_table[u - 0x1806u + joining_offset_0x1806u];
|
||||
break;
|
||||
|
||||
case 0x2u:
|
||||
if (hb_in_range (u, 0x200Cu, 0x200Du)) return joining_table[u - 0x200Cu + joining_offset_0x200cu];
|
||||
if (hb_in_range (u, 0x2066u, 0x2069u)) return joining_table[u - 0x2066u + joining_offset_0x2066u];
|
||||
if (hb_in_range<hb_codepoint_t> (u, 0x200Cu, 0x2069u)) return joining_table[u - 0x200Cu + joining_offset_0x200cu];
|
||||
break;
|
||||
|
||||
case 0xAu:
|
||||
if (hb_in_range (u, 0xA840u, 0xA873u)) return joining_table[u - 0xA840u + joining_offset_0xa840u];
|
||||
if (hb_in_range<hb_codepoint_t> (u, 0xA840u, 0xA873u)) return joining_table[u - 0xA840u + joining_offset_0xa840u];
|
||||
break;
|
||||
|
||||
case 0x10u:
|
||||
if (hb_in_range (u, 0x10AC0u, 0x10AEFu)) return joining_table[u - 0x10AC0u + joining_offset_0x10ac0u];
|
||||
if (hb_in_range (u, 0x10B80u, 0x10BAFu)) return joining_table[u - 0x10B80u + joining_offset_0x10b80u];
|
||||
if (hb_in_range<hb_codepoint_t> (u, 0x10AC0u, 0x10AEFu)) return joining_table[u - 0x10AC0u + joining_offset_0x10ac0u];
|
||||
if (hb_in_range<hb_codepoint_t> (u, 0x10B80u, 0x10BAFu)) return joining_table[u - 0x10B80u + joining_offset_0x10b80u];
|
||||
break;
|
||||
|
||||
case 0x1Eu:
|
||||
if (hb_in_range<hb_codepoint_t> (u, 0x1E900u, 0x1E943u)) return joining_table[u - 0x1E900u + joining_offset_0x1e900u];
|
||||
break;
|
||||
|
||||
default:
|
||||
|
@ -160,6 +171,7 @@ joining_type (hb_codepoint_t u)
|
|||
|
||||
#undef X
|
||||
#undef R
|
||||
#undef T
|
||||
#undef U
|
||||
#undef A
|
||||
#undef DR
|
||||
|
|
|
@ -199,6 +199,9 @@ collect_features_arabic (hb_ot_shape_planner_t *plan)
|
|||
* work. However, testing shows that rlig and calt are applied
|
||||
* together for Mongolian in Uniscribe. As such, we only add a
|
||||
* pause for Arabic, not other scripts.
|
||||
*
|
||||
* A pause after calt is required to make KFGQPC Uthmanic Script HAFS
|
||||
* work correctly. See https://github.com/behdad/harfbuzz/issues/505
|
||||
*/
|
||||
|
||||
map->add_gsub_pause (nuke_joiners);
|
||||
|
@ -222,6 +225,8 @@ collect_features_arabic (hb_ot_shape_planner_t *plan)
|
|||
if (plan->props.script == HB_SCRIPT_ARABIC)
|
||||
map->add_gsub_pause (arabic_fallback_shape);
|
||||
|
||||
/* 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);
|
||||
|
||||
|
@ -316,7 +321,10 @@ arabic_joining (hb_buffer_t *buffer)
|
|||
const arabic_state_table_entry *entry = &arabic_state_table[state][this_type];
|
||||
|
||||
if (entry->prev_action != NONE && prev != (unsigned int) -1)
|
||||
{
|
||||
info[prev].arabic_shaping_action() = entry->prev_action;
|
||||
buffer->unsafe_to_break (prev, i + 1);
|
||||
}
|
||||
|
||||
info[i].arabic_shaping_action() = entry->curr_action;
|
||||
|
||||
|
@ -345,7 +353,7 @@ mongolian_variation_selectors (hb_buffer_t *buffer)
|
|||
unsigned int count = buffer->len;
|
||||
hb_glyph_info_t *info = buffer->info;
|
||||
for (unsigned int i = 1; i < count; i++)
|
||||
if (unlikely (hb_in_range (info[i].codepoint, 0x180Bu, 0x180Du)))
|
||||
if (unlikely (hb_in_range<hb_codepoint_t> (info[i].codepoint, 0x180Bu, 0x180Du)))
|
||||
info[i].arabic_shaping_action() = info[i - 1].arabic_shaping_action();
|
||||
}
|
||||
|
||||
|
@ -463,10 +471,6 @@ apply_stch (const hb_ot_shape_plan_t *plan,
|
|||
* Second pass applies the stretch, copying things to the end of buffer.
|
||||
*/
|
||||
|
||||
/* 30 = 2048 / 70.
|
||||
* https://www.microsoft.com/typography/cursivescriptguidelines.mspx */
|
||||
hb_position_t overlap = font->x_scale / 30;
|
||||
DEBUG_MSG (ARABIC, NULL, "overlap for stretching is %d", overlap);
|
||||
int sign = font->x_scale < 0 ? -1 : +1;
|
||||
unsigned int extra_glyphs_needed = 0; // Set during MEASURE, used during CUT
|
||||
typedef enum { MEASURE, CUT } step_t;
|
||||
|
@ -504,18 +508,15 @@ apply_stch (const hb_ot_shape_plan_t *plan,
|
|||
hb_in_range<unsigned> (info[i - 1].arabic_shaping_action(), STCH_FIXED, STCH_REPEATING))
|
||||
{
|
||||
i--;
|
||||
hb_glyph_extents_t extents;
|
||||
if (!font->get_glyph_extents (info[i].codepoint, &extents))
|
||||
extents.width = 0;
|
||||
extents.width -= overlap;
|
||||
hb_position_t width = font->get_glyph_h_advance (info[i].codepoint);
|
||||
if (info[i].arabic_shaping_action() == STCH_FIXED)
|
||||
{
|
||||
w_fixed += extents.width;
|
||||
w_fixed += width;
|
||||
n_fixed++;
|
||||
}
|
||||
else
|
||||
{
|
||||
w_repeating += extents.width;
|
||||
w_repeating += width;
|
||||
n_repeating++;
|
||||
}
|
||||
}
|
||||
|
@ -540,9 +541,20 @@ apply_stch (const hb_ot_shape_plan_t *plan,
|
|||
/* Number of additional times to repeat each repeating tile. */
|
||||
int n_copies = 0;
|
||||
|
||||
hb_position_t w_remaining = w_total - w_fixed - overlap;
|
||||
hb_position_t w_remaining = w_total - w_fixed;
|
||||
if (sign * w_remaining > sign * w_repeating && sign * w_repeating > 0)
|
||||
n_copies = (sign * w_remaining + sign * w_repeating / 4) / (sign * w_repeating) - 1;
|
||||
n_copies = (sign * w_remaining) / (sign * w_repeating) - 1;
|
||||
|
||||
/* See if we can improve the fit by adding an extra repeat and squeezing them together a bit. */
|
||||
hb_position_t extra_repeat_overlap = 0;
|
||||
hb_position_t shortfall = sign * w_remaining - sign * w_repeating * (n_copies + 1);
|
||||
if (shortfall > 0 && n_repeating > 0)
|
||||
{
|
||||
++n_copies;
|
||||
hb_position_t excess = (n_copies + 1) * sign * w_repeating - sign * w_remaining;
|
||||
if (excess > 0)
|
||||
extra_repeat_overlap = excess / (n_copies * n_repeating);
|
||||
}
|
||||
|
||||
if (step == MEASURE)
|
||||
{
|
||||
|
@ -551,13 +563,10 @@ apply_stch (const hb_ot_shape_plan_t *plan,
|
|||
}
|
||||
else
|
||||
{
|
||||
hb_position_t x_offset = -overlap;
|
||||
hb_position_t x_offset = 0;
|
||||
for (unsigned int k = end; k > start; k--)
|
||||
{
|
||||
hb_glyph_extents_t extents;
|
||||
if (!font->get_glyph_extents (info[k - 1].codepoint, &extents))
|
||||
extents.width = 0;
|
||||
extents.width -= overlap;
|
||||
hb_position_t width = font->get_glyph_h_advance (info[k - 1].codepoint);
|
||||
|
||||
unsigned int repeat = 1;
|
||||
if (info[k - 1].arabic_shaping_action() == STCH_REPEATING)
|
||||
|
@ -567,7 +576,9 @@ apply_stch (const hb_ot_shape_plan_t *plan,
|
|||
repeat, info[k - 1].codepoint, j);
|
||||
for (unsigned int n = 0; n < repeat; n++)
|
||||
{
|
||||
x_offset -= extents.width;
|
||||
x_offset -= width;
|
||||
if (n > 0)
|
||||
x_offset += extra_repeat_overlap;
|
||||
pos[k - 1].x_offset = x_offset;
|
||||
/* Append copy. */
|
||||
--j;
|
||||
|
@ -615,6 +626,7 @@ const hb_ot_complex_shaper_t _hb_ot_complex_shaper_arabic =
|
|||
NULL, /* decompose */
|
||||
NULL, /* compose */
|
||||
setup_masks_arabic,
|
||||
NULL, /* disable_otl */
|
||||
HB_OT_SHAPE_ZERO_WIDTH_MARKS_BY_GDEF_LATE,
|
||||
true, /* fallback_position */
|
||||
};
|
||||
|
|
|
@ -40,6 +40,7 @@ const hb_ot_complex_shaper_t _hb_ot_complex_shaper_default =
|
|||
NULL, /* decompose */
|
||||
NULL, /* compose */
|
||||
NULL, /* setup_masks */
|
||||
HB_OT_SHAPE_ZERO_WIDTH_MARKS_DEFAULT,
|
||||
NULL, /* disable_otl */
|
||||
HB_OT_SHAPE_ZERO_WIDTH_MARKS_BY_GDEF_LATE,
|
||||
true, /* fallback_position */
|
||||
};
|
||||
|
|
|
@ -32,7 +32,7 @@
|
|||
|
||||
/* Same order as the feature array below */
|
||||
enum {
|
||||
NONE,
|
||||
_JMO,
|
||||
|
||||
LJMO,
|
||||
VJMO,
|
||||
|
@ -105,16 +105,16 @@ data_destroy_hangul (void *data)
|
|||
#define NCount (VCount * TCount)
|
||||
#define SCount (LCount * NCount)
|
||||
|
||||
#define isCombiningL(u) (hb_in_range ((u), LBase, LBase+LCount-1))
|
||||
#define isCombiningV(u) (hb_in_range ((u), VBase, VBase+VCount-1))
|
||||
#define isCombiningT(u) (hb_in_range ((u), TBase+1, TBase+TCount-1))
|
||||
#define isCombinedS(u) (hb_in_range ((u), SBase, SBase+SCount-1))
|
||||
#define isCombiningL(u) (hb_in_range<hb_codepoint_t> ((u), LBase, LBase+LCount-1))
|
||||
#define isCombiningV(u) (hb_in_range<hb_codepoint_t> ((u), VBase, VBase+VCount-1))
|
||||
#define isCombiningT(u) (hb_in_range<hb_codepoint_t> ((u), TBase+1, TBase+TCount-1))
|
||||
#define isCombinedS(u) (hb_in_range<hb_codepoint_t> ((u), SBase, SBase+SCount-1))
|
||||
|
||||
#define isL(u) (hb_in_ranges ((u), 0x1100u, 0x115Fu, 0xA960u, 0xA97Cu))
|
||||
#define isV(u) (hb_in_ranges ((u), 0x1160u, 0x11A7u, 0xD7B0u, 0xD7C6u))
|
||||
#define isT(u) (hb_in_ranges ((u), 0x11A8u, 0x11FFu, 0xD7CBu, 0xD7FBu))
|
||||
#define isL(u) (hb_in_ranges<hb_codepoint_t> ((u), 0x1100u, 0x115Fu, 0xA960u, 0xA97Cu))
|
||||
#define isV(u) (hb_in_ranges<hb_codepoint_t> ((u), 0x1160u, 0x11A7u, 0xD7B0u, 0xD7C6u))
|
||||
#define isT(u) (hb_in_ranges<hb_codepoint_t> ((u), 0x11A8u, 0x11FFu, 0xD7CBu, 0xD7FBu))
|
||||
|
||||
#define isHangulTone(u) (hb_in_range ((u), 0x302Eu, 0x302Fu))
|
||||
#define isHangulTone(u) (hb_in_range<hb_codepoint_t> ((u), 0x302Eu, 0x302Fu))
|
||||
|
||||
/* buffer var allocations */
|
||||
#define hangul_shaping_feature() complex_var_u8_0() /* hangul jamo shaping feature */
|
||||
|
@ -202,6 +202,7 @@ preprocess_text_hangul (const hb_ot_shape_plan_t *plan,
|
|||
if (start < end && end == buffer->out_len)
|
||||
{
|
||||
/* Tone mark follows a valid syllable; move it in front, unless it's zero width. */
|
||||
buffer->unsafe_to_break_from_outbuffer (start, buffer->idx);
|
||||
buffer->next_glyph ();
|
||||
if (!is_zero_width_char (font, u))
|
||||
{
|
||||
|
@ -258,6 +259,7 @@ preprocess_text_hangul (const hb_ot_shape_plan_t *plan,
|
|||
else
|
||||
t = 0; /* The next character was not a trailing jamo. */
|
||||
}
|
||||
buffer->unsafe_to_break (buffer->idx, buffer->idx + (t ? 3 : 2));
|
||||
|
||||
/* We've got a syllable <L,V,T?>; see if it can potentially be composed. */
|
||||
if (isCombiningL (l) && isCombiningV (v) && (t == 0 || isCombiningT (t)))
|
||||
|
@ -322,6 +324,8 @@ preprocess_text_hangul (const hb_ot_shape_plan_t *plan,
|
|||
end = start + 1;
|
||||
continue;
|
||||
}
|
||||
else
|
||||
buffer->unsafe_to_break (buffer->idx, buffer->idx + 2); /* Mark unsafe between LV and T. */
|
||||
}
|
||||
|
||||
/* Otherwise, decompose if font doesn't support <LV> or <LVT>,
|
||||
|
@ -368,6 +372,8 @@ preprocess_text_hangul (const hb_ot_shape_plan_t *plan,
|
|||
buffer->merge_out_clusters (start, end);
|
||||
continue;
|
||||
}
|
||||
else if ((!tindex && buffer->idx + 1 < count && isT (buffer->cur(+1).codepoint)))
|
||||
buffer->unsafe_to_break (buffer->idx, buffer->idx + 2); /* Mark unsafe between LV and T. */
|
||||
}
|
||||
|
||||
if (has_glyph)
|
||||
|
@ -419,6 +425,7 @@ const hb_ot_complex_shaper_t _hb_ot_complex_shaper_hangul =
|
|||
NULL, /* decompose */
|
||||
NULL, /* compose */
|
||||
setup_masks_hangul,
|
||||
NULL, /* disable_otl */
|
||||
HB_OT_SHAPE_ZERO_WIDTH_MARKS_NONE,
|
||||
false, /* fallback_position */
|
||||
};
|
||||
|
|
|
@ -68,7 +68,7 @@ compose_hebrew (const hb_ot_shape_normalize_context_t *c,
|
|||
0xFB4Au /* TAV */
|
||||
};
|
||||
|
||||
bool found = c->unicode->compose (a, b, ab);
|
||||
bool found = (bool) c->unicode->compose (a, b, ab);
|
||||
|
||||
if (!found && !c->plan->has_mark)
|
||||
{
|
||||
|
@ -154,6 +154,18 @@ compose_hebrew (const hb_ot_shape_normalize_context_t *c,
|
|||
return found;
|
||||
}
|
||||
|
||||
static bool
|
||||
disable_otl_hebrew (const hb_ot_shape_plan_t *plan)
|
||||
{
|
||||
/* For Hebrew shaper, use fallback if GPOS does not have 'hebr'
|
||||
* script. This matches Uniscribe better, and makes fonts like
|
||||
* Arial that have GSUB/GPOS/GDEF but no data for Hebrew work.
|
||||
* See:
|
||||
* https://github.com/behdad/harfbuzz/issues/347#issuecomment-267838368
|
||||
*/
|
||||
return plan->map.chosen_script[1] != HB_TAG ('h','e','b','r');
|
||||
}
|
||||
|
||||
|
||||
const hb_ot_complex_shaper_t _hb_ot_complex_shaper_hebrew =
|
||||
{
|
||||
|
@ -168,6 +180,7 @@ const hb_ot_complex_shaper_t _hb_ot_complex_shaper_hebrew =
|
|||
NULL, /* decompose */
|
||||
compose_hebrew,
|
||||
NULL, /* setup_masks */
|
||||
disable_otl_hebrew,
|
||||
HB_OT_SHAPE_ZERO_WIDTH_MARKS_BY_GDEF_LATE,
|
||||
true, /* fallback_position */
|
||||
};
|
||||
|
|
File diff suppressed because it is too large
Load Diff
|
@ -57,7 +57,6 @@ Repha = 15;
|
|||
Ra = 16;
|
||||
CM = 17;
|
||||
Symbol= 18;
|
||||
CM2 = 31;
|
||||
|
||||
c = (C | Ra); # is_consonant
|
||||
n = ((ZWNJ?.RS)? (N.N?)?); # is_consonant_modifier
|
||||
|
@ -73,7 +72,7 @@ syllable_tail = (z?.SM.SM?.ZWNJ?)? A{0,3}? VD{0,2};
|
|||
place_holder = PLACEHOLDER | DOTTEDCIRCLE;
|
||||
halant_group = (z?.h.(ZWJ.N?)?);
|
||||
final_halant_group = halant_group | h.ZWNJ;
|
||||
medial_group = CM?.CM2?;
|
||||
medial_group = CM?;
|
||||
halant_or_matra_group = (final_halant_group | (h.ZWJ)? matra_group{0,4}) (Coeng (cn|V))?;
|
||||
|
||||
|
||||
|
|
|
@ -60,11 +60,10 @@ enum indic_category_t {
|
|||
OT_Repha = 15, /* Atomically-encoded logical or visual repha. */
|
||||
OT_Ra = 16,
|
||||
OT_CM = 17, /* Consonant-Medial. */
|
||||
OT_Symbol = 18, /* Avagraha, etc that take marks (SM,A,VD). */
|
||||
OT_CM2 = 31 /* Consonant-Medial, second slot. */
|
||||
OT_Symbol = 18 /* Avagraha, etc that take marks (SM,A,VD). */
|
||||
};
|
||||
|
||||
#define MEDIAL_FLAGS (FLAG (OT_CM) | FLAG (OT_CM2))
|
||||
#define MEDIAL_FLAGS (FLAG (OT_CM))
|
||||
|
||||
/* Note:
|
||||
*
|
||||
|
@ -109,27 +108,31 @@ enum indic_syllabic_category_t {
|
|||
|
||||
INDIC_SYLLABIC_CATEGORY_AVAGRAHA = OT_Symbol,
|
||||
INDIC_SYLLABIC_CATEGORY_BINDU = OT_SM,
|
||||
INDIC_SYLLABIC_CATEGORY_BRAHMI_JOINING_NUMBER = OT_PLACEHOLDER, /* TODO */
|
||||
INDIC_SYLLABIC_CATEGORY_BRAHMI_JOINING_NUMBER = OT_PLACEHOLDER, /* Don't care. */
|
||||
INDIC_SYLLABIC_CATEGORY_CANTILLATION_MARK = OT_A,
|
||||
INDIC_SYLLABIC_CATEGORY_CONSONANT = OT_C,
|
||||
INDIC_SYLLABIC_CATEGORY_CONSONANT_DEAD = OT_C,
|
||||
INDIC_SYLLABIC_CATEGORY_CONSONANT_FINAL = OT_CM,
|
||||
INDIC_SYLLABIC_CATEGORY_CONSONANT_HEAD_LETTER = OT_C,
|
||||
INDIC_SYLLABIC_CATEGORY_CONSONANT_KILLER = OT_M, /* U+17CD only. */
|
||||
INDIC_SYLLABIC_CATEGORY_CONSONANT_MEDIAL = OT_CM,
|
||||
INDIC_SYLLABIC_CATEGORY_CONSONANT_PLACEHOLDER = OT_PLACEHOLDER,
|
||||
INDIC_SYLLABIC_CATEGORY_CONSONANT_PRECEDING_REPHA = OT_Repha,
|
||||
INDIC_SYLLABIC_CATEGORY_CONSONANT_PREFIXED = OT_X, /* Don't care. */
|
||||
INDIC_SYLLABIC_CATEGORY_CONSONANT_SUBJOINED = OT_CM,
|
||||
INDIC_SYLLABIC_CATEGORY_CONSONANT_SUCCEEDING_REPHA = OT_N,
|
||||
INDIC_SYLLABIC_CATEGORY_CONSONANT_WITH_STACKER = OT_C,
|
||||
INDIC_SYLLABIC_CATEGORY_GEMINATION_MARK = OT_SM,
|
||||
INDIC_SYLLABIC_CATEGORY_INVISIBLE_STACKER = OT_H, /* TODO */
|
||||
INDIC_SYLLABIC_CATEGORY_INVISIBLE_STACKER = OT_Coeng,
|
||||
INDIC_SYLLABIC_CATEGORY_JOINER = OT_ZWJ,
|
||||
INDIC_SYLLABIC_CATEGORY_MODIFYING_LETTER = OT_X,
|
||||
INDIC_SYLLABIC_CATEGORY_NON_JOINER = OT_ZWNJ,
|
||||
INDIC_SYLLABIC_CATEGORY_NUKTA = OT_N,
|
||||
INDIC_SYLLABIC_CATEGORY_NUMBER = OT_PLACEHOLDER,
|
||||
INDIC_SYLLABIC_CATEGORY_NUMBER_JOINER = OT_PLACEHOLDER, /* TODO */
|
||||
INDIC_SYLLABIC_CATEGORY_PURE_KILLER = OT_H, /* TODO */
|
||||
INDIC_SYLLABIC_CATEGORY_NUMBER_JOINER = OT_PLACEHOLDER, /* Don't care. */
|
||||
INDIC_SYLLABIC_CATEGORY_PURE_KILLER = OT_M, /* Is like a vowel matra. */
|
||||
INDIC_SYLLABIC_CATEGORY_REGISTER_SHIFTER = OT_RS,
|
||||
INDIC_SYLLABIC_CATEGORY_SYLLABLE_MODIFIER = OT_SM,
|
||||
INDIC_SYLLABIC_CATEGORY_TONE_LETTER = OT_X,
|
||||
INDIC_SYLLABIC_CATEGORY_TONE_MARK = OT_N,
|
||||
INDIC_SYLLABIC_CATEGORY_VIRAMA = OT_H,
|
||||
|
@ -162,17 +165,23 @@ enum indic_matra_category_t {
|
|||
};
|
||||
|
||||
#define INDIC_COMBINE_CATEGORIES(S,M) \
|
||||
(ASSERT_STATIC_EXPR_ZERO (M == INDIC_MATRA_CATEGORY_NOT_APPLICABLE || \
|
||||
( \
|
||||
S == INDIC_SYLLABIC_CATEGORY_CONSONANT_MEDIAL || \
|
||||
S == INDIC_SYLLABIC_CATEGORY_GEMINATION_MARK || \
|
||||
S == INDIC_SYLLABIC_CATEGORY_REGISTER_SHIFTER || \
|
||||
S == INDIC_SYLLABIC_CATEGORY_CONSONANT_SUCCEEDING_REPHA || \
|
||||
S == INDIC_SYLLABIC_CATEGORY_VIRAMA || \
|
||||
S == INDIC_SYLLABIC_CATEGORY_VOWEL_DEPENDENT || \
|
||||
false)) + \
|
||||
ASSERT_STATIC_EXPR_ZERO (S < 255 && M < 255) + \
|
||||
((M << 8) | S))
|
||||
( \
|
||||
ASSERT_STATIC_EXPR_ZERO (S < 255 && M < 255) + \
|
||||
( S | \
|
||||
( \
|
||||
( \
|
||||
S == INDIC_SYLLABIC_CATEGORY_CONSONANT_MEDIAL || \
|
||||
S == INDIC_SYLLABIC_CATEGORY_GEMINATION_MARK || \
|
||||
S == INDIC_SYLLABIC_CATEGORY_REGISTER_SHIFTER || \
|
||||
S == INDIC_SYLLABIC_CATEGORY_CONSONANT_SUCCEEDING_REPHA || \
|
||||
S == INDIC_SYLLABIC_CATEGORY_VIRAMA || \
|
||||
S == INDIC_SYLLABIC_CATEGORY_VOWEL_DEPENDENT || \
|
||||
false \
|
||||
? M : INDIC_MATRA_CATEGORY_NOT_APPLICABLE \
|
||||
) << 8 \
|
||||
) \
|
||||
) \
|
||||
)
|
||||
|
||||
HB_INTERNAL INDIC_TABLE_ELEMENT_TYPE
|
||||
hb_indic_get_categories (hb_codepoint_t u);
|
||||
|
|
|
@ -2,67 +2,71 @@
|
|||
/*
|
||||
* The following table is generated by running:
|
||||
*
|
||||
* ./gen-indic-table.py IndicSyllabicCategory.txt IndicMatraCategory.txt Blocks.txt
|
||||
* ./gen-indic-table.py IndicSyllabicCategory.txt IndicPositionalCategory.txt Blocks.txt
|
||||
*
|
||||
* on files with these headers:
|
||||
*
|
||||
* # IndicSyllabicCategory-7.0.0.txt
|
||||
* # Date: 2014-06-03, 07:00:00 GMT [KW, LI, AG, RP]
|
||||
* # IndicMatraCategory-7.0.0.txt
|
||||
* # Date: 2014-06-03, 07:00:00 GMT [KW, LI, AG, RP]
|
||||
* # Blocks-7.0.0.txt
|
||||
* # Date: 2014-04-03, 23:23:00 GMT [RP, KW]
|
||||
* # IndicSyllabicCategory-9.0.0.txt
|
||||
* # Date: 2016-05-21, 02:46:00 GMT [RP]
|
||||
* # IndicPositionalCategory-9.0.0.txt
|
||||
* # Date: 2016-02-25, 00:48:00 GMT [RP]
|
||||
* # Blocks-9.0.0.txt
|
||||
* # Date: 2016-02-05, 23:48:00 GMT [KW]
|
||||
*/
|
||||
|
||||
#include "hb-ot-shape-complex-indic-private.hh"
|
||||
|
||||
|
||||
#define ISC_A INDIC_SYLLABIC_CATEGORY_AVAGRAHA /* 13 chars; Avagraha */
|
||||
#define ISC_Bi INDIC_SYLLABIC_CATEGORY_BINDU /* 59 chars; Bindu */
|
||||
#define ISC_A INDIC_SYLLABIC_CATEGORY_AVAGRAHA /* 15 chars; Avagraha */
|
||||
#define ISC_Bi INDIC_SYLLABIC_CATEGORY_BINDU /* 67 chars; Bindu */
|
||||
#define ISC_BJN INDIC_SYLLABIC_CATEGORY_BRAHMI_JOINING_NUMBER /* 20 chars; Brahmi_Joining_Number */
|
||||
#define ISC_Ca INDIC_SYLLABIC_CATEGORY_CANTILLATION_MARK /* 30 chars; Cantillation_Mark */
|
||||
#define ISC_C INDIC_SYLLABIC_CATEGORY_CONSONANT /* 1744 chars; Consonant */
|
||||
#define ISC_CD INDIC_SYLLABIC_CATEGORY_CONSONANT_DEAD /* 7 chars; Consonant_Dead */
|
||||
#define ISC_CF INDIC_SYLLABIC_CATEGORY_CONSONANT_FINAL /* 61 chars; Consonant_Final */
|
||||
#define ISC_Ca INDIC_SYLLABIC_CATEGORY_CANTILLATION_MARK /* 53 chars; Cantillation_Mark */
|
||||
#define ISC_C INDIC_SYLLABIC_CATEGORY_CONSONANT /* 1907 chars; Consonant */
|
||||
#define ISC_CD INDIC_SYLLABIC_CATEGORY_CONSONANT_DEAD /* 10 chars; Consonant_Dead */
|
||||
#define ISC_CF INDIC_SYLLABIC_CATEGORY_CONSONANT_FINAL /* 62 chars; Consonant_Final */
|
||||
#define ISC_CHL INDIC_SYLLABIC_CATEGORY_CONSONANT_HEAD_LETTER /* 5 chars; Consonant_Head_Letter */
|
||||
#define ISC_CM INDIC_SYLLABIC_CATEGORY_CONSONANT_MEDIAL /* 19 chars; Consonant_Medial */
|
||||
#define ISC_CP INDIC_SYLLABIC_CATEGORY_CONSONANT_PLACEHOLDER /* 11 chars; Consonant_Placeholder */
|
||||
#define ISC_CK INDIC_SYLLABIC_CATEGORY_CONSONANT_KILLER /* 2 chars; Consonant_Killer */
|
||||
#define ISC_CM INDIC_SYLLABIC_CATEGORY_CONSONANT_MEDIAL /* 22 chars; Consonant_Medial */
|
||||
#define ISC_CP INDIC_SYLLABIC_CATEGORY_CONSONANT_PLACEHOLDER /* 16 chars; Consonant_Placeholder */
|
||||
#define ISC_CPR INDIC_SYLLABIC_CATEGORY_CONSONANT_PRECEDING_REPHA /* 1 chars; Consonant_Preceding_Repha */
|
||||
#define ISC_CS INDIC_SYLLABIC_CATEGORY_CONSONANT_SUBJOINED /* 61 chars; Consonant_Subjoined */
|
||||
#define ISC_CPrf INDIC_SYLLABIC_CATEGORY_CONSONANT_PREFIXED /* 2 chars; Consonant_Prefixed */
|
||||
#define ISC_CS INDIC_SYLLABIC_CATEGORY_CONSONANT_SUBJOINED /* 90 chars; Consonant_Subjoined */
|
||||
#define ISC_CSR INDIC_SYLLABIC_CATEGORY_CONSONANT_SUCCEEDING_REPHA /* 4 chars; Consonant_Succeeding_Repha */
|
||||
#define ISC_CWS INDIC_SYLLABIC_CATEGORY_CONSONANT_WITH_STACKER /* 4 chars; Consonant_With_Stacker */
|
||||
#define ISC_GM INDIC_SYLLABIC_CATEGORY_GEMINATION_MARK /* 2 chars; Gemination_Mark */
|
||||
#define ISC_IS INDIC_SYLLABIC_CATEGORY_INVISIBLE_STACKER /* 7 chars; Invisible_Stacker */
|
||||
#define ISC_ZWJ INDIC_SYLLABIC_CATEGORY_JOINER /* 1 chars; Joiner */
|
||||
#define ISC_ML INDIC_SYLLABIC_CATEGORY_MODIFYING_LETTER /* 1 chars; Modifying_Letter */
|
||||
#define ISC_ZWNJ INDIC_SYLLABIC_CATEGORY_NON_JOINER /* 1 chars; Non_Joiner */
|
||||
#define ISC_N INDIC_SYLLABIC_CATEGORY_NUKTA /* 18 chars; Nukta */
|
||||
#define ISC_Nd INDIC_SYLLABIC_CATEGORY_NUMBER /* 408 chars; Number */
|
||||
#define ISC_N INDIC_SYLLABIC_CATEGORY_NUKTA /* 24 chars; Nukta */
|
||||
#define ISC_Nd INDIC_SYLLABIC_CATEGORY_NUMBER /* 459 chars; Number */
|
||||
#define ISC_NJ INDIC_SYLLABIC_CATEGORY_NUMBER_JOINER /* 1 chars; Number_Joiner */
|
||||
#define ISC_x INDIC_SYLLABIC_CATEGORY_OTHER /* 1 chars; Other */
|
||||
#define ISC_PK INDIC_SYLLABIC_CATEGORY_PURE_KILLER /* 15 chars; Pure_Killer */
|
||||
#define ISC_RS INDIC_SYLLABIC_CATEGORY_REGISTER_SHIFTER /* 3 chars; Register_Shifter */
|
||||
#define ISC_PK INDIC_SYLLABIC_CATEGORY_PURE_KILLER /* 16 chars; Pure_Killer */
|
||||
#define ISC_RS INDIC_SYLLABIC_CATEGORY_REGISTER_SHIFTER /* 2 chars; Register_Shifter */
|
||||
#define ISC_SM INDIC_SYLLABIC_CATEGORY_SYLLABLE_MODIFIER /* 22 chars; Syllable_Modifier */
|
||||
#define ISC_TL INDIC_SYLLABIC_CATEGORY_TONE_LETTER /* 7 chars; Tone_Letter */
|
||||
#define ISC_TM INDIC_SYLLABIC_CATEGORY_TONE_MARK /* 62 chars; Tone_Mark */
|
||||
#define ISC_V INDIC_SYLLABIC_CATEGORY_VIRAMA /* 22 chars; Virama */
|
||||
#define ISC_Vs INDIC_SYLLABIC_CATEGORY_VISARGA /* 29 chars; Visarga */
|
||||
#define ISC_TM INDIC_SYLLABIC_CATEGORY_TONE_MARK /* 42 chars; Tone_Mark */
|
||||
#define ISC_V INDIC_SYLLABIC_CATEGORY_VIRAMA /* 24 chars; Virama */
|
||||
#define ISC_Vs INDIC_SYLLABIC_CATEGORY_VISARGA /* 31 chars; Visarga */
|
||||
#define ISC_Vo INDIC_SYLLABIC_CATEGORY_VOWEL /* 30 chars; Vowel */
|
||||
#define ISC_M INDIC_SYLLABIC_CATEGORY_VOWEL_DEPENDENT /* 553 chars; Vowel_Dependent */
|
||||
#define ISC_VI INDIC_SYLLABIC_CATEGORY_VOWEL_INDEPENDENT /* 395 chars; Vowel_Independent */
|
||||
#define ISC_M INDIC_SYLLABIC_CATEGORY_VOWEL_DEPENDENT /* 602 chars; Vowel_Dependent */
|
||||
#define ISC_VI INDIC_SYLLABIC_CATEGORY_VOWEL_INDEPENDENT /* 431 chars; Vowel_Independent */
|
||||
|
||||
#define IMC_B INDIC_MATRA_CATEGORY_BOTTOM /* 142 chars; Bottom */
|
||||
#define IMC_B INDIC_MATRA_CATEGORY_BOTTOM /* 300 chars; Bottom */
|
||||
#define IMC_BR INDIC_MATRA_CATEGORY_BOTTOM_AND_RIGHT /* 2 chars; Bottom_And_Right */
|
||||
#define IMC_L INDIC_MATRA_CATEGORY_LEFT /* 57 chars; Left */
|
||||
#define IMC_LR INDIC_MATRA_CATEGORY_LEFT_AND_RIGHT /* 21 chars; Left_And_Right */
|
||||
#define IMC_x INDIC_MATRA_CATEGORY_NOT_APPLICABLE /* 1 chars; Not_Applicable */
|
||||
#define IMC_O INDIC_MATRA_CATEGORY_OVERSTRUCK /* 2 chars; Overstruck */
|
||||
#define IMC_R INDIC_MATRA_CATEGORY_RIGHT /* 163 chars; Right */
|
||||
#define IMC_T INDIC_MATRA_CATEGORY_TOP /* 169 chars; Top */
|
||||
#define IMC_O INDIC_MATRA_CATEGORY_OVERSTRUCK /* 10 chars; Overstruck */
|
||||
#define IMC_R INDIC_MATRA_CATEGORY_RIGHT /* 258 chars; Right */
|
||||
#define IMC_T INDIC_MATRA_CATEGORY_TOP /* 342 chars; Top */
|
||||
#define IMC_TB INDIC_MATRA_CATEGORY_TOP_AND_BOTTOM /* 10 chars; Top_And_Bottom */
|
||||
#define IMC_TBR INDIC_MATRA_CATEGORY_TOP_AND_BOTTOM_AND_RIGHT /* 1 chars; Top_And_Bottom_And_Right */
|
||||
#define IMC_TL INDIC_MATRA_CATEGORY_TOP_AND_LEFT /* 6 chars; Top_And_Left */
|
||||
#define IMC_TLR INDIC_MATRA_CATEGORY_TOP_AND_LEFT_AND_RIGHT /* 4 chars; Top_And_Left_And_Right */
|
||||
#define IMC_TR INDIC_MATRA_CATEGORY_TOP_AND_RIGHT /* 13 chars; Top_And_Right */
|
||||
#define IMC_VOL INDIC_MATRA_CATEGORY_VISUAL_ORDER_LEFT /* 15 chars; Visual_Order_Left */
|
||||
#define IMC_VOL INDIC_MATRA_CATEGORY_VISUAL_ORDER_LEFT /* 19 chars; Visual_Order_Left */
|
||||
|
||||
#define _(S,M) INDIC_COMBINE_CATEGORIES (ISC_##S, IMC_##M)
|
||||
|
||||
|
@ -79,29 +83,33 @@ static const INDIC_TABLE_ELEMENT_TYPE indic_table[] = {
|
|||
/* 0030 */ _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x),
|
||||
/* 0038 */ _(Nd,x), _(Nd,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
|
||||
#define indic_offset_0x00d0u 24
|
||||
#define indic_offset_0x00b0u 24
|
||||
|
||||
|
||||
/* Latin-1 Supplement */
|
||||
|
||||
/* 00B0 */ _(x,x), _(x,x), _(SM,x), _(SM,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* 00B8 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* 00C0 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* 00C8 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* 00D0 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(CP,x),
|
||||
|
||||
#define indic_offset_0x0900u 32
|
||||
#define indic_offset_0x0900u 64
|
||||
|
||||
|
||||
/* Devanagari */
|
||||
|
||||
/* 0900 */ _(Bi,x), _(Bi,x), _(Bi,x), _(Vs,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x),
|
||||
/* 0900 */ _(Bi,T), _(Bi,T), _(Bi,T), _(Vs,R), _(VI,x), _(VI,x), _(VI,x), _(VI,x),
|
||||
/* 0908 */ _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x),
|
||||
/* 0910 */ _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 0918 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 0920 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 0928 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 0930 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 0938 */ _(C,x), _(C,x), _(M,T), _(M,R), _(N,x), _(A,x), _(M,R), _(M,L),
|
||||
/* 0938 */ _(C,x), _(C,x), _(M,T), _(M,R), _(N,B), _(A,x), _(M,R), _(M,L),
|
||||
/* 0940 */ _(M,R), _(M,B), _(M,B), _(M,B), _(M,B), _(M,T), _(M,T), _(M,T),
|
||||
/* 0948 */ _(M,T), _(M,R), _(M,R), _(M,R), _(M,R), _(V,B), _(M,L), _(M,R),
|
||||
/* 0950 */ _(x,x), _(TM,x), _(TM,x), _(x,x), _(x,x), _(M,T), _(M,B), _(M,B),
|
||||
/* 0950 */ _(x,x), _(Ca,T), _(Ca,B), _(x,T), _(x,T), _(M,T), _(M,B), _(M,B),
|
||||
/* 0958 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 0960 */ _(VI,x), _(VI,x), _(M,B), _(M,B), _(x,x), _(x,x), _(Nd,x), _(Nd,x),
|
||||
/* 0968 */ _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x),
|
||||
|
@ -110,14 +118,14 @@ static const INDIC_TABLE_ELEMENT_TYPE indic_table[] = {
|
|||
|
||||
/* Bengali */
|
||||
|
||||
/* 0980 */ _(x,x), _(Bi,x), _(Bi,x), _(Vs,x), _(x,x), _(VI,x), _(VI,x), _(VI,x),
|
||||
/* 0980 */ _(x,x), _(Bi,T), _(Bi,R), _(Vs,R), _(x,x), _(VI,x), _(VI,x), _(VI,x),
|
||||
/* 0988 */ _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(x,x), _(x,x), _(VI,x),
|
||||
/* 0990 */ _(VI,x), _(x,x), _(x,x), _(VI,x), _(VI,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 0998 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 09A0 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 09A8 */ _(C,x), _(x,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 09B0 */ _(C,x), _(x,x), _(C,x), _(x,x), _(x,x), _(x,x), _(C,x), _(C,x),
|
||||
/* 09B8 */ _(C,x), _(C,x), _(x,x), _(x,x), _(N,x), _(A,x), _(M,R), _(M,L),
|
||||
/* 09B8 */ _(C,x), _(C,x), _(x,x), _(x,x), _(N,B), _(A,x), _(M,R), _(M,L),
|
||||
/* 09C0 */ _(M,R), _(M,B), _(M,B), _(M,B), _(M,B), _(x,x), _(x,x), _(M,L),
|
||||
/* 09C8 */ _(M,L), _(x,x), _(x,x), _(M,LR), _(M,LR), _(V,B), _(CD,x), _(x,x),
|
||||
/* 09D0 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(M,R),
|
||||
|
@ -129,33 +137,33 @@ static const INDIC_TABLE_ELEMENT_TYPE indic_table[] = {
|
|||
|
||||
/* Gurmukhi */
|
||||
|
||||
/* 0A00 */ _(x,x), _(Bi,x), _(Bi,x), _(Vs,x), _(x,x), _(VI,x), _(VI,x), _(VI,x),
|
||||
/* 0A00 */ _(x,x), _(Bi,T), _(Bi,T), _(Vs,R), _(x,x), _(VI,x), _(VI,x), _(VI,x),
|
||||
/* 0A08 */ _(VI,x), _(VI,x), _(VI,x), _(x,x), _(x,x), _(x,x), _(x,x), _(VI,x),
|
||||
/* 0A10 */ _(VI,x), _(x,x), _(x,x), _(VI,x), _(VI,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 0A18 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 0A20 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 0A28 */ _(C,x), _(x,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 0A30 */ _(C,x), _(x,x), _(C,x), _(C,x), _(x,x), _(C,x), _(C,x), _(x,x),
|
||||
/* 0A38 */ _(C,x), _(C,x), _(x,x), _(x,x), _(N,x), _(x,x), _(M,R), _(M,L),
|
||||
/* 0A38 */ _(C,x), _(C,x), _(x,x), _(x,x), _(N,B), _(x,x), _(M,R), _(M,L),
|
||||
/* 0A40 */ _(M,R), _(M,B), _(M,B), _(x,x), _(x,x), _(x,x), _(x,x), _(M,T),
|
||||
/* 0A48 */ _(M,T), _(x,x), _(x,x), _(M,T), _(M,T), _(V,B), _(x,x), _(x,x),
|
||||
/* 0A50 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* 0A58 */ _(x,x), _(C,x), _(C,x), _(C,x), _(C,x), _(x,x), _(C,x), _(x,x),
|
||||
/* 0A60 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(Nd,x), _(Nd,x),
|
||||
/* 0A68 */ _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x),
|
||||
/* 0A70 */ _(Bi,x), _(GM,T), _(CP,x), _(CP,x), _(x,x), _(CM,x), _(x,x), _(x,x),
|
||||
/* 0A70 */ _(Bi,T), _(GM,T), _(CP,x), _(CP,x), _(x,x), _(CM,B), _(x,x), _(x,x),
|
||||
/* 0A78 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
|
||||
/* Gujarati */
|
||||
|
||||
/* 0A80 */ _(x,x), _(Bi,x), _(Bi,x), _(Vs,x), _(x,x), _(VI,x), _(VI,x), _(VI,x),
|
||||
/* 0A80 */ _(x,x), _(Bi,T), _(Bi,T), _(Vs,R), _(x,x), _(VI,x), _(VI,x), _(VI,x),
|
||||
/* 0A88 */ _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(x,x), _(VI,x),
|
||||
/* 0A90 */ _(VI,x), _(VI,x), _(x,x), _(VI,x), _(VI,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 0A98 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 0AA0 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 0AA8 */ _(C,x), _(x,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 0AB0 */ _(C,x), _(x,x), _(C,x), _(C,x), _(x,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 0AB8 */ _(C,x), _(C,x), _(x,x), _(x,x), _(N,x), _(A,x), _(M,R), _(M,L),
|
||||
/* 0AB8 */ _(C,x), _(C,x), _(x,x), _(x,x), _(N,B), _(A,x), _(M,R), _(M,L),
|
||||
/* 0AC0 */ _(M,R), _(M,B), _(M,B), _(M,B), _(M,B), _(M,T), _(x,x), _(M,T),
|
||||
/* 0AC8 */ _(M,T), _(M,TR), _(x,x), _(M,R), _(M,R), _(V,B), _(x,x), _(x,x),
|
||||
/* 0AD0 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
|
@ -163,18 +171,18 @@ static const INDIC_TABLE_ELEMENT_TYPE indic_table[] = {
|
|||
/* 0AE0 */ _(VI,x), _(VI,x), _(M,B), _(M,B), _(x,x), _(x,x), _(Nd,x), _(Nd,x),
|
||||
/* 0AE8 */ _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x),
|
||||
/* 0AF0 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* 0AF8 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* 0AF8 */ _(x,x), _(C,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
|
||||
/* Oriya */
|
||||
|
||||
/* 0B00 */ _(x,x), _(Bi,x), _(Bi,x), _(Vs,x), _(x,x), _(VI,x), _(VI,x), _(VI,x),
|
||||
/* 0B00 */ _(x,x), _(Bi,T), _(Bi,R), _(Vs,R), _(x,x), _(VI,x), _(VI,x), _(VI,x),
|
||||
/* 0B08 */ _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(x,x), _(x,x), _(VI,x),
|
||||
/* 0B10 */ _(VI,x), _(x,x), _(x,x), _(VI,x), _(VI,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 0B18 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 0B20 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 0B28 */ _(C,x), _(x,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 0B30 */ _(C,x), _(x,x), _(C,x), _(C,x), _(x,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 0B38 */ _(C,x), _(C,x), _(x,x), _(x,x), _(N,x), _(A,x), _(M,R), _(M,T),
|
||||
/* 0B38 */ _(C,x), _(C,x), _(x,x), _(x,x), _(N,B), _(A,x), _(M,R), _(M,T),
|
||||
/* 0B40 */ _(M,R), _(M,B), _(M,B), _(M,B), _(M,B), _(x,x), _(x,x), _(M,L),
|
||||
/* 0B48 */ _(M,TL), _(x,x), _(x,x), _(M,LR),_(M,TLR), _(V,B), _(x,x), _(x,x),
|
||||
/* 0B50 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(M,T), _(M,TR),
|
||||
|
@ -186,7 +194,7 @@ static const INDIC_TABLE_ELEMENT_TYPE indic_table[] = {
|
|||
|
||||
/* Tamil */
|
||||
|
||||
/* 0B80 */ _(x,x), _(x,x), _(Bi,x), _(ML,x), _(x,x), _(VI,x), _(VI,x), _(VI,x),
|
||||
/* 0B80 */ _(x,x), _(x,x), _(Bi,T), _(ML,x), _(x,x), _(VI,x), _(VI,x), _(VI,x),
|
||||
/* 0B88 */ _(VI,x), _(VI,x), _(VI,x), _(x,x), _(x,x), _(x,x), _(VI,x), _(VI,x),
|
||||
/* 0B90 */ _(VI,x), _(x,x), _(VI,x), _(VI,x), _(VI,x), _(C,x), _(x,x), _(x,x),
|
||||
/* 0B98 */ _(x,x), _(C,x), _(C,x), _(x,x), _(C,x), _(x,x), _(C,x), _(C,x),
|
||||
|
@ -194,7 +202,7 @@ static const INDIC_TABLE_ELEMENT_TYPE indic_table[] = {
|
|||
/* 0BA8 */ _(C,x), _(C,x), _(C,x), _(x,x), _(x,x), _(x,x), _(C,x), _(C,x),
|
||||
/* 0BB0 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 0BB8 */ _(C,x), _(C,x), _(x,x), _(x,x), _(x,x), _(x,x), _(M,R), _(M,R),
|
||||
/* 0BC0 */ _(M,T), _(M,B), _(M,B), _(x,x), _(x,x), _(x,x), _(M,L), _(M,L),
|
||||
/* 0BC0 */ _(M,T), _(M,R), _(M,R), _(x,x), _(x,x), _(x,x), _(M,L), _(M,L),
|
||||
/* 0BC8 */ _(M,L), _(x,x), _(M,LR), _(M,LR), _(M,LR), _(V,T), _(x,x), _(x,x),
|
||||
/* 0BD0 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(M,R),
|
||||
/* 0BD8 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
|
@ -205,7 +213,7 @@ static const INDIC_TABLE_ELEMENT_TYPE indic_table[] = {
|
|||
|
||||
/* Telugu */
|
||||
|
||||
/* 0C00 */ _(Bi,x), _(Bi,x), _(Bi,x), _(Vs,x), _(x,x), _(VI,x), _(VI,x), _(VI,x),
|
||||
/* 0C00 */ _(Bi,T), _(Bi,R), _(Bi,R), _(Vs,R), _(x,x), _(VI,x), _(VI,x), _(VI,x),
|
||||
/* 0C08 */ _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(x,x), _(VI,x), _(VI,x),
|
||||
/* 0C10 */ _(VI,x), _(x,x), _(VI,x), _(VI,x), _(VI,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 0C18 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
|
@ -216,7 +224,7 @@ static const INDIC_TABLE_ELEMENT_TYPE indic_table[] = {
|
|||
/* 0C40 */ _(M,T), _(M,R), _(M,R), _(M,R), _(M,R), _(x,x), _(M,T), _(M,T),
|
||||
/* 0C48 */ _(M,TB), _(x,x), _(M,T), _(M,T), _(M,T), _(V,T), _(x,x), _(x,x),
|
||||
/* 0C50 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(M,T), _(M,B), _(x,x),
|
||||
/* 0C58 */ _(C,x), _(C,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* 0C58 */ _(C,x), _(C,x), _(C,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* 0C60 */ _(VI,x), _(VI,x), _(M,B), _(M,B), _(x,x), _(x,x), _(Nd,x), _(Nd,x),
|
||||
/* 0C68 */ _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x),
|
||||
/* 0C70 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
|
@ -224,26 +232,26 @@ static const INDIC_TABLE_ELEMENT_TYPE indic_table[] = {
|
|||
|
||||
/* Kannada */
|
||||
|
||||
/* 0C80 */ _(x,x), _(Bi,x), _(Bi,x), _(Vs,x), _(x,x), _(VI,x), _(VI,x), _(VI,x),
|
||||
/* 0C80 */ _(x,x), _(Bi,T), _(Bi,R), _(Vs,R), _(x,x), _(VI,x), _(VI,x), _(VI,x),
|
||||
/* 0C88 */ _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(x,x), _(VI,x), _(VI,x),
|
||||
/* 0C90 */ _(VI,x), _(x,x), _(VI,x), _(VI,x), _(VI,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 0C98 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 0CA0 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 0CA8 */ _(C,x), _(x,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 0CB0 */ _(C,x), _(C,x), _(C,x), _(C,x), _(x,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 0CB8 */ _(C,x), _(C,x), _(x,x), _(x,x), _(N,x), _(A,x), _(M,R), _(M,T),
|
||||
/* 0CB8 */ _(C,x), _(C,x), _(x,x), _(x,x), _(N,B), _(A,x), _(M,R), _(M,T),
|
||||
/* 0CC0 */ _(M,TR), _(M,R), _(M,R), _(M,R), _(M,R), _(x,x), _(M,T), _(M,TR),
|
||||
/* 0CC8 */ _(M,TR), _(x,x), _(M,TR), _(M,TR), _(M,T), _(V,T), _(x,x), _(x,x),
|
||||
/* 0CD0 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(M,R), _(M,R), _(x,x),
|
||||
/* 0CD8 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(C,x), _(x,x),
|
||||
/* 0CE0 */ _(VI,x), _(VI,x), _(M,B), _(M,B), _(x,x), _(x,x), _(Nd,x), _(Nd,x),
|
||||
/* 0CE8 */ _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x),
|
||||
/* 0CF0 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* 0CF0 */ _(x,x),_(CWS,x),_(CWS,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* 0CF8 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
|
||||
/* Malayalam */
|
||||
|
||||
/* 0D00 */ _(x,x), _(Bi,x), _(Bi,x), _(Vs,x), _(x,x), _(VI,x), _(VI,x), _(VI,x),
|
||||
/* 0D00 */ _(x,x), _(Bi,T), _(Bi,R), _(Vs,R), _(x,x), _(VI,x), _(VI,x), _(VI,x),
|
||||
/* 0D08 */ _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(x,x), _(VI,x), _(VI,x),
|
||||
/* 0D10 */ _(VI,x), _(x,x), _(VI,x), _(VI,x), _(VI,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 0D18 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
|
@ -253,8 +261,8 @@ static const INDIC_TABLE_ELEMENT_TYPE indic_table[] = {
|
|||
/* 0D38 */ _(C,x), _(C,x), _(C,x), _(x,x), _(x,x), _(A,x), _(M,R), _(M,R),
|
||||
/* 0D40 */ _(M,R), _(M,R), _(M,R), _(M,B), _(M,B), _(x,x), _(M,L), _(M,L),
|
||||
/* 0D48 */ _(M,L), _(x,x), _(M,LR), _(M,LR), _(M,LR), _(V,T),_(CPR,x), _(x,x),
|
||||
/* 0D50 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(M,R),
|
||||
/* 0D58 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* 0D50 */ _(x,x), _(x,x), _(x,x), _(x,x), _(CD,x), _(CD,x), _(CD,x), _(M,R),
|
||||
/* 0D58 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(VI,x),
|
||||
/* 0D60 */ _(VI,x), _(VI,x), _(M,B), _(M,B), _(x,x), _(x,x), _(Nd,x), _(Nd,x),
|
||||
/* 0D68 */ _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x),
|
||||
/* 0D70 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
|
@ -262,7 +270,7 @@ static const INDIC_TABLE_ELEMENT_TYPE indic_table[] = {
|
|||
|
||||
/* Sinhala */
|
||||
|
||||
/* 0D80 */ _(x,x), _(x,x), _(Bi,x), _(Vs,x), _(x,x), _(VI,x), _(VI,x), _(VI,x),
|
||||
/* 0D80 */ _(x,x), _(x,x), _(Bi,R), _(Vs,R), _(x,x), _(VI,x), _(VI,x), _(VI,x),
|
||||
/* 0D88 */ _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x),
|
||||
/* 0D90 */ _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(x,x),
|
||||
/* 0D98 */ _(x,x), _(x,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
|
@ -278,7 +286,7 @@ static const INDIC_TABLE_ELEMENT_TYPE indic_table[] = {
|
|||
/* 0DE8 */ _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x),
|
||||
/* 0DF0 */ _(x,x), _(x,x), _(M,R), _(M,R), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
|
||||
#define indic_offset_0x1000u 1304
|
||||
#define indic_offset_0x1000u 1336
|
||||
|
||||
|
||||
/* Myanmar */
|
||||
|
@ -289,52 +297,24 @@ static const INDIC_TABLE_ELEMENT_TYPE indic_table[] = {
|
|||
/* 1018 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 1020 */ _(C,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x),
|
||||
/* 1028 */ _(VI,x), _(VI,x), _(VI,x), _(M,R), _(M,R), _(M,T), _(M,T), _(M,B),
|
||||
/* 1030 */ _(M,B), _(M,L), _(M,T), _(M,T), _(M,T), _(M,T), _(Bi,x), _(TM,x),
|
||||
/* 1038 */ _(Vs,x), _(IS,x), _(PK,T), _(CM,x), _(CM,x), _(CM,x), _(CM,x), _(C,x),
|
||||
/* 1030 */ _(M,B), _(M,L), _(M,T), _(M,T), _(M,T), _(M,T), _(Bi,T), _(TM,B),
|
||||
/* 1038 */ _(Vs,R), _(IS,x), _(PK,T), _(CM,R), _(CM,x), _(CM,B), _(CM,B), _(C,x),
|
||||
/* 1040 */ _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x),
|
||||
/* 1048 */ _(Nd,x), _(Nd,x), _(x,x), _(x,x), _(x,x), _(x,x), _(CP,x), _(x,x),
|
||||
/* 1050 */ _(C,x), _(C,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(M,R), _(M,R),
|
||||
/* 1058 */ _(M,B), _(M,B), _(C,x), _(C,x), _(C,x), _(C,x), _(CM,x), _(CM,x),
|
||||
/* 1060 */ _(CM,x), _(C,x), _(M,R), _(TM,x), _(TM,x), _(C,x), _(C,x), _(M,R),
|
||||
/* 1068 */ _(M,R), _(TM,x), _(TM,x), _(TM,x), _(TM,x), _(TM,x), _(C,x), _(C,x),
|
||||
/* 1058 */ _(M,B), _(M,B), _(C,x), _(C,x), _(C,x), _(C,x), _(CM,B), _(CM,B),
|
||||
/* 1060 */ _(CM,B), _(C,x), _(M,R), _(TM,R), _(TM,R), _(C,x), _(C,x), _(M,R),
|
||||
/* 1068 */ _(M,R), _(TM,R), _(TM,R), _(TM,R), _(TM,R), _(TM,R), _(C,x), _(C,x),
|
||||
/* 1070 */ _(C,x), _(M,T), _(M,T), _(M,T), _(M,T), _(C,x), _(C,x), _(C,x),
|
||||
/* 1078 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 1080 */ _(C,x), _(C,x), _(CM,x), _(M,R), _(M,L), _(M,T), _(M,T), _(TM,x),
|
||||
/* 1088 */ _(TM,x), _(TM,x), _(TM,x), _(TM,x), _(TM,x), _(TM,x), _(C,x), _(TM,x),
|
||||
/* 1080 */ _(C,x), _(C,x), _(CM,B), _(M,R), _(M,L), _(M,T), _(M,T), _(TM,R),
|
||||
/* 1088 */ _(TM,R), _(TM,R), _(TM,R), _(TM,R), _(TM,R), _(TM,B), _(C,x), _(TM,R),
|
||||
/* 1090 */ _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x),
|
||||
/* 1098 */ _(Nd,x), _(Nd,x), _(TM,x), _(TM,x), _(M,R), _(M,T), _(x,x), _(x,x),
|
||||
/* 1098 */ _(Nd,x), _(Nd,x), _(TM,R), _(TM,R), _(M,R), _(M,T), _(x,x), _(x,x),
|
||||
|
||||
#define indic_offset_0x1700u 1464
|
||||
#define indic_offset_0x1780u 1496
|
||||
|
||||
|
||||
/* Tagalog */
|
||||
|
||||
/* 1700 */ _(VI,x), _(VI,x), _(VI,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 1708 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(x,x), _(C,x), _(C,x),
|
||||
/* 1710 */ _(C,x), _(C,x), _(M,T), _(M,B), _(PK,B), _(x,x), _(x,x), _(x,x),
|
||||
/* 1718 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
|
||||
/* Hanunoo */
|
||||
|
||||
/* 1720 */ _(VI,x), _(VI,x), _(VI,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 1728 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 1730 */ _(C,x), _(C,x), _(M,T), _(M,B), _(PK,B), _(x,x), _(x,x), _(x,x),
|
||||
/* 1738 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
|
||||
/* Buhid */
|
||||
|
||||
/* 1740 */ _(VI,x), _(VI,x), _(VI,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 1748 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 1750 */ _(C,x), _(C,x), _(M,T), _(M,B), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* 1758 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
|
||||
/* Tagbanwa */
|
||||
|
||||
/* 1760 */ _(VI,x), _(VI,x), _(VI,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 1768 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(x,x), _(C,x), _(C,x),
|
||||
/* 1770 */ _(C,x), _(x,x), _(M,T), _(M,B), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* 1778 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
|
||||
/* Khmer */
|
||||
|
||||
/* 1780 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
|
@ -345,515 +325,72 @@ static const INDIC_TABLE_ELEMENT_TYPE indic_table[] = {
|
|||
/* 17A8 */ _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x),
|
||||
/* 17B0 */ _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(x,x), _(x,x), _(M,R), _(M,T),
|
||||
/* 17B8 */ _(M,T), _(M,T), _(M,T), _(M,B), _(M,B), _(M,B), _(M,TL),_(M,TLR),
|
||||
/* 17C0 */ _(M,LR), _(M,L), _(M,L), _(M,L), _(M,LR), _(M,LR), _(Bi,x), _(Vs,x),
|
||||
/* 17C8 */ _(M,R), _(RS,T), _(RS,T), _(RS,T),_(CSR,T), _(M,T), _(M,T), _(M,T),
|
||||
/* 17D0 */ _(M,T), _(PK,T), _(IS,x), _(M,T), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* 17D8 */ _(x,x), _(x,x), _(x,x), _(x,x), _(A,x), _(x,x), _(x,x), _(x,x),
|
||||
/* 17C0 */ _(M,LR), _(M,L), _(M,L), _(M,L), _(M,LR), _(M,LR), _(Bi,T), _(Vs,R),
|
||||
/* 17C8 */ _(M,R), _(RS,T), _(RS,T), _(SM,T),_(CSR,T), _(CK,T), _(SM,T), _(SM,T),
|
||||
/* 17D0 */ _(SM,T), _(PK,T), _(IS,x), _(SM,T), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* 17D8 */ _(x,x), _(x,x), _(x,x), _(x,x), _(A,x), _(SM,T), _(x,x), _(x,x),
|
||||
/* 17E0 */ _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x),
|
||||
/* 17E8 */ _(Nd,x), _(Nd,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
|
||||
#define indic_offset_0x1900u 1704
|
||||
|
||||
|
||||
/* Limbu */
|
||||
|
||||
/* 1900 */ _(CP,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 1908 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 1910 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 1918 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(x,x),
|
||||
/* 1920 */ _(M,T), _(M,T), _(M,B), _(M,R), _(M,R), _(M,TR), _(M,TR), _(M,T),
|
||||
/* 1928 */ _(M,T), _(CS,x), _(CS,x), _(CS,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* 1930 */ _(CF,x), _(CF,x), _(Bi,x), _(CF,x), _(CF,x), _(CF,x), _(CF,x), _(CF,x),
|
||||
/* 1938 */ _(CF,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* 1940 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(Nd,x), _(Nd,x),
|
||||
/* 1948 */ _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x),
|
||||
|
||||
/* Tai Le */
|
||||
|
||||
/* 1950 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 1958 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 1960 */ _(C,x), _(C,x), _(C,x), _(Vo,x), _(Vo,x), _(Vo,x), _(Vo,x), _(Vo,x),
|
||||
/* 1968 */ _(Vo,x), _(Vo,x), _(Vo,x), _(Vo,x), _(Vo,x), _(Vo,x), _(x,x), _(x,x),
|
||||
/* 1970 */ _(TL,x), _(TL,x), _(TL,x), _(TL,x), _(TL,x), _(x,x), _(x,x), _(x,x),
|
||||
/* 1978 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
|
||||
/* New Tai Lue */
|
||||
|
||||
/* 1980 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 1988 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 1990 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 1998 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 19A0 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 19A8 */ _(C,x), _(C,x), _(C,x), _(C,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* 19B0 */ _(M,R), _(M,R), _(M,R), _(M,R), _(M,R), _(M,L), _(M,L), _(M,L),
|
||||
/* 19B8 */ _(M,R), _(M,R), _(M,L), _(M,R), _(M,R), _(M,R), _(M,R), _(M,R),
|
||||
/* 19C0 */ _(M,R), _(CF,x), _(CF,x), _(CF,x), _(CF,x), _(CF,x), _(CF,x), _(CF,x),
|
||||
/* 19C8 */ _(TM,x), _(TM,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* 19D0 */ _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x),
|
||||
/* 19D8 */ _(Nd,x), _(Nd,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* 19E0 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* 19E8 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* 19F0 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* 19F8 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
|
||||
/* Buginese */
|
||||
|
||||
/* 1A00 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 1A08 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 1A10 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(M,T),
|
||||
/* 1A18 */ _(M,B), _(M,L), _(M,R), _(M,T), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
|
||||
/* Tai Tham */
|
||||
|
||||
/* 1A20 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 1A28 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 1A30 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 1A38 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 1A40 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 1A48 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(VI,x), _(VI,x), _(VI,x),
|
||||
/* 1A50 */ _(VI,x), _(VI,x), _(VI,x), _(C,x), _(C,x), _(CM,L), _(CM,x), _(CF,x),
|
||||
/* 1A58 */ _(CF,x), _(CF,x), _(CF,x), _(CF,x), _(CF,x), _(CF,x), _(CF,x), _(x,x),
|
||||
/* 1A60 */ _(IS,x), _(M,R), _(M,T), _(M,R), _(M,R), _(M,T), _(M,T), _(M,T),
|
||||
/* 1A68 */ _(M,T), _(M,B), _(M,B), _(M,T), _(M,B), _(M,R), _(M,L), _(M,L),
|
||||
/* 1A70 */ _(M,L), _(M,L), _(M,L), _(M,T), _(M,T), _(TM,x), _(TM,x), _(TM,x),
|
||||
/* 1A78 */ _(TM,x), _(TM,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* 1A80 */ _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x),
|
||||
/* 1A88 */ _(Nd,x), _(Nd,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* 1A90 */ _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x),
|
||||
/* 1A98 */ _(Nd,x), _(Nd,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
|
||||
#define indic_offset_0x1b00u 2120
|
||||
|
||||
|
||||
/* Balinese */
|
||||
|
||||
/* 1B00 */ _(Bi,x), _(Bi,x), _(Bi,x),_(CSR,x), _(Vs,x), _(VI,x), _(VI,x), _(VI,x),
|
||||
/* 1B08 */ _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x),
|
||||
/* 1B10 */ _(VI,x), _(VI,x), _(VI,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 1B18 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 1B20 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 1B28 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 1B30 */ _(C,x), _(C,x), _(C,x), _(C,x), _(N,x), _(M,R), _(M,T), _(M,T),
|
||||
/* 1B38 */ _(M,B), _(M,B), _(M,B), _(M,BR), _(M,TB),_(M,TBR), _(M,L), _(M,L),
|
||||
/* 1B40 */ _(M,LR), _(M,LR), _(M,T), _(M,TR), _(V,R), _(C,x), _(C,x), _(C,x),
|
||||
/* 1B48 */ _(C,x), _(C,x), _(C,x), _(C,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* 1B50 */ _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x),
|
||||
/* 1B58 */ _(Nd,x), _(Nd,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* 1B60 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* 1B68 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* 1B70 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* 1B78 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
|
||||
/* Sundanese */
|
||||
|
||||
/* 1B80 */ _(Bi,x),_(CSR,x), _(Vs,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x),
|
||||
/* 1B88 */ _(VI,x), _(VI,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 1B90 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 1B98 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 1BA0 */ _(C,x), _(CS,x), _(CS,x), _(CS,x), _(M,T), _(M,B), _(M,L), _(M,R),
|
||||
/* 1BA8 */ _(M,T), _(M,T), _(PK,R), _(IS,x), _(CS,x), _(CS,x), _(C,x), _(C,x),
|
||||
/* 1BB0 */ _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x),
|
||||
/* 1BB8 */ _(Nd,x), _(Nd,x), _(A,x), _(C,x), _(C,x), _(C,x), _(CF,x), _(CF,x),
|
||||
|
||||
/* Batak */
|
||||
|
||||
/* 1BC0 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 1BC8 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 1BD0 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 1BD8 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 1BE0 */ _(C,x), _(C,x), _(C,x), _(C,x), _(VI,x), _(VI,x), _(N,x), _(M,R),
|
||||
/* 1BE8 */ _(M,T), _(M,T), _(M,R), _(M,R), _(M,R), _(M,T), _(M,R), _(M,T),
|
||||
/* 1BF0 */ _(CF,x), _(CF,x), _(PK,R), _(PK,R), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* 1BF8 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
|
||||
/* Lepcha */
|
||||
|
||||
/* 1C00 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 1C08 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 1C10 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 1C18 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 1C20 */ _(C,x), _(C,x), _(C,x), _(C,x), _(CS,x), _(CS,x), _(M,R), _(M,L),
|
||||
/* 1C28 */ _(M,L), _(M,TL), _(M,R), _(M,R), _(M,B), _(CF,x), _(CF,x), _(CF,x),
|
||||
/* 1C30 */ _(CF,x), _(CF,x), _(CF,x), _(CF,x), _(Bi,L), _(Bi,L), _(x,x), _(N,x),
|
||||
/* 1C38 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* 1C40 */ _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x),
|
||||
/* 1C48 */ _(Nd,x), _(Nd,x), _(x,x), _(x,x), _(x,x), _(C,x), _(C,x), _(C,x),
|
||||
|
||||
#define indic_offset_0x1cd0u 2456
|
||||
#define indic_offset_0x1cd0u 1608
|
||||
|
||||
|
||||
/* Vedic Extensions */
|
||||
|
||||
/* 1CD0 */ _(TM,x), _(TM,x), _(TM,x), _(x,x), _(TM,x), _(TM,x), _(TM,x), _(TM,x),
|
||||
/* 1CD8 */ _(TM,x), _(TM,x), _(TM,x), _(TM,x), _(TM,x), _(TM,x), _(TM,x), _(TM,x),
|
||||
/* 1CE0 */ _(TM,x), _(TM,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* 1CE8 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* 1CF0 */ _(x,x), _(x,x), _(Vs,x), _(Vs,x), _(TM,x), _(x,x), _(x,x), _(x,x),
|
||||
/* 1CD0 */ _(Ca,T), _(Ca,T), _(Ca,T), _(x,x), _(Ca,O), _(Ca,B), _(Ca,B), _(Ca,B),
|
||||
/* 1CD8 */ _(Ca,B), _(Ca,B), _(Ca,T), _(Ca,T), _(Ca,B), _(Ca,B), _(Ca,B), _(Ca,B),
|
||||
/* 1CE0 */ _(Ca,T), _(Ca,R), _(x,O), _(x,O), _(x,O), _(x,O), _(x,O), _(x,O),
|
||||
/* 1CE8 */ _(x,O), _(x,x), _(x,x), _(x,x), _(x,x), _(x,B), _(x,x), _(x,x),
|
||||
/* 1CF0 */ _(x,x), _(x,x), _(Vs,x), _(Vs,x), _(Ca,T), _(x,x), _(x,x), _(x,x),
|
||||
/* 1CF8 */ _(Ca,x), _(Ca,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
|
||||
#define indic_offset_0x2008u 2496
|
||||
#define indic_offset_0x2008u 1656
|
||||
|
||||
|
||||
/* General Punctuation */
|
||||
|
||||
/* 2008 */ _(x,x), _(x,x), _(x,x), _(x,x),_(ZWNJ,x),_(ZWJ,x), _(x,x), _(x,x),
|
||||
/* 2010 */ _(x,x), _(x,x), _(CP,x), _(CP,x), _(CP,x), _(x,x), _(x,x), _(x,x),
|
||||
/* 2010 */ _(CP,x), _(CP,x), _(CP,x), _(CP,x), _(CP,x), _(x,x), _(x,x), _(x,x),
|
||||
|
||||
#define indic_offset_0xa800u 2512
|
||||
#define indic_offset_0x2070u 1672
|
||||
|
||||
|
||||
/* Syloti Nagri */
|
||||
/* Superscripts and Subscripts */
|
||||
|
||||
/* A800 */ _(VI,x), _(VI,x), _(x,x), _(VI,x), _(VI,x), _(VI,x), _(PK,T), _(C,x),
|
||||
/* A808 */ _(C,x), _(C,x), _(C,x), _(Bi,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* A810 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* A818 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* A820 */ _(C,x), _(C,x), _(C,x), _(M,R), _(M,R), _(M,B), _(M,T), _(M,R),
|
||||
/* A828 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* A830 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* A838 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* 2070 */ _(x,x), _(x,x), _(x,x), _(x,x), _(SM,x), _(x,x), _(x,x), _(x,x),
|
||||
/* 2078 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* 2080 */ _(x,x), _(x,x), _(SM,x), _(SM,x), _(SM,x), _(x,x), _(x,x), _(x,x),
|
||||
|
||||
/* Phags-pa */
|
||||
#define indic_offset_0xa8e0u 1696
|
||||
|
||||
/* A840 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* A848 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* A850 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* A858 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(Vo,x), _(Vo,x),
|
||||
/* A860 */ _(Vo,x), _(Vo,x), _(C,x), _(C,x), _(C,x), _(C,x), _(Vo,x), _(CS,x),
|
||||
/* A868 */ _(CS,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* A870 */ _(C,x), _(CS,x), _(C,x), _(Bi,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* A878 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
|
||||
/* Saurashtra */
|
||||
|
||||
/* A880 */ _(Bi,x), _(Vs,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x),
|
||||
/* A888 */ _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x),
|
||||
/* A890 */ _(VI,x), _(VI,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* A898 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* A8A0 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* A8A8 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* A8B0 */ _(C,x), _(C,x), _(C,x), _(C,x), _(CF,x), _(M,R), _(M,R), _(M,R),
|
||||
/* A8B8 */ _(M,R), _(M,R), _(M,R), _(M,R), _(M,R), _(M,R), _(M,R), _(M,R),
|
||||
/* A8C0 */ _(M,R), _(M,R), _(M,R), _(M,R), _(V,B), _(x,x), _(x,x), _(x,x),
|
||||
/* A8C8 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* A8D0 */ _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x),
|
||||
/* A8D8 */ _(Nd,x), _(Nd,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
|
||||
/* Devanagari Extended */
|
||||
|
||||
/* A8E0 */ _(Ca,x), _(Ca,x), _(Ca,x), _(Ca,x), _(Ca,x), _(Ca,x), _(Ca,x), _(Ca,x),
|
||||
/* A8E8 */ _(Ca,x), _(Ca,x), _(Ca,x), _(Ca,x), _(Ca,x), _(Ca,x), _(Ca,x), _(Ca,x),
|
||||
/* A8F0 */ _(Ca,x), _(Ca,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* A8F8 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* A8E0 */ _(Ca,T), _(Ca,T), _(Ca,T), _(Ca,T), _(Ca,T), _(Ca,T), _(Ca,T), _(Ca,T),
|
||||
/* A8E8 */ _(Ca,T), _(Ca,T), _(Ca,T), _(Ca,T), _(Ca,T), _(Ca,T), _(Ca,T), _(Ca,T),
|
||||
/* A8F0 */ _(Ca,T), _(Ca,T), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
|
||||
/* Kayah Li */
|
||||
#define indic_offset_0xa9e0u 1720
|
||||
|
||||
/* A900 */ _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x),
|
||||
/* A908 */ _(Nd,x), _(Nd,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* A910 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* A918 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* A920 */ _(C,x), _(C,x), _(Vo,x), _(Vo,x), _(Vo,x), _(Vo,x), _(Vo,x), _(Vo,x),
|
||||
/* A928 */ _(Vo,x), _(Vo,x), _(Vo,x), _(TM,x), _(TM,x), _(TM,x), _(x,x), _(x,x),
|
||||
|
||||
/* Rejang */
|
||||
|
||||
/* A930 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* A938 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* A940 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(M,B),
|
||||
/* A948 */ _(M,B), _(M,B), _(M,T), _(M,B), _(M,B), _(M,B), _(M,B), _(CF,x),
|
||||
/* A950 */ _(CF,x), _(CF,x), _(CF,x), _(PK,R), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* A958 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* A960 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* A968 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* A970 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* A978 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
|
||||
/* Javanese */
|
||||
|
||||
/* A980 */ _(Bi,x), _(Bi,x),_(CSR,x), _(Vs,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x),
|
||||
/* A988 */ _(VI,x), _(C,x), _(C,x), _(C,x), _(VI,x), _(VI,x), _(VI,x), _(C,x),
|
||||
/* A990 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* A998 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* A9A0 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* A9A8 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* A9B0 */ _(C,x), _(C,x), _(C,x), _(N,x), _(M,R), _(M,R), _(M,T), _(M,T),
|
||||
/* A9B8 */ _(M,B), _(M,B), _(M,L), _(M,L), _(M,T), _(CS,x), _(CM,x), _(CM,x),
|
||||
/* A9C0 */ _(V,BR), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* A9C8 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* A9D0 */ _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x),
|
||||
/* A9D8 */ _(Nd,x), _(Nd,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
|
||||
/* Myanmar Extended-B */
|
||||
|
||||
/* A9E0 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(x,x), _(x,x), _(C,x),
|
||||
/* A9E0 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(M,T), _(x,x), _(C,x),
|
||||
/* A9E8 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* A9F0 */ _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x),
|
||||
/* A9F8 */ _(Nd,x), _(Nd,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(x,x),
|
||||
|
||||
/* Cham */
|
||||
#define indic_offset_0xaa60u 1752
|
||||
|
||||
/* AA00 */ _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(C,x), _(C,x),
|
||||
/* AA08 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* AA10 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* AA18 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* AA20 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* AA28 */ _(C,x), _(M,T), _(M,T), _(M,T), _(M,T), _(M,B), _(M,T), _(M,L),
|
||||
/* AA30 */ _(M,L), _(M,T), _(M,B), _(CM,x), _(CM,L), _(CM,x), _(CM,x), _(x,x),
|
||||
/* AA38 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* AA40 */ _(CF,x), _(CF,x), _(CF,x), _(CF,x), _(CF,x), _(CF,x), _(CF,x), _(CF,x),
|
||||
/* AA48 */ _(CF,x), _(CF,x), _(CF,x), _(CF,x), _(CF,x), _(CF,x), _(x,x), _(x,x),
|
||||
/* AA50 */ _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x),
|
||||
/* AA58 */ _(Nd,x), _(Nd,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
|
||||
/* Myanmar Extended-A */
|
||||
|
||||
/* AA60 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* AA68 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* AA70 */ _(x,x), _(C,x), _(C,x), _(C,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* AA78 */ _(x,x), _(x,x), _(C,x), _(TM,x), _(TM,x), _(TM,x), _(C,x), _(C,x),
|
||||
/* AA70 */ _(x,x), _(C,x), _(C,x), _(C,x), _(CP,x), _(CP,x), _(CP,x), _(x,x),
|
||||
/* AA78 */ _(x,x), _(x,x), _(C,x), _(TM,R), _(TM,T), _(TM,R), _(C,x), _(C,x),
|
||||
|
||||
/* Tai Viet */
|
||||
|
||||
/* AA80 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* AA88 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* AA90 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* AA98 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* AAA0 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* AAA8 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* AAB0 */ _(M,T), _(M,R), _(M,T), _(M,T), _(M,B),_(M,VOL),_(M,VOL), _(M,T),
|
||||
/* AAB8 */ _(M,T),_(M,VOL), _(M,R),_(M,VOL),_(M,VOL), _(M,R), _(M,T), _(TM,x),
|
||||
/* AAC0 */ _(TL,x), _(TM,x), _(TL,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* AAC8 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* AAD0 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* AAD8 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
|
||||
/* Meetei Mayek Extensions */
|
||||
|
||||
/* AAE0 */ _(VI,x), _(VI,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* AAE8 */ _(C,x), _(C,x), _(C,x), _(M,L), _(M,B), _(M,T), _(M,L), _(M,R),
|
||||
/* AAF0 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(Vs,x), _(IS,x), _(x,x),
|
||||
|
||||
#define indic_offset_0xabc0u 3272
|
||||
|
||||
|
||||
/* Meetei Mayek */
|
||||
|
||||
/* ABC0 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* ABC8 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(VI,x), _(VI,x),
|
||||
/* ABD0 */ _(C,x), _(VI,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* ABD8 */ _(C,x), _(C,x), _(C,x), _(CF,x), _(CF,x), _(CF,x), _(CF,x), _(CF,x),
|
||||
/* ABE0 */ _(CF,x), _(CF,x), _(CF,x), _(M,R), _(M,R), _(M,T), _(M,R), _(M,R),
|
||||
/* ABE8 */ _(M,B), _(M,R), _(M,R), _(x,x), _(TM,x), _(PK,B), _(x,x), _(x,x),
|
||||
/* ABF0 */ _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x),
|
||||
/* ABF8 */ _(Nd,x), _(Nd,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
|
||||
#define indic_offset_0x10a00u 3336
|
||||
|
||||
|
||||
/* Kharoshthi */
|
||||
|
||||
/* 10A00 */ _(C,x), _(M,O), _(M,B), _(M,B), _(x,x), _(M,T), _(M,O), _(x,x),
|
||||
/* 10A08 */ _(x,x), _(x,x), _(x,x), _(x,x), _(M,B), _(x,x), _(Bi,x), _(Vs,x),
|
||||
/* 10A10 */ _(C,x), _(C,x), _(C,x), _(C,x), _(x,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 10A18 */ _(x,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 10A20 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 10A28 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 10A30 */ _(C,x), _(C,x), _(C,x), _(C,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* 10A38 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(IS,x),
|
||||
/* 10A40 */ _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x),
|
||||
|
||||
#define indic_offset_0x11000u 3408
|
||||
|
||||
|
||||
/* Brahmi */
|
||||
|
||||
/* 11000 */ _(Bi,x), _(Bi,x), _(Vs,x), _(x,x), _(x,x), _(VI,x), _(VI,x), _(VI,x),
|
||||
/* 11008 */ _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x),
|
||||
/* 11010 */ _(VI,x), _(VI,x), _(VI,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 11018 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 11020 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 11028 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 11030 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 11038 */ _(M,T), _(M,T), _(M,T), _(M,T), _(M,B), _(M,B), _(M,B), _(M,B),
|
||||
/* 11040 */ _(M,B), _(M,B), _(M,T), _(M,T), _(M,T), _(M,T), _(V,T), _(x,x),
|
||||
/* 11048 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* 11050 */ _(x,x), _(x,x),_(BJN,x),_(BJN,x),_(BJN,x),_(BJN,x),_(BJN,x),_(BJN,x),
|
||||
/* 11058 */_(BJN,x),_(BJN,x),_(BJN,x),_(BJN,x),_(BJN,x),_(BJN,x),_(BJN,x),_(BJN,x),
|
||||
/* 11060 */_(BJN,x),_(BJN,x),_(BJN,x),_(BJN,x),_(BJN,x),_(BJN,x), _(Nd,x), _(Nd,x),
|
||||
/* 11068 */ _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x),
|
||||
/* 11070 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* 11078 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(NJ,x),
|
||||
|
||||
/* Kaithi */
|
||||
|
||||
/* 11080 */ _(Bi,x), _(Bi,x), _(Vs,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x),
|
||||
/* 11088 */ _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 11090 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 11098 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 110A0 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 110A8 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 110B0 */ _(M,R), _(M,L), _(M,R), _(M,B), _(M,B), _(M,T), _(M,T), _(M,R),
|
||||
/* 110B8 */ _(M,R), _(V,B), _(N,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
|
||||
#define indic_offset_0x11100u 3600
|
||||
|
||||
|
||||
/* Chakma */
|
||||
|
||||
/* 11100 */ _(Bi,x), _(Bi,x), _(Vs,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(C,x),
|
||||
/* 11108 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 11110 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 11118 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 11120 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(M,T),
|
||||
/* 11128 */ _(M,T), _(M,T), _(M,B), _(M,B), _(M,L), _(M,T), _(M,TB), _(M,TB),
|
||||
/* 11130 */ _(M,T), _(M,B), _(M,B), _(IS,x), _(PK,T), _(x,x), _(Nd,x), _(Nd,x),
|
||||
/* 11138 */ _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x),
|
||||
/* 11140 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* 11148 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
|
||||
/* Mahajani */
|
||||
|
||||
/* 11150 */ _(Vo,x), _(Vo,x), _(Vo,x), _(Vo,x), _(Vo,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 11158 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 11160 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 11168 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 11170 */ _(C,x), _(C,x), _(C,x), _(N,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* 11178 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
|
||||
/* Sharada */
|
||||
|
||||
/* 11180 */ _(Bi,x), _(Bi,x), _(Vs,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x),
|
||||
/* 11188 */ _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x),
|
||||
/* 11190 */ _(VI,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 11198 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 111A0 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 111A8 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 111B0 */ _(C,x), _(C,x), _(C,x), _(M,R), _(M,L), _(M,R), _(M,B), _(M,B),
|
||||
/* 111B8 */ _(M,B), _(M,B), _(M,B), _(M,B), _(M,T), _(M,T), _(M,T), _(M,TR),
|
||||
/* 111C0 */ _(V,R), _(A,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* 111C8 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* 111D0 */ _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x),
|
||||
/* 111D8 */ _(Nd,x), _(Nd,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
|
||||
/* Sinhala Archaic Numbers */
|
||||
|
||||
/* 111E0 */ _(x,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x),
|
||||
/* 111E8 */ _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x),
|
||||
/* 111F0 */ _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(x,x), _(x,x), _(x,x),
|
||||
/* 111F8 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
|
||||
/* Khojki */
|
||||
|
||||
/* 11200 */ _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x),
|
||||
/* 11208 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 11210 */ _(C,x), _(C,x), _(x,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 11218 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 11220 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 11228 */ _(C,x), _(C,x), _(C,x), _(C,x), _(M,R), _(M,R), _(M,R), _(M,B),
|
||||
/* 11230 */ _(M,T), _(M,T), _(M,TR), _(M,TR), _(Bi,x), _(V,R), _(N,x), _(GM,T),
|
||||
|
||||
#define indic_offset_0x112b0u 3912
|
||||
|
||||
|
||||
/* Khudawadi */
|
||||
|
||||
/* 112B0 */ _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x),
|
||||
/* 112B8 */ _(VI,x), _(VI,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 112C0 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 112C8 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 112D0 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 112D8 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(Bi,x),
|
||||
/* 112E0 */ _(M,R), _(M,L), _(M,R), _(M,B), _(M,B), _(M,T), _(M,T), _(M,T),
|
||||
/* 112E8 */ _(M,T), _(N,x), _(PK,B), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* 112F0 */ _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x),
|
||||
/* 112F8 */ _(Nd,x), _(Nd,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
|
||||
/* Grantha */
|
||||
|
||||
/* 11300 */ _(x,x), _(Bi,x), _(Bi,x), _(Vs,x), _(x,x), _(VI,x), _(VI,x), _(VI,x),
|
||||
/* 11308 */ _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(x,x), _(x,x), _(VI,x),
|
||||
/* 11310 */ _(VI,x), _(x,x), _(x,x), _(VI,x), _(VI,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 11318 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 11320 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 11328 */ _(C,x), _(x,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 11330 */ _(C,x), _(x,x), _(C,x), _(C,x), _(x,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 11338 */ _(C,x), _(C,x), _(x,x), _(x,x), _(N,x), _(A,x), _(M,R), _(M,R),
|
||||
/* 11340 */ _(M,T), _(M,R), _(M,R), _(M,R), _(M,R), _(x,x), _(x,x), _(M,L),
|
||||
/* 11348 */ _(M,L), _(x,x), _(x,x), _(M,LR), _(M,LR), _(V,R), _(x,x), _(x,x),
|
||||
/* 11350 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(M,R),
|
||||
/* 11358 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* 11360 */ _(VI,x), _(VI,x), _(M,R), _(M,R), _(x,x), _(x,x), _(Ca,x), _(Ca,x),
|
||||
/* 11368 */ _(Ca,x), _(Ca,x), _(Ca,x), _(Ca,x), _(Ca,x), _(x,x), _(x,x), _(x,x),
|
||||
/* 11370 */ _(Ca,x), _(Ca,x), _(Ca,x), _(Ca,x), _(Ca,x), _(x,x), _(x,x), _(x,x),
|
||||
|
||||
#define indic_offset_0x11480u 4112
|
||||
|
||||
|
||||
/* Tirhuta */
|
||||
|
||||
/* 11480 */ _(x,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x),
|
||||
/* 11488 */ _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(C,x),
|
||||
/* 11490 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 11498 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 114A0 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 114A8 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 114B0 */ _(M,R), _(M,L), _(M,R), _(M,B), _(M,B), _(M,B), _(M,B), _(M,B),
|
||||
/* 114B8 */ _(M,B), _(M,L), _(M,T), _(M,TL), _(M,LR), _(M,R), _(M,LR), _(Bi,x),
|
||||
/* 114C0 */ _(Bi,x), _(Vs,x), _(V,B), _(N,x), _(A,x), _(x,x), _(x,x), _(x,x),
|
||||
/* 114C8 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* 114D0 */ _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x),
|
||||
/* 114D8 */ _(Nd,x), _(Nd,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
|
||||
#define indic_offset_0x11580u 4208
|
||||
|
||||
|
||||
/* Siddham */
|
||||
|
||||
/* 11580 */ _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x),
|
||||
/* 11588 */ _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(C,x), _(C,x),
|
||||
/* 11590 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 11598 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 115A0 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 115A8 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(M,R),
|
||||
/* 115B0 */ _(M,L), _(M,R), _(M,B), _(M,B), _(M,B), _(M,B), _(x,x), _(x,x),
|
||||
/* 115B8 */ _(M,L), _(M,TL), _(M,LR),_(M,TLR), _(Bi,x), _(Bi,x), _(Vs,x), _(V,B),
|
||||
/* 115C0 */ _(N,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
|
||||
#define indic_offset_0x11600u 4280
|
||||
|
||||
|
||||
/* Modi */
|
||||
|
||||
/* 11600 */ _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x),
|
||||
/* 11608 */ _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(C,x), _(C,x),
|
||||
/* 11610 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 11618 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 11620 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 11628 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 11630 */ _(M,R), _(M,R), _(M,R), _(M,B), _(M,B), _(M,B), _(M,B), _(M,B),
|
||||
/* 11638 */ _(M,B), _(M,T), _(M,T), _(M,R), _(M,R), _(Bi,x), _(Vs,x), _(V,B),
|
||||
/* 11640 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* 11648 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* 11650 */ _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x),
|
||||
/* 11658 */ _(Nd,x), _(Nd,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* 11660 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* 11668 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* 11670 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* 11678 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
|
||||
/* Takri */
|
||||
|
||||
/* 11680 */ _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x), _(VI,x),
|
||||
/* 11688 */ _(VI,x), _(VI,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 11690 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 11698 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 116A0 */ _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x), _(C,x),
|
||||
/* 116A8 */ _(C,x), _(C,x), _(C,x), _(Bi,x), _(Vs,x), _(M,T), _(M,L), _(M,R),
|
||||
/* 116B0 */ _(M,B), _(M,B), _(M,T), _(M,T), _(M,T), _(M,T), _(V,T), _(N,x),
|
||||
/* 116B8 */ _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
/* 116C0 */ _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x), _(Nd,x),
|
||||
/* 116C8 */ _(Nd,x), _(Nd,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x), _(x,x),
|
||||
|
||||
}; /* Table items: 4488; occupancy: 73% */
|
||||
}; /* Table items: 1784; occupancy: 69% */
|
||||
|
||||
INDIC_TABLE_ELEMENT_TYPE
|
||||
hb_indic_get_categories (hb_codepoint_t u)
|
||||
|
@ -861,41 +398,35 @@ hb_indic_get_categories (hb_codepoint_t u)
|
|||
switch (u >> 12)
|
||||
{
|
||||
case 0x0u:
|
||||
if (hb_in_range (u, 0x0028u, 0x003Fu)) return indic_table[u - 0x0028u + indic_offset_0x0028u];
|
||||
if (hb_in_range (u, 0x00D0u, 0x00D7u)) return indic_table[u - 0x00D0u + indic_offset_0x00d0u];
|
||||
if (hb_in_range (u, 0x0900u, 0x0DF7u)) return indic_table[u - 0x0900u + indic_offset_0x0900u];
|
||||
if (hb_in_range<hb_codepoint_t> (u, 0x0028u, 0x003Fu)) return indic_table[u - 0x0028u + indic_offset_0x0028u];
|
||||
if (hb_in_range<hb_codepoint_t> (u, 0x00B0u, 0x00D7u)) return indic_table[u - 0x00B0u + indic_offset_0x00b0u];
|
||||
if (hb_in_range<hb_codepoint_t> (u, 0x0900u, 0x0DF7u)) return indic_table[u - 0x0900u + indic_offset_0x0900u];
|
||||
if (unlikely (u == 0x00A0u)) return _(CP,x);
|
||||
break;
|
||||
|
||||
case 0x1u:
|
||||
if (hb_in_range (u, 0x1000u, 0x109Fu)) return indic_table[u - 0x1000u + indic_offset_0x1000u];
|
||||
if (hb_in_range (u, 0x1700u, 0x17EFu)) return indic_table[u - 0x1700u + indic_offset_0x1700u];
|
||||
if (hb_in_range (u, 0x1900u, 0x1A9Fu)) return indic_table[u - 0x1900u + indic_offset_0x1900u];
|
||||
if (hb_in_range (u, 0x1B00u, 0x1C4Fu)) return indic_table[u - 0x1B00u + indic_offset_0x1b00u];
|
||||
if (hb_in_range (u, 0x1CD0u, 0x1CF7u)) return indic_table[u - 0x1CD0u + indic_offset_0x1cd0u];
|
||||
if (hb_in_range<hb_codepoint_t> (u, 0x1000u, 0x109Fu)) return indic_table[u - 0x1000u + indic_offset_0x1000u];
|
||||
if (hb_in_range<hb_codepoint_t> (u, 0x1780u, 0x17EFu)) return indic_table[u - 0x1780u + indic_offset_0x1780u];
|
||||
if (hb_in_range<hb_codepoint_t> (u, 0x1CD0u, 0x1CFFu)) return indic_table[u - 0x1CD0u + indic_offset_0x1cd0u];
|
||||
break;
|
||||
|
||||
case 0x2u:
|
||||
if (hb_in_range (u, 0x2008u, 0x2017u)) return indic_table[u - 0x2008u + indic_offset_0x2008u];
|
||||
if (hb_in_range<hb_codepoint_t> (u, 0x2008u, 0x2017u)) return indic_table[u - 0x2008u + indic_offset_0x2008u];
|
||||
if (hb_in_range<hb_codepoint_t> (u, 0x2070u, 0x2087u)) return indic_table[u - 0x2070u + indic_offset_0x2070u];
|
||||
if (unlikely (u == 0x25CCu)) return _(CP,x);
|
||||
break;
|
||||
|
||||
case 0xAu:
|
||||
if (hb_in_range (u, 0xA800u, 0xAAF7u)) return indic_table[u - 0xA800u + indic_offset_0xa800u];
|
||||
if (hb_in_range (u, 0xABC0u, 0xABFFu)) return indic_table[u - 0xABC0u + indic_offset_0xabc0u];
|
||||
break;
|
||||
|
||||
case 0x10u:
|
||||
if (hb_in_range (u, 0x10A00u, 0x10A47u)) return indic_table[u - 0x10A00u + indic_offset_0x10a00u];
|
||||
if (hb_in_range<hb_codepoint_t> (u, 0xA8E0u, 0xA8F7u)) return indic_table[u - 0xA8E0u + indic_offset_0xa8e0u];
|
||||
if (hb_in_range<hb_codepoint_t> (u, 0xA9E0u, 0xA9FFu)) return indic_table[u - 0xA9E0u + indic_offset_0xa9e0u];
|
||||
if (hb_in_range<hb_codepoint_t> (u, 0xAA60u, 0xAA7Fu)) return indic_table[u - 0xAA60u + indic_offset_0xaa60u];
|
||||
break;
|
||||
|
||||
case 0x11u:
|
||||
if (hb_in_range (u, 0x11000u, 0x110BFu)) return indic_table[u - 0x11000u + indic_offset_0x11000u];
|
||||
if (hb_in_range (u, 0x11100u, 0x11237u)) return indic_table[u - 0x11100u + indic_offset_0x11100u];
|
||||
if (hb_in_range (u, 0x112B0u, 0x11377u)) return indic_table[u - 0x112B0u + indic_offset_0x112b0u];
|
||||
if (hb_in_range (u, 0x11480u, 0x114DFu)) return indic_table[u - 0x11480u + indic_offset_0x11480u];
|
||||
if (hb_in_range (u, 0x11580u, 0x115C7u)) return indic_table[u - 0x11580u + indic_offset_0x11580u];
|
||||
if (hb_in_range (u, 0x11600u, 0x116CFu)) return indic_table[u - 0x11600u + indic_offset_0x11600u];
|
||||
// According to ScriptExtensions.txt, these Grantha marks may also be used in Tamil,
|
||||
// so the Indic shaper needs to know their categories.
|
||||
if (unlikely (u == 0x11303)) return _(Vs,R);
|
||||
if (unlikely (u == 0x1133c)) return _(N,B);
|
||||
break;
|
||||
|
||||
default:
|
||||
|
@ -914,11 +445,14 @@ hb_indic_get_categories (hb_codepoint_t u)
|
|||
#undef ISC_CD
|
||||
#undef ISC_CF
|
||||
#undef ISC_CHL
|
||||
#undef ISC_CK
|
||||
#undef ISC_CM
|
||||
#undef ISC_CP
|
||||
#undef ISC_CPR
|
||||
#undef ISC_CPrf
|
||||
#undef ISC_CS
|
||||
#undef ISC_CSR
|
||||
#undef ISC_CWS
|
||||
#undef ISC_GM
|
||||
#undef ISC_IS
|
||||
#undef ISC_ZWJ
|
||||
|
@ -930,6 +464,7 @@ hb_indic_get_categories (hb_codepoint_t u)
|
|||
#undef ISC_x
|
||||
#undef ISC_PK
|
||||
#undef ISC_RS
|
||||
#undef ISC_SM
|
||||
#undef ISC_TL
|
||||
#undef ISC_TM
|
||||
#undef ISC_V
|
||||
|
|
|
@ -176,32 +176,16 @@ set_indic_properties (hb_glyph_info_t &info)
|
|||
* Re-assign category
|
||||
*/
|
||||
|
||||
|
||||
/* The spec says U+0952 is OT_A. However, testing shows that Uniscribe
|
||||
* treats a whole bunch of characters similarly.
|
||||
* TESTS: For example, for U+0951:
|
||||
* U+092E,U+0947,U+0952
|
||||
* U+092E,U+0952,U+0947
|
||||
* U+092E,U+0947,U+0951
|
||||
* U+092E,U+0951,U+0947
|
||||
* U+092E,U+0951,U+0952
|
||||
* U+092E,U+0952,U+0951
|
||||
*/
|
||||
if (unlikely (hb_in_ranges (u, 0x0951u, 0x0952u,
|
||||
0x1CD0u, 0x1CD2u,
|
||||
0x1CD4u, 0x1CE1u) ||
|
||||
u == 0x1CF4u))
|
||||
cat = OT_A;
|
||||
/* The following act more like the Bindus. */
|
||||
else if (unlikely (hb_in_range (u, 0x0953u, 0x0954u)))
|
||||
if (unlikely (hb_in_range<hb_codepoint_t> (u, 0x0953u, 0x0954u)))
|
||||
cat = OT_SM;
|
||||
/* The following act like consonants. */
|
||||
else if (unlikely (hb_in_ranges (u, 0x0A72u, 0x0A73u,
|
||||
else if (unlikely (hb_in_ranges<hb_codepoint_t> (u, 0x0A72u, 0x0A73u,
|
||||
0x1CF5u, 0x1CF6u)))
|
||||
cat = OT_C;
|
||||
/* TODO: The following should only be allowed after a Visarga.
|
||||
* For now, just treat them like regular tone marks. */
|
||||
else if (unlikely (hb_in_range (u, 0x1CE2u, 0x1CE8u)))
|
||||
else if (unlikely (hb_in_range<hb_codepoint_t> (u, 0x1CE2u, 0x1CE8u)))
|
||||
cat = OT_A;
|
||||
/* TODO: The following should only be allowed after some of
|
||||
* the nasalization marks, maybe only for U+1CE9..U+1CF1.
|
||||
|
@ -209,28 +193,26 @@ set_indic_properties (hb_glyph_info_t &info)
|
|||
else if (unlikely (u == 0x1CEDu))
|
||||
cat = OT_A;
|
||||
/* The following take marks in standalone clusters, similar to Avagraha. */
|
||||
else if (unlikely (hb_in_ranges (u, 0xA8F2u, 0xA8F7u,
|
||||
else if (unlikely (hb_in_ranges<hb_codepoint_t> (u, 0xA8F2u, 0xA8F7u,
|
||||
0x1CE9u, 0x1CECu,
|
||||
0x1CEEu, 0x1CF1u)))
|
||||
{
|
||||
cat = OT_Symbol;
|
||||
ASSERT_STATIC ((int) INDIC_SYLLABIC_CATEGORY_AVAGRAHA == OT_Symbol);
|
||||
}
|
||||
else if (unlikely (hb_in_range (u, 0x17CDu, 0x17D1u) ||
|
||||
else if (unlikely (hb_in_range<hb_codepoint_t> (u, 0x17CDu, 0x17D1u) ||
|
||||
u == 0x17CBu || u == 0x17D3u || u == 0x17DDu)) /* Khmer Various signs */
|
||||
{
|
||||
/* These are like Top Matras. */
|
||||
/* These can occur mid-syllable (eg. before matras), even though Unicode marks them as Syllable_Modifier.
|
||||
* https://github.com/roozbehp/unicode-data/issues/5 */
|
||||
cat = OT_M;
|
||||
pos = POS_ABOVE_C;
|
||||
}
|
||||
|
||||
else if (unlikely (u == 0x17C6u)) cat = OT_N; /* Khmer Bindu doesn't like to be repositioned. */
|
||||
else if (unlikely (u == 0x17D2u)) cat = OT_Coeng; /* Khmer coeng */
|
||||
else if (unlikely (hb_in_range (u, 0x2010u, 0x2011u)))
|
||||
else if (unlikely (hb_in_range<hb_codepoint_t> (u, 0x2010u, 0x2011u)))
|
||||
cat = OT_PLACEHOLDER;
|
||||
else if (unlikely (u == 0x25CCu)) cat = OT_DOTTEDCIRCLE;
|
||||
else if (unlikely (u == 0xA982u)) cat = OT_SM; /* Javanese repha. */
|
||||
else if (unlikely (u == 0xA9BEu)) cat = OT_CM2; /* Javanese medial ya. */
|
||||
else if (unlikely (u == 0xA9BDu)) { cat = OT_M; pos = POS_POST_C; } /* Javanese vocalic r. */
|
||||
|
||||
|
||||
/*
|
||||
|
@ -296,11 +278,6 @@ enum blwf_mode_t {
|
|||
BLWF_MODE_PRE_AND_POST, /* Below-forms feature applied to pre-base and post-base. */
|
||||
BLWF_MODE_POST_ONLY /* Below-forms feature applied to post-base only. */
|
||||
};
|
||||
enum pref_len_t {
|
||||
PREF_LEN_1 = 1,
|
||||
PREF_LEN_2 = 2,
|
||||
PREF_LEN_DONT_CARE = PREF_LEN_2
|
||||
};
|
||||
struct indic_config_t
|
||||
{
|
||||
hb_script_t script;
|
||||
|
@ -310,26 +287,24 @@ struct indic_config_t
|
|||
reph_position_t reph_pos;
|
||||
reph_mode_t reph_mode;
|
||||
blwf_mode_t blwf_mode;
|
||||
pref_len_t pref_len;
|
||||
};
|
||||
|
||||
static const indic_config_t indic_configs[] =
|
||||
{
|
||||
/* Default. Should be first. */
|
||||
{HB_SCRIPT_INVALID, false, 0,BASE_POS_LAST, REPH_POS_BEFORE_POST,REPH_MODE_IMPLICIT, BLWF_MODE_PRE_AND_POST, PREF_LEN_1},
|
||||
{HB_SCRIPT_DEVANAGARI,true, 0x094Du,BASE_POS_LAST, REPH_POS_BEFORE_POST,REPH_MODE_IMPLICIT, BLWF_MODE_PRE_AND_POST, PREF_LEN_DONT_CARE},
|
||||
{HB_SCRIPT_BENGALI, true, 0x09CDu,BASE_POS_LAST, REPH_POS_AFTER_SUB, REPH_MODE_IMPLICIT, BLWF_MODE_PRE_AND_POST, PREF_LEN_DONT_CARE},
|
||||
{HB_SCRIPT_GURMUKHI, true, 0x0A4Du,BASE_POS_LAST, REPH_POS_BEFORE_SUB, REPH_MODE_IMPLICIT, BLWF_MODE_PRE_AND_POST, PREF_LEN_DONT_CARE},
|
||||
{HB_SCRIPT_GUJARATI, true, 0x0ACDu,BASE_POS_LAST, REPH_POS_BEFORE_POST,REPH_MODE_IMPLICIT, BLWF_MODE_PRE_AND_POST, PREF_LEN_DONT_CARE},
|
||||
{HB_SCRIPT_ORIYA, true, 0x0B4Du,BASE_POS_LAST, REPH_POS_AFTER_MAIN, REPH_MODE_IMPLICIT, BLWF_MODE_PRE_AND_POST, PREF_LEN_DONT_CARE},
|
||||
{HB_SCRIPT_TAMIL, true, 0x0BCDu,BASE_POS_LAST, REPH_POS_AFTER_POST, REPH_MODE_IMPLICIT, BLWF_MODE_PRE_AND_POST, PREF_LEN_2},
|
||||
{HB_SCRIPT_TELUGU, true, 0x0C4Du,BASE_POS_LAST, REPH_POS_AFTER_POST, REPH_MODE_EXPLICIT, BLWF_MODE_POST_ONLY, PREF_LEN_2},
|
||||
{HB_SCRIPT_KANNADA, true, 0x0CCDu,BASE_POS_LAST, REPH_POS_AFTER_POST, REPH_MODE_IMPLICIT, BLWF_MODE_POST_ONLY, PREF_LEN_2},
|
||||
{HB_SCRIPT_MALAYALAM, true, 0x0D4Du,BASE_POS_LAST, REPH_POS_AFTER_MAIN, REPH_MODE_LOG_REPHA,BLWF_MODE_PRE_AND_POST, PREF_LEN_2},
|
||||
{HB_SCRIPT_INVALID, false, 0,BASE_POS_LAST, REPH_POS_BEFORE_POST,REPH_MODE_IMPLICIT, BLWF_MODE_PRE_AND_POST},
|
||||
{HB_SCRIPT_DEVANAGARI,true, 0x094Du,BASE_POS_LAST, REPH_POS_BEFORE_POST,REPH_MODE_IMPLICIT, BLWF_MODE_PRE_AND_POST},
|
||||
{HB_SCRIPT_BENGALI, true, 0x09CDu,BASE_POS_LAST, REPH_POS_AFTER_SUB, REPH_MODE_IMPLICIT, BLWF_MODE_PRE_AND_POST},
|
||||
{HB_SCRIPT_GURMUKHI, true, 0x0A4Du,BASE_POS_LAST, REPH_POS_BEFORE_SUB, REPH_MODE_IMPLICIT, BLWF_MODE_PRE_AND_POST},
|
||||
{HB_SCRIPT_GUJARATI, true, 0x0ACDu,BASE_POS_LAST, REPH_POS_BEFORE_POST,REPH_MODE_IMPLICIT, BLWF_MODE_PRE_AND_POST},
|
||||
{HB_SCRIPT_ORIYA, true, 0x0B4Du,BASE_POS_LAST, REPH_POS_AFTER_MAIN, REPH_MODE_IMPLICIT, BLWF_MODE_PRE_AND_POST},
|
||||
{HB_SCRIPT_TAMIL, true, 0x0BCDu,BASE_POS_LAST, REPH_POS_AFTER_POST, REPH_MODE_IMPLICIT, BLWF_MODE_PRE_AND_POST},
|
||||
{HB_SCRIPT_TELUGU, true, 0x0C4Du,BASE_POS_LAST, REPH_POS_AFTER_POST, REPH_MODE_EXPLICIT, BLWF_MODE_POST_ONLY},
|
||||
{HB_SCRIPT_KANNADA, true, 0x0CCDu,BASE_POS_LAST, REPH_POS_AFTER_POST, REPH_MODE_IMPLICIT, BLWF_MODE_POST_ONLY},
|
||||
{HB_SCRIPT_MALAYALAM, true, 0x0D4Du,BASE_POS_LAST, REPH_POS_AFTER_MAIN, REPH_MODE_LOG_REPHA,BLWF_MODE_PRE_AND_POST},
|
||||
{HB_SCRIPT_SINHALA, false,0x0DCAu,BASE_POS_LAST_SINHALA,
|
||||
REPH_POS_AFTER_MAIN, REPH_MODE_EXPLICIT, BLWF_MODE_PRE_AND_POST, PREF_LEN_DONT_CARE},
|
||||
{HB_SCRIPT_KHMER, false,0x17D2u,BASE_POS_FIRST,REPH_POS_DONT_CARE, REPH_MODE_VIS_REPHA,BLWF_MODE_PRE_AND_POST, PREF_LEN_2},
|
||||
{HB_SCRIPT_JAVANESE, false,0xA9C0u,BASE_POS_FIRST,REPH_POS_DONT_CARE, REPH_MODE_VIS_REPHA,BLWF_MODE_PRE_AND_POST, PREF_LEN_1},
|
||||
REPH_POS_AFTER_MAIN, REPH_MODE_EXPLICIT, BLWF_MODE_PRE_AND_POST},
|
||||
{HB_SCRIPT_KHMER, false,0x17D2u,BASE_POS_FIRST,REPH_POS_DONT_CARE, REPH_MODE_VIS_REPHA,BLWF_MODE_PRE_AND_POST},
|
||||
};
|
||||
|
||||
|
||||
|
@ -445,12 +420,12 @@ collect_features_indic (hb_ot_shape_planner_t *plan)
|
|||
unsigned int i = 0;
|
||||
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);
|
||||
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 (final_reordering);
|
||||
for (; i < INDIC_NUM_FEATURES; i++) {
|
||||
map->add_feature (indic_features[i].tag, 1, indic_features[i].flags | F_MANUAL_ZWJ);
|
||||
map->add_feature (indic_features[i].tag, 1, indic_features[i].flags | F_MANUAL_ZWJ | F_MANUAL_ZWNJ);
|
||||
}
|
||||
|
||||
map->add_global_bool_feature (HB_TAG('c','a','l','t'));
|
||||
|
@ -512,12 +487,12 @@ struct indic_shape_plan_t
|
|||
hb_codepoint_t glyph = virama_glyph;
|
||||
if (unlikely (virama_glyph == (hb_codepoint_t) -1))
|
||||
{
|
||||
if (!config->virama || !font->get_glyph (config->virama, 0, &glyph))
|
||||
if (!config->virama || !font->get_nominal_glyph (config->virama, &glyph))
|
||||
glyph = 0;
|
||||
/* Technically speaking, the spec says we should apply 'locl' to virama too.
|
||||
* Maybe one day... */
|
||||
|
||||
/* Our get_glyph() function needs a font, so we can't get the virama glyph
|
||||
/* Our get_nominal_glyph() function needs a font, so we can't get the virama glyph
|
||||
* during shape planning... Instead, overwrite it here. It's safe. Don't worry! */
|
||||
(const_cast<indic_shape_plan_t *> (this))->virama_glyph = glyph;
|
||||
}
|
||||
|
@ -557,8 +532,15 @@ data_create_indic (const hb_ot_shape_plan_t *plan)
|
|||
indic_plan->virama_glyph = (hb_codepoint_t) -1;
|
||||
|
||||
/* Use zero-context would_substitute() matching for new-spec of the main
|
||||
* Indic scripts, and scripts with one spec only, but not for old-specs. */
|
||||
bool zero_context = !indic_plan->is_old_spec;
|
||||
* Indic scripts, and scripts with one spec only, but not for old-specs.
|
||||
* The new-spec for all dual-spec scripts says zero-context matching happens.
|
||||
*
|
||||
* However, testing with Malayalam shows that old and new spec both allow
|
||||
* context. Testing with Bengali new-spec however shows that it doesn't.
|
||||
* So, the heuristic here is the way it is. It should *only* be changed,
|
||||
* as we discover more cases of what Windows does. DON'T TOUCH OTHERWISE.
|
||||
*/
|
||||
bool zero_context = !indic_plan->is_old_spec && plan->props.script != HB_SCRIPT_MALAYALAM;
|
||||
indic_plan->rphf.init (&plan->map, HB_TAG('r','p','h','f'), zero_context);
|
||||
indic_plan->pref.init (&plan->map, HB_TAG('p','r','e','f'), zero_context);
|
||||
indic_plan->blwf.init (&plan->map, HB_TAG('b','l','w','f'), zero_context);
|
||||
|
@ -600,12 +582,8 @@ consonant_position_from_face (const indic_shape_plan_t *indic_plan,
|
|||
if (indic_plan->pstf.would_substitute (glyphs , 2, face) ||
|
||||
indic_plan->pstf.would_substitute (glyphs+1, 2, face))
|
||||
return POS_POST_C;
|
||||
unsigned int pref_len = indic_plan->config->pref_len;
|
||||
if ((pref_len == PREF_LEN_2 &&
|
||||
(indic_plan->pref.would_substitute (glyphs , 2, face) ||
|
||||
indic_plan->pref.would_substitute (glyphs+1, 2, face)))
|
||||
|| (pref_len == PREF_LEN_1 &&
|
||||
indic_plan->pref.would_substitute (glyphs+1, 1, face)))
|
||||
if (indic_plan->pref.would_substitute (glyphs , 2, face) ||
|
||||
indic_plan->pref.would_substitute (glyphs+1, 2, face))
|
||||
return POS_POST_C;
|
||||
return POS_BASE_C;
|
||||
}
|
||||
|
@ -646,6 +624,8 @@ setup_syllables (const hb_ot_shape_plan_t *plan HB_UNUSED,
|
|||
hb_buffer_t *buffer)
|
||||
{
|
||||
find_syllables (buffer);
|
||||
foreach_syllable (buffer, start, end)
|
||||
buffer->unsafe_to_break (start, end);
|
||||
}
|
||||
|
||||
static int
|
||||
|
@ -754,10 +734,6 @@ initial_reordering_consonant_syllable (const hb_ot_shape_plan_t *plan,
|
|||
|
||||
switch (indic_plan->config->base_pos)
|
||||
{
|
||||
default:
|
||||
assert (false);
|
||||
HB_FALLTHROUGH;
|
||||
|
||||
case BASE_POS_LAST:
|
||||
{
|
||||
/* -> starting from the end of the syllable, move backwards */
|
||||
|
@ -1115,10 +1091,9 @@ initial_reordering_consonant_syllable (const hb_ot_shape_plan_t *plan,
|
|||
}
|
||||
}
|
||||
|
||||
unsigned int pref_len = indic_plan->config->pref_len;
|
||||
unsigned int pref_len = 2;
|
||||
if (indic_plan->mask_array[PREF] && base + pref_len < end)
|
||||
{
|
||||
assert (1 <= pref_len && pref_len <= 2);
|
||||
/* Find a Halant,Ra sequence and mark it for pre-base reordering processing. */
|
||||
for (unsigned int i = base + 1; i + pref_len - 1 < end; i++) {
|
||||
hb_codepoint_t glyphs[2];
|
||||
|
@ -1231,7 +1206,7 @@ insert_dotted_circles (const hb_ot_shape_plan_t *plan HB_UNUSED,
|
|||
|
||||
|
||||
hb_codepoint_t dottedcircle_glyph;
|
||||
if (!font->get_glyph (0x25CCu, 0, &dottedcircle_glyph))
|
||||
if (!font->get_nominal_glyph (0x25CCu, &dottedcircle_glyph))
|
||||
return;
|
||||
|
||||
hb_glyph_info_t dottedcircle = {0};
|
||||
|
@ -1258,7 +1233,7 @@ insert_dotted_circles (const hb_ot_shape_plan_t *plan HB_UNUSED,
|
|||
/* TODO Set glyph_props? */
|
||||
|
||||
/* Insert dottedcircle after possible Repha. */
|
||||
while (buffer->idx < buffer->len &&
|
||||
while (buffer->idx < buffer->len && !buffer->in_error &&
|
||||
last_syllable == buffer->cur().syllable() &&
|
||||
buffer->cur().indic_category() == OT_Repha)
|
||||
buffer->next_glyph ();
|
||||
|
@ -1328,7 +1303,7 @@ final_reordering_syllable (const hb_ot_shape_plan_t *plan,
|
|||
for (base = start; base < end; base++)
|
||||
if (info[base].indic_position() >= POS_BASE_C)
|
||||
{
|
||||
if (try_pref && base + 1 < end && indic_plan->config->pref_len == 2)
|
||||
if (try_pref && base + 1 < end)
|
||||
{
|
||||
for (unsigned int i = base + 1; i < end; i++)
|
||||
if ((info[i].mask & indic_plan->mask_array[PREF]) != 0)
|
||||
|
@ -1348,6 +1323,25 @@ final_reordering_syllable (const hb_ot_shape_plan_t *plan,
|
|||
break;
|
||||
}
|
||||
}
|
||||
/* For Malayalam, skip over unformed below- (but NOT post-) forms. */
|
||||
if (buffer->props.script == HB_SCRIPT_MALAYALAM)
|
||||
{
|
||||
for (unsigned int i = base + 1; i < end; i++)
|
||||
{
|
||||
while (i < end && is_joiner (info[i]))
|
||||
i++;
|
||||
if (i == end || !is_halant_or_coeng (info[i]))
|
||||
break;
|
||||
i++; /* Skip halant. */
|
||||
while (i < end && is_joiner (info[i]))
|
||||
i++;
|
||||
if (i < end && is_consonant (info[i]) && info[i].indic_position() == POS_BELOW_C)
|
||||
{
|
||||
base = i;
|
||||
info[base].indic_position() = POS_BASE_C;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (start < base && info[base].indic_position() > POS_BASE_C)
|
||||
base--;
|
||||
|
@ -1514,7 +1508,7 @@ final_reordering_syllable (const hb_ot_shape_plan_t *plan,
|
|||
if (reph_pos == REPH_POS_AFTER_SUB)
|
||||
{
|
||||
new_reph_pos = base;
|
||||
while (new_reph_pos < end &&
|
||||
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))))
|
||||
new_reph_pos++;
|
||||
if (new_reph_pos < end)
|
||||
|
@ -1591,7 +1585,6 @@ final_reordering_syllable (const hb_ot_shape_plan_t *plan,
|
|||
|
||||
if (try_pref && base + 1 < end) /* Otherwise there can't be any pre-base reordering Ra. */
|
||||
{
|
||||
unsigned int pref_len = indic_plan->config->pref_len;
|
||||
for (unsigned int i = base + 1; i < end; i++)
|
||||
if ((info[i].mask & indic_plan->mask_array[PREF]) != 0)
|
||||
{
|
||||
|
@ -1602,10 +1595,8 @@ final_reordering_syllable (const hb_ot_shape_plan_t *plan,
|
|||
/* Note: We just check that something got substituted. We don't check that
|
||||
* the <pref> feature actually did it...
|
||||
*
|
||||
* If pref len is longer than one, then only reorder if it ligated. If
|
||||
* pref len is one, only reorder if it didn't ligate with other things. */
|
||||
if (_hb_glyph_info_substituted (&info[i]) &&
|
||||
((pref_len == 1) ^ _hb_glyph_info_ligated_and_didnt_multiply (&info[i])))
|
||||
* Reorder pref only if it ligated. */
|
||||
if (_hb_glyph_info_ligated_and_didnt_multiply (&info[i]))
|
||||
{
|
||||
/*
|
||||
* 2. Try to find a target position the same way as for pre-base matra.
|
||||
|
@ -1733,37 +1724,32 @@ decompose_indic (const hb_ot_shape_normalize_context_t *c,
|
|||
switch (ab)
|
||||
{
|
||||
/* Don't decompose these. */
|
||||
case 0x0931u : return false;
|
||||
case 0x0B94u : return false;
|
||||
case 0x0931u : return false; /* DEVANAGARI LETTER RRA */
|
||||
case 0x0B94u : return false; /* TAMIL LETTER AU */
|
||||
|
||||
|
||||
/*
|
||||
* Decompose split matras that don't have Unicode decompositions.
|
||||
*/
|
||||
|
||||
case 0x0F77u : *a = 0x0FB2u; *b= 0x0F81u; return true;
|
||||
case 0x0F79u : *a = 0x0FB3u; *b= 0x0F81u; return true;
|
||||
/* Khmer */
|
||||
case 0x17BEu : *a = 0x17C1u; *b= 0x17BEu; return true;
|
||||
case 0x17BFu : *a = 0x17C1u; *b= 0x17BFu; return true;
|
||||
case 0x17C0u : *a = 0x17C1u; *b= 0x17C0u; return true;
|
||||
case 0x17C4u : *a = 0x17C1u; *b= 0x17C4u; return true;
|
||||
case 0x17C5u : *a = 0x17C1u; *b= 0x17C5u; return true;
|
||||
case 0x1925u : *a = 0x1920u; *b= 0x1923u; return true;
|
||||
case 0x1926u : *a = 0x1920u; *b= 0x1924u; return true;
|
||||
case 0x1B3Cu : *a = 0x1B42u; *b= 0x1B3Cu; return true;
|
||||
case 0x1112Eu : *a = 0x11127u; *b= 0x11131u; return true;
|
||||
case 0x1112Fu : *a = 0x11127u; *b= 0x11132u; return true;
|
||||
|
||||
#if 0
|
||||
/* Gujarati */
|
||||
/* This one has no decomposition in Unicode, but needs no decomposition either. */
|
||||
/* case 0x0AC9u : return false; */
|
||||
|
||||
/* Oriya */
|
||||
case 0x0B57u : *a = no decomp, -> RIGHT; return true;
|
||||
case 0x1C29u : *a = no decomp, -> LEFT; return true;
|
||||
case 0xA9C0u : *a = no decomp, -> RIGHT; return true;
|
||||
case 0x111BuF : *a = no decomp, -> ABOVE; return true;
|
||||
#endif
|
||||
}
|
||||
|
||||
if ((ab == 0x0DDAu || hb_in_range (ab, 0x0DDCu, 0x0DDEu)))
|
||||
if ((ab == 0x0DDAu || hb_in_range<hb_codepoint_t> (ab, 0x0DDCu, 0x0DDEu)))
|
||||
{
|
||||
/*
|
||||
* Sinhala split matras... Let the fun begin.
|
||||
|
@ -1796,7 +1782,7 @@ decompose_indic (const hb_ot_shape_normalize_context_t *c,
|
|||
hb_codepoint_t glyph;
|
||||
|
||||
if (hb_options ().uniscribe_bug_compatible ||
|
||||
(c->font->get_glyph (ab, 0, &glyph) &&
|
||||
(c->font->get_nominal_glyph (ab, &glyph) &&
|
||||
indic_plan->pstf.would_substitute (&glyph, 1, c->font->face)))
|
||||
{
|
||||
/* Ok, safe to use Uniscribe-style decomposition. */
|
||||
|
@ -1806,7 +1792,7 @@ decompose_indic (const hb_ot_shape_normalize_context_t *c,
|
|||
}
|
||||
}
|
||||
|
||||
return c->unicode->decompose (ab, a, b);
|
||||
return (bool) c->unicode->decompose (ab, a, b);
|
||||
}
|
||||
|
||||
static bool
|
||||
|
@ -1822,7 +1808,7 @@ compose_indic (const hb_ot_shape_normalize_context_t *c,
|
|||
/* Composition-exclusion exceptions that we want to recompose. */
|
||||
if (a == 0x09AFu && b == 0x09BCu) { *ab = 0x09DFu; return true; }
|
||||
|
||||
return c->unicode->compose (a, b, ab);
|
||||
return (bool) c->unicode->compose (a, b, ab);
|
||||
}
|
||||
|
||||
|
||||
|
@ -1839,6 +1825,7 @@ const hb_ot_complex_shaper_t _hb_ot_complex_shaper_indic =
|
|||
decompose_indic,
|
||||
compose_indic,
|
||||
setup_masks_indic,
|
||||
NULL, /* disable_otl */
|
||||
HB_OT_SHAPE_ZERO_WIDTH_MARKS_NONE,
|
||||
false, /* fallback_position */
|
||||
};
|
||||
|
|
|
@ -175,7 +175,7 @@ set_myanmar_properties (hb_glyph_info_t &info)
|
|||
/* Myanmar
|
||||
* http://www.microsoft.com/typography/OpenTypeDev/myanmar/intro.htm#analyze
|
||||
*/
|
||||
if (unlikely (hb_in_range (u, 0xFE00u, 0xFE0Fu)))
|
||||
if (unlikely (hb_in_range<hb_codepoint_t> (u, 0xFE00u, 0xFE0Fu)))
|
||||
cat = (indic_category_t) OT_VS;
|
||||
|
||||
switch (u)
|
||||
|
@ -199,6 +199,10 @@ set_myanmar_properties (hb_glyph_info_t &info)
|
|||
cat = (indic_category_t) OT_A;
|
||||
break;
|
||||
|
||||
case 0x1039u:
|
||||
cat = (indic_category_t) OT_H;
|
||||
break;
|
||||
|
||||
case 0x103Au:
|
||||
cat = (indic_category_t) OT_As;
|
||||
break;
|
||||
|
@ -245,6 +249,11 @@ set_myanmar_properties (hb_glyph_info_t &info)
|
|||
case 0x104Au: case 0x104Bu:
|
||||
cat = (indic_category_t) OT_P;
|
||||
break;
|
||||
|
||||
case 0xAA74u: case 0xAA75u: case 0xAA76u:
|
||||
/* https://github.com/roozbehp/unicode-data/issues/3 */
|
||||
cat = (indic_category_t) OT_C;
|
||||
break;
|
||||
}
|
||||
|
||||
if (cat == OT_M)
|
||||
|
@ -288,6 +297,8 @@ setup_syllables (const hb_ot_shape_plan_t *plan HB_UNUSED,
|
|||
hb_buffer_t *buffer)
|
||||
{
|
||||
find_syllables (buffer);
|
||||
foreach_syllable (buffer, start, end)
|
||||
buffer->unsafe_to_break (start, end);
|
||||
}
|
||||
|
||||
static int
|
||||
|
@ -435,7 +446,7 @@ insert_dotted_circles (const hb_ot_shape_plan_t *plan HB_UNUSED,
|
|||
|
||||
|
||||
hb_codepoint_t dottedcircle_glyph;
|
||||
if (!font->get_glyph (0x25CCu, 0, &dottedcircle_glyph))
|
||||
if (!font->get_nominal_glyph (0x25CCu, &dottedcircle_glyph))
|
||||
return;
|
||||
|
||||
hb_glyph_info_t dottedcircle = {0};
|
||||
|
@ -447,7 +458,7 @@ insert_dotted_circles (const hb_ot_shape_plan_t *plan HB_UNUSED,
|
|||
|
||||
buffer->idx = 0;
|
||||
unsigned int last_syllable = 0;
|
||||
while (buffer->idx < buffer->len)
|
||||
while (buffer->idx < buffer->len && !buffer->in_error)
|
||||
{
|
||||
unsigned int syllable = buffer->cur().syllable();
|
||||
syllable_type_t syllable_type = (syllable_type_t) (syllable & 0x0F);
|
||||
|
@ -512,6 +523,7 @@ const hb_ot_complex_shaper_t _hb_ot_complex_shaper_myanmar_old =
|
|||
NULL, /* decompose */
|
||||
NULL, /* compose */
|
||||
NULL, /* setup_masks */
|
||||
NULL, /* disable_otl */
|
||||
HB_OT_SHAPE_ZERO_WIDTH_MARKS_BY_GDEF_LATE,
|
||||
true, /* fallback_position */
|
||||
};
|
||||
|
@ -529,6 +541,7 @@ const hb_ot_complex_shaper_t _hb_ot_complex_shaper_myanmar =
|
|||
NULL, /* decompose */
|
||||
NULL, /* compose */
|
||||
setup_masks_myanmar,
|
||||
NULL, /* disable_otl */
|
||||
HB_OT_SHAPE_ZERO_WIDTH_MARKS_BY_GDEF_EARLY,
|
||||
false, /* fallback_position */
|
||||
};
|
||||
|
|
|
@ -41,12 +41,8 @@
|
|||
|
||||
enum hb_ot_shape_zero_width_marks_type_t {
|
||||
HB_OT_SHAPE_ZERO_WIDTH_MARKS_NONE,
|
||||
// HB_OT_SHAPE_ZERO_WIDTH_MARKS_BY_UNICODE_EARLY,
|
||||
HB_OT_SHAPE_ZERO_WIDTH_MARKS_BY_UNICODE_LATE,
|
||||
HB_OT_SHAPE_ZERO_WIDTH_MARKS_BY_GDEF_EARLY,
|
||||
HB_OT_SHAPE_ZERO_WIDTH_MARKS_BY_GDEF_LATE,
|
||||
|
||||
HB_OT_SHAPE_ZERO_WIDTH_MARKS_DEFAULT = HB_OT_SHAPE_ZERO_WIDTH_MARKS_BY_UNICODE_LATE
|
||||
HB_OT_SHAPE_ZERO_WIDTH_MARKS_BY_GDEF_LATE
|
||||
};
|
||||
|
||||
|
||||
|
@ -150,6 +146,14 @@ struct hb_ot_complex_shaper_t
|
|||
hb_buffer_t *buffer,
|
||||
hb_font_t *font);
|
||||
|
||||
/* disable_otl()
|
||||
* Called during shape().
|
||||
* If set and returns true, GDEF/GSUB/GPOS of the font are ignored
|
||||
* and fallback operations used.
|
||||
* May be NULL.
|
||||
*/
|
||||
bool (*disable_otl) (const hb_ot_shape_plan_t *plan);
|
||||
|
||||
hb_ot_shape_zero_width_marks_type_t zero_width_marks;
|
||||
|
||||
bool fallback_position;
|
||||
|
@ -187,6 +191,9 @@ hb_ot_shape_complex_categorize (const hb_ot_shape_planner_t *planner)
|
|||
case HB_SCRIPT_MANICHAEAN:
|
||||
case HB_SCRIPT_PSALTER_PAHLAVI:
|
||||
|
||||
/* Unicode-9.0 additions */
|
||||
case HB_SCRIPT_ADLAM:
|
||||
|
||||
/* For Arabic script, use the Arabic shaper even if no OT script tag was found.
|
||||
* This is because we do fallback shaping for Arabic script (and not others).
|
||||
* But note that Arabic shaping is applicable only to horizontal layout; for
|
||||
|
@ -245,9 +252,6 @@ hb_ot_shape_complex_categorize (const hb_ot_shape_planner_t *planner)
|
|||
/* Unicode-3.0 additions */
|
||||
case HB_SCRIPT_SINHALA:
|
||||
|
||||
/* Unicode-5.2 additions */
|
||||
case HB_SCRIPT_JAVANESE:
|
||||
|
||||
/* If the designer designed the font for the 'DFLT' script,
|
||||
* use the default shaper. Otherwise, use the specific shaper.
|
||||
* Note that for some simple scripts, there may not be *any*
|
||||
|
@ -320,7 +324,7 @@ hb_ot_shape_complex_categorize (const hb_ot_shape_planner_t *planner)
|
|||
|
||||
/* Unicode-5.2 additions */
|
||||
case HB_SCRIPT_EGYPTIAN_HIEROGLYPHS:
|
||||
//case HB_SCRIPT_JAVANESE:
|
||||
case HB_SCRIPT_JAVANESE:
|
||||
case HB_SCRIPT_KAITHI:
|
||||
case HB_SCRIPT_MEETEI_MAYEK:
|
||||
case HB_SCRIPT_TAI_THAM:
|
||||
|
@ -349,6 +353,15 @@ hb_ot_shape_complex_categorize (const hb_ot_shape_planner_t *planner)
|
|||
case HB_SCRIPT_SIDDHAM:
|
||||
case HB_SCRIPT_TIRHUTA:
|
||||
|
||||
/* Unicode-8.0 additions */
|
||||
case HB_SCRIPT_AHOM:
|
||||
//case HB_SCRIPT_MULTANI:
|
||||
|
||||
/* Unicode-9.0 additions */
|
||||
case HB_SCRIPT_BHAIKSUKI:
|
||||
case HB_SCRIPT_MARCHEN:
|
||||
case HB_SCRIPT_NEWA:
|
||||
|
||||
/* If the designer designed the font for the 'DFLT' script,
|
||||
* use the default shaper. Otherwise, use the specific shaper.
|
||||
* Note that for some simple scripts, there may not be *any*
|
||||
|
|
|
@ -52,7 +52,7 @@ get_consonant_type (hb_codepoint_t u)
|
|||
return RC;
|
||||
if (u == 0x0E0Eu || u == 0x0E0Fu)
|
||||
return DC;
|
||||
if (hb_in_range (u, 0x0E01u, 0x0E2Eu))
|
||||
if (hb_in_range<hb_codepoint_t> (u, 0x0E01u, 0x0E2Eu))
|
||||
return NC;
|
||||
return NOT_CONSONANT;
|
||||
}
|
||||
|
@ -70,12 +70,12 @@ enum thai_mark_type_t
|
|||
static thai_mark_type_t
|
||||
get_mark_type (hb_codepoint_t u)
|
||||
{
|
||||
if (u == 0x0E31u || hb_in_range (u, 0x0E34u, 0x0E37u) ||
|
||||
u == 0x0E47u || hb_in_range (u, 0x0E4Du, 0x0E4Eu))
|
||||
if (u == 0x0E31u || hb_in_range<hb_codepoint_t> (u, 0x0E34u, 0x0E37u) ||
|
||||
u == 0x0E47u || hb_in_range<hb_codepoint_t> (u, 0x0E4Du, 0x0E4Eu))
|
||||
return AV;
|
||||
if (hb_in_range (u, 0x0E38u, 0x0E3Au))
|
||||
if (hb_in_range<hb_codepoint_t> (u, 0x0E38u, 0x0E3Au))
|
||||
return BV;
|
||||
if (hb_in_range (u, 0x0E48u, 0x0E4Cu))
|
||||
if (hb_in_range<hb_codepoint_t> (u, 0x0E48u, 0x0E4Cu))
|
||||
return T;
|
||||
return NOT_MARK;
|
||||
}
|
||||
|
@ -139,7 +139,6 @@ thai_pua_shape (hb_codepoint_t u, thai_action_t action, hb_font_t *font)
|
|||
};
|
||||
|
||||
switch (action) {
|
||||
default: assert (false); HB_FALLTHROUGH;
|
||||
case NOP: return u;
|
||||
case SD: pua_mappings = SD_mappings; break;
|
||||
case SDL: pua_mappings = SDL_mappings; break;
|
||||
|
@ -245,6 +244,7 @@ do_thai_pua_shaping (const hb_ot_shape_plan_t *plan HB_UNUSED,
|
|||
/* At least one of the above/below actions is NOP. */
|
||||
thai_action_t action = above_edge.action != NOP ? above_edge.action : below_edge.action;
|
||||
|
||||
buffer->unsafe_to_break (base, i);
|
||||
if (action == RD)
|
||||
info[base].codepoint = thai_pua_shape (info[base].codepoint, action, font);
|
||||
else
|
||||
|
@ -311,7 +311,7 @@ preprocess_text_thai (const hb_ot_shape_plan_t *plan,
|
|||
#define IS_SARA_AM(x) (((x) & ~0x0080u) == 0x0E33u)
|
||||
#define NIKHAHIT_FROM_SARA_AM(x) ((x) - 0x0E33u + 0x0E4Du)
|
||||
#define SARA_AA_FROM_SARA_AM(x) ((x) - 1)
|
||||
#define IS_TONE_MARK(x) (hb_in_ranges ((x) & ~0x0080u, 0x0E34u, 0x0E37u, 0x0E47u, 0x0E4Eu, 0x0E31u, 0x0E31u))
|
||||
#define IS_TONE_MARK(x) (hb_in_ranges<hb_codepoint_t> ((x) & ~0x0080u, 0x0E34u, 0x0E37u, 0x0E47u, 0x0E4Eu, 0x0E31u, 0x0E31u))
|
||||
|
||||
buffer->clear_output ();
|
||||
unsigned int count = buffer->len;
|
||||
|
@ -377,6 +377,7 @@ const hb_ot_complex_shaper_t _hb_ot_complex_shaper_thai =
|
|||
NULL, /* decompose */
|
||||
NULL, /* compose */
|
||||
NULL, /* setup_masks */
|
||||
HB_OT_SHAPE_ZERO_WIDTH_MARKS_DEFAULT,
|
||||
NULL, /* disable_otl */
|
||||
HB_OT_SHAPE_ZERO_WIDTH_MARKS_BY_GDEF_LATE,
|
||||
false,/* fallback_position */
|
||||
};
|
||||
|
|
|
@ -57,6 +57,7 @@ const hb_ot_complex_shaper_t _hb_ot_complex_shaper_tibetan =
|
|||
NULL, /* decompose */
|
||||
NULL, /* compose */
|
||||
NULL, /* setup_masks */
|
||||
HB_OT_SHAPE_ZERO_WIDTH_MARKS_DEFAULT,
|
||||
NULL, /* disable_otl */
|
||||
HB_OT_SHAPE_ZERO_WIDTH_MARKS_BY_GDEF_LATE,
|
||||
true, /* fallback_position */
|
||||
};
|
||||
|
|
|
@ -36,335 +36,270 @@
|
|||
|
||||
#line 38 "hb-ot-shape-complex-use-machine.hh"
|
||||
static const unsigned char _use_syllable_machine_trans_keys[] = {
|
||||
0u, 0u, 4u, 4u, 1u, 1u, 0u, 39u, 21u, 21u, 8u, 39u, 8u, 39u, 1u, 1u,
|
||||
8u, 39u, 8u, 39u, 8u, 39u, 8u, 26u, 8u, 26u, 8u, 26u, 8u, 39u, 8u, 39u,
|
||||
1u, 1u, 0u, 39u, 21u, 21u, 8u, 39u, 8u, 39u, 1u, 1u, 8u, 39u, 8u, 39u,
|
||||
8u, 39u, 8u, 26u, 8u, 26u, 8u, 26u, 8u, 39u, 8u, 39u, 8u, 39u, 8u, 39u,
|
||||
8u, 39u, 8u, 39u, 8u, 39u, 8u, 39u, 8u, 39u, 8u, 39u, 8u, 39u, 8u, 39u,
|
||||
8u, 39u, 8u, 39u, 8u, 39u, 1u, 1u, 8u, 39u, 8u, 39u, 8u, 26u, 8u, 26u,
|
||||
8u, 26u, 8u, 39u, 8u, 39u, 8u, 39u, 8u, 39u, 8u, 39u, 8u, 39u, 8u, 39u,
|
||||
8u, 39u, 12u, 21u, 12u, 13u, 8u, 39u, 8u, 39u, 8u, 39u, 8u, 39u, 8u, 26u,
|
||||
13u, 21u, 4u, 4u, 13u, 13u, 8u, 39u, 8u, 39u, 8u, 39u, 8u, 39u, 8u, 26u,
|
||||
8u, 26u, 8u, 26u, 8u, 39u, 8u, 39u, 8u, 39u, 8u, 39u, 8u, 39u, 8u, 39u,
|
||||
8u, 39u, 8u, 39u, 8u, 39u, 8u, 39u, 1u, 39u, 8u, 39u, 21u, 42u, 41u, 42u,
|
||||
42u, 42u, 0
|
||||
8u, 39u, 8u, 39u, 8u, 39u, 8u, 39u, 8u, 39u, 1u, 1u, 1u, 39u, 8u, 39u,
|
||||
21u, 42u, 41u, 42u, 42u, 42u, 0
|
||||
};
|
||||
|
||||
static const char _use_syllable_machine_key_spans[] = {
|
||||
0, 1, 1, 40, 1, 32, 32, 1,
|
||||
32, 32, 32, 19, 19, 19, 32, 32,
|
||||
1, 40, 1, 32, 32, 1, 32, 32,
|
||||
32, 19, 19, 19, 32, 32, 32, 32,
|
||||
32, 32, 32, 32, 32, 32, 32, 32,
|
||||
32, 32, 32, 1, 32, 32, 19, 19,
|
||||
19, 32, 32, 32, 32, 32, 32, 32,
|
||||
32, 10, 2, 32, 32, 32, 32, 19,
|
||||
9, 1, 1, 32, 32, 32, 32, 19,
|
||||
19, 19, 32, 32, 32, 32, 32, 32,
|
||||
32, 32, 32, 32, 39, 32, 22, 2,
|
||||
1
|
||||
32, 32, 32, 32, 32, 1, 39, 32,
|
||||
22, 2, 1
|
||||
};
|
||||
|
||||
static const short _use_syllable_machine_index_offsets[] = {
|
||||
0, 0, 2, 4, 45, 47, 80, 113,
|
||||
115, 148, 181, 214, 234, 254, 274, 307,
|
||||
340, 373, 406, 439, 472, 505, 538, 571,
|
||||
604, 637, 670, 703, 705, 738, 771, 791,
|
||||
811, 831, 864, 897, 930, 963, 996, 1029,
|
||||
1062, 1095, 1106, 1109, 1142, 1175, 1208, 1241,
|
||||
1261, 1281, 1301, 1334, 1367, 1400, 1433, 1466,
|
||||
1499, 1532, 1565, 1598, 1631, 1671, 1704, 1727,
|
||||
1730
|
||||
0, 2, 43, 45, 78, 111, 113, 146,
|
||||
179, 212, 232, 252, 272, 305, 338, 371,
|
||||
404, 437, 470, 503, 536, 569, 602, 635,
|
||||
668, 678, 680, 682, 715, 748, 781, 814,
|
||||
834, 854, 874, 907, 940, 973, 1006, 1039,
|
||||
1072, 1105, 1138, 1171, 1204, 1237, 1239, 1279,
|
||||
1312, 1335, 1338
|
||||
};
|
||||
|
||||
static const char _use_syllable_machine_indicies[] = {
|
||||
1, 0, 3, 2, 4, 5, 6,
|
||||
4, 1, 5, 8, 8, 7, 8, 8,
|
||||
3, 9, 8, 8, 8, 4, 4, 10,
|
||||
11, 8, 8, 12, 13, 14, 15, 16,
|
||||
17, 18, 12, 19, 20, 21, 22, 23,
|
||||
24, 8, 25, 26, 27, 8, 29, 28,
|
||||
31, 30, 30, 32, 33, 30, 30, 30,
|
||||
30, 30, 30, 30, 30, 34, 35, 36,
|
||||
37, 38, 39, 40, 41, 35, 42, 34,
|
||||
43, 44, 45, 46, 30, 47, 48, 49,
|
||||
30, 31, 30, 30, 32, 33, 30, 30,
|
||||
30, 30, 30, 30, 30, 30, 50, 35,
|
||||
36, 37, 38, 39, 40, 41, 35, 42,
|
||||
43, 43, 44, 45, 46, 30, 47, 48,
|
||||
49, 30, 32, 51, 31, 30, 30, 32,
|
||||
33, 30, 30, 30, 30, 30, 30, 30,
|
||||
30, 30, 35, 36, 37, 38, 39, 40,
|
||||
41, 35, 42, 43, 43, 44, 45, 46,
|
||||
30, 47, 48, 49, 30, 31, 30, 30,
|
||||
30, 30, 30, 30, 30, 30, 30, 30,
|
||||
30, 30, 30, 35, 36, 37, 38, 39,
|
||||
30, 30, 30, 30, 30, 30, 44, 45,
|
||||
46, 30, 47, 48, 49, 30, 31, 30,
|
||||
30, 30, 30, 30, 30, 30, 30, 30,
|
||||
30, 30, 30, 30, 30, 36, 37, 38,
|
||||
39, 30, 30, 30, 30, 30, 30, 30,
|
||||
30, 30, 30, 47, 48, 49, 30, 31,
|
||||
30, 30, 30, 30, 30, 30, 30, 30,
|
||||
30, 30, 30, 30, 30, 30, 30, 37,
|
||||
38, 39, 30, 31, 30, 30, 30, 30,
|
||||
30, 30, 30, 30, 30, 30, 30, 30,
|
||||
30, 30, 30, 30, 38, 39, 30, 31,
|
||||
30, 30, 30, 30, 30, 30, 30, 30,
|
||||
30, 30, 30, 30, 30, 30, 30, 30,
|
||||
30, 39, 30, 31, 30, 30, 30, 30,
|
||||
30, 30, 30, 30, 30, 30, 30, 30,
|
||||
30, 30, 30, 37, 38, 39, 30, 30,
|
||||
30, 30, 30, 30, 30, 30, 30, 30,
|
||||
47, 48, 49, 30, 31, 30, 30, 30,
|
||||
30, 30, 30, 30, 30, 30, 30, 30,
|
||||
30, 30, 30, 30, 37, 38, 39, 30,
|
||||
30, 30, 30, 30, 30, 30, 30, 30,
|
||||
30, 30, 48, 49, 30, 31, 30, 30,
|
||||
30, 30, 30, 30, 30, 30, 30, 30,
|
||||
30, 30, 30, 30, 30, 37, 38, 39,
|
||||
30, 30, 30, 30, 30, 30, 30, 30,
|
||||
30, 30, 30, 30, 49, 30, 31, 30,
|
||||
30, 30, 30, 30, 30, 30, 30, 30,
|
||||
30, 30, 30, 30, 30, 36, 37, 38,
|
||||
39, 30, 30, 30, 30, 30, 30, 44,
|
||||
45, 46, 30, 47, 48, 49, 30, 31,
|
||||
30, 30, 30, 30, 30, 30, 30, 30,
|
||||
30, 30, 30, 30, 30, 30, 36, 37,
|
||||
38, 39, 30, 30, 30, 30, 30, 30,
|
||||
30, 45, 46, 30, 47, 48, 49, 30,
|
||||
31, 30, 30, 30, 30, 30, 30, 30,
|
||||
30, 30, 30, 30, 30, 30, 30, 36,
|
||||
37, 38, 39, 30, 30, 30, 30, 30,
|
||||
30, 30, 30, 46, 30, 47, 48, 49,
|
||||
30, 31, 30, 30, 30, 30, 30, 30,
|
||||
30, 30, 30, 30, 30, 30, 30, 35,
|
||||
36, 37, 38, 39, 30, 41, 35, 30,
|
||||
30, 30, 44, 45, 46, 30, 47, 48,
|
||||
49, 30, 31, 30, 30, 30, 30, 30,
|
||||
30, 30, 30, 30, 30, 30, 30, 30,
|
||||
35, 36, 37, 38, 39, 30, 30, 35,
|
||||
30, 30, 30, 44, 45, 46, 30, 47,
|
||||
48, 49, 30, 31, 30, 30, 30, 30,
|
||||
30, 30, 30, 30, 30, 30, 30, 30,
|
||||
30, 35, 36, 37, 38, 39, 40, 41,
|
||||
35, 30, 30, 30, 44, 45, 46, 30,
|
||||
47, 48, 49, 30, 31, 30, 30, 32,
|
||||
33, 30, 30, 30, 30, 30, 30, 30,
|
||||
30, 30, 35, 36, 37, 38, 39, 40,
|
||||
41, 35, 42, 30, 43, 44, 45, 46,
|
||||
30, 47, 48, 49, 30, 31, 30, 30,
|
||||
32, 33, 30, 30, 30, 30, 30, 30,
|
||||
30, 30, 30, 35, 36, 37, 38, 39,
|
||||
40, 41, 35, 42, 34, 43, 44, 45,
|
||||
46, 30, 47, 48, 49, 30, 53, 52,
|
||||
52, 54, 55, 52, 52, 52, 52, 52,
|
||||
52, 52, 52, 56, 52, 57, 58, 59,
|
||||
60, 61, 62, 57, 63, 56, 64, 52,
|
||||
52, 52, 52, 65, 66, 67, 52, 53,
|
||||
52, 52, 54, 55, 52, 52, 52, 52,
|
||||
52, 52, 52, 52, 68, 52, 57, 58,
|
||||
59, 60, 61, 62, 57, 63, 64, 64,
|
||||
52, 52, 52, 52, 65, 66, 67, 52,
|
||||
54, 51, 53, 52, 52, 54, 55, 52,
|
||||
52, 52, 52, 52, 52, 52, 52, 52,
|
||||
52, 57, 58, 59, 60, 61, 62, 57,
|
||||
63, 64, 64, 52, 52, 52, 52, 65,
|
||||
66, 67, 52, 53, 52, 52, 52, 52,
|
||||
52, 52, 52, 52, 52, 52, 52, 52,
|
||||
52, 52, 57, 58, 59, 60, 52, 52,
|
||||
52, 52, 52, 52, 52, 52, 52, 52,
|
||||
65, 66, 67, 52, 53, 52, 52, 52,
|
||||
52, 52, 52, 52, 52, 52, 52, 52,
|
||||
52, 52, 52, 52, 58, 59, 60, 52,
|
||||
53, 52, 52, 52, 52, 52, 52, 52,
|
||||
52, 52, 52, 52, 52, 52, 52, 52,
|
||||
52, 59, 60, 52, 53, 52, 52, 52,
|
||||
52, 52, 52, 52, 52, 52, 52, 52,
|
||||
52, 52, 52, 52, 52, 52, 60, 52,
|
||||
53, 52, 52, 52, 52, 52, 52, 52,
|
||||
52, 52, 52, 52, 52, 52, 52, 52,
|
||||
58, 59, 60, 52, 52, 52, 52, 52,
|
||||
52, 52, 52, 52, 52, 65, 66, 67,
|
||||
52, 53, 52, 52, 52, 52, 52, 52,
|
||||
52, 52, 52, 52, 52, 52, 52, 52,
|
||||
52, 58, 59, 60, 52, 52, 52, 52,
|
||||
52, 52, 52, 52, 52, 52, 52, 66,
|
||||
67, 52, 53, 52, 52, 52, 52, 52,
|
||||
52, 52, 52, 52, 52, 52, 52, 52,
|
||||
52, 52, 58, 59, 60, 52, 52, 52,
|
||||
52, 52, 52, 52, 52, 52, 52, 52,
|
||||
52, 67, 52, 53, 52, 52, 52, 52,
|
||||
52, 52, 52, 52, 52, 52, 52, 52,
|
||||
52, 52, 57, 58, 59, 60, 52, 62,
|
||||
57, 52, 52, 52, 52, 52, 52, 52,
|
||||
65, 66, 67, 52, 53, 52, 52, 52,
|
||||
52, 52, 52, 52, 52, 52, 52, 52,
|
||||
52, 52, 52, 57, 58, 59, 60, 52,
|
||||
52, 57, 52, 52, 52, 52, 52, 52,
|
||||
52, 65, 66, 67, 52, 53, 52, 52,
|
||||
52, 52, 52, 52, 52, 52, 52, 52,
|
||||
52, 52, 52, 52, 57, 58, 59, 60,
|
||||
61, 62, 57, 52, 52, 52, 52, 52,
|
||||
52, 52, 65, 66, 67, 52, 53, 52,
|
||||
52, 54, 55, 52, 52, 52, 52, 52,
|
||||
52, 52, 52, 52, 52, 57, 58, 59,
|
||||
60, 61, 62, 57, 63, 52, 64, 52,
|
||||
52, 52, 52, 65, 66, 67, 52, 53,
|
||||
52, 52, 54, 55, 52, 52, 52, 52,
|
||||
52, 52, 52, 52, 52, 52, 57, 58,
|
||||
59, 60, 61, 62, 57, 63, 56, 64,
|
||||
52, 52, 52, 52, 65, 66, 67, 52,
|
||||
70, 71, 69, 69, 69, 69, 69, 69,
|
||||
69, 72, 69, 70, 71, 69, 7, 73,
|
||||
73, 3, 9, 73, 73, 73, 73, 73,
|
||||
73, 73, 73, 74, 12, 13, 14, 15,
|
||||
16, 17, 18, 12, 19, 21, 21, 22,
|
||||
23, 24, 73, 25, 26, 27, 73, 7,
|
||||
73, 73, 3, 9, 73, 73, 73, 73,
|
||||
73, 73, 73, 73, 73, 12, 13, 14,
|
||||
15, 16, 17, 18, 12, 19, 21, 21,
|
||||
22, 23, 24, 73, 25, 26, 27, 73,
|
||||
7, 73, 73, 73, 73, 73, 73, 73,
|
||||
73, 73, 73, 73, 73, 73, 12, 13,
|
||||
14, 15, 16, 73, 73, 73, 73, 73,
|
||||
73, 22, 23, 24, 73, 25, 26, 27,
|
||||
73, 7, 73, 73, 73, 73, 73, 73,
|
||||
73, 73, 73, 73, 73, 73, 73, 73,
|
||||
13, 14, 15, 16, 73, 73, 73, 73,
|
||||
73, 73, 73, 73, 73, 73, 25, 26,
|
||||
27, 73, 7, 73, 73, 73, 73, 73,
|
||||
73, 73, 73, 73, 73, 73, 73, 73,
|
||||
73, 73, 14, 15, 16, 73, 7, 73,
|
||||
73, 73, 73, 73, 73, 73, 73, 73,
|
||||
73, 73, 73, 73, 73, 73, 73, 15,
|
||||
16, 73, 7, 73, 73, 73, 73, 73,
|
||||
73, 73, 73, 73, 73, 73, 73, 73,
|
||||
73, 73, 73, 73, 16, 73, 7, 73,
|
||||
73, 73, 73, 73, 73, 73, 73, 73,
|
||||
73, 73, 73, 73, 73, 73, 14, 15,
|
||||
16, 73, 73, 73, 73, 73, 73, 73,
|
||||
73, 73, 73, 25, 26, 27, 73, 7,
|
||||
73, 73, 73, 73, 73, 73, 73, 73,
|
||||
73, 73, 73, 73, 73, 73, 73, 14,
|
||||
15, 16, 73, 73, 73, 73, 73, 73,
|
||||
73, 73, 73, 73, 73, 26, 27, 73,
|
||||
7, 73, 73, 73, 73, 73, 73, 73,
|
||||
73, 73, 73, 73, 73, 73, 73, 73,
|
||||
14, 15, 16, 73, 73, 73, 73, 73,
|
||||
73, 73, 73, 73, 73, 73, 73, 27,
|
||||
73, 7, 73, 73, 73, 73, 73, 73,
|
||||
73, 73, 73, 73, 73, 73, 73, 73,
|
||||
13, 14, 15, 16, 73, 73, 73, 73,
|
||||
73, 73, 22, 23, 24, 73, 25, 26,
|
||||
27, 73, 7, 73, 73, 73, 73, 73,
|
||||
73, 73, 73, 73, 73, 73, 73, 73,
|
||||
73, 13, 14, 15, 16, 73, 73, 73,
|
||||
73, 73, 73, 73, 23, 24, 73, 25,
|
||||
26, 27, 73, 7, 73, 73, 73, 73,
|
||||
73, 73, 73, 73, 73, 73, 73, 73,
|
||||
73, 73, 13, 14, 15, 16, 73, 73,
|
||||
73, 73, 73, 73, 73, 73, 24, 73,
|
||||
25, 26, 27, 73, 7, 73, 73, 73,
|
||||
73, 73, 73, 73, 73, 73, 73, 73,
|
||||
73, 73, 12, 13, 14, 15, 16, 73,
|
||||
18, 12, 73, 73, 73, 22, 23, 24,
|
||||
73, 25, 26, 27, 73, 7, 73, 73,
|
||||
73, 73, 73, 73, 73, 73, 73, 73,
|
||||
73, 73, 73, 12, 13, 14, 15, 16,
|
||||
73, 73, 12, 73, 73, 73, 22, 23,
|
||||
24, 73, 25, 26, 27, 73, 7, 73,
|
||||
73, 73, 73, 73, 73, 73, 73, 73,
|
||||
73, 73, 73, 73, 12, 13, 14, 15,
|
||||
16, 17, 18, 12, 73, 73, 73, 22,
|
||||
23, 24, 73, 25, 26, 27, 73, 7,
|
||||
73, 73, 3, 9, 73, 73, 73, 73,
|
||||
73, 73, 73, 73, 73, 12, 13, 14,
|
||||
15, 16, 17, 18, 12, 19, 73, 21,
|
||||
22, 23, 24, 73, 25, 26, 27, 73,
|
||||
5, 6, 73, 73, 5, 73, 73, 7,
|
||||
73, 73, 3, 9, 73, 73, 73, 73,
|
||||
73, 73, 73, 73, 73, 12, 13, 14,
|
||||
15, 16, 17, 18, 12, 19, 20, 21,
|
||||
22, 23, 24, 73, 25, 26, 27, 73,
|
||||
7, 73, 73, 3, 9, 73, 73, 73,
|
||||
73, 73, 73, 73, 73, 73, 12, 13,
|
||||
14, 15, 16, 17, 18, 12, 19, 20,
|
||||
21, 22, 23, 24, 73, 25, 26, 27,
|
||||
73, 76, 75, 75, 75, 75, 75, 75,
|
||||
75, 75, 75, 75, 75, 75, 75, 75,
|
||||
75, 75, 75, 75, 75, 76, 77, 75,
|
||||
76, 77, 75, 77, 75, 0
|
||||
1, 0, 2, 3, 4, 2, 5, 3,
|
||||
4, 4, 6, 4, 4, 1, 7, 4,
|
||||
4, 4, 2, 2, 8, 9, 4, 4,
|
||||
10, 11, 12, 13, 14, 15, 16, 10,
|
||||
17, 18, 19, 20, 21, 22, 4, 23,
|
||||
24, 25, 4, 27, 26, 29, 28, 28,
|
||||
30, 31, 28, 28, 28, 28, 28, 28,
|
||||
28, 28, 32, 33, 34, 35, 36, 37,
|
||||
38, 39, 33, 40, 32, 41, 42, 43,
|
||||
44, 28, 45, 46, 47, 28, 29, 28,
|
||||
28, 30, 31, 28, 28, 28, 28, 28,
|
||||
28, 28, 28, 48, 33, 34, 35, 36,
|
||||
37, 38, 39, 33, 40, 41, 41, 42,
|
||||
43, 44, 28, 45, 46, 47, 28, 30,
|
||||
49, 29, 28, 28, 30, 31, 28, 28,
|
||||
28, 28, 28, 28, 28, 28, 28, 33,
|
||||
34, 35, 36, 37, 38, 39, 33, 40,
|
||||
41, 41, 42, 43, 44, 28, 45, 46,
|
||||
47, 28, 29, 28, 28, 28, 28, 28,
|
||||
28, 28, 28, 28, 28, 28, 28, 28,
|
||||
33, 34, 35, 36, 37, 28, 28, 28,
|
||||
28, 28, 28, 42, 43, 44, 28, 45,
|
||||
46, 47, 28, 29, 28, 28, 28, 28,
|
||||
28, 28, 28, 28, 28, 28, 28, 28,
|
||||
28, 28, 34, 35, 36, 37, 28, 28,
|
||||
28, 28, 28, 28, 28, 28, 28, 28,
|
||||
45, 46, 47, 28, 29, 28, 28, 28,
|
||||
28, 28, 28, 28, 28, 28, 28, 28,
|
||||
28, 28, 28, 28, 35, 36, 37, 28,
|
||||
29, 28, 28, 28, 28, 28, 28, 28,
|
||||
28, 28, 28, 28, 28, 28, 28, 28,
|
||||
28, 36, 37, 28, 29, 28, 28, 28,
|
||||
28, 28, 28, 28, 28, 28, 28, 28,
|
||||
28, 28, 28, 28, 28, 28, 37, 28,
|
||||
29, 28, 28, 28, 28, 28, 28, 28,
|
||||
28, 28, 28, 28, 28, 28, 28, 28,
|
||||
35, 36, 37, 28, 28, 28, 28, 28,
|
||||
28, 28, 28, 28, 28, 45, 46, 47,
|
||||
28, 29, 28, 28, 28, 28, 28, 28,
|
||||
28, 28, 28, 28, 28, 28, 28, 28,
|
||||
28, 35, 36, 37, 28, 28, 28, 28,
|
||||
28, 28, 28, 28, 28, 28, 28, 46,
|
||||
47, 28, 29, 28, 28, 28, 28, 28,
|
||||
28, 28, 28, 28, 28, 28, 28, 28,
|
||||
28, 28, 35, 36, 37, 28, 28, 28,
|
||||
28, 28, 28, 28, 28, 28, 28, 28,
|
||||
28, 47, 28, 29, 28, 28, 28, 28,
|
||||
28, 28, 28, 28, 28, 28, 28, 28,
|
||||
28, 28, 34, 35, 36, 37, 28, 28,
|
||||
28, 28, 28, 28, 42, 43, 44, 28,
|
||||
45, 46, 47, 28, 29, 28, 28, 28,
|
||||
28, 28, 28, 28, 28, 28, 28, 28,
|
||||
28, 28, 28, 34, 35, 36, 37, 28,
|
||||
28, 28, 28, 28, 28, 28, 43, 44,
|
||||
28, 45, 46, 47, 28, 29, 28, 28,
|
||||
28, 28, 28, 28, 28, 28, 28, 28,
|
||||
28, 28, 28, 28, 34, 35, 36, 37,
|
||||
28, 28, 28, 28, 28, 28, 28, 28,
|
||||
44, 28, 45, 46, 47, 28, 29, 28,
|
||||
28, 28, 28, 28, 28, 28, 28, 28,
|
||||
28, 28, 28, 28, 33, 34, 35, 36,
|
||||
37, 28, 39, 33, 28, 28, 28, 42,
|
||||
43, 44, 28, 45, 46, 47, 28, 29,
|
||||
28, 28, 28, 28, 28, 28, 28, 28,
|
||||
28, 28, 28, 28, 28, 33, 34, 35,
|
||||
36, 37, 28, 50, 33, 28, 28, 28,
|
||||
42, 43, 44, 28, 45, 46, 47, 28,
|
||||
29, 28, 28, 28, 28, 28, 28, 28,
|
||||
28, 28, 28, 28, 28, 28, 33, 34,
|
||||
35, 36, 37, 28, 28, 33, 28, 28,
|
||||
28, 42, 43, 44, 28, 45, 46, 47,
|
||||
28, 29, 28, 28, 28, 28, 28, 28,
|
||||
28, 28, 28, 28, 28, 28, 28, 33,
|
||||
34, 35, 36, 37, 38, 39, 33, 28,
|
||||
28, 28, 42, 43, 44, 28, 45, 46,
|
||||
47, 28, 29, 28, 28, 30, 31, 28,
|
||||
28, 28, 28, 28, 28, 28, 28, 28,
|
||||
33, 34, 35, 36, 37, 38, 39, 33,
|
||||
40, 28, 41, 42, 43, 44, 28, 45,
|
||||
46, 47, 28, 29, 28, 28, 30, 31,
|
||||
28, 28, 28, 28, 28, 28, 28, 28,
|
||||
28, 33, 34, 35, 36, 37, 38, 39,
|
||||
33, 40, 32, 41, 42, 43, 44, 28,
|
||||
45, 46, 47, 28, 52, 51, 51, 51,
|
||||
51, 51, 51, 51, 53, 51, 5, 54,
|
||||
52, 51, 6, 55, 55, 1, 56, 55,
|
||||
55, 55, 55, 55, 55, 55, 55, 57,
|
||||
10, 11, 12, 13, 14, 15, 16, 10,
|
||||
17, 19, 19, 20, 21, 22, 55, 23,
|
||||
24, 25, 55, 6, 55, 55, 1, 56,
|
||||
55, 55, 55, 55, 55, 55, 55, 55,
|
||||
55, 10, 11, 12, 13, 14, 15, 16,
|
||||
10, 17, 19, 19, 20, 21, 22, 55,
|
||||
23, 24, 25, 55, 6, 55, 55, 55,
|
||||
55, 55, 55, 55, 55, 55, 55, 55,
|
||||
55, 55, 10, 11, 12, 13, 14, 55,
|
||||
55, 55, 55, 55, 55, 20, 21, 22,
|
||||
55, 23, 24, 25, 55, 6, 55, 55,
|
||||
55, 55, 55, 55, 55, 55, 55, 55,
|
||||
55, 55, 55, 55, 11, 12, 13, 14,
|
||||
55, 55, 55, 55, 55, 55, 55, 55,
|
||||
55, 55, 23, 24, 25, 55, 6, 55,
|
||||
55, 55, 55, 55, 55, 55, 55, 55,
|
||||
55, 55, 55, 55, 55, 55, 12, 13,
|
||||
14, 55, 6, 55, 55, 55, 55, 55,
|
||||
55, 55, 55, 55, 55, 55, 55, 55,
|
||||
55, 55, 55, 13, 14, 55, 6, 55,
|
||||
55, 55, 55, 55, 55, 55, 55, 55,
|
||||
55, 55, 55, 55, 55, 55, 55, 55,
|
||||
14, 55, 6, 55, 55, 55, 55, 55,
|
||||
55, 55, 55, 55, 55, 55, 55, 55,
|
||||
55, 55, 12, 13, 14, 55, 55, 55,
|
||||
55, 55, 55, 55, 55, 55, 55, 23,
|
||||
24, 25, 55, 6, 55, 55, 55, 55,
|
||||
55, 55, 55, 55, 55, 55, 55, 55,
|
||||
55, 55, 55, 12, 13, 14, 55, 55,
|
||||
55, 55, 55, 55, 55, 55, 55, 55,
|
||||
55, 24, 25, 55, 6, 55, 55, 55,
|
||||
55, 55, 55, 55, 55, 55, 55, 55,
|
||||
55, 55, 55, 55, 12, 13, 14, 55,
|
||||
55, 55, 55, 55, 55, 55, 55, 55,
|
||||
55, 55, 55, 25, 55, 6, 55, 55,
|
||||
55, 55, 55, 55, 55, 55, 55, 55,
|
||||
55, 55, 55, 55, 11, 12, 13, 14,
|
||||
55, 55, 55, 55, 55, 55, 20, 21,
|
||||
22, 55, 23, 24, 25, 55, 6, 55,
|
||||
55, 55, 55, 55, 55, 55, 55, 55,
|
||||
55, 55, 55, 55, 55, 11, 12, 13,
|
||||
14, 55, 55, 55, 55, 55, 55, 55,
|
||||
21, 22, 55, 23, 24, 25, 55, 6,
|
||||
55, 55, 55, 55, 55, 55, 55, 55,
|
||||
55, 55, 55, 55, 55, 55, 11, 12,
|
||||
13, 14, 55, 55, 55, 55, 55, 55,
|
||||
55, 55, 22, 55, 23, 24, 25, 55,
|
||||
6, 55, 55, 55, 55, 55, 55, 55,
|
||||
55, 55, 55, 55, 55, 55, 10, 11,
|
||||
12, 13, 14, 55, 16, 10, 55, 55,
|
||||
55, 20, 21, 22, 55, 23, 24, 25,
|
||||
55, 6, 55, 55, 55, 55, 55, 55,
|
||||
55, 55, 55, 55, 55, 55, 55, 10,
|
||||
11, 12, 13, 14, 55, 58, 10, 55,
|
||||
55, 55, 20, 21, 22, 55, 23, 24,
|
||||
25, 55, 6, 55, 55, 55, 55, 55,
|
||||
55, 55, 55, 55, 55, 55, 55, 55,
|
||||
10, 11, 12, 13, 14, 55, 55, 10,
|
||||
55, 55, 55, 20, 21, 22, 55, 23,
|
||||
24, 25, 55, 6, 55, 55, 55, 55,
|
||||
55, 55, 55, 55, 55, 55, 55, 55,
|
||||
55, 10, 11, 12, 13, 14, 15, 16,
|
||||
10, 55, 55, 55, 20, 21, 22, 55,
|
||||
23, 24, 25, 55, 6, 55, 55, 1,
|
||||
56, 55, 55, 55, 55, 55, 55, 55,
|
||||
55, 55, 10, 11, 12, 13, 14, 15,
|
||||
16, 10, 17, 55, 19, 20, 21, 22,
|
||||
55, 23, 24, 25, 55, 1, 59, 3,
|
||||
55, 55, 55, 3, 55, 55, 6, 55,
|
||||
55, 1, 56, 55, 55, 55, 55, 55,
|
||||
55, 55, 55, 55, 10, 11, 12, 13,
|
||||
14, 15, 16, 10, 17, 18, 19, 20,
|
||||
21, 22, 55, 23, 24, 25, 55, 6,
|
||||
55, 55, 1, 56, 55, 55, 55, 55,
|
||||
55, 55, 55, 55, 55, 10, 11, 12,
|
||||
13, 14, 15, 16, 10, 17, 18, 19,
|
||||
20, 21, 22, 55, 23, 24, 25, 55,
|
||||
61, 60, 60, 60, 60, 60, 60, 60,
|
||||
60, 60, 60, 60, 60, 60, 60, 60,
|
||||
60, 60, 60, 60, 61, 62, 60, 61,
|
||||
62, 60, 62, 60, 0
|
||||
};
|
||||
|
||||
static const char _use_syllable_machine_trans_targs[] = {
|
||||
3, 41, 3, 43, 4, 5, 25, 3,
|
||||
0, 2, 60, 62, 45, 46, 47, 48,
|
||||
49, 56, 57, 58, 61, 59, 53, 54,
|
||||
55, 50, 51, 52, 3, 3, 3, 3,
|
||||
6, 7, 24, 9, 10, 11, 12, 13,
|
||||
20, 21, 22, 23, 17, 18, 19, 14,
|
||||
15, 16, 8, 3, 3, 3, 26, 27,
|
||||
40, 29, 30, 31, 32, 36, 37, 38,
|
||||
39, 33, 34, 35, 28, 3, 3, 1,
|
||||
42, 3, 44, 3, 63, 64
|
||||
1, 27, 2, 3, 1, 24, 1, 45,
|
||||
46, 48, 29, 30, 31, 32, 33, 40,
|
||||
41, 43, 47, 44, 37, 38, 39, 34,
|
||||
35, 36, 1, 1, 1, 1, 4, 5,
|
||||
23, 7, 8, 9, 10, 11, 18, 19,
|
||||
21, 22, 15, 16, 17, 12, 13, 14,
|
||||
6, 1, 20, 1, 25, 26, 1, 1,
|
||||
0, 28, 42, 1, 1, 49, 50
|
||||
};
|
||||
|
||||
static const char _use_syllable_machine_trans_actions[] = {
|
||||
1, 2, 3, 4, 0, 0, 0, 7,
|
||||
0, 0, 4, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 4, 4, 0, 0,
|
||||
0, 0, 0, 0, 8, 9, 10, 11,
|
||||
1, 2, 0, 0, 5, 0, 6, 0,
|
||||
2, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 2, 2, 0, 0, 0, 0,
|
||||
0, 0, 7, 8, 9, 10, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 12, 13, 14, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 15, 16, 0,
|
||||
2, 17, 4, 18, 0, 0
|
||||
0, 11, 0, 12, 0, 0, 13, 14,
|
||||
0, 2, 0, 15, 16, 0, 0
|
||||
};
|
||||
|
||||
static const char _use_syllable_machine_to_state_actions[] = {
|
||||
0, 0, 0, 5, 0, 0, 0, 0,
|
||||
0, 3, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0
|
||||
0, 0, 0
|
||||
};
|
||||
|
||||
static const char _use_syllable_machine_from_state_actions[] = {
|
||||
0, 0, 0, 6, 0, 0, 0, 0,
|
||||
0, 4, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0
|
||||
0, 0, 0
|
||||
};
|
||||
|
||||
static const short _use_syllable_machine_eof_trans[] = {
|
||||
0, 1, 3, 0, 29, 31, 31, 52,
|
||||
31, 31, 31, 31, 31, 31, 31, 31,
|
||||
31, 31, 31, 31, 31, 31, 31, 31,
|
||||
31, 53, 53, 52, 53, 53, 53, 53,
|
||||
53, 53, 53, 53, 53, 53, 53, 53,
|
||||
53, 70, 70, 74, 74, 74, 74, 74,
|
||||
74, 74, 74, 74, 74, 74, 74, 74,
|
||||
74, 74, 74, 74, 74, 74, 76, 76,
|
||||
76
|
||||
1, 0, 27, 29, 29, 50, 29, 29,
|
||||
29, 29, 29, 29, 29, 29, 29, 29,
|
||||
29, 29, 29, 29, 29, 29, 29, 29,
|
||||
52, 55, 52, 56, 56, 56, 56, 56,
|
||||
56, 56, 56, 56, 56, 56, 56, 56,
|
||||
56, 56, 56, 56, 56, 60, 56, 56,
|
||||
61, 61, 61
|
||||
};
|
||||
|
||||
static const int use_syllable_machine_start = 3;
|
||||
static const int use_syllable_machine_first_final = 3;
|
||||
static const int use_syllable_machine_error = 0;
|
||||
static const int use_syllable_machine_start = 1;
|
||||
static const int use_syllable_machine_first_final = 1;
|
||||
static const int use_syllable_machine_error = -1;
|
||||
|
||||
static const int use_syllable_machine_en_main = 3;
|
||||
static const int use_syllable_machine_en_main = 1;
|
||||
|
||||
|
||||
#line 38 "hb-ot-shape-complex-use-machine.rl"
|
||||
|
||||
|
||||
|
||||
#line 145 "hb-ot-shape-complex-use-machine.rl"
|
||||
#line 139 "hb-ot-shape-complex-use-machine.rl"
|
||||
|
||||
|
||||
#define found_syllable(syllable_type) \
|
||||
|
@ -384,7 +319,7 @@ find_syllables (hb_buffer_t *buffer)
|
|||
int cs;
|
||||
hb_glyph_info_t *info = buffer->info;
|
||||
|
||||
#line 388 "hb-ot-shape-complex-use-machine.hh"
|
||||
#line 323 "hb-ot-shape-complex-use-machine.hh"
|
||||
{
|
||||
cs = use_syllable_machine_start;
|
||||
ts = 0;
|
||||
|
@ -392,7 +327,7 @@ find_syllables (hb_buffer_t *buffer)
|
|||
act = 0;
|
||||
}
|
||||
|
||||
#line 166 "hb-ot-shape-complex-use-machine.rl"
|
||||
#line 160 "hb-ot-shape-complex-use-machine.rl"
|
||||
|
||||
|
||||
p = 0;
|
||||
|
@ -401,7 +336,7 @@ find_syllables (hb_buffer_t *buffer)
|
|||
unsigned int last = 0;
|
||||
unsigned int syllable_serial = 1;
|
||||
|
||||
#line 405 "hb-ot-shape-complex-use-machine.hh"
|
||||
#line 340 "hb-ot-shape-complex-use-machine.hh"
|
||||
{
|
||||
int _slen;
|
||||
int _trans;
|
||||
|
@ -409,15 +344,13 @@ find_syllables (hb_buffer_t *buffer)
|
|||
const char *_inds;
|
||||
if ( p == pe )
|
||||
goto _test_eof;
|
||||
if ( cs == 0 )
|
||||
goto _out;
|
||||
_resume:
|
||||
switch ( _use_syllable_machine_from_state_actions[cs] ) {
|
||||
case 6:
|
||||
case 4:
|
||||
#line 1 "NONE"
|
||||
{ts = p;}
|
||||
break;
|
||||
#line 421 "hb-ot-shape-complex-use-machine.hh"
|
||||
#line 354 "hb-ot-shape-complex-use-machine.hh"
|
||||
}
|
||||
|
||||
_keys = _use_syllable_machine_trans_keys + (cs<<1);
|
||||
|
@ -439,92 +372,70 @@ _eof_trans:
|
|||
#line 1 "NONE"
|
||||
{te = p+1;}
|
||||
break;
|
||||
case 9:
|
||||
#line 134 "hb-ot-shape-complex-use-machine.rl"
|
||||
case 8:
|
||||
#line 128 "hb-ot-shape-complex-use-machine.rl"
|
||||
{te = p+1;{ found_syllable (independent_cluster); }}
|
||||
break;
|
||||
case 11:
|
||||
#line 136 "hb-ot-shape-complex-use-machine.rl"
|
||||
{te = p+1;{ found_syllable (consonant_cluster); }}
|
||||
case 10:
|
||||
#line 130 "hb-ot-shape-complex-use-machine.rl"
|
||||
{te = p+1;{ found_syllable (standard_cluster); }}
|
||||
break;
|
||||
case 14:
|
||||
#line 137 "hb-ot-shape-complex-use-machine.rl"
|
||||
{te = p+1;{ found_syllable (vowel_cluster); }}
|
||||
break;
|
||||
case 16:
|
||||
#line 138 "hb-ot-shape-complex-use-machine.rl"
|
||||
{te = p+1;{ found_syllable (number_joiner_terminated_cluster); }}
|
||||
break;
|
||||
case 7:
|
||||
#line 141 "hb-ot-shape-complex-use-machine.rl"
|
||||
case 6:
|
||||
#line 134 "hb-ot-shape-complex-use-machine.rl"
|
||||
{te = p+1;{ found_syllable (broken_cluster); }}
|
||||
break;
|
||||
case 8:
|
||||
#line 134 "hb-ot-shape-complex-use-machine.rl"
|
||||
case 5:
|
||||
#line 135 "hb-ot-shape-complex-use-machine.rl"
|
||||
{te = p+1;{ found_syllable (non_cluster); }}
|
||||
break;
|
||||
case 7:
|
||||
#line 128 "hb-ot-shape-complex-use-machine.rl"
|
||||
{te = p;p--;{ found_syllable (independent_cluster); }}
|
||||
break;
|
||||
case 12:
|
||||
#line 135 "hb-ot-shape-complex-use-machine.rl"
|
||||
case 11:
|
||||
#line 129 "hb-ot-shape-complex-use-machine.rl"
|
||||
{te = p;p--;{ found_syllable (virama_terminated_cluster); }}
|
||||
break;
|
||||
case 10:
|
||||
#line 136 "hb-ot-shape-complex-use-machine.rl"
|
||||
{te = p;p--;{ found_syllable (consonant_cluster); }}
|
||||
case 9:
|
||||
#line 130 "hb-ot-shape-complex-use-machine.rl"
|
||||
{te = p;p--;{ found_syllable (standard_cluster); }}
|
||||
break;
|
||||
case 13:
|
||||
#line 137 "hb-ot-shape-complex-use-machine.rl"
|
||||
{te = p;p--;{ found_syllable (vowel_cluster); }}
|
||||
#line 131 "hb-ot-shape-complex-use-machine.rl"
|
||||
{te = p;p--;{ found_syllable (number_joiner_terminated_cluster); }}
|
||||
break;
|
||||
case 15:
|
||||
#line 139 "hb-ot-shape-complex-use-machine.rl"
|
||||
case 12:
|
||||
#line 132 "hb-ot-shape-complex-use-machine.rl"
|
||||
{te = p;p--;{ found_syllable (numeral_cluster); }}
|
||||
break;
|
||||
case 18:
|
||||
#line 140 "hb-ot-shape-complex-use-machine.rl"
|
||||
case 16:
|
||||
#line 133 "hb-ot-shape-complex-use-machine.rl"
|
||||
{te = p;p--;{ found_syllable (symbol_cluster); }}
|
||||
break;
|
||||
case 17:
|
||||
#line 141 "hb-ot-shape-complex-use-machine.rl"
|
||||
case 14:
|
||||
#line 134 "hb-ot-shape-complex-use-machine.rl"
|
||||
{te = p;p--;{ found_syllable (broken_cluster); }}
|
||||
break;
|
||||
case 15:
|
||||
#line 135 "hb-ot-shape-complex-use-machine.rl"
|
||||
{te = p;p--;{ found_syllable (non_cluster); }}
|
||||
break;
|
||||
case 1:
|
||||
#line 139 "hb-ot-shape-complex-use-machine.rl"
|
||||
{{p = ((te))-1;}{ found_syllable (numeral_cluster); }}
|
||||
#line 134 "hb-ot-shape-complex-use-machine.rl"
|
||||
{{p = ((te))-1;}{ found_syllable (broken_cluster); }}
|
||||
break;
|
||||
case 3:
|
||||
#line 1 "NONE"
|
||||
{ switch( act ) {
|
||||
case 0:
|
||||
{{cs = 0; goto _again;}}
|
||||
break;
|
||||
case 8:
|
||||
{{p = ((te))-1;} found_syllable (broken_cluster); }
|
||||
break;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case 4:
|
||||
#line 1 "NONE"
|
||||
{te = p+1;}
|
||||
#line 141 "hb-ot-shape-complex-use-machine.rl"
|
||||
{act = 8;}
|
||||
break;
|
||||
#line 513 "hb-ot-shape-complex-use-machine.hh"
|
||||
#line 428 "hb-ot-shape-complex-use-machine.hh"
|
||||
}
|
||||
|
||||
_again:
|
||||
switch ( _use_syllable_machine_to_state_actions[cs] ) {
|
||||
case 5:
|
||||
case 3:
|
||||
#line 1 "NONE"
|
||||
{ts = 0;}
|
||||
#line 1 "NONE"
|
||||
{act = 0;}
|
||||
break;
|
||||
#line 524 "hb-ot-shape-complex-use-machine.hh"
|
||||
#line 437 "hb-ot-shape-complex-use-machine.hh"
|
||||
}
|
||||
|
||||
if ( cs == 0 )
|
||||
goto _out;
|
||||
if ( ++p != pe )
|
||||
goto _resume;
|
||||
_test_eof: {}
|
||||
|
@ -536,10 +447,9 @@ _again:
|
|||
}
|
||||
}
|
||||
|
||||
_out: {}
|
||||
}
|
||||
|
||||
#line 175 "hb-ot-shape-complex-use-machine.rl"
|
||||
#line 169 "hb-ot-shape-complex-use-machine.rl"
|
||||
|
||||
}
|
||||
|
||||
|
|
|
@ -44,7 +44,6 @@
|
|||
O = 0; # OTHER
|
||||
|
||||
B = 1; # BASE
|
||||
IV = 2; # BASE_VOWEL
|
||||
IND = 3; # BASE_IND
|
||||
N = 4; # BASE_NUM
|
||||
GB = 5; # BASE_OTHER
|
||||
|
@ -90,17 +89,18 @@ SMBlw = 42; # SYM_MOD_BELOW
|
|||
|
||||
|
||||
consonant_modifiers = CMAbv* CMBlw* ((H B | SUB) VS? CMAbv? CMBlw*)*;
|
||||
medial_consonants = MPre? MAbv? MBlw? MPst?;
|
||||
# Override: Allow two MBlw. https://github.com/behdad/harfbuzz/issues/376
|
||||
medial_consonants = MPre? MAbv? MBlw?.MBlw? MPst?;
|
||||
dependent_vowels = VPre* VAbv* VBlw* VPst*;
|
||||
vowel_modifiers = VMPre* VMAbv* VMBlw* VMPst*;
|
||||
final_consonants = FAbv* FBlw* FPst* FM?;
|
||||
|
||||
virama_terminated_cluster =
|
||||
R? (B | GB | IV) VS?
|
||||
R? (B | GB) VS?
|
||||
consonant_modifiers
|
||||
H
|
||||
;
|
||||
consonant_cluster =
|
||||
standard_cluster =
|
||||
R? (B | GB) VS?
|
||||
consonant_modifiers
|
||||
medial_consonants
|
||||
|
@ -108,13 +108,6 @@ consonant_cluster =
|
|||
vowel_modifiers
|
||||
final_consonants
|
||||
;
|
||||
vowel_cluster =
|
||||
R? (IV) VS?
|
||||
consonant_modifiers
|
||||
medial_consonants
|
||||
vowel_modifiers
|
||||
final_consonants
|
||||
;
|
||||
|
||||
broken_cluster =
|
||||
R?
|
||||
|
@ -125,20 +118,21 @@ broken_cluster =
|
|||
final_consonants
|
||||
;
|
||||
|
||||
number_joiner_terminated_cluster = N VS? (HN N VS?)* H;
|
||||
number_joiner_terminated_cluster = N VS? (HN N VS?)* HN;
|
||||
numeral_cluster = N VS? (HN N VS?)*;
|
||||
symbol_cluster = S VS? SMAbv* SMBlw*;
|
||||
independent_cluster = (IND | O | Rsv | WJ) VS?;
|
||||
other = any;
|
||||
|
||||
main := |*
|
||||
independent_cluster => { found_syllable (independent_cluster); };
|
||||
virama_terminated_cluster => { found_syllable (virama_terminated_cluster); };
|
||||
consonant_cluster => { found_syllable (consonant_cluster); };
|
||||
vowel_cluster => { found_syllable (vowel_cluster); };
|
||||
standard_cluster => { found_syllable (standard_cluster); };
|
||||
number_joiner_terminated_cluster => { found_syllable (number_joiner_terminated_cluster); };
|
||||
numeral_cluster => { found_syllable (numeral_cluster); };
|
||||
symbol_cluster => { found_syllable (symbol_cluster); };
|
||||
broken_cluster => { found_syllable (broken_cluster); };
|
||||
other => { found_syllable (non_cluster); };
|
||||
*|;
|
||||
|
||||
|
||||
|
|
|
@ -46,7 +46,6 @@ enum use_category_t {
|
|||
USE_O = 0, /* OTHER */
|
||||
|
||||
USE_B = 1, /* BASE */
|
||||
USE_IV = 2, /* BASE_VOWEL */
|
||||
USE_IND = 3, /* BASE_IND */
|
||||
USE_N = 4, /* BASE_NUM */
|
||||
USE_GB = 5, /* BASE_OTHER */
|
||||
|
|
|
@ -6,12 +6,12 @@
|
|||
*
|
||||
* on files with these headers:
|
||||
*
|
||||
* # IndicSyllabicCategory-8.0.0.txt
|
||||
* # Date: 2015-05-12, 10:00:00 GMT [RP, KW, LI]
|
||||
* # IndicPositionalCategory-8.0.0.txt
|
||||
* # Date: 2015-05-12, 10:00:00 GMT [RP, KW, LI]
|
||||
* # Blocks-8.0.0.txt
|
||||
* # Date: 2014-11-10, 23:04:00 GMT [KW]
|
||||
* # IndicSyllabicCategory-9.0.0.txt
|
||||
* # Date: 2016-05-21, 02:46:00 GMT [RP]
|
||||
* # IndicPositionalCategory-9.0.0.txt
|
||||
* # Date: 2016-06-09, 19:33:00 GMT [RP]
|
||||
* # Blocks-9.0.0.txt
|
||||
* # Date: 2016-02-05, 23:48:00 GMT [KW]
|
||||
* UnicodeData.txt does not have a header.
|
||||
*/
|
||||
|
||||
|
@ -24,7 +24,6 @@
|
|||
#define H USE_H /* HALANT */
|
||||
#define HN USE_HN /* HALANT_NUM */
|
||||
#define IND USE_IND /* BASE_IND */
|
||||
#define IV USE_IV /* BASE_VOWEL */
|
||||
#define N USE_N /* BASE_NUM */
|
||||
#define O USE_O /* OTHER */
|
||||
#define R USE_R /* REPHA */
|
||||
|
@ -80,30 +79,30 @@ static const USE_TABLE_ELEMENT_TYPE use_table[] = {
|
|||
|
||||
/* Devanagari */
|
||||
|
||||
/* 0900 */ VMAbv, VMAbv, VMAbv, VMPst, IV, IV, IV, IV, IV, IV, IV, IV, IV, IV, IV, IV,
|
||||
/* 0910 */ IV, IV, IV, IV, IV, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 0900 */ VMAbv, VMAbv, VMAbv, VMPst, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 0910 */ B, B, B, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 0920 */ B, B, B, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 0930 */ B, B, B, B, B, B, B, B, B, B, VAbv, VPst, CMBlw, B, VPst, VPre,
|
||||
/* 0940 */ VPst, VBlw, VBlw, VBlw, VBlw, VAbv, VAbv, VAbv, VAbv, VPst, VPst, VPst, VPst, H, VPre, VPst,
|
||||
/* 0950 */ O, VMAbv, VMBlw, O, O, VAbv, VBlw, VBlw, B, B, B, B, B, B, B, B,
|
||||
/* 0960 */ IV, IV, VBlw, VBlw, O, O, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 0970 */ O, O, IV, IV, IV, IV, IV, IV, B, B, B, B, B, B, B, B,
|
||||
/* 0960 */ B, B, VBlw, VBlw, O, O, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 0970 */ O, O, B, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
|
||||
/* Bengali */
|
||||
|
||||
/* 0980 */ O, VMAbv, VMPst, VMPst, O, IV, IV, IV, IV, IV, IV, IV, IV, O, O, IV,
|
||||
/* 0990 */ IV, O, O, IV, IV, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 0980 */ O, VMAbv, VMPst, VMPst, O, B, B, B, B, B, B, B, B, O, O, B,
|
||||
/* 0990 */ B, O, O, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 09A0 */ B, B, B, B, B, B, B, B, B, O, B, B, B, B, B, B,
|
||||
/* 09B0 */ B, O, B, O, O, O, B, B, B, B, O, O, CMBlw, B, VPst, VPre,
|
||||
/* 09C0 */ VPst, VBlw, VBlw, VBlw, VBlw, O, O, VPre, VPre, O, O, VPre, VPre, H, IND, O,
|
||||
/* 09D0 */ O, O, O, O, O, O, O, VPst, O, O, O, O, B, B, O, B,
|
||||
/* 09E0 */ IV, IV, VBlw, VBlw, O, O, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 09E0 */ B, B, VBlw, VBlw, O, O, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 09F0 */ B, B, O, O, O, O, O, O, O, O, O, O, O, O, O, O,
|
||||
|
||||
/* Gurmukhi */
|
||||
|
||||
/* 0A00 */ O, VMAbv, VMAbv, VMPst, O, IV, IV, IV, IV, IV, IV, O, O, O, O, IV,
|
||||
/* 0A10 */ IV, O, O, IV, IV, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 0A00 */ O, VMAbv, VMAbv, VMPst, O, B, B, B, B, B, B, O, O, O, O, B,
|
||||
/* 0A10 */ B, O, O, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 0A20 */ B, B, B, B, B, B, B, B, B, O, B, B, B, B, B, B,
|
||||
/* 0A30 */ B, O, B, B, O, B, B, O, B, B, O, O, CMBlw, O, VPst, VPre,
|
||||
/* 0A40 */ VPst, VBlw, VBlw, O, O, O, O, VAbv, VAbv, O, O, VAbv, VAbv, H, O, O,
|
||||
|
@ -113,30 +112,30 @@ static const USE_TABLE_ELEMENT_TYPE use_table[] = {
|
|||
|
||||
/* Gujarati */
|
||||
|
||||
/* 0A80 */ O, VMAbv, VMAbv, VMPst, O, IV, IV, IV, IV, IV, IV, IV, IV, IV, O, IV,
|
||||
/* 0A90 */ IV, IV, O, IV, IV, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 0A80 */ O, VMAbv, VMAbv, VMPst, O, B, B, B, B, B, B, B, B, B, O, B,
|
||||
/* 0A90 */ B, B, O, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 0AA0 */ B, B, B, B, B, B, B, B, B, O, B, B, B, B, B, B,
|
||||
/* 0AB0 */ B, O, B, B, O, B, B, B, B, B, O, O, CMBlw, B, VPst, VPre,
|
||||
/* 0AC0 */ VPst, VBlw, VBlw, VBlw, VBlw, VAbv, O, VAbv, VAbv, VAbv, O, VPst, VPst, H, O, O,
|
||||
/* 0AD0 */ O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O,
|
||||
/* 0AE0 */ IV, IV, VBlw, VBlw, O, O, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 0AE0 */ B, B, VBlw, VBlw, O, O, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 0AF0 */ O, O, O, O, O, O, O, O, O, B, O, O, O, O, O, O,
|
||||
|
||||
/* Oriya */
|
||||
|
||||
/* 0B00 */ O, VMAbv, VMPst, VMPst, O, IV, IV, IV, IV, IV, IV, IV, IV, O, O, IV,
|
||||
/* 0B10 */ IV, O, O, IV, IV, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 0B00 */ O, VMAbv, VMPst, VMPst, O, B, B, B, B, B, B, B, B, O, O, B,
|
||||
/* 0B10 */ B, O, O, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 0B20 */ B, B, B, B, B, B, B, B, B, O, B, B, B, B, B, B,
|
||||
/* 0B30 */ B, O, B, B, O, B, B, B, B, B, O, O, CMBlw, B, VPst, VAbv,
|
||||
/* 0B40 */ VPst, VBlw, VBlw, VBlw, VBlw, O, O, VPre, VPre, O, O, VPre, VPre, H, O, O,
|
||||
/* 0B50 */ O, O, O, O, O, O, VAbv, VAbv, O, O, O, O, B, B, O, B,
|
||||
/* 0B60 */ IV, IV, VBlw, VBlw, O, O, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 0B60 */ B, B, VBlw, VBlw, O, O, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 0B70 */ O, B, O, O, O, O, O, O, O, O, O, O, O, O, O, O,
|
||||
|
||||
/* Tamil */
|
||||
|
||||
/* 0B80 */ O, O, VMAbv, IND, O, IV, IV, IV, IV, IV, IV, O, O, O, IV, IV,
|
||||
/* 0B90 */ IV, O, IV, IV, IV, B, O, O, O, B, B, O, B, O, B, B,
|
||||
/* 0B80 */ O, O, VMAbv, IND, O, B, B, B, B, B, B, O, O, O, B, B,
|
||||
/* 0B90 */ B, O, B, B, B, B, O, O, O, B, B, O, B, O, B, B,
|
||||
/* 0BA0 */ O, O, O, B, B, O, O, O, B, B, B, O, O, O, B, B,
|
||||
/* 0BB0 */ B, B, B, B, B, B, B, B, B, B, O, O, O, O, VPst, VPst,
|
||||
/* 0BC0 */ VAbv, VPst, VPst, O, O, O, VPre, VPre, VPre, O, VPre, VPre, VPre, H, O, O,
|
||||
|
@ -146,41 +145,41 @@ static const USE_TABLE_ELEMENT_TYPE use_table[] = {
|
|||
|
||||
/* Telugu */
|
||||
|
||||
/* 0C00 */ VMAbv, VMPst, VMPst, VMPst, O, IV, IV, IV, IV, IV, IV, IV, IV, O, IV, IV,
|
||||
/* 0C10 */ IV, O, IV, IV, IV, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 0C00 */ VMAbv, VMPst, VMPst, VMPst, O, B, B, B, B, B, B, B, B, O, B, B,
|
||||
/* 0C10 */ B, O, B, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 0C20 */ B, B, B, B, B, B, B, B, B, O, B, B, B, B, B, B,
|
||||
/* 0C30 */ B, B, B, B, B, B, B, B, B, B, O, O, O, B, VAbv, VAbv,
|
||||
/* 0C40 */ VAbv, VPst, VPst, VPst, VPst, O, VAbv, VAbv, VAbv, O, VAbv, VAbv, VAbv, H, O, O,
|
||||
/* 0C50 */ O, O, O, O, O, VAbv, VBlw, O, B, B, B, O, O, O, O, O,
|
||||
/* 0C60 */ IV, IV, VBlw, VBlw, O, O, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 0C60 */ B, B, VBlw, VBlw, O, O, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 0C70 */ O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O,
|
||||
|
||||
/* Kannada */
|
||||
|
||||
/* 0C80 */ O, VMAbv, VMPst, VMPst, O, IV, IV, IV, IV, IV, IV, IV, IV, O, IV, IV,
|
||||
/* 0C90 */ IV, O, IV, IV, IV, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 0C80 */ O, VMAbv, VMPst, VMPst, O, B, B, B, B, B, B, B, B, O, B, B,
|
||||
/* 0C90 */ B, O, B, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 0CA0 */ B, B, B, B, B, B, B, B, B, O, B, B, B, B, B, B,
|
||||
/* 0CB0 */ B, B, B, B, O, B, B, B, B, B, O, O, CMBlw, B, VPst, VAbv,
|
||||
/* 0CC0 */ VAbv, VPst, VPst, VPst, VPst, O, VAbv, VAbv, VAbv, O, VAbv, VAbv, VAbv, H, O, O,
|
||||
/* 0CD0 */ O, O, O, O, O, VPst, VPst, O, O, O, O, O, O, O, B, O,
|
||||
/* 0CE0 */ IV, IV, VBlw, VBlw, O, O, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 0CE0 */ B, B, VBlw, VBlw, O, O, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 0CF0 */ O, R, R, O, O, O, O, O, O, O, O, O, O, O, O, O,
|
||||
|
||||
/* Malayalam */
|
||||
|
||||
/* 0D00 */ O, VMAbv, VMPst, VMPst, O, IV, IV, IV, IV, IV, IV, IV, IV, O, IV, IV,
|
||||
/* 0D10 */ IV, O, IV, IV, IV, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 0D00 */ O, VMAbv, VMPst, VMPst, O, B, B, B, B, B, B, B, B, O, B, B,
|
||||
/* 0D10 */ B, O, B, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 0D20 */ B, B, B, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 0D30 */ B, B, B, B, B, B, B, B, B, B, B, O, O, B, VPst, VPst,
|
||||
/* 0D40 */ VPst, VPst, VPst, VBlw, VBlw, O, VPre, VPre, VPre, O, VPre, VPre, VPre, H, R, O,
|
||||
/* 0D50 */ O, O, O, O, O, O, O, VPst, O, O, O, O, O, O, O, IV,
|
||||
/* 0D60 */ IV, IV, VBlw, VBlw, O, O, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 0D50 */ O, O, O, O, IND, IND, IND, VPst, O, O, O, O, O, O, O, B,
|
||||
/* 0D60 */ B, B, VBlw, VBlw, O, O, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 0D70 */ O, O, O, O, O, O, O, O, O, O, IND, IND, IND, IND, IND, IND,
|
||||
|
||||
/* Sinhala */
|
||||
|
||||
/* 0D80 */ O, O, VMPst, VMPst, O, IV, IV, IV, IV, IV, IV, IV, IV, IV, IV, IV,
|
||||
/* 0D90 */ IV, IV, IV, IV, IV, IV, IV, O, O, O, B, B, B, B, B, B,
|
||||
/* 0D80 */ O, O, VMPst, VMPst, O, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 0D90 */ B, B, B, B, B, B, B, O, O, O, B, B, B, B, B, B,
|
||||
/* 0DA0 */ B, B, B, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 0DB0 */ B, B, O, B, B, B, B, B, B, B, B, B, O, B, O, O,
|
||||
/* 0DC0 */ B, B, B, B, B, B, B, O, O, O, H, O, O, O, O, VPst,
|
||||
|
@ -195,10 +194,10 @@ static const USE_TABLE_ELEMENT_TYPE use_table[] = {
|
|||
|
||||
/* 1000 */ B, B, B, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 1010 */ B, B, B, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 1020 */ B, IV, IV, IV, IV, IV, IV, IV, IV, IV, IV, VPst, VPst, VAbv, VAbv, VBlw,
|
||||
/* 1020 */ B, B, B, B, B, B, B, B, B, B, B, VPst, VPst, VAbv, VAbv, VBlw,
|
||||
/* 1030 */ VBlw, VPre, VAbv, VAbv, VAbv, VAbv, VMAbv, VMBlw, VMPst, H, VAbv, MPst, MPre, MBlw, MBlw, B,
|
||||
/* 1040 */ B, B, B, B, B, B, B, B, B, B, O, O, O, O, GB, O,
|
||||
/* 1050 */ B, B, IV, IV, IV, IV, VPst, VPst, VBlw, VBlw, B, B, B, B, MBlw, MBlw,
|
||||
/* 1050 */ B, B, B, B, B, B, VPst, VPst, VBlw, VBlw, B, B, B, B, MBlw, MBlw,
|
||||
/* 1060 */ MBlw, B, VPst, VMPst, VMPst, B, B, VPst, VPst, VMPst, VMPst, VMPst, VMPst, VMPst, B, B,
|
||||
/* 1070 */ B, VAbv, VAbv, VAbv, VAbv, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 1080 */ B, B, MBlw, VPst, VPre, VAbv, VAbv, VMPst, VMPst, VMPst, VMPst, VMPst, VMPst, VMBlw, B, VMPst,
|
||||
|
@ -209,30 +208,30 @@ static const USE_TABLE_ELEMENT_TYPE use_table[] = {
|
|||
|
||||
/* Tagalog */
|
||||
|
||||
/* 1700 */ IV, IV, IV, B, B, B, B, B, B, B, B, B, B, O, B, B,
|
||||
/* 1700 */ B, B, B, B, B, B, B, B, B, B, B, B, B, O, B, B,
|
||||
/* 1710 */ B, B, VAbv, VBlw, VBlw, O, O, O, O, O, O, O, O, O, O, O,
|
||||
|
||||
/* Hanunoo */
|
||||
|
||||
/* 1720 */ IV, IV, IV, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 1720 */ B, B, B, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 1730 */ B, B, VAbv, VBlw, VBlw, O, O, O, O, O, O, O, O, O, O, O,
|
||||
|
||||
/* Buhid */
|
||||
|
||||
/* 1740 */ IV, IV, IV, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 1740 */ B, B, B, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 1750 */ B, B, VAbv, VBlw, O, O, O, O, O, O, O, O, O, O, O, O,
|
||||
|
||||
/* Tagbanwa */
|
||||
|
||||
/* 1760 */ IV, IV, IV, B, B, B, B, B, B, B, B, B, B, O, B, B,
|
||||
/* 1760 */ B, B, B, B, B, B, B, B, B, B, B, B, B, O, B, B,
|
||||
/* 1770 */ B, O, VAbv, VBlw, O, O, O, O, O, O, O, O, O, O, O, O,
|
||||
|
||||
/* Khmer */
|
||||
|
||||
/* 1780 */ B, B, B, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 1790 */ B, B, B, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 17A0 */ B, B, B, IV, IV, IV, IV, IV, IV, IV, IV, IV, IV, IV, IV, IV,
|
||||
/* 17B0 */ IV, IV, IV, IV, O, O, VPst, VAbv, VAbv, VAbv, VAbv, VBlw, VBlw, VBlw, VPre, VPre,
|
||||
/* 17A0 */ B, B, B, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 17B0 */ B, B, B, B, O, O, VPst, VAbv, VAbv, VAbv, VAbv, VBlw, VBlw, VBlw, VPre, VPre,
|
||||
/* 17C0 */ VPre, VPre, VPre, VPre, VPre, VPre, VMAbv, VMPst, VPst, VMAbv, VMAbv, FM, FAbv, CMAbv, FM, FM,
|
||||
/* 17D0 */ FM, VAbv, H, FM, O, O, O, O, O, O, O, O, B, VAbv, O, O,
|
||||
/* 17E0 */ B, B, B, B, B, B, B, B, B, B, O, O, O, O, O, O,
|
||||
|
@ -274,8 +273,8 @@ static const USE_TABLE_ELEMENT_TYPE use_table[] = {
|
|||
|
||||
/* 1A20 */ B, B, B, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 1A30 */ B, B, B, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 1A40 */ B, B, B, B, B, B, B, B, B, B, B, B, B, IV, IV, IV,
|
||||
/* 1A50 */ IV, IV, IV, B, B, MPre, MBlw, FPst, FAbv, FAbv, FAbv, FBlw, FBlw, FBlw, FBlw, O,
|
||||
/* 1A40 */ B, B, B, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 1A50 */ B, B, B, B, B, MPre, MBlw, FPst, FAbv, FAbv, FAbv, FBlw, FBlw, FBlw, FBlw, O,
|
||||
/* 1A60 */ H, VPst, VAbv, VPst, VPst, VAbv, VAbv, VAbv, VAbv, VBlw, VBlw, VAbv, VBlw, VPst, VPre, VPre,
|
||||
/* 1A70 */ VPre, VPre, VPre, VAbv, VAbv, VMAbv, VMAbv, VMAbv, VMAbv, VMAbv, FM, FM, FM, O, O, FM,
|
||||
/* 1A80 */ B, B, B, B, B, B, B, B, B, B, O, O, O, O, O, O,
|
||||
|
@ -286,8 +285,8 @@ static const USE_TABLE_ELEMENT_TYPE use_table[] = {
|
|||
|
||||
/* Balinese */
|
||||
|
||||
/* 1B00 */ VMAbv, VMAbv, VMAbv, FAbv, VMPst, IV, IV, IV, IV, IV, IV, IV, IV, IV, IV, IV,
|
||||
/* 1B10 */ IV, IV, IV, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 1B00 */ VMAbv, VMAbv, VMAbv, FAbv, VMPst, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 1B10 */ B, B, B, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 1B20 */ B, B, B, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 1B30 */ B, B, B, B, CMAbv, VPst, VAbv, VAbv, VBlw, VBlw, VBlw, VBlw, VAbv, VAbv, VPre, VPre,
|
||||
/* 1B40 */ VPre, VPre, VAbv, VAbv, H, B, B, B, B, B, B, B, O, O, O, O,
|
||||
|
@ -297,7 +296,7 @@ static const USE_TABLE_ELEMENT_TYPE use_table[] = {
|
|||
|
||||
/* Sundanese */
|
||||
|
||||
/* 1B80 */ VMAbv, FAbv, VMPst, IV, IV, IV, IV, IV, IV, IV, B, B, B, B, B, B,
|
||||
/* 1B80 */ VMAbv, FAbv, VMPst, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 1B90 */ B, B, B, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 1BA0 */ B, SUB, SUB, SUB, VAbv, VBlw, VPre, VPst, VAbv, VAbv, VPst, H, SUB, SUB, B, B,
|
||||
/* 1BB0 */ B, B, B, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
|
@ -306,7 +305,7 @@ static const USE_TABLE_ELEMENT_TYPE use_table[] = {
|
|||
|
||||
/* 1BC0 */ B, B, B, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 1BD0 */ B, B, B, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 1BE0 */ B, B, B, B, IV, IV, CMAbv, VPst, VAbv, VAbv, VPst, VPst, VPst, VAbv, VPst, VAbv,
|
||||
/* 1BE0 */ B, B, B, B, B, B, CMAbv, VPst, VAbv, VAbv, VPst, VPst, VPst, VAbv, VPst, VAbv,
|
||||
/* 1BF0 */ FAbv, FAbv, VPst, VPst, O, O, O, O, O, O, O, O, O, O, O, O,
|
||||
|
||||
/* Lepcha */
|
||||
|
@ -326,14 +325,20 @@ static const USE_TABLE_ELEMENT_TYPE use_table[] = {
|
|||
/* 1CE0 */ VMAbv, VMPst, VMBlw, VMBlw, VMBlw, VMBlw, VMBlw, VMBlw, VMBlw, O, O, O, O, VMBlw, O, O,
|
||||
/* 1CF0 */ O, O, VMPst, VMPst, VMAbv, O, O, O, VMAbv, VMAbv, O, O, O, O, O, O,
|
||||
|
||||
#define use_offset_0x2008u 2552
|
||||
#define use_offset_0x1df8u 2552
|
||||
|
||||
|
||||
/* Combining Diacritical Marks Supplement */
|
||||
O, O, O, FM, O, O, O, O,
|
||||
|
||||
#define use_offset_0x2008u 2560
|
||||
|
||||
|
||||
/* General Punctuation */
|
||||
O, O, O, O, ZWNJ, ZWJ, O, O,
|
||||
/* 2010 */ GB, GB, GB, GB, GB, O, O, O,
|
||||
|
||||
#define use_offset_0x2060u 2568
|
||||
#define use_offset_0x2060u 2576
|
||||
|
||||
/* 2060 */ WJ, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O,
|
||||
|
||||
|
@ -342,12 +347,12 @@ static const USE_TABLE_ELEMENT_TYPE use_table[] = {
|
|||
/* 2070 */ O, O, O, O, FM, O, O, O, O, O, O, O, O, O, O, O,
|
||||
/* 2080 */ O, O, FM, FM, FM, O, O, O,
|
||||
|
||||
#define use_offset_0xa800u 2608
|
||||
#define use_offset_0xa800u 2616
|
||||
|
||||
|
||||
/* Syloti Nagri */
|
||||
|
||||
/* A800 */ IV, IV, O, IV, IV, IV, VAbv, B, B, B, B, VMAbv, B, B, B, B,
|
||||
/* A800 */ B, B, O, B, B, B, VAbv, B, B, B, B, VMAbv, B, B, B, B,
|
||||
/* A810 */ B, B, B, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* A820 */ B, B, B, VPst, VPst, VBlw, VAbv, VPst, O, O, O, O, O, O, O, O,
|
||||
/* A830 */ O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O,
|
||||
|
@ -361,11 +366,11 @@ static const USE_TABLE_ELEMENT_TYPE use_table[] = {
|
|||
|
||||
/* Saurashtra */
|
||||
|
||||
/* A880 */ VMPst, VMPst, IV, IV, IV, IV, IV, IV, IV, IV, IV, IV, IV, IV, IV, IV,
|
||||
/* A890 */ IV, IV, B, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* A880 */ VMPst, VMPst, B, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* A890 */ B, B, B, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* A8A0 */ B, B, B, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* A8B0 */ B, B, B, B, FPst, VPst, VPst, VPst, VPst, VPst, VPst, VPst, VPst, VPst, VPst, VPst,
|
||||
/* A8C0 */ VPst, VPst, VPst, VPst, H, O, O, O, O, O, O, O, O, O, O, O,
|
||||
/* A8C0 */ VPst, VPst, VPst, VPst, H, VMAbv, O, O, O, O, O, O, O, O, O, O,
|
||||
/* A8D0 */ B, B, B, B, B, B, B, B, B, B, O, O, O, O, O, O,
|
||||
|
||||
/* Devanagari Extended */
|
||||
|
@ -389,7 +394,7 @@ static const USE_TABLE_ELEMENT_TYPE use_table[] = {
|
|||
|
||||
/* Javanese */
|
||||
|
||||
/* A980 */ VMAbv, VMAbv, FAbv, VMPst, IV, IV, IV, IV, IV, B, B, B, IV, IV, IV, B,
|
||||
/* A980 */ VMAbv, VMAbv, FAbv, VMPst, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* A990 */ B, B, B, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* A9A0 */ B, B, B, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* A9B0 */ B, B, B, CMAbv, VPst, VPst, VAbv, VAbv, VBlw, VBlw, VPre, VPre, VAbv, SUB, MPst, MPst,
|
||||
|
@ -403,9 +408,9 @@ static const USE_TABLE_ELEMENT_TYPE use_table[] = {
|
|||
|
||||
/* Cham */
|
||||
|
||||
/* AA00 */ IV, IV, IV, IV, IV, IV, B, B, B, B, B, B, B, B, B, B,
|
||||
/* AA00 */ B, B, B, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* AA10 */ B, B, B, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* AA20 */ B, B, B, B, B, B, B, B, B, VAbv, VAbv, VAbv, VAbv, VBlw, VAbv, VPre,
|
||||
/* AA20 */ B, B, B, B, B, B, B, B, B, VMAbv, VAbv, VAbv, VAbv, VBlw, VAbv, VPre,
|
||||
/* AA30 */ VPre, VAbv, VBlw, MPst, MPre, MBlw, MBlw, O, O, O, O, O, O, O, O, O,
|
||||
/* AA40 */ B, B, B, FAbv, B, B, B, B, B, B, B, B, FAbv, FPst, O, O,
|
||||
/* AA50 */ B, B, B, B, B, B, B, B, B, B, O, O, O, O, O, O,
|
||||
|
@ -413,7 +418,7 @@ static const USE_TABLE_ELEMENT_TYPE use_table[] = {
|
|||
/* Myanmar Extended-A */
|
||||
|
||||
/* AA60 */ B, B, B, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* AA70 */ O, B, B, B, O, O, O, O, O, O, B, VMPst, VMAbv, VMPst, B, B,
|
||||
/* AA70 */ O, B, B, B, GB, GB, GB, O, O, O, B, VMPst, VMAbv, VMPst, B, B,
|
||||
|
||||
/* Tai Viet */
|
||||
|
||||
|
@ -426,27 +431,27 @@ static const USE_TABLE_ELEMENT_TYPE use_table[] = {
|
|||
|
||||
/* Meetei Mayek Extensions */
|
||||
|
||||
/* AAE0 */ IV, IV, B, B, B, B, B, B, B, B, B, VPre, VBlw, VAbv, VPre, VPst,
|
||||
/* AAE0 */ B, B, B, B, B, B, B, B, B, B, B, VPre, VBlw, VAbv, VPre, VPst,
|
||||
/* AAF0 */ O, O, O, O, O, VMPst, H, O,
|
||||
|
||||
#define use_offset_0xabc0u 3368
|
||||
#define use_offset_0xabc0u 3376
|
||||
|
||||
|
||||
/* Meetei Mayek */
|
||||
|
||||
/* ABC0 */ B, B, B, B, B, B, B, B, B, B, B, B, B, B, IV, IV,
|
||||
/* ABD0 */ B, IV, B, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* ABC0 */ B, B, B, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* ABD0 */ B, B, B, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* ABE0 */ B, B, B, VPst, VPst, VAbv, VPst, VPst, VBlw, VPst, VPst, O, VMPst, VBlw, O, O,
|
||||
/* ABF0 */ B, B, B, B, B, B, B, B, B, B, O, O, O, O, O, O,
|
||||
|
||||
#define use_offset_0xfe00u 3432
|
||||
#define use_offset_0xfe00u 3440
|
||||
|
||||
|
||||
/* Variation Selectors */
|
||||
|
||||
/* FE00 */ VS, VS, VS, VS, VS, VS, VS, VS, VS, VS, VS, VS, VS, VS, VS, VS,
|
||||
|
||||
#define use_offset_0x10a00u 3448
|
||||
#define use_offset_0x10a00u 3456
|
||||
|
||||
|
||||
/* Kharoshthi */
|
||||
|
@ -457,13 +462,13 @@ static const USE_TABLE_ELEMENT_TYPE use_table[] = {
|
|||
/* 10A30 */ B, B, B, B, O, O, O, O, CMAbv, CMBlw, CMBlw, O, O, O, O, H,
|
||||
/* 10A40 */ B, B, B, B, B, B, B, B,
|
||||
|
||||
#define use_offset_0x11000u 3520
|
||||
#define use_offset_0x11000u 3528
|
||||
|
||||
|
||||
/* Brahmi */
|
||||
|
||||
/* 11000 */ VMPst, VMAbv, VMPst, R, R, IV, IV, IV, IV, IV, IV, IV, IV, IV, IV, IV,
|
||||
/* 11010 */ IV, IV, IV, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 11000 */ VMPst, VMAbv, VMPst, R, R, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 11010 */ B, B, B, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 11020 */ B, B, B, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 11030 */ B, B, B, B, B, B, B, B, VAbv, VAbv, VAbv, VAbv, VBlw, VBlw, VBlw, VBlw,
|
||||
/* 11040 */ VBlw, VBlw, VAbv, VAbv, VAbv, VAbv, H, O, O, O, O, O, O, O, O, O,
|
||||
|
@ -473,17 +478,17 @@ static const USE_TABLE_ELEMENT_TYPE use_table[] = {
|
|||
|
||||
/* Kaithi */
|
||||
|
||||
/* 11080 */ VMAbv, VMAbv, VMPst, IV, IV, IV, IV, IV, IV, IV, IV, IV, IV, B, B, B,
|
||||
/* 11080 */ VMAbv, VMAbv, VMPst, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 11090 */ B, B, B, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 110A0 */ B, B, B, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 110B0 */ VPst, VPre, VPst, VBlw, VBlw, VAbv, VAbv, VPst, VPst, H, CMBlw, O, O, O, O, O,
|
||||
|
||||
#define use_offset_0x11100u 3712
|
||||
#define use_offset_0x11100u 3720
|
||||
|
||||
|
||||
/* Chakma */
|
||||
|
||||
/* 11100 */ VMAbv, VMAbv, VMAbv, IV, IV, IV, IV, B, B, B, B, B, B, B, B, B,
|
||||
/* 11100 */ VMAbv, VMAbv, VMAbv, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 11110 */ B, B, B, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 11120 */ B, B, B, B, B, B, B, VAbv, VAbv, VAbv, VBlw, VBlw, VPre, VAbv, VAbv, VAbv,
|
||||
/* 11130 */ VAbv, VBlw, VBlw, H, VAbv, O, B, B, B, B, B, B, B, B, B, B,
|
||||
|
@ -497,8 +502,8 @@ static const USE_TABLE_ELEMENT_TYPE use_table[] = {
|
|||
|
||||
/* Sharada */
|
||||
|
||||
/* 11180 */ VMAbv, VMAbv, VMPst, IV, IV, IV, IV, IV, IV, IV, IV, IV, IV, IV, IV, IV,
|
||||
/* 11190 */ IV, B, B, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 11180 */ VMAbv, VMAbv, VMPst, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 11190 */ B, B, B, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 111A0 */ B, B, B, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 111B0 */ B, B, B, VPst, VPre, VPst, VBlw, VBlw, VBlw, VBlw, VBlw, VBlw, VAbv, VAbv, VAbv, VAbv,
|
||||
/* 111C0 */ H, B, R, R, O, O, O, O, O, O, CMBlw, VAbv, VBlw, O, O, O,
|
||||
|
@ -511,23 +516,23 @@ static const USE_TABLE_ELEMENT_TYPE use_table[] = {
|
|||
|
||||
/* Khojki */
|
||||
|
||||
/* 11200 */ IV, IV, IV, IV, IV, IV, IV, IV, B, B, B, B, B, B, B, B,
|
||||
/* 11200 */ B, B, B, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 11210 */ B, B, O, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 11220 */ B, B, B, B, B, B, B, B, B, B, B, B, VPst, VPst, VPst, VBlw,
|
||||
/* 11230 */ VAbv, VAbv, VAbv, VAbv, VMAbv, H, CMAbv, CMAbv,
|
||||
/* 11230 */ VAbv, VAbv, VAbv, VAbv, VMAbv, H, CMAbv, CMAbv, O, O, O, O, O, O, VMAbv, O,
|
||||
|
||||
#define use_offset_0x11280u 4024
|
||||
#define use_offset_0x11280u 4040
|
||||
|
||||
|
||||
/* Multani */
|
||||
|
||||
/* 11280 */ IV, IV, IV, IV, B, B, B, O, B, O, B, B, B, B, O, B,
|
||||
/* 11280 */ B, B, B, B, B, B, B, O, B, O, B, B, B, B, O, B,
|
||||
/* 11290 */ B, B, B, B, B, B, B, B, B, B, B, B, B, B, O, B,
|
||||
/* 112A0 */ B, B, B, B, B, B, B, B, B, O, O, O, O, O, O, O,
|
||||
|
||||
/* Khudawadi */
|
||||
|
||||
/* 112B0 */ IV, IV, IV, IV, IV, IV, IV, IV, IV, IV, B, B, B, B, B, B,
|
||||
/* 112B0 */ B, B, B, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 112C0 */ B, B, B, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 112D0 */ B, B, B, B, B, B, B, B, B, B, B, B, B, B, B, VMAbv,
|
||||
/* 112E0 */ VPst, VPre, VPst, VBlw, VBlw, VAbv, VAbv, VAbv, VAbv, CMBlw, VBlw, O, O, O, O, O,
|
||||
|
@ -535,44 +540,55 @@ static const USE_TABLE_ELEMENT_TYPE use_table[] = {
|
|||
|
||||
/* Grantha */
|
||||
|
||||
/* 11300 */ VMAbv, VMAbv, VMPst, VMPst, O, IV, IV, IV, IV, IV, IV, IV, IV, O, O, IV,
|
||||
/* 11310 */ IV, O, O, IV, IV, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 11300 */ VMAbv, VMAbv, VMPst, VMPst, O, B, B, B, B, B, B, B, B, O, O, B,
|
||||
/* 11310 */ B, O, O, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 11320 */ B, B, B, B, B, B, B, B, B, O, B, B, B, B, B, B,
|
||||
/* 11330 */ B, O, B, B, O, B, B, B, B, B, O, O, CMBlw, B, VPst, VPst,
|
||||
/* 11340 */ VAbv, VPst, VPst, VPst, VPst, O, O, VPre, VPre, O, O, VPre, VPre, H, O, O,
|
||||
/* 11350 */ O, O, O, O, O, O, O, VPst, O, O, O, O, O, O, O, O,
|
||||
/* 11360 */ IV, IV, VPst, VPst, O, O, VMAbv, VMAbv, VMAbv, VMAbv, VMAbv, VMAbv, VMAbv, O, O, O,
|
||||
/* 11360 */ B, B, VPst, VPst, O, O, VMAbv, VMAbv, VMAbv, VMAbv, VMAbv, VMAbv, VMAbv, O, O, O,
|
||||
/* 11370 */ VMAbv, VMAbv, VMAbv, VMAbv, VMAbv, O, O, O,
|
||||
|
||||
#define use_offset_0x11480u 4272
|
||||
#define use_offset_0x11400u 4288
|
||||
|
||||
|
||||
/* Newa */
|
||||
|
||||
/* 11400 */ B, B, B, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 11410 */ B, B, B, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 11420 */ B, B, B, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 11430 */ B, B, B, B, B, VPst, VPre, VPst, VBlw, VBlw, VBlw, VBlw, VBlw, VBlw, VAbv, VAbv,
|
||||
/* 11440 */ VPst, VPst, H, VMAbv, VMAbv, VMPst, CMBlw, B, O, O, O, O, O, O, O, O,
|
||||
/* 11450 */ B, B, B, B, B, B, B, B, B, B, O, O, O, O, O, O,
|
||||
/* 11460 */ O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O,
|
||||
/* 11470 */ O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O,
|
||||
|
||||
/* Tirhuta */
|
||||
|
||||
/* 11480 */ O, IV, IV, IV, IV, IV, IV, IV, IV, IV, IV, IV, IV, IV, IV, B,
|
||||
/* 11480 */ O, B, B, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 11490 */ B, B, B, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 114A0 */ B, B, B, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 114B0 */ VPst, VPre, VPst, VBlw, VBlw, VBlw, VBlw, VBlw, VBlw, VPre, VAbv, VPre, VPre, VPst, VPre, VMAbv,
|
||||
/* 114C0 */ VMAbv, VMPst, H, CMBlw, B, O, O, O, O, O, O, O, O, O, O, O,
|
||||
/* 114D0 */ B, B, B, B, B, B, B, B, B, B, O, O, O, O, O, O,
|
||||
|
||||
#define use_offset_0x11580u 4368
|
||||
#define use_offset_0x11580u 4512
|
||||
|
||||
|
||||
/* Siddham */
|
||||
|
||||
/* 11580 */ IV, IV, IV, IV, IV, IV, IV, IV, IV, IV, IV, IV, IV, IV, B, B,
|
||||
/* 11580 */ B, B, B, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 11590 */ B, B, B, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 115A0 */ B, B, B, B, B, B, B, B, B, B, B, B, B, B, B, VPst,
|
||||
/* 115B0 */ VPre, VPst, VBlw, VBlw, VBlw, VBlw, O, O, VPre, VPre, VPre, VPre, VMAbv, VMAbv, VMPst, H,
|
||||
/* 115C0 */ CMBlw, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O,
|
||||
/* 115D0 */ O, O, O, O, O, O, O, O, IV, IV, IV, IV, VBlw, VBlw, O, O,
|
||||
/* 115D0 */ O, O, O, O, O, O, O, O, B, B, B, B, VBlw, VBlw, O, O,
|
||||
/* 115E0 */ O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O,
|
||||
/* 115F0 */ O, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O,
|
||||
|
||||
/* Modi */
|
||||
|
||||
/* 11600 */ IV, IV, IV, IV, IV, IV, IV, IV, IV, IV, IV, IV, IV, IV, B, B,
|
||||
/* 11600 */ B, B, B, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 11610 */ B, B, B, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 11620 */ B, B, B, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 11630 */ VPst, VPst, VPst, VBlw, VBlw, VBlw, VBlw, VBlw, VBlw, VAbv, VAbv, VPst, VPst, VMAbv, VMPst, H,
|
||||
|
@ -583,7 +599,7 @@ static const USE_TABLE_ELEMENT_TYPE use_table[] = {
|
|||
|
||||
/* Takri */
|
||||
|
||||
/* 11680 */ IV, IV, IV, IV, IV, IV, IV, IV, IV, IV, B, B, B, B, B, B,
|
||||
/* 11680 */ B, B, B, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 11690 */ B, B, B, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 116A0 */ B, B, B, B, B, B, B, B, B, B, B, VMAbv, VMPst, VAbv, VPre, VPst,
|
||||
/* 116B0 */ VBlw, VBlw, VAbv, VAbv, VAbv, VAbv, H, CMBlw, O, O, O, O, O, O, O, O,
|
||||
|
@ -599,7 +615,28 @@ static const USE_TABLE_ELEMENT_TYPE use_table[] = {
|
|||
/* 11720 */ VPst, VPst, VAbv, VAbv, VBlw, VBlw, VPre, VAbv, VBlw, VAbv, VAbv, VAbv, O, O, O, O,
|
||||
/* 11730 */ B, B, B, B, B, B, B, B, B, B, B, B, O, O, O, O,
|
||||
|
||||
}; /* Table items: 4816; occupancy: 72% */
|
||||
#define use_offset_0x11c00u 4960
|
||||
|
||||
|
||||
/* Bhaiksuki */
|
||||
|
||||
/* 11C00 */ B, B, B, B, B, B, B, B, B, O, B, B, B, B, B, B,
|
||||
/* 11C10 */ B, B, B, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 11C20 */ B, B, B, B, B, B, B, B, B, B, B, B, B, B, B, VPst,
|
||||
/* 11C30 */ VAbv, VAbv, VBlw, VBlw, VBlw, VBlw, VBlw, O, VAbv, VAbv, VAbv, VAbv, VMAbv, VMAbv, VMPst, H,
|
||||
/* 11C40 */ B, O, O, O, O, O, O, O, O, O, O, O, O, O, O, O,
|
||||
/* 11C50 */ B, B, B, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 11C60 */ B, B, B, B, B, B, B, B, B, B, B, B, B, O, O, O,
|
||||
|
||||
/* Marchen */
|
||||
|
||||
/* 11C70 */ O, O, B, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 11C80 */ B, B, B, B, B, B, B, B, B, B, B, B, B, B, B, B,
|
||||
/* 11C90 */ O, O, SUB, SUB, SUB, SUB, SUB, SUB, SUB, SUB, SUB, SUB, SUB, SUB, SUB, SUB,
|
||||
/* 11CA0 */ SUB, SUB, SUB, SUB, SUB, SUB, SUB, SUB, O, SUB, SUB, SUB, SUB, SUB, SUB, SUB,
|
||||
/* 11CB0 */ VBlw, VPre, VBlw, VAbv, VPst, VMAbv, VMAbv, O,
|
||||
|
||||
}; /* Table items: 5144; occupancy: 72% */
|
||||
|
||||
USE_TABLE_ELEMENT_TYPE
|
||||
hb_use_get_categories (hb_codepoint_t u)
|
||||
|
@ -607,45 +644,47 @@ hb_use_get_categories (hb_codepoint_t u)
|
|||
switch (u >> 12)
|
||||
{
|
||||
case 0x0u:
|
||||
if (hb_in_range (u, 0x0028u, 0x003Fu)) return use_table[u - 0x0028u + use_offset_0x0028u];
|
||||
if (hb_in_range (u, 0x00A0u, 0x00D7u)) return use_table[u - 0x00A0u + use_offset_0x00a0u];
|
||||
if (hb_in_range (u, 0x0900u, 0x0DF7u)) return use_table[u - 0x0900u + use_offset_0x0900u];
|
||||
if (hb_in_range<hb_codepoint_t> (u, 0x0028u, 0x003Fu)) return use_table[u - 0x0028u + use_offset_0x0028u];
|
||||
if (hb_in_range<hb_codepoint_t> (u, 0x00A0u, 0x00D7u)) return use_table[u - 0x00A0u + use_offset_0x00a0u];
|
||||
if (hb_in_range<hb_codepoint_t> (u, 0x0900u, 0x0DF7u)) return use_table[u - 0x0900u + use_offset_0x0900u];
|
||||
if (unlikely (u == 0x034Fu)) return CGJ;
|
||||
break;
|
||||
|
||||
case 0x1u:
|
||||
if (hb_in_range (u, 0x1000u, 0x109Fu)) return use_table[u - 0x1000u + use_offset_0x1000u];
|
||||
if (hb_in_range (u, 0x1700u, 0x17EFu)) return use_table[u - 0x1700u + use_offset_0x1700u];
|
||||
if (hb_in_range (u, 0x1900u, 0x1A9Fu)) return use_table[u - 0x1900u + use_offset_0x1900u];
|
||||
if (hb_in_range (u, 0x1B00u, 0x1C4Fu)) return use_table[u - 0x1B00u + use_offset_0x1b00u];
|
||||
if (hb_in_range (u, 0x1CD0u, 0x1CFFu)) return use_table[u - 0x1CD0u + use_offset_0x1cd0u];
|
||||
if (hb_in_range<hb_codepoint_t> (u, 0x1000u, 0x109Fu)) return use_table[u - 0x1000u + use_offset_0x1000u];
|
||||
if (hb_in_range<hb_codepoint_t> (u, 0x1700u, 0x17EFu)) return use_table[u - 0x1700u + use_offset_0x1700u];
|
||||
if (hb_in_range<hb_codepoint_t> (u, 0x1900u, 0x1A9Fu)) return use_table[u - 0x1900u + use_offset_0x1900u];
|
||||
if (hb_in_range<hb_codepoint_t> (u, 0x1B00u, 0x1C4Fu)) return use_table[u - 0x1B00u + use_offset_0x1b00u];
|
||||
if (hb_in_range<hb_codepoint_t> (u, 0x1CD0u, 0x1CFFu)) return use_table[u - 0x1CD0u + use_offset_0x1cd0u];
|
||||
if (hb_in_range<hb_codepoint_t> (u, 0x1DF8u, 0x1DFFu)) return use_table[u - 0x1DF8u + use_offset_0x1df8u];
|
||||
break;
|
||||
|
||||
case 0x2u:
|
||||
if (hb_in_range (u, 0x2008u, 0x2017u)) return use_table[u - 0x2008u + use_offset_0x2008u];
|
||||
if (hb_in_range (u, 0x2060u, 0x2087u)) return use_table[u - 0x2060u + use_offset_0x2060u];
|
||||
if (hb_in_range<hb_codepoint_t> (u, 0x2008u, 0x2017u)) return use_table[u - 0x2008u + use_offset_0x2008u];
|
||||
if (hb_in_range<hb_codepoint_t> (u, 0x2060u, 0x2087u)) return use_table[u - 0x2060u + use_offset_0x2060u];
|
||||
if (unlikely (u == 0x25CCu)) return GB;
|
||||
break;
|
||||
|
||||
case 0xAu:
|
||||
if (hb_in_range (u, 0xA800u, 0xAAF7u)) return use_table[u - 0xA800u + use_offset_0xa800u];
|
||||
if (hb_in_range (u, 0xABC0u, 0xABFFu)) return use_table[u - 0xABC0u + use_offset_0xabc0u];
|
||||
if (hb_in_range<hb_codepoint_t> (u, 0xA800u, 0xAAF7u)) return use_table[u - 0xA800u + use_offset_0xa800u];
|
||||
if (hb_in_range<hb_codepoint_t> (u, 0xABC0u, 0xABFFu)) return use_table[u - 0xABC0u + use_offset_0xabc0u];
|
||||
break;
|
||||
|
||||
case 0xFu:
|
||||
if (hb_in_range (u, 0xFE00u, 0xFE0Fu)) return use_table[u - 0xFE00u + use_offset_0xfe00u];
|
||||
if (hb_in_range<hb_codepoint_t> (u, 0xFE00u, 0xFE0Fu)) return use_table[u - 0xFE00u + use_offset_0xfe00u];
|
||||
break;
|
||||
|
||||
case 0x10u:
|
||||
if (hb_in_range (u, 0x10A00u, 0x10A47u)) return use_table[u - 0x10A00u + use_offset_0x10a00u];
|
||||
if (hb_in_range<hb_codepoint_t> (u, 0x10A00u, 0x10A47u)) return use_table[u - 0x10A00u + use_offset_0x10a00u];
|
||||
break;
|
||||
|
||||
case 0x11u:
|
||||
if (hb_in_range (u, 0x11000u, 0x110BFu)) return use_table[u - 0x11000u + use_offset_0x11000u];
|
||||
if (hb_in_range (u, 0x11100u, 0x11237u)) return use_table[u - 0x11100u + use_offset_0x11100u];
|
||||
if (hb_in_range (u, 0x11280u, 0x11377u)) return use_table[u - 0x11280u + use_offset_0x11280u];
|
||||
if (hb_in_range (u, 0x11480u, 0x114DFu)) return use_table[u - 0x11480u + use_offset_0x11480u];
|
||||
if (hb_in_range (u, 0x11580u, 0x1173Fu)) return use_table[u - 0x11580u + use_offset_0x11580u];
|
||||
if (hb_in_range<hb_codepoint_t> (u, 0x11000u, 0x110BFu)) return use_table[u - 0x11000u + use_offset_0x11000u];
|
||||
if (hb_in_range<hb_codepoint_t> (u, 0x11100u, 0x1123Fu)) return use_table[u - 0x11100u + use_offset_0x11100u];
|
||||
if (hb_in_range<hb_codepoint_t> (u, 0x11280u, 0x11377u)) return use_table[u - 0x11280u + use_offset_0x11280u];
|
||||
if (hb_in_range<hb_codepoint_t> (u, 0x11400u, 0x114DFu)) return use_table[u - 0x11400u + use_offset_0x11400u];
|
||||
if (hb_in_range<hb_codepoint_t> (u, 0x11580u, 0x1173Fu)) return use_table[u - 0x11580u + use_offset_0x11580u];
|
||||
if (hb_in_range<hb_codepoint_t> (u, 0x11C00u, 0x11CB7u)) return use_table[u - 0x11C00u + use_offset_0x11c00u];
|
||||
if (unlikely (u == 0x1107Fu)) return HN;
|
||||
break;
|
||||
|
||||
|
@ -662,7 +701,6 @@ hb_use_get_categories (hb_codepoint_t u)
|
|||
#undef H
|
||||
#undef HN
|
||||
#undef IND
|
||||
#undef IV
|
||||
#undef N
|
||||
#undef O
|
||||
#undef R
|
||||
|
|
|
@ -184,6 +184,9 @@ has_arabic_joining (hb_script_t script)
|
|||
case HB_SCRIPT_MANICHAEAN:
|
||||
case HB_SCRIPT_PSALTER_PAHLAVI:
|
||||
|
||||
/* Unicode-9.0 additions */
|
||||
case HB_SCRIPT_ADLAM:
|
||||
|
||||
return true;
|
||||
|
||||
default:
|
||||
|
@ -227,12 +230,12 @@ data_destroy_use (void *data)
|
|||
enum syllable_type_t {
|
||||
independent_cluster,
|
||||
virama_terminated_cluster,
|
||||
consonant_cluster,
|
||||
vowel_cluster,
|
||||
standard_cluster,
|
||||
number_joiner_terminated_cluster,
|
||||
numeral_cluster,
|
||||
symbol_cluster,
|
||||
broken_cluster,
|
||||
non_cluster,
|
||||
};
|
||||
|
||||
#include "hb-ot-shape-complex-use-machine.hh"
|
||||
|
@ -285,6 +288,9 @@ static void
|
|||
setup_topographical_masks (const hb_ot_shape_plan_t *plan,
|
||||
hb_buffer_t *buffer)
|
||||
{
|
||||
const use_shape_plan_t *use_plan = (const use_shape_plan_t *) plan->data;
|
||||
if (use_plan->arabic_plan)
|
||||
return;
|
||||
|
||||
ASSERT_STATIC (INIT < 4 && ISOL < 4 && MEDI < 4 && FINA < 4);
|
||||
hb_mask_t masks[4], all_masks = 0;
|
||||
|
@ -309,13 +315,13 @@ setup_topographical_masks (const hb_ot_shape_plan_t *plan,
|
|||
{
|
||||
case independent_cluster:
|
||||
case symbol_cluster:
|
||||
case non_cluster:
|
||||
/* These don't join. Nothing to do. */
|
||||
last_form = _NONE;
|
||||
break;
|
||||
|
||||
case virama_terminated_cluster:
|
||||
case consonant_cluster:
|
||||
case vowel_cluster:
|
||||
case standard_cluster:
|
||||
case number_joiner_terminated_cluster:
|
||||
case numeral_cluster:
|
||||
case broken_cluster:
|
||||
|
@ -348,6 +354,8 @@ setup_syllables (const hb_ot_shape_plan_t *plan,
|
|||
hb_buffer_t *buffer)
|
||||
{
|
||||
find_syllables (buffer);
|
||||
foreach_syllable (buffer, start, end)
|
||||
buffer->unsafe_to_break (start, end);
|
||||
setup_rphf_mask (plan, buffer);
|
||||
setup_topographical_masks (plan, buffer);
|
||||
}
|
||||
|
@ -360,7 +368,7 @@ clear_substitution_flags (const hb_ot_shape_plan_t *plan,
|
|||
hb_glyph_info_t *info = buffer->info;
|
||||
unsigned int count = buffer->len;
|
||||
for (unsigned int i = 0; i < count; i++)
|
||||
_hb_glyph_info_clear_substituted_and_ligated_and_multiplied (&info[i]);
|
||||
_hb_glyph_info_clear_substituted (&info[i]);
|
||||
}
|
||||
|
||||
static void
|
||||
|
@ -405,6 +413,12 @@ record_pref (const hb_ot_shape_plan_t *plan,
|
|||
}
|
||||
}
|
||||
|
||||
static inline bool
|
||||
is_halant (const hb_glyph_info_t &info)
|
||||
{
|
||||
return info.use_category() == USE_H && !_hb_glyph_info_ligated (&info);
|
||||
}
|
||||
|
||||
static void
|
||||
reorder_syllable (hb_buffer_t *buffer, unsigned int start, unsigned int end)
|
||||
{
|
||||
|
@ -412,28 +426,26 @@ reorder_syllable (hb_buffer_t *buffer, unsigned int start, unsigned int end)
|
|||
/* Only a few syllable types need reordering. */
|
||||
if (unlikely (!(FLAG_SAFE (syllable_type) &
|
||||
(FLAG (virama_terminated_cluster) |
|
||||
FLAG (consonant_cluster) |
|
||||
FLAG (vowel_cluster) |
|
||||
FLAG (standard_cluster) |
|
||||
FLAG (broken_cluster) |
|
||||
0))))
|
||||
return;
|
||||
|
||||
hb_glyph_info_t *info = buffer->info;
|
||||
|
||||
#define HALANT_FLAGS FLAG(USE_H)
|
||||
#define BASE_FLAGS (FLAG (USE_B) | FLAG (USE_GB) | FLAG (USE_IV))
|
||||
#define BASE_FLAGS (FLAG (USE_B) | FLAG (USE_GB))
|
||||
|
||||
/* Move things forward. */
|
||||
if (info[start].use_category() == USE_R && end - start > 1)
|
||||
{
|
||||
/* Got a repha. Reorder it to after first base, before first halant. */
|
||||
for (unsigned int i = start + 1; i < end; i++)
|
||||
if (FLAG_UNSAFE (info[i].use_category()) & (HALANT_FLAGS | BASE_FLAGS))
|
||||
if ((FLAG_UNSAFE (info[i].use_category()) & (BASE_FLAGS)) || is_halant (info[i]))
|
||||
{
|
||||
/* If we hit a halant, move before it; otherwise it's a base: move to it's
|
||||
* place, and shift things in between backward. */
|
||||
|
||||
if (info[i].use_category() == USE_H)
|
||||
if (is_halant (info[i]))
|
||||
i--;
|
||||
|
||||
buffer->merge_clusters (start, i + 1);
|
||||
|
@ -450,11 +462,11 @@ reorder_syllable (hb_buffer_t *buffer, unsigned int start, unsigned int end)
|
|||
for (unsigned int i = start; i < end; i++)
|
||||
{
|
||||
uint32_t flag = FLAG_UNSAFE (info[i].use_category());
|
||||
if (flag & (HALANT_FLAGS | BASE_FLAGS))
|
||||
if ((flag & (BASE_FLAGS)) || is_halant (info[i]))
|
||||
{
|
||||
/* If we hit a halant, move before it; otherwise it's a base: move to it's
|
||||
/* If we hit a halant, move after it; otherwise it's a base: move to it's
|
||||
* place, and shift things in between backward. */
|
||||
if (info[i].use_category() == USE_H)
|
||||
if (is_halant (info[i]))
|
||||
j = i + 1;
|
||||
else
|
||||
j = i;
|
||||
|
@ -491,7 +503,7 @@ insert_dotted_circles (const hb_ot_shape_plan_t *plan HB_UNUSED,
|
|||
return;
|
||||
|
||||
hb_glyph_info_t dottedcircle = {0};
|
||||
if (!font->get_glyph (0x25CCu, 0, &dottedcircle.codepoint))
|
||||
if (!font->get_nominal_glyph (0x25CCu, &dottedcircle.codepoint))
|
||||
return;
|
||||
dottedcircle.use_category() = hb_use_get_categories (0x25CC);
|
||||
|
||||
|
@ -514,7 +526,7 @@ insert_dotted_circles (const hb_ot_shape_plan_t *plan HB_UNUSED,
|
|||
/* TODO Set glyph_props? */
|
||||
|
||||
/* Insert dottedcircle after possible Repha. */
|
||||
while (buffer->idx < buffer->len &&
|
||||
while (buffer->idx < buffer->len && !buffer->in_error &&
|
||||
last_syllable == buffer->cur().syllable() &&
|
||||
buffer->cur().use_category() == USE_R)
|
||||
buffer->next_glyph ();
|
||||
|
@ -548,6 +560,25 @@ reorder (const hb_ot_shape_plan_t *plan,
|
|||
HB_BUFFER_DEALLOCATE_VAR (buffer, use_category);
|
||||
}
|
||||
|
||||
static bool
|
||||
decompose_use (const hb_ot_shape_normalize_context_t *c,
|
||||
hb_codepoint_t ab,
|
||||
hb_codepoint_t *a,
|
||||
hb_codepoint_t *b)
|
||||
{
|
||||
switch (ab)
|
||||
{
|
||||
/* Chakma:
|
||||
* Special case where the Unicode decomp gives matras in the wrong order
|
||||
* for cluster validation.
|
||||
*/
|
||||
case 0x1112Eu : *a = 0x11127u; *b= 0x11131u; return true;
|
||||
case 0x1112Fu : *a = 0x11127u; *b= 0x11132u; return true;
|
||||
}
|
||||
|
||||
return (bool) c->unicode->decompose (ab, a, b);
|
||||
}
|
||||
|
||||
static bool
|
||||
compose_use (const hb_ot_shape_normalize_context_t *c,
|
||||
hb_codepoint_t a,
|
||||
|
@ -558,7 +589,7 @@ compose_use (const hb_ot_shape_normalize_context_t *c,
|
|||
if (HB_UNICODE_GENERAL_CATEGORY_IS_MARK (c->unicode->general_category (a)))
|
||||
return false;
|
||||
|
||||
return c->unicode->compose (a, b, ab);
|
||||
return (bool)c->unicode->compose (a, b, ab);
|
||||
}
|
||||
|
||||
|
||||
|
@ -572,9 +603,10 @@ const hb_ot_complex_shaper_t _hb_ot_complex_shaper_use =
|
|||
NULL, /* preprocess_text */
|
||||
NULL, /* postprocess_glyphs */
|
||||
HB_OT_SHAPE_NORMALIZATION_MODE_COMPOSED_DIACRITICS_NO_SHORT_CIRCUIT,
|
||||
NULL, /* decompose */
|
||||
decompose_use,
|
||||
compose_use,
|
||||
setup_masks_use,
|
||||
HB_OT_SHAPE_ZERO_WIDTH_MARKS_NONE,
|
||||
NULL, /* disable_otl */
|
||||
HB_OT_SHAPE_ZERO_WIDTH_MARKS_BY_GDEF_EARLY,
|
||||
false, /* fallback_position */
|
||||
};
|
||||
|
|
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue