/*
See license.txt in the root of this project.
*/
# include "luametatex.h"
# include "lmtoptional.h"
/*tex
This is using similar c-lua-interfacing code as that Kai Eigner wrote for ffi. I cleaned it up
a bit but the principles remain because that way we are downward compatible. Don't expect
miracles here. We use function pointers as we delay binding to the module. We use the system
library as it comes, because after all, that is what is expected: shaping conform what the
system offers.
This interface is only for testing. We load the font in \LUA\ anyway, so we don't need to
collect information here. The code runs on top of the \CONTEXT\ font plugin interface that
itself was written for testing purposes. When we wanted to test uniscribe the hb command
line program could be used for that, but more direct support was also added. The tests that
were done at that time (irr it was when xetex switched to hb and folks used that as reference)
ended up in articles. Later we used this mechanism to check how Idris advanced Arabic font
behaves in different shapers (context, uniscribe, hb, ...) as we try to follow uniscribe when
possible and this gave the glue to that. It showed interesting differences and overlap in
interpretation (and made us wonder when bugs - in whatever program or standard - get turned
into features, but that's another matter, and we can always adapt and provide variants and
overloads if needed).
The following code is not dependent on h files so we don't need to install a whole bunch of
dependencies. Also, because we delay loading, there is no default overhead in startup. The
loading of the library happens (as usual) at the \LUA\ end, but in order for it to work okay
the initializer needs to be called, so that the functions get resolved. So, it works a bit
like the ffi interface: delayed loading, but (maybe) with a bit less overhead. I should
probably look at the latest api to see if things can be done with less code but on the other
hand there is no real reason to change something that already worked okay some years ago.
I guess that the script enumeration is no longer right but it probably doesn't matter as
numbers are passed anyway. We can probably make that into an integer (I need to test that
some day) as these enumerations are just that: integers, and the less hard-coding we have
here the better.
When this module is used (which is triggered via loading an optional module and setting the
mode in a font definition) other features of the \CONTEXT\ font handler are lost for that
specific font instance, simply because these mechanism operate independently. But that is
probably what a user expects anyway: no interference from other code, just the results from
a library. It makes no sense to complicate the machinery even more. This is comparable with
basemode and nodemode that are also seperated code paths.
So, we could probably simplify the following typedefs, but this is what Kai started with so
I stick to it. From the enumerations only the direction constant is used.
*/
typedef struct hb_blob_t hb_blob_t;
/* typedef int hb_memory_mode_t; */
typedef enum hb_memory_mode_t {
HB_MEMORY_MODE_DUPLICATE,
HB_MEMORY_MODE_READONLY,
HB_MEMORY_MODE_WRITABLE,
HB_MEMORY_MODE_READONLY_MAY_MAKE_WRITABLE
} hb_memory_mode_t;
typedef void (*hb_destroy_func_t) (
void *user_data
);
typedef struct hb_face_t hb_face_t;
typedef const struct hb_language_impl_t *hb_language_t;
typedef struct hb_buffer_t hb_buffer_t;
/* typedef int hb_script_t; */
/* typedef int hb_direction_t; */
/*
The content of this enum doesn't really matter here because we don't use it. Integers are
passed around. So, even if the following is not up to date we're okay.
*/
typedef enum hb_script_t {
HB_SCRIPT_COMMON, HB_SCRIPT_INHERITED, HB_SCRIPT_UNKNOWN,
HB_SCRIPT_ARABIC, HB_SCRIPT_ARMENIAN, HB_SCRIPT_BENGALI, HB_SCRIPT_CYRILLIC,
HB_SCRIPT_DEVANAGARI, HB_SCRIPT_GEORGIAN, HB_SCRIPT_GREEK,
HB_SCRIPT_GUJARATI, HB_SCRIPT_GURMUKHI, HB_SCRIPT_HANGUL, HB_SCRIPT_HAN,
HB_SCRIPT_HEBREW, HB_SCRIPT_HIRAGANA, HB_SCRIPT_KANNADA, HB_SCRIPT_KATAKANA,
HB_SCRIPT_LAO, HB_SCRIPT_LATIN, HB_SCRIPT_MALAYALAM, HB_SCRIPT_ORIYA,
HB_SCRIPT_TAMIL, HB_SCRIPT_TELUGU, HB_SCRIPT_THAI, HB_SCRIPT_TIBETAN,
HB_SCRIPT_BOPOMOFO, HB_SCRIPT_BRAILLE, HB_SCRIPT_CANADIAN_SYLLABICS,
HB_SCRIPT_CHEROKEE, HB_SCRIPT_ETHIOPIC, HB_SCRIPT_KHMER, HB_SCRIPT_MONGOLIAN,
HB_SCRIPT_MYANMAR, HB_SCRIPT_OGHAM, HB_SCRIPT_RUNIC, HB_SCRIPT_SINHALA,
HB_SCRIPT_SYRIAC, HB_SCRIPT_THAANA, HB_SCRIPT_YI, HB_SCRIPT_DESERET,
HB_SCRIPT_GOTHIC, HB_SCRIPT_OLD_ITALIC, HB_SCRIPT_BUHID, HB_SCRIPT_HANUNOO,
HB_SCRIPT_TAGALOG, HB_SCRIPT_TAGBANWA, HB_SCRIPT_CYPRIOT, HB_SCRIPT_LIMBU,
HB_SCRIPT_LINEAR_B, HB_SCRIPT_OSMANYA, HB_SCRIPT_SHAVIAN, HB_SCRIPT_TAI_LE,
HB_SCRIPT_UGARITIC, HB_SCRIPT_BUGINESE, HB_SCRIPT_COPTIC,
HB_SCRIPT_GLAGOLITIC, HB_SCRIPT_KHAROSHTHI, HB_SCRIPT_NEW_TAI_LUE,
HB_SCRIPT_OLD_PERSIAN, HB_SCRIPT_SYLOTI_NAGRI, HB_SCRIPT_TIFINAGH,
HB_SCRIPT_BALINESE, HB_SCRIPT_CUNEIFORM, HB_SCRIPT_NKO, HB_SCRIPT_PHAGS_PA,
HB_SCRIPT_PHOENICIAN, HB_SCRIPT_CARIAN, HB_SCRIPT_CHAM, HB_SCRIPT_KAYAH_LI,
HB_SCRIPT_LEPCHA, HB_SCRIPT_LYCIAN, HB_SCRIPT_LYDIAN, HB_SCRIPT_OL_CHIKI,
HB_SCRIPT_REJANG, HB_SCRIPT_SAURASHTRA, HB_SCRIPT_SUNDANESE, HB_SCRIPT_VAI,
HB_SCRIPT_AVESTAN, HB_SCRIPT_BAMUM, HB_SCRIPT_EGYPTIAN_HIEROGLYPHS,
HB_SCRIPT_IMPERIAL_ARAMAIC, HB_SCRIPT_INSCRIPTIONAL_PAHLAVI,
HB_SCRIPT_INSCRIPTIONAL_PARTHIAN, HB_SCRIPT_JAVANESE, HB_SCRIPT_KAITHI,
HB_SCRIPT_LISU, HB_SCRIPT_MEETEI_MAYEK, HB_SCRIPT_OLD_SOUTH_ARABIAN,
HB_SCRIPT_OLD_TURKIC, HB_SCRIPT_SAMARITAN, HB_SCRIPT_TAI_THAM,
HB_SCRIPT_TAI_VIET, HB_SCRIPT_BATAK, HB_SCRIPT_BRAHMI, HB_SCRIPT_MANDAIC,
HB_SCRIPT_CHAKMA, HB_SCRIPT_MEROITIC_CURSIVE, HB_SCRIPT_MEROITIC_HIEROGLYPHS,
HB_SCRIPT_MIAO, HB_SCRIPT_SHARADA, HB_SCRIPT_SORA_SOMPENG, HB_SCRIPT_TAKRI,
HB_SCRIPT_BASSA_VAH, HB_SCRIPT_CAUCASIAN_ALBANIAN, HB_SCRIPT_DUPLOYAN,
HB_SCRIPT_ELBASAN, HB_SCRIPT_GRANTHA, HB_SCRIPT_KHOJKI, HB_SCRIPT_KHUDAWADI,
HB_SCRIPT_LINEAR_A, HB_SCRIPT_MAHAJANI, HB_SCRIPT_MANICHAEAN,
HB_SCRIPT_MENDE_KIKAKUI, HB_SCRIPT_MODI, HB_SCRIPT_MRO, HB_SCRIPT_NABATAEAN,
HB_SCRIPT_OLD_NORTH_ARABIAN, HB_SCRIPT_OLD_PERMIC, HB_SCRIPT_PAHAWH_HMONG,
HB_SCRIPT_PALMYRENE, HB_SCRIPT_PAU_CIN_HAU, HB_SCRIPT_PSALTER_PAHLAVI,
HB_SCRIPT_SIDDHAM, HB_SCRIPT_TIRHUTA, HB_SCRIPT_WARANG_CITI, HB_SCRIPT_AHOM,
HB_SCRIPT_ANATOLIAN_HIEROGLYPHS, HB_SCRIPT_HATRAN, HB_SCRIPT_MULTANI,
HB_SCRIPT_OLD_HUNGARIAN, HB_SCRIPT_SIGNWRITING, HB_SCRIPT_ADLAM,
HB_SCRIPT_BHAIKSUKI, HB_SCRIPT_MARCHEN, HB_SCRIPT_OSAGE, HB_SCRIPT_TANGUT,
HB_SCRIPT_NEWA, HB_SCRIPT_MASARAM_GONDI, HB_SCRIPT_NUSHU, HB_SCRIPT_SOYOMBO,
HB_SCRIPT_ZANABAZAR_SQUARE, HB_SCRIPT_DOGRA, HB_SCRIPT_GUNJALA_GONDI,
HB_SCRIPT_HANIFI_ROHINGYA, HB_SCRIPT_MAKASAR, HB_SCRIPT_MEDEFAIDRIN,
HB_SCRIPT_OLD_SOGDIAN, HB_SCRIPT_SOGDIAN, HB_SCRIPT_ELYMAIC,
HB_SCRIPT_NANDINAGARI, HB_SCRIPT_NYIAKENG_PUACHUE_HMONG, HB_SCRIPT_WANCHO,
HB_SCRIPT_INVALID, _HB_SCRIPT_MAX_VALUE, _HB_SCRIPT_MAX_VALUE_SIGNED,
} hb_script_t;
typedef enum hb_direction_t {
HB_DIRECTION_INVALID,
HB_DIRECTION_LTR,
HB_DIRECTION_RTL,
HB_DIRECTION_TTB,
HB_DIRECTION_BTT
} hb_direction_t;
typedef int hb_bool_t;
typedef uint32_t hb_tag_t;
typedef struct hb_feature_t {
hb_tag_t tag;
uint32_t value;
unsigned int start;
unsigned int end;
} hb_feature_t;
typedef struct hb_font_t hb_font_t;
typedef uint32_t hb_codepoint_t;
typedef int32_t hb_position_t;
typedef uint32_t hb_mask_t;
typedef union _hb_var_int_t {
uint32_t u32;
int32_t i32;
uint16_t u16[2];
int16_t i16[2];
uint8_t u8[4];
int8_t i8[4];
} hb_var_int_t;
typedef struct hb_glyph_info_t {
hb_codepoint_t codepoint;
hb_mask_t mask;
uint32_t cluster;
/* private */
hb_var_int_t var1;
hb_var_int_t var2;
} hb_glyph_info_t;
typedef struct hb_glyph_position_t {
hb_position_t x_advance;
hb_position_t y_advance;
hb_position_t x_offset;
hb_position_t y_offset;
/* private */
hb_var_int_t var;
} hb_glyph_position_t;
/*tex
We only need to initialize the font and call a shaper. There is no need to interface more as we
won't use those features. I never compiled this library myself and just took it from the system
(e.g from inkscape). Keep in mind that names can be different on windows and linux.
If needed we can reuse buffers and cache a bit more but it probably doesn't make much difference
performance wise. Also, in a bit more complex document font handling is not the most time
critical and when you use specific scripts in \TEX\ that are not supported otherwise and
therefore demand a library run time is probably the least of your problems. So best is that we
keep it all abstract.
*/
# define HBLIB_METATABLE "optional.hblib"
typedef struct hblib_data {
hb_font_t *font;
} hblib_data;
typedef struct hblib_state_info {
int initialized;
int padding;
const char * (*hb_version_string) (
void
);
hb_blob_t * (*hb_blob_create) (
const char *data,
unsigned int length,
hb_memory_mode_t mode, /* Could be int I guess. */
void *user_data,
hb_destroy_func_t destroy
);
void (*hb_blob_destroy) (
hb_blob_t *blob
);
hb_face_t * (*hb_face_create) (
hb_blob_t *blob,
unsigned int index
);
void (*hb_face_destroy) (
hb_face_t *face
);
hb_language_t (*hb_language_from_string) (
const char *str,
int len
);
void (*hb_buffer_set_language) (
hb_buffer_t *buffer,
hb_language_t language
);
hb_script_t (*hb_script_from_string) (
const char *s,
int len
);
void (*hb_buffer_set_script) (
hb_buffer_t *buffer,
hb_script_t script
);
hb_direction_t (*hb_direction_from_string) (
const char *str,
int len
);
void (*hb_buffer_set_direction) (
hb_buffer_t *buffer,
hb_direction_t direction
);
hb_bool_t (*hb_feature_from_string) (
const char *str,
int len,
hb_feature_t *feature
);
hb_bool_t (*hb_shape_full) (
hb_font_t *font,
hb_buffer_t *buffer,
const hb_feature_t *features,
unsigned int num_features,
const char * const *shaper_list
);
hb_buffer_t * (*hb_buffer_create )(
void
);
void (*hb_buffer_destroy)(
hb_buffer_t *buffer
);
void (*hb_buffer_add_utf8) (
hb_buffer_t *buffer,
const char *text,
int text_length,
unsigned int item_offset,
int item_length
);
void (*hb_buffer_add_utf32) (
hb_buffer_t *buffer,
const char *text,
int text_length,
unsigned int item_offset,
int item_length
);
/* void (*hb_buffer_add) (
hb_buffer_t *buffer,
hb_codepoint_t codepoint,
unsigned int cluster
); */
unsigned int (*hb_buffer_get_length) (
hb_buffer_t *buffer
);
hb_glyph_info_t * (*hb_buffer_get_glyph_infos) (
hb_buffer_t *buffer,
unsigned int *length
);
hb_glyph_position_t * (*hb_buffer_get_glyph_positions) (
hb_buffer_t *buffer,
unsigned int *length
);
void (*hb_buffer_reverse) (
hb_buffer_t *buffer
);
void (*hb_buffer_reset) (
hb_buffer_t *buffer
);
void (*hb_buffer_guess_segment_properties) (
hb_buffer_t *buffer
);
hb_font_t * (*hb_font_create) (
hb_face_t *face
);
void (*hb_font_destroy) (
hb_font_t *font
);
void (*hb_font_set_scale) (
hb_font_t *font,
int x_scale,
int y_scale
);
void (*hb_ot_font_set_funcs) (
hb_font_t *font
);
unsigned int (*hb_face_get_upem) (
hb_face_t *face
);
const char ** (*hb_shape_list_shapers) (
void
);
} hblib_state_info;
static hblib_state_info hblib_state = {
.initialized = 0,
.padding = 0,
.hb_version_string = NULL,
.hb_blob_create = NULL,
.hb_blob_destroy = NULL,
.hb_face_create = NULL,
.hb_face_destroy = NULL,
.hb_language_from_string = NULL,
.hb_buffer_set_language = NULL,
.hb_script_from_string = NULL,
.hb_buffer_set_script = NULL,
.hb_direction_from_string = NULL,
.hb_buffer_set_direction = NULL,
.hb_feature_from_string = NULL,
.hb_shape_full = NULL,
.hb_buffer_create = NULL,
.hb_buffer_destroy = NULL,
.hb_buffer_add_utf8 = NULL,
.hb_buffer_add_utf32 = NULL,
/* .hb_buffer_add = NULL, */
.hb_buffer_get_length = NULL,
.hb_buffer_get_glyph_infos = NULL,
.hb_buffer_get_glyph_positions = NULL,
.hb_buffer_reverse = NULL,
.hb_buffer_reset = NULL,
.hb_buffer_guess_segment_properties = NULL,
.hb_font_create = NULL,
.hb_font_destroy = NULL,
.hb_font_set_scale = NULL,
.hb_ot_font_set_funcs = NULL,
.hb_face_get_upem = NULL,
.hb_shape_list_shapers = NULL,
};
/* <boolean> = initialize(full_path_of_library) */
static int hblib_initialize(lua_State * L)
{
if (! hblib_state.initialized) {
const char *filename = lua_tostring(L, 1);
if (filename) {
lmt_library lib = lmt_library_load(filename);
hblib_state.hb_version_string = lmt_library_find(lib, "hb_version_string");
hblib_state.hb_language_from_string = lmt_library_find(lib, "hb_language_from_string");
hblib_state.hb_script_from_string = lmt_library_find(lib, "hb_script_from_string");
hblib_state.hb_direction_from_string = lmt_library_find(lib, "hb_direction_from_string");
hblib_state.hb_feature_from_string = lmt_library_find(lib, "hb_feature_from_string");
hblib_state.hb_buffer_set_language = lmt_library_find(lib, "hb_buffer_set_language");
hblib_state.hb_buffer_set_script = lmt_library_find(lib, "hb_buffer_set_script");
hblib_state.hb_buffer_set_direction = lmt_library_find(lib, "hb_buffer_set_direction");
hblib_state.hb_buffer_create = lmt_library_find(lib, "hb_buffer_create");
hblib_state.hb_buffer_destroy = lmt_library_find(lib, "hb_buffer_destroy");
hblib_state.hb_buffer_reverse = lmt_library_find(lib, "hb_buffer_reverse");
hblib_state.hb_buffer_get_length = lmt_library_find(lib, "hb_buffer_get_length");
hblib_state.hb_buffer_reset = lmt_library_find(lib, "hb_buffer_reset");
hblib_state.hb_buffer_add_utf8 = lmt_library_find(lib, "hb_buffer_add_utf8");
hblib_state.hb_buffer_add_utf32 = lmt_library_find(lib, "hb_buffer_add_utf32");
hblib_state.hb_blob_create = lmt_library_find(lib, "hb_blob_create");
hblib_state.hb_blob_destroy = lmt_library_find(lib, "hb_blob_destroy");
hblib_state.hb_face_create = lmt_library_find(lib, "hb_face_create");
hblib_state.hb_face_destroy = lmt_library_find(lib, "hb_face_destroy");
hblib_state.hb_face_get_upem = lmt_library_find(lib, "hb_face_get_upem");
hblib_state.hb_font_create = lmt_library_find(lib, "hb_font_create");
hblib_state.hb_font_destroy = lmt_library_find(lib, "hb_font_destroy");
hblib_state.hb_font_set_scale = lmt_library_find(lib, "hb_font_set_scale");
hblib_state.hb_shape_list_shapers = lmt_library_find(lib, "hb_shape_list_shapers");
hblib_state.hb_shape_full = lmt_library_find(lib, "hb_shape_full");
hblib_state.hb_ot_font_set_funcs = lmt_library_find(lib, "hb_ot_font_set_funcs");
hblib_state.hb_buffer_guess_segment_properties = lmt_library_find(lib, "hb_buffer_guess_segment_properties");
hblib_state.hb_buffer_get_glyph_positions = lmt_library_find(lib, "hb_buffer_get_glyph_positions");
hblib_state.hb_buffer_get_glyph_infos = lmt_library_find(lib, "hb_buffer_get_glyph_infos");
hblib_state.initialized = lmt_library_okay(lib);
}
}
lua_pushboolean(L, hblib_state.initialized);
return 1;
}
/* <string> = getversion() */
static int hblib_get_version(lua_State * L)
{
if (hblib_state.initialized) {
lua_pushstring(L, hblib_state.hb_version_string());
return 1;
} else {
return 0;
}
}
/* <instance> = loadfont(identifier, fontdata) */
static int hblib_load_font(lua_State * L)
{
if (hblib_state.initialized) {
int id = (int) lua_tointeger(L, 1);
const char *str= lua_tostring(L, 2);
int size = (int) lua_rawlen(L, 2);
hb_blob_t *blob = hblib_state.hb_blob_create(str, size, 0, NULL, NULL);
hb_face_t *face = hblib_state.hb_face_create(blob, id);
unsigned int scale = hblib_state.hb_face_get_upem(face);
hb_font_t *font = hblib_state.hb_font_create(face);
hblib_data *data = lua_newuserdatauv(L, sizeof(data), 0);
hblib_state.hb_font_set_scale(font, scale, scale);
hblib_state.hb_ot_font_set_funcs(font);
data->font = font;
luaL_getmetatable(L, HBLIB_METATABLE);
lua_setmetatable(L, -2);
hblib_state.hb_blob_destroy(blob);
hblib_state.hb_face_destroy(face);
return 1;
} else {
return 0;
}
}
/* <table> = shapestring(instance, script, language, direction, { shapers }, { features }, text, reverse) */
static int hblib_utf8len(const char *text, size_t size) /* todo: take from utilities */
{
size_t ls = size;
int ind = 0;
int num = 0;
while (ind < (int) ls) {
unsigned char i = (unsigned char) *(text + ind);
if (i < 0x80) {
ind += 1;
} else if (i >= 0xF0) {
ind += 4;
} else if (i >= 0xE0) {
ind += 3;
} else if (i >= 0xC0) {
ind += 2;
} else {
ind += 1;
}
num += 1;
}
return num;
}
static int hblib_utf32len(const char *text, size_t size)
{
/* not okay, hb doesn't stop at \0 */
/* (void) s; */
/* return (int) size / 4; */
/* so we do this instead */
size_t ls = size;
int ind = 0;
int num = 0;
while (ind < (int) ls) {
unsigned char i = (unsigned char) *(text + ind);
if (i) {
ind += 4;
} else {
break;
}
num += 1;
}
return num;
}
/*tex
Maybe with |utfbits == 0| take a table with code points, but then we might also need cluster
stuff, so there is no gain here.
I remember some issues with passing features (maybe because some defaults are always set) but
it's not really that important because one actually expects the library to handle them that way
(read: only enable additional ones). But I will look into it when needed.
*/
static int hblib_shape_string(lua_State * L)
{
if (hblib_state.initialized) {
hblib_data *data = luaL_checkudata(L, 1, HBLIB_METATABLE);
if (data == NULL) {
lua_pushnil(L);
} else {
/* Maybe we can better take a table, so it's a yet undecided api. */
size_t nofscript = 0;
const char *script = lua_tolstring(L, 2, &nofscript);
size_t noflanguage = 0;
const char *language = lua_tolstring(L, 3, &noflanguage);
size_t nofdirection = 0;
const char *direction = lua_tolstring(L, 4, &nofdirection);
int nofshapers = 0;
const char * *shapers = NULL; /* slot 5 */
int noffeatures = 0;
hb_feature_t *features = NULL; /* slot 6 */
size_t noftext = 0;
const char *text = lua_tolstring(L, 7, &noftext);
int reverse = lua_toboolean(L, 8);
int utfbits = (int) luaL_optinteger(L, 9, 8);
hb_buffer_t *buffer = NULL;
/*
Shapers are passed as a table; why not pass the length here too ... simpler in
ffi -) Maybe I'll make this more static: a general setshaper or so, which is
more natural than having it as argument to the shape function.
MSVC wants |char**| for the shapers and gcc wants |const char**| i.e.\ doesn't
like a cast so we just accept the less annoying MSVC warning.
*/
if (lua_istable(L, 5)) {
lua_Unsigned n = lua_rawlen(L, 5);
if (n > 0) {
// shapers = malloc((size_t) (n + 1) * sizeof(char *));
shapers = calloc((size_t) (n + 1), sizeof(char *));
if (shapers) {
for (lua_Unsigned i = 0; i < n; i++) {
lua_rawgeti(L, 5, i + 1);
if (lua_isstring(L, -1)) {
shapers[nofshapers] = lua_tostring(L, -1);
nofshapers += 1;
}
lua_pop(L, 1);
}
} else {
luaL_error(L, "optional hblib: unable to allocate shaper memory");
}
/* sentinal */
shapers[nofshapers] = NULL;
}
}
/*
Features need to be converted to a table of features (manual work); simpler in
ffi -) Maybe I'll move this to the loadfont function.
*/
if (lua_istable(L, 6)) {
lua_Unsigned n = lua_rawlen(L, 6);
if (n > 0) {
features = malloc((size_t) n * sizeof(hb_feature_t));
if (features) {
for (lua_Unsigned i = 0; i < n; i++) {
lua_rawgeti(L, 6, i + 1);
if (lua_isstring(L, -1)) {
size_t l = 0;
const char *s = lua_tolstring(L, -1, &l);
hblib_state.hb_feature_from_string(s, (int) l, &features[noffeatures]);
noffeatures += 1;
}
lua_pop(L, 1);
}
} else {
luaL_error(L, "optional hblib: unable to allocate feature memory");
}
}
}
/* Some preparations (see original ffi variant). */
buffer = hblib_state.hb_buffer_create(); /* we could put this in the data blob */
/*
When using ffi we used to use utf32 plus some slack because utf8 crashed. It would
be more handy if we could pass an array of integers (maybe we can).
*/
if (utfbits == 32) {
hblib_state.hb_buffer_add_utf32(buffer, text, (int) noftext, 0, (int) hblib_utf32len(text, noftext));
} else { /* 8 */
hblib_state.hb_buffer_add_utf8(buffer, text, (int) noftext, 0, (int) hblib_utf8len(text, noftext));
}
hblib_state.hb_buffer_set_language(buffer, hblib_state.hb_language_from_string(language, (int) noflanguage));
hblib_state.hb_buffer_set_script(buffer, hblib_state.hb_script_from_string(script, (int) nofscript));
hblib_state.hb_buffer_set_direction(buffer, hblib_state.hb_direction_from_string(direction, (int) nofdirection));
hblib_state.hb_buffer_guess_segment_properties(buffer);
/* Do it! */
hblib_state.hb_shape_full(data->font, buffer, features, noffeatures, shapers);
/* Fixup. */
if (reverse) {
hblib_state.hb_buffer_reverse(buffer);
}
/* Convert the result: plain and simple.*/
{
unsigned length = hblib_state.hb_buffer_get_length(buffer);
hb_glyph_info_t *infos = hblib_state.hb_buffer_get_glyph_infos(buffer, NULL);
hb_glyph_position_t *positions = hblib_state.hb_buffer_get_glyph_positions(buffer, NULL);
lua_createtable(L, length, 0);
for (unsigned i = 0; i < length; i++) {
lua_createtable(L, 6, 0);
lua_pushinteger(L, infos[i].codepoint);
lua_rawseti(L, -2, 1);
lua_pushinteger(L, infos[i].cluster);
lua_rawseti(L, -2, 2);
lua_pushinteger(L, positions[i].x_offset);
lua_rawseti(L, -2, 3);
lua_pushinteger(L, positions[i].y_offset);
lua_rawseti(L, -2, 4);
lua_pushinteger(L, positions[i].x_advance);
lua_rawseti(L, -2, 5);
lua_pushinteger(L, positions[i].y_advance);
lua_rawseti(L, -2, 6);
lua_rawseti(L, -2, (lua_Integer) i + 1);
}
}
/*
We have a crash after many runs but why ... a printf("!") actually solves it. Do we need to free
something more? SOmethign to so with utf32 (used to be utf8 issue).
*/
hblib_state.hb_buffer_destroy(buffer);
free((void *) shapers); /* we didn't make copies of the lua strings, ms compiler gives warning */
free((void *) features);
}
return 1;
} else {
return 0;
}
}
/* <table> = getshapers() */
static int hblib_get_shapers(lua_State * L)
{
if (hblib_state.initialized) {
const char * *shapers = hblib_state.hb_shape_list_shapers();
if (shapers) {
int nofshapers = 0;
lua_createtable(L, 1, 0);
while (1) {
const char *s = shapers[nofshapers];
if (s) {
nofshapers++;
lua_pushstring(L, s);
lua_rawseti(L, -2, nofshapers);
} else {
break;
}
}
return 1;
}
}
return 0;
}
/* private */
static int hblib_free(lua_State * L)
{
if (hblib_state.initialized) {
hblib_data *data = luaL_checkudata(L, 1, HBLIB_METATABLE);
if (data) {
hblib_state.hb_font_destroy(data->font);
}
}
return 0;
}
/* <string> = tostring(instance) */
static int hblib_tostring(lua_State * L)
{
if (hblib_state.initialized) {
hblib_data *data = luaL_checkudata(L, 1, HBLIB_METATABLE);
if (data) {
lua_pushfstring(L, "<optional.hblib.instance %p>", data);
} else {
lua_pushnil(L);
}
return 1;
} else {
return 0;
}
}
/*tex We can do with a rather mimimal user data object. */
static const struct luaL_Reg hblib_metatable[] = {
{ "__tostring", hblib_tostring },
{ "__gc", hblib_free },
{ NULL, NULL },
};
/*tex
Idem, just the collected calls of the ffi variant. The less the better because that way there
is no tricky code needed at the \LUA\ end.
*/
static struct luaL_Reg hblib_function_list[] = {
{ "initialize", hblib_initialize },
{ "getversion", hblib_get_version },
{ "getshapers", hblib_get_shapers },
{ "loadfont", hblib_load_font },
{ "shapestring", hblib_shape_string },
{ NULL, NULL },
};
int luaopen_hb(lua_State *L)
{
luaL_newmetatable(L, HBLIB_METATABLE);
luaL_setfuncs(L, hblib_metatable, 0);
lmt_library_register(L, "hb", hblib_function_list);
return 0;
}