From 72f12cdcd93ddf25c74770d931b3e82b3711815b Mon Sep 17 00:00:00 2001 From: Vladimir 'phcoder' Serbinenko Date: Thu, 7 Jan 2010 16:37:53 +0100 Subject: [PATCH] Group combining diacritics --- autogen.sh | 2 +- font/font.c | 344 ++++++-- include/grub/{bidi.h => unicode.h} | 40 +- unidata.c | 1169 +++++++++++++++++----------- util/grub-mkfont.c | 3 + util/import_bidi.py | 52 -- util/import_unicode.py | 67 ++ 7 files changed, 1116 insertions(+), 561 deletions(-) rename include/grub/{bidi.h => unicode.h} (57%) delete mode 100644 util/import_bidi.py create mode 100644 util/import_unicode.py diff --git a/autogen.sh b/autogen.sh index 7aac1c534..5d0b5a282 100755 --- a/autogen.sh +++ b/autogen.sh @@ -13,7 +13,7 @@ echo timestamp > stamp-h.in python util/import_gcry.py lib/libgcrypt/ . -python util/import_bidi.py util/UnicodeData.txt unidata.c +python util/import_unicode.py util/UnicodeData.txt unidata.c for rmk in conf/*.rmk ${GRUB_CONTRIB}/*/conf/*.rmk; do if test -e $rmk ; then diff --git a/font/font.c b/font/font.c index cd5908d5c..54b6a1048 100644 --- a/font/font.c +++ b/font/font.c @@ -27,7 +27,7 @@ #include #include #include -#include +#include #ifndef FONT_DEBUG #define FONT_DEBUG 0 @@ -882,7 +882,10 @@ grub_font_get_string_width (grub_font_t font, const char *str) grub_utf8_to_ucs4 (&code, 1, ptr, -1, &ptr) > 0; ) { glyph = grub_font_get_glyph_with_fallback (font, code); - width += glyph->device_width; + if (glyph) + width += glyph->device_width; + else + width += unknown_glyph->device_width; } return width; @@ -989,13 +992,210 @@ grub_font_get_glyph_with_fallback (grub_font_t font, grub_uint32_t code) } } - if (best_glyph) - return best_glyph; - else - /* Glyph not available in any font. Return unknown glyph. */ - return unknown_glyph; + return best_glyph; } +static struct grub_font_glyph * +grub_font_dup_glyph (struct grub_font_glyph *glyph) +{ + static struct grub_font_glyph *ret; + ret = grub_malloc (sizeof (*ret) + (glyph->width * glyph->height + 7) / 8); + if (!ret) + return NULL; + grub_memcpy (ret, glyph, sizeof (*ret) + + (glyph->width * glyph->height + 7) / 8); + return ret; +} + +/* FIXME: suboptimal. */ +static void +grub_font_blit_glyph (struct grub_font_glyph *target, + struct grub_font_glyph *src, + unsigned dx, unsigned dy) +{ + unsigned src_bit, tgt_bit, src_byte, tgt_byte; + unsigned i, j; + for (i = 0; i < src->height; i++) + { + src_bit = (src->width * i) % 8; + src_byte = (src->width * i) / 8; + tgt_bit = (target->width * (dy + i) + dx) % 8; + tgt_byte = (target->width * (dy + i) + dx) / 8; + for (j = 0; j < src->width; j++) + { + target->bitmap[tgt_byte] |= ((src->bitmap[src_byte] << src_bit) + & 0x80) >> tgt_bit; + src_bit++; + tgt_bit++; + if (src_bit == 8) + { + src_byte++; + src_bit = 0; + } + if (tgt_bit == 8) + { + tgt_byte++; + tgt_bit = 0; + } + } + } +} + +static inline enum grub_comb_type +get_comb_type (grub_uint32_t c) +{ + static grub_uint8_t *comb_types = NULL; + struct grub_unicode_compact_range *cur; + + if (!comb_types) + { + unsigned i; + comb_types = grub_zalloc (GRUB_UNICODE_MAX_CACHED_CHAR); + if (comb_types) + for (cur = grub_unicode_compact; cur->end; cur++) + for (i = cur->start; i <= cur->end + && i < GRUB_UNICODE_MAX_CACHED_CHAR; i++) + comb_types[i] = cur->comb_type; + else + grub_errno = GRUB_ERR_NONE; + } + + if (comb_types && c < GRUB_UNICODE_MAX_CACHED_CHAR) + return comb_types[c]; + + for (cur = grub_unicode_compact; cur->end; cur++) + if (cur->start <= c && c <= cur->end) + return cur->comb_type; + + return GRUB_BIDI_TYPE_L; +} + +static struct grub_font_glyph * +grub_font_construct_glyph (grub_font_t hinted_font, + const struct grub_unicode_glyph *glyph_id) +{ + grub_font_t font; + grub_uint16_t width; + grub_uint16_t height; + grub_int16_t offset_x; + grub_int16_t offset_y; + grub_uint16_t device_width; + struct grub_font_glyph *main_glyph; + struct grub_font_glyph **combining_glyphs; + unsigned i; + struct grub_font_glyph *glyph; + + main_glyph = grub_font_get_glyph_with_fallback (hinted_font, glyph_id->base); + + if (!main_glyph) + { + /* Glyph not available in any font. Return unknown glyph. */ + return grub_font_dup_glyph (unknown_glyph); + } + + if (!glyph_id->ncomb) + return grub_font_dup_glyph (main_glyph); + + combining_glyphs = grub_malloc (sizeof (combining_glyphs[0]) + * glyph_id->ncomb); + if (!combining_glyphs) + { + grub_errno = GRUB_ERR_NONE; + return grub_font_dup_glyph (main_glyph); + } + + font = main_glyph->font; + width = main_glyph->width; + height = main_glyph->height; + offset_x = main_glyph->offset_x; + offset_y = main_glyph->offset_y; + device_width = main_glyph->device_width; + + for (i = 0; i < glyph_id->ncomb; i++) + { + enum grub_comb_type combtype; + combining_glyphs[i] + = grub_font_get_glyph_with_fallback (font, glyph_id->combining[i]); + if (!combining_glyphs[i]) + continue; + combtype = get_comb_type (glyph_id->combining[i]); + switch (combtype) + { + default: + { + /* Default handling. Just draw combining character on top + of base character. + FIXME: support more unicode types correctly. + */ + grub_int16_t nx = main_glyph->device_width + + combining_glyphs[i]->offset_x; + + device_width += combining_glyphs[i]->device_width; + if (nx < offset_x) + { + width += offset_x - nx; + offset_x = nx; + } + if (offset_y > combining_glyphs[i]->offset_y) + { + height += offset_y - combining_glyphs[i]->offset_y; + offset_y = combining_glyphs[i]->offset_y; + } + if (nx + combining_glyphs[i]->width - offset_x >= width) + width = nx + combining_glyphs[i]->width - offset_x + 1; + if (height + < (combining_glyphs[i]->height + + combining_glyphs[i]->offset_y) - offset_y) + height = (combining_glyphs[i]->height + + combining_glyphs[i]->offset_y) - offset_y; + } + } + } + + glyph = grub_zalloc (sizeof (*glyph) + (width * height + 7) / 8); + if (!glyph) + { + grub_errno = GRUB_ERR_NONE; + return grub_font_dup_glyph (main_glyph); + } + + glyph->font = font; + glyph->width = width; + glyph->height = height; + glyph->offset_x = offset_x; + glyph->offset_y = offset_y; + glyph->device_width = device_width; + + grub_font_blit_glyph (glyph, main_glyph, main_glyph->offset_x - offset_x, + (height + offset_y) + - (main_glyph->height + main_glyph->offset_y)); + + for (i = 0; i < glyph_id->ncomb; i++) + { + enum grub_comb_type combtype; + if (!combining_glyphs[i]) + continue; + combtype = get_comb_type (glyph_id->combining[i]); + switch (combtype) + { + default: + { + /* Default handling. Just draw combining character on top + of base character. + FIXME: support more unicode types correctly. + */ + grub_font_blit_glyph (glyph, combining_glyphs[i], + main_glyph->device_width + + combining_glyphs[i]->offset_x - offset_x, + (height + offset_y) + - (combining_glyphs[i]->height + + combining_glyphs[i]->offset_y)); + } + } + } + + return glyph; +} /* Draw the specified glyph at (x, y). The y coordinate designates the baseline of the character, while the x coordinate designates the left @@ -1051,27 +1251,27 @@ static inline enum grub_bidi_type get_bidi_type (grub_uint32_t c) { static grub_uint8_t *bidi_types = NULL; - struct grub_bidi_compact_range *cur; + struct grub_unicode_compact_range *cur; if (!bidi_types) { unsigned i; - bidi_types = grub_zalloc (GRUB_BIDI_MAX_CACHED_UNICODE_CHAR); + bidi_types = grub_zalloc (GRUB_UNICODE_MAX_CACHED_CHAR); if (bidi_types) - for (cur = grub_bidi_compact; cur->end; cur++) + for (cur = grub_unicode_compact; cur->end; cur++) for (i = cur->start; i <= cur->end - && i < GRUB_BIDI_MAX_CACHED_UNICODE_CHAR; i++) - bidi_types[i] = cur->type; + && i < GRUB_UNICODE_MAX_CACHED_CHAR; i++) + bidi_types[i] = cur->bidi_type; else grub_errno = GRUB_ERR_NONE; } - if (bidi_types && c < GRUB_BIDI_MAX_CACHED_UNICODE_CHAR) + if (bidi_types && c < GRUB_UNICODE_MAX_CACHED_CHAR) return bidi_types[c]; - for (cur = grub_bidi_compact; cur->end; cur++) + for (cur = grub_unicode_compact; cur->end; cur++) if (cur->start <= c && c <= cur->end) - return cur->type; + return cur->bidi_type; return GRUB_BIDI_TYPE_L; } @@ -1079,7 +1279,7 @@ get_bidi_type (grub_uint32_t c) static grub_ssize_t grub_err_bidi_logical_to_visual (grub_uint32_t *logical, grub_size_t logical_len, - grub_uint32_t **visual) + struct grub_unicode_glyph **visual_out) { enum grub_bidi_type type = GRUB_BIDI_TYPE_L; enum override_status {OVERRIDE_NEUTRAL = 0, OVERRIDE_R, OVERRIDE_L}; @@ -1092,9 +1292,9 @@ grub_err_bidi_logical_to_visual (grub_uint32_t *logical, enum override_status stack_override[GRUB_BIDI_MAX_EXPLICIT_LEVEL + 3]; unsigned stack_depth = 0; unsigned invalid_pushes = 0; - unsigned no_markers_len = 0; + unsigned visual_len = 0; unsigned run_start, run_end; - grub_uint32_t *no_markers; + struct grub_unicode_glyph *visual; unsigned cur_level; auto void push_stack (unsigned new_override, unsigned new_level); @@ -1130,13 +1330,13 @@ grub_err_bidi_logical_to_visual (grub_uint32_t *logical, auto void revert (unsigned start, unsigned end); void revert (unsigned start, unsigned end) { - grub_uint32_t t; + struct grub_unicode_glyph t; unsigned k, tl; for (k = 0; k <= (end - start) / 2; k++) { - t = no_markers[start+k]; - no_markers[start+k] = no_markers[end-k]; - no_markers[end-k] = t; + t = visual[start+k]; + visual[start+k] = visual[end-k]; + visual[end-k] = t; tl = levels[start+k]; levels[start+k] = levels[end-k]; levels[end-k] = tl; @@ -1154,8 +1354,8 @@ grub_err_bidi_logical_to_visual (grub_uint32_t *logical, return -1; } - no_markers = grub_malloc (sizeof (resolved_types[0]) * logical_len); - if (!no_markers) + visual = grub_malloc (sizeof (visual[0]) * logical_len); + if (!visual) { grub_free (resolved_types); grub_free (levels); @@ -1178,6 +1378,27 @@ grub_err_bidi_logical_to_visual (grub_uint32_t *logical, cur_override = OVERRIDE_NEUTRAL; for (i = 0; i < logical_len; i++) { + /* Variation selectors >= 17 are outside of BMP and SMP. + Handle variation selectors first to avoid potentially costly lookups. + */ + if (logical[i] >= GRUB_UNICODE_VARIATION_SELECTOR_1 + && logical[i] <= GRUB_UNICODE_VARIATION_SELECTOR_16) + { + if (!visual_len) + continue; + visual[visual_len - 1].variant + = logical[i] - GRUB_UNICODE_VARIATION_SELECTOR_1 + 1; + } + if (logical[i] >= GRUB_UNICODE_VARIATION_SELECTOR_17 + && logical[i] <= GRUB_UNICODE_VARIATION_SELECTOR_256) + { + if (!visual_len) + continue; + visual[visual_len - 1].variant + = logical[i] - GRUB_UNICODE_VARIATION_SELECTOR_17 + 17; + continue; + } + type = get_bidi_type (logical[i]); switch (type) { @@ -1199,28 +1420,54 @@ grub_err_bidi_logical_to_visual (grub_uint32_t *logical, case GRUB_BIDI_TYPE_BN: break; default: - levels[no_markers_len] = cur_level; - if (cur_override != OVERRIDE_NEUTRAL) - resolved_types[no_markers_len] = - (cur_override == OVERRIDE_L) ? GRUB_BIDI_TYPE_L : GRUB_BIDI_TYPE_R; - else - resolved_types[no_markers_len] = type; - no_markers[no_markers_len] = logical[i]; - no_markers_len++; + { + enum grub_comb_type comb_type; + comb_type = get_comb_type (logical[i]); + if (comb_type) + { + grub_uint32_t *n; + if (!visual_len) + break; + n = grub_realloc (visual[visual_len - 1].combining, + sizeof (grub_uint32_t) + * (visual[visual_len - 1].ncomb + 1)); + if (!n) + { + grub_errno = GRUB_ERR_NONE; + break; + } + visual[visual_len - 1].combining = n; + visual[visual_len - 1].combining[visual[visual_len - 1].ncomb] + = logical[i]; + visual[visual_len - 1].ncomb++; + break; + } + levels[visual_len] = cur_level; + if (cur_override != OVERRIDE_NEUTRAL) + resolved_types[visual_len] = + (cur_override == OVERRIDE_L) ? GRUB_BIDI_TYPE_L : GRUB_BIDI_TYPE_R; + else + resolved_types[visual_len] = type; + visual[visual_len].base = logical[i]; + visual[visual_len].variant = 0; + visual[visual_len].ncomb = 0; + visual[visual_len].combining = NULL; + visual_len++; + } } } - for (run_start = 0; run_start < no_markers_len; run_start = run_end) + for (run_start = 0; run_start < visual_len; run_start = run_end) { unsigned prev_level, next_level, cur_run_level; unsigned last_type, last_strong_type; - for (run_end = run_start; run_end < no_markers_len && + for (run_end = run_start; run_end < visual_len && levels[run_end] == levels[run_start]; run_end++); if (run_start == 0) prev_level = base_level; else prev_level = levels[run_start - 1]; - if (run_end == no_markers_len) + if (run_end == visual_len) next_level = base_level; else next_level = levels[run_end]; @@ -1350,7 +1597,7 @@ grub_err_bidi_logical_to_visual (grub_uint32_t *logical, } } - for (i = 0; i < no_markers_len; i++) + for (i = 0; i < visual_len; i++) { if (!(levels[i] & 1) && resolved_types[i] == GRUB_BIDI_TYPE_R) { @@ -1377,7 +1624,7 @@ grub_err_bidi_logical_to_visual (grub_uint32_t *logical, unsigned min_odd_level = 0xffffffff; unsigned max_level = 0; unsigned j; - for (i = 0; i < no_markers_len; i++) + for (i = 0; i < visual_len; i++) { if (levels[i] > max_level) max_level = levels[i]; @@ -1387,11 +1634,11 @@ grub_err_bidi_logical_to_visual (grub_uint32_t *logical, for (j = max_level; j >= min_odd_level; j--) { unsigned in = 0; - for (i = 0; i < no_markers_len; i++) + for (i = 0; i < visual_len; i++) { if (i != 0 && levels[i] >= j && levels[i-1] < j) in = i; - if (levels[i] >= j && (i + 1 == no_markers_len || levels[i+1] < j)) + if (levels[i] >= j && (i + 1 == visual_len || levels[i+1] < j)) revert (in, i); } } @@ -1399,8 +1646,8 @@ grub_err_bidi_logical_to_visual (grub_uint32_t *logical, grub_free (levels); - *visual = no_markers; - return no_markers_len; + *visual_out = visual; + return visual_len; } /* Draw a UTF-8 string of text on the current video render target. @@ -1415,8 +1662,9 @@ grub_font_draw_string (const char *str, grub_font_t font, { int x; struct grub_font_glyph *glyph; - grub_uint32_t *logical, *visual, *ptr; + grub_uint32_t *logical; grub_ssize_t logical_len, visual_len; + struct grub_unicode_glyph *visual, *ptr; logical_len = grub_utf8_to_ucs4_alloc (str, &logical, 0); if (logical_len < 0) @@ -1429,10 +1677,14 @@ grub_font_draw_string (const char *str, grub_font_t font, for (ptr = visual, x = left_x; ptr < visual + visual_len; ptr++) { - glyph = grub_font_get_glyph_with_fallback (font, *ptr); - if (grub_font_draw_glyph (glyph, color, x, baseline_y) - != GRUB_ERR_NONE) - return grub_errno; + grub_err_t err; + glyph = grub_font_construct_glyph (font, ptr); + if (!glyph) + return grub_errno; + err = grub_font_draw_glyph (glyph, color, x, baseline_y); + grub_free (glyph); + if (err) + return err; x += glyph->device_width; } diff --git a/include/grub/bidi.h b/include/grub/unicode.h similarity index 57% rename from include/grub/bidi.h rename to include/grub/unicode.h index 8612d6e24..79d553eec 100644 --- a/include/grub/bidi.h +++ b/include/grub/unicode.h @@ -21,11 +21,12 @@ #include -struct grub_bidi_compact_range +struct grub_unicode_compact_range { - grub_uint32_t start:24; - grub_uint32_t end:24; - grub_uint8_t type; + grub_uint32_t start:21; + grub_uint32_t end:21; + grub_uint8_t bidi_type:5; + grub_uint8_t comb_type; } __attribute__ ((packed)); enum grub_bidi_type @@ -51,9 +52,36 @@ enum grub_bidi_type GRUB_BIDI_TYPE_ON }; -extern struct grub_bidi_compact_range grub_bidi_compact[]; +enum grub_comb_type + { + GRUB_UNICODE_STACK_BELOW = 220, + GRUB_UNICODE_STACK_ABOVE = 230, + /* If combining nature is indicated only by class and + not "combining type". */ + GRUB_UNICODE_COMB_ME = 253, + GRUB_UNICODE_COMB_MC = 254, + GRUB_UNICODE_COMB_MN = 255, + }; -#define GRUB_BIDI_MAX_CACHED_UNICODE_CHAR 0x20000 +/* This structure describes a glyph as opposed to character. */ +struct grub_unicode_glyph +{ + grub_uint32_t base; + /* Unicode permits 256 variation selectors but since we need a value + for "default" we have to use grub_uint16_t. */ + grub_uint16_t variant; + grub_size_t ncomb; + grub_uint32_t *combining; +}; + +#define GRUB_UNICODE_VARIATION_SELECTOR_1 0xfe00 +#define GRUB_UNICODE_VARIATION_SELECTOR_16 0xfe0f +#define GRUB_UNICODE_VARIATION_SELECTOR_17 0xe0100 +#define GRUB_UNICODE_VARIATION_SELECTOR_256 0xe01ef + +extern struct grub_unicode_compact_range grub_unicode_compact[]; + +#define GRUB_UNICODE_MAX_CACHED_CHAR 0x20000 /* Unicode mandates an arbitrary limit. */ #define GRUB_BIDI_MAX_EXPLICIT_LEVEL 61 diff --git a/unidata.c b/unidata.c index f4467c920..02d0f9712 100644 --- a/unidata.c +++ b/unidata.c @@ -1,458 +1,715 @@ -#include +#include -struct grub_bidi_compact_range grub_bidi_compact[] = { -{0x0, 0x8, GRUB_BIDI_TYPE_BN}, -{0x9, 0x9, GRUB_BIDI_TYPE_S}, -{0xa, 0xa, GRUB_BIDI_TYPE_B}, -{0xb, 0xb, GRUB_BIDI_TYPE_S}, -{0xc, 0xc, GRUB_BIDI_TYPE_WS}, -{0xd, 0xd, GRUB_BIDI_TYPE_B}, -{0xe, 0x1b, GRUB_BIDI_TYPE_BN}, -{0x1c, 0x1e, GRUB_BIDI_TYPE_B}, -{0x1f, 0x1f, GRUB_BIDI_TYPE_S}, -{0x20, 0x20, GRUB_BIDI_TYPE_WS}, -{0x21, 0x22, GRUB_BIDI_TYPE_ON}, -{0x23, 0x25, GRUB_BIDI_TYPE_ET}, -{0x26, 0x2a, GRUB_BIDI_TYPE_ON}, -{0x2b, 0x2b, GRUB_BIDI_TYPE_ES}, -{0x2c, 0x2c, GRUB_BIDI_TYPE_CS}, -{0x2d, 0x2d, GRUB_BIDI_TYPE_ES}, -{0x2e, 0x2f, GRUB_BIDI_TYPE_CS}, -{0x30, 0x39, GRUB_BIDI_TYPE_EN}, -{0x3a, 0x3a, GRUB_BIDI_TYPE_CS}, -{0x3b, 0x40, GRUB_BIDI_TYPE_ON}, -{0x5b, 0x60, GRUB_BIDI_TYPE_ON}, -{0x7b, 0x7e, GRUB_BIDI_TYPE_ON}, -{0x7f, 0x84, GRUB_BIDI_TYPE_BN}, -{0x85, 0x85, GRUB_BIDI_TYPE_B}, -{0x86, 0x9f, GRUB_BIDI_TYPE_BN}, -{0xa0, 0xa0, GRUB_BIDI_TYPE_CS}, -{0xa1, 0xa1, GRUB_BIDI_TYPE_ON}, -{0xa2, 0xa5, GRUB_BIDI_TYPE_ET}, -{0xa6, 0xa9, GRUB_BIDI_TYPE_ON}, -{0xab, 0xac, GRUB_BIDI_TYPE_ON}, -{0xad, 0xad, GRUB_BIDI_TYPE_BN}, -{0xae, 0xaf, GRUB_BIDI_TYPE_ON}, -{0xb0, 0xb1, GRUB_BIDI_TYPE_ET}, -{0xb2, 0xb3, GRUB_BIDI_TYPE_EN}, -{0xb4, 0xb4, GRUB_BIDI_TYPE_ON}, -{0xb6, 0xb8, GRUB_BIDI_TYPE_ON}, -{0xb9, 0xb9, GRUB_BIDI_TYPE_EN}, -{0xbb, 0xbf, GRUB_BIDI_TYPE_ON}, -{0xd7, 0xd7, GRUB_BIDI_TYPE_ON}, -{0xf7, 0xf7, GRUB_BIDI_TYPE_ON}, -{0x2b9, 0x2ba, GRUB_BIDI_TYPE_ON}, -{0x2c2, 0x2cf, GRUB_BIDI_TYPE_ON}, -{0x2d2, 0x2df, GRUB_BIDI_TYPE_ON}, -{0x2e5, 0x2ed, GRUB_BIDI_TYPE_ON}, -{0x2ef, 0x2ff, GRUB_BIDI_TYPE_ON}, -{0x300, 0x36f, GRUB_BIDI_TYPE_NSM}, -{0x374, 0x375, GRUB_BIDI_TYPE_ON}, -{0x37e, 0x37e, GRUB_BIDI_TYPE_ON}, -{0x384, 0x385, GRUB_BIDI_TYPE_ON}, -{0x387, 0x387, GRUB_BIDI_TYPE_ON}, -{0x3f6, 0x3f6, GRUB_BIDI_TYPE_ON}, -{0x483, 0x489, GRUB_BIDI_TYPE_NSM}, -{0x58a, 0x58a, GRUB_BIDI_TYPE_ON}, -{0x591, 0x5bd, GRUB_BIDI_TYPE_NSM}, -{0x5be, 0x5be, GRUB_BIDI_TYPE_R}, -{0x5bf, 0x5bf, GRUB_BIDI_TYPE_NSM}, -{0x5c0, 0x5c0, GRUB_BIDI_TYPE_R}, -{0x5c1, 0x5c2, GRUB_BIDI_TYPE_NSM}, -{0x5c3, 0x5c3, GRUB_BIDI_TYPE_R}, -{0x5c4, 0x5c5, GRUB_BIDI_TYPE_NSM}, -{0x5c6, 0x5c6, GRUB_BIDI_TYPE_R}, -{0x5c7, 0x5c7, GRUB_BIDI_TYPE_NSM}, -{0x5d0, 0x5ea, GRUB_BIDI_TYPE_R}, -{0x5f0, 0x5f4, GRUB_BIDI_TYPE_R}, -{0x600, 0x603, GRUB_BIDI_TYPE_AN}, -{0x606, 0x607, GRUB_BIDI_TYPE_ON}, -{0x608, 0x608, GRUB_BIDI_TYPE_AL}, -{0x609, 0x60a, GRUB_BIDI_TYPE_ET}, -{0x60b, 0x60b, GRUB_BIDI_TYPE_AL}, -{0x60c, 0x60c, GRUB_BIDI_TYPE_CS}, -{0x60d, 0x60d, GRUB_BIDI_TYPE_AL}, -{0x60e, 0x60f, GRUB_BIDI_TYPE_ON}, -{0x610, 0x61a, GRUB_BIDI_TYPE_NSM}, -{0x61b, 0x61b, GRUB_BIDI_TYPE_AL}, -{0x61e, 0x61f, GRUB_BIDI_TYPE_AL}, -{0x621, 0x64a, GRUB_BIDI_TYPE_AL}, -{0x64b, 0x65e, GRUB_BIDI_TYPE_NSM}, -{0x660, 0x669, GRUB_BIDI_TYPE_AN}, -{0x66a, 0x66a, GRUB_BIDI_TYPE_ET}, -{0x66b, 0x66c, GRUB_BIDI_TYPE_AN}, -{0x66d, 0x66f, GRUB_BIDI_TYPE_AL}, -{0x670, 0x670, GRUB_BIDI_TYPE_NSM}, -{0x671, 0x6d5, GRUB_BIDI_TYPE_AL}, -{0x6d6, 0x6dc, GRUB_BIDI_TYPE_NSM}, -{0x6dd, 0x6dd, GRUB_BIDI_TYPE_AN}, -{0x6de, 0x6e4, GRUB_BIDI_TYPE_NSM}, -{0x6e5, 0x6e6, GRUB_BIDI_TYPE_AL}, -{0x6e7, 0x6e8, GRUB_BIDI_TYPE_NSM}, -{0x6e9, 0x6e9, GRUB_BIDI_TYPE_ON}, -{0x6ea, 0x6ed, GRUB_BIDI_TYPE_NSM}, -{0x6ee, 0x6ef, GRUB_BIDI_TYPE_AL}, -{0x6f0, 0x6f9, GRUB_BIDI_TYPE_EN}, -{0x6fa, 0x70d, GRUB_BIDI_TYPE_AL}, -{0x70f, 0x70f, GRUB_BIDI_TYPE_BN}, -{0x710, 0x710, GRUB_BIDI_TYPE_AL}, -{0x711, 0x711, GRUB_BIDI_TYPE_NSM}, -{0x712, 0x72f, GRUB_BIDI_TYPE_AL}, -{0x730, 0x74a, GRUB_BIDI_TYPE_NSM}, -{0x74d, 0x7a5, GRUB_BIDI_TYPE_AL}, -{0x7a6, 0x7b0, GRUB_BIDI_TYPE_NSM}, -{0x7b1, 0x7b1, GRUB_BIDI_TYPE_AL}, -{0x7c0, 0x7ea, GRUB_BIDI_TYPE_R}, -{0x7eb, 0x7f3, GRUB_BIDI_TYPE_NSM}, -{0x7f4, 0x7f5, GRUB_BIDI_TYPE_R}, -{0x7f6, 0x7f9, GRUB_BIDI_TYPE_ON}, -{0x7fa, 0x7fa, GRUB_BIDI_TYPE_R}, -{0x901, 0x902, GRUB_BIDI_TYPE_NSM}, -{0x93c, 0x93c, GRUB_BIDI_TYPE_NSM}, -{0x941, 0x948, GRUB_BIDI_TYPE_NSM}, -{0x94d, 0x94d, GRUB_BIDI_TYPE_NSM}, -{0x951, 0x954, GRUB_BIDI_TYPE_NSM}, -{0x962, 0x963, GRUB_BIDI_TYPE_NSM}, -{0x981, 0x981, GRUB_BIDI_TYPE_NSM}, -{0x9bc, 0x9bc, GRUB_BIDI_TYPE_NSM}, -{0x9c1, 0x9c4, GRUB_BIDI_TYPE_NSM}, -{0x9cd, 0x9cd, GRUB_BIDI_TYPE_NSM}, -{0x9e2, 0x9e3, GRUB_BIDI_TYPE_NSM}, -{0x9f2, 0x9f3, GRUB_BIDI_TYPE_ET}, -{0xa01, 0xa02, GRUB_BIDI_TYPE_NSM}, -{0xa3c, 0xa3c, GRUB_BIDI_TYPE_NSM}, -{0xa41, 0xa42, GRUB_BIDI_TYPE_NSM}, -{0xa47, 0xa48, GRUB_BIDI_TYPE_NSM}, -{0xa4b, 0xa4d, GRUB_BIDI_TYPE_NSM}, -{0xa51, 0xa51, GRUB_BIDI_TYPE_NSM}, -{0xa70, 0xa71, GRUB_BIDI_TYPE_NSM}, -{0xa75, 0xa75, GRUB_BIDI_TYPE_NSM}, -{0xa81, 0xa82, GRUB_BIDI_TYPE_NSM}, -{0xabc, 0xabc, GRUB_BIDI_TYPE_NSM}, -{0xac1, 0xac5, GRUB_BIDI_TYPE_NSM}, -{0xac7, 0xac8, GRUB_BIDI_TYPE_NSM}, -{0xacd, 0xacd, GRUB_BIDI_TYPE_NSM}, -{0xae2, 0xae3, GRUB_BIDI_TYPE_NSM}, -{0xaf1, 0xaf1, GRUB_BIDI_TYPE_ET}, -{0xb01, 0xb01, GRUB_BIDI_TYPE_NSM}, -{0xb3c, 0xb3c, GRUB_BIDI_TYPE_NSM}, -{0xb3f, 0xb3f, GRUB_BIDI_TYPE_NSM}, -{0xb41, 0xb44, GRUB_BIDI_TYPE_NSM}, -{0xb4d, 0xb4d, GRUB_BIDI_TYPE_NSM}, -{0xb56, 0xb56, GRUB_BIDI_TYPE_NSM}, -{0xb62, 0xb63, GRUB_BIDI_TYPE_NSM}, -{0xb82, 0xb82, GRUB_BIDI_TYPE_NSM}, -{0xbc0, 0xbc0, GRUB_BIDI_TYPE_NSM}, -{0xbcd, 0xbcd, GRUB_BIDI_TYPE_NSM}, -{0xbf3, 0xbf8, GRUB_BIDI_TYPE_ON}, -{0xbf9, 0xbf9, GRUB_BIDI_TYPE_ET}, -{0xbfa, 0xbfa, GRUB_BIDI_TYPE_ON}, -{0xc3e, 0xc40, GRUB_BIDI_TYPE_NSM}, -{0xc46, 0xc48, GRUB_BIDI_TYPE_NSM}, -{0xc4a, 0xc4d, GRUB_BIDI_TYPE_NSM}, -{0xc55, 0xc56, GRUB_BIDI_TYPE_NSM}, -{0xc62, 0xc63, GRUB_BIDI_TYPE_NSM}, -{0xc78, 0xc7e, GRUB_BIDI_TYPE_ON}, -{0xcbc, 0xcbc, GRUB_BIDI_TYPE_NSM}, -{0xccc, 0xccd, GRUB_BIDI_TYPE_NSM}, -{0xce2, 0xce3, GRUB_BIDI_TYPE_NSM}, -{0xcf1, 0xcf2, GRUB_BIDI_TYPE_ON}, -{0xd41, 0xd44, GRUB_BIDI_TYPE_NSM}, -{0xd4d, 0xd4d, GRUB_BIDI_TYPE_NSM}, -{0xd62, 0xd63, GRUB_BIDI_TYPE_NSM}, -{0xdca, 0xdca, GRUB_BIDI_TYPE_NSM}, -{0xdd2, 0xdd4, GRUB_BIDI_TYPE_NSM}, -{0xdd6, 0xdd6, GRUB_BIDI_TYPE_NSM}, -{0xe31, 0xe31, GRUB_BIDI_TYPE_NSM}, -{0xe34, 0xe3a, GRUB_BIDI_TYPE_NSM}, -{0xe3f, 0xe3f, GRUB_BIDI_TYPE_ET}, -{0xe47, 0xe4e, GRUB_BIDI_TYPE_NSM}, -{0xeb1, 0xeb1, GRUB_BIDI_TYPE_NSM}, -{0xeb4, 0xeb9, GRUB_BIDI_TYPE_NSM}, -{0xebb, 0xebc, GRUB_BIDI_TYPE_NSM}, -{0xec8, 0xecd, GRUB_BIDI_TYPE_NSM}, -{0xf18, 0xf19, GRUB_BIDI_TYPE_NSM}, -{0xf35, 0xf35, GRUB_BIDI_TYPE_NSM}, -{0xf37, 0xf37, GRUB_BIDI_TYPE_NSM}, -{0xf39, 0xf39, GRUB_BIDI_TYPE_NSM}, -{0xf3a, 0xf3d, GRUB_BIDI_TYPE_ON}, -{0xf71, 0xf7e, GRUB_BIDI_TYPE_NSM}, -{0xf80, 0xf84, GRUB_BIDI_TYPE_NSM}, -{0xf86, 0xf87, GRUB_BIDI_TYPE_NSM}, -{0xf90, 0xf97, GRUB_BIDI_TYPE_NSM}, -{0xf99, 0xfbc, GRUB_BIDI_TYPE_NSM}, -{0xfc6, 0xfc6, GRUB_BIDI_TYPE_NSM}, -{0x102d, 0x1030, GRUB_BIDI_TYPE_NSM}, -{0x1032, 0x1037, GRUB_BIDI_TYPE_NSM}, -{0x1039, 0x103a, GRUB_BIDI_TYPE_NSM}, -{0x103d, 0x103e, GRUB_BIDI_TYPE_NSM}, -{0x1058, 0x1059, GRUB_BIDI_TYPE_NSM}, -{0x105e, 0x1060, GRUB_BIDI_TYPE_NSM}, -{0x1071, 0x1074, GRUB_BIDI_TYPE_NSM}, -{0x1082, 0x1082, GRUB_BIDI_TYPE_NSM}, -{0x1085, 0x1086, GRUB_BIDI_TYPE_NSM}, -{0x108d, 0x108d, GRUB_BIDI_TYPE_NSM}, -{0x135f, 0x135f, GRUB_BIDI_TYPE_NSM}, -{0x1390, 0x1399, GRUB_BIDI_TYPE_ON}, -{0x1680, 0x1680, GRUB_BIDI_TYPE_WS}, -{0x169b, 0x169c, GRUB_BIDI_TYPE_ON}, -{0x1712, 0x1714, GRUB_BIDI_TYPE_NSM}, -{0x1732, 0x1734, GRUB_BIDI_TYPE_NSM}, -{0x1752, 0x1753, GRUB_BIDI_TYPE_NSM}, -{0x1772, 0x1773, GRUB_BIDI_TYPE_NSM}, -{0x17b7, 0x17bd, GRUB_BIDI_TYPE_NSM}, -{0x17c6, 0x17c6, GRUB_BIDI_TYPE_NSM}, -{0x17c9, 0x17d3, GRUB_BIDI_TYPE_NSM}, -{0x17db, 0x17db, GRUB_BIDI_TYPE_ET}, -{0x17dd, 0x17dd, GRUB_BIDI_TYPE_NSM}, -{0x17f0, 0x17f9, GRUB_BIDI_TYPE_ON}, -{0x1800, 0x180a, GRUB_BIDI_TYPE_ON}, -{0x180b, 0x180d, GRUB_BIDI_TYPE_NSM}, -{0x180e, 0x180e, GRUB_BIDI_TYPE_WS}, -{0x18a9, 0x18a9, GRUB_BIDI_TYPE_NSM}, -{0x1920, 0x1922, GRUB_BIDI_TYPE_NSM}, -{0x1927, 0x1928, GRUB_BIDI_TYPE_NSM}, -{0x1932, 0x1932, GRUB_BIDI_TYPE_NSM}, -{0x1939, 0x193b, GRUB_BIDI_TYPE_NSM}, -{0x1940, 0x1940, GRUB_BIDI_TYPE_ON}, -{0x1944, 0x1945, GRUB_BIDI_TYPE_ON}, -{0x19de, 0x19ff, GRUB_BIDI_TYPE_ON}, -{0x1a17, 0x1a18, GRUB_BIDI_TYPE_NSM}, -{0x1b00, 0x1b03, GRUB_BIDI_TYPE_NSM}, -{0x1b34, 0x1b34, GRUB_BIDI_TYPE_NSM}, -{0x1b36, 0x1b3a, GRUB_BIDI_TYPE_NSM}, -{0x1b3c, 0x1b3c, GRUB_BIDI_TYPE_NSM}, -{0x1b42, 0x1b42, GRUB_BIDI_TYPE_NSM}, -{0x1b6b, 0x1b73, GRUB_BIDI_TYPE_NSM}, -{0x1b80, 0x1b81, GRUB_BIDI_TYPE_NSM}, -{0x1ba2, 0x1ba5, GRUB_BIDI_TYPE_NSM}, -{0x1ba8, 0x1ba9, GRUB_BIDI_TYPE_NSM}, -{0x1c2c, 0x1c33, GRUB_BIDI_TYPE_NSM}, -{0x1c36, 0x1c37, GRUB_BIDI_TYPE_NSM}, -{0x1dc0, 0x1de6, GRUB_BIDI_TYPE_NSM}, -{0x1dfe, 0x1dff, GRUB_BIDI_TYPE_NSM}, -{0x1fbd, 0x1fbd, GRUB_BIDI_TYPE_ON}, -{0x1fbf, 0x1fc1, GRUB_BIDI_TYPE_ON}, -{0x1fcd, 0x1fcf, GRUB_BIDI_TYPE_ON}, -{0x1fdd, 0x1fdf, GRUB_BIDI_TYPE_ON}, -{0x1fed, 0x1fef, GRUB_BIDI_TYPE_ON}, -{0x1ffd, 0x1ffe, GRUB_BIDI_TYPE_ON}, -{0x2000, 0x200a, GRUB_BIDI_TYPE_WS}, -{0x200b, 0x200d, GRUB_BIDI_TYPE_BN}, -{0x200f, 0x200f, GRUB_BIDI_TYPE_R}, -{0x2010, 0x2027, GRUB_BIDI_TYPE_ON}, -{0x2028, 0x2028, GRUB_BIDI_TYPE_WS}, -{0x2029, 0x2029, GRUB_BIDI_TYPE_B}, -{0x202a, 0x202a, GRUB_BIDI_TYPE_LRE}, -{0x202b, 0x202b, GRUB_BIDI_TYPE_RLE}, -{0x202c, 0x202c, GRUB_BIDI_TYPE_PDF}, -{0x202d, 0x202d, GRUB_BIDI_TYPE_LRO}, -{0x202e, 0x202e, GRUB_BIDI_TYPE_RLO}, -{0x202f, 0x202f, GRUB_BIDI_TYPE_CS}, -{0x2030, 0x2034, GRUB_BIDI_TYPE_ET}, -{0x2035, 0x2043, GRUB_BIDI_TYPE_ON}, -{0x2044, 0x2044, GRUB_BIDI_TYPE_CS}, -{0x2045, 0x205e, GRUB_BIDI_TYPE_ON}, -{0x205f, 0x205f, GRUB_BIDI_TYPE_WS}, -{0x2060, 0x2064, GRUB_BIDI_TYPE_BN}, -{0x206a, 0x206f, GRUB_BIDI_TYPE_BN}, -{0x2070, 0x2070, GRUB_BIDI_TYPE_EN}, -{0x2074, 0x2079, GRUB_BIDI_TYPE_EN}, -{0x207a, 0x207b, GRUB_BIDI_TYPE_ES}, -{0x207c, 0x207e, GRUB_BIDI_TYPE_ON}, -{0x2080, 0x2089, GRUB_BIDI_TYPE_EN}, -{0x208a, 0x208b, GRUB_BIDI_TYPE_ES}, -{0x208c, 0x208e, GRUB_BIDI_TYPE_ON}, -{0x20a0, 0x20b5, GRUB_BIDI_TYPE_ET}, -{0x20d0, 0x20f0, GRUB_BIDI_TYPE_NSM}, -{0x2100, 0x2101, GRUB_BIDI_TYPE_ON}, -{0x2103, 0x2106, GRUB_BIDI_TYPE_ON}, -{0x2108, 0x2109, GRUB_BIDI_TYPE_ON}, -{0x2114, 0x2114, GRUB_BIDI_TYPE_ON}, -{0x2116, 0x2118, GRUB_BIDI_TYPE_ON}, -{0x211e, 0x2123, GRUB_BIDI_TYPE_ON}, -{0x2125, 0x2125, GRUB_BIDI_TYPE_ON}, -{0x2127, 0x2127, GRUB_BIDI_TYPE_ON}, -{0x2129, 0x2129, GRUB_BIDI_TYPE_ON}, -{0x212e, 0x212e, GRUB_BIDI_TYPE_ET}, -{0x213a, 0x213b, GRUB_BIDI_TYPE_ON}, -{0x2140, 0x2144, GRUB_BIDI_TYPE_ON}, -{0x214a, 0x214d, GRUB_BIDI_TYPE_ON}, -{0x2153, 0x215f, GRUB_BIDI_TYPE_ON}, -{0x2190, 0x2211, GRUB_BIDI_TYPE_ON}, -{0x2212, 0x2212, GRUB_BIDI_TYPE_ES}, -{0x2213, 0x2213, GRUB_BIDI_TYPE_ET}, -{0x2214, 0x2335, GRUB_BIDI_TYPE_ON}, -{0x237b, 0x2394, GRUB_BIDI_TYPE_ON}, -{0x2396, 0x23e7, GRUB_BIDI_TYPE_ON}, -{0x2400, 0x2426, GRUB_BIDI_TYPE_ON}, -{0x2440, 0x244a, GRUB_BIDI_TYPE_ON}, -{0x2460, 0x2487, GRUB_BIDI_TYPE_ON}, -{0x2488, 0x249b, GRUB_BIDI_TYPE_EN}, -{0x24ea, 0x269d, GRUB_BIDI_TYPE_ON}, -{0x26a0, 0x26ab, GRUB_BIDI_TYPE_ON}, -{0x26ad, 0x26bc, GRUB_BIDI_TYPE_ON}, -{0x26c0, 0x26c3, GRUB_BIDI_TYPE_ON}, -{0x2701, 0x2704, GRUB_BIDI_TYPE_ON}, -{0x2706, 0x2709, GRUB_BIDI_TYPE_ON}, -{0x270c, 0x2727, GRUB_BIDI_TYPE_ON}, -{0x2729, 0x274b, GRUB_BIDI_TYPE_ON}, -{0x274d, 0x274d, GRUB_BIDI_TYPE_ON}, -{0x274f, 0x2752, GRUB_BIDI_TYPE_ON}, -{0x2756, 0x2756, GRUB_BIDI_TYPE_ON}, -{0x2758, 0x275e, GRUB_BIDI_TYPE_ON}, -{0x2761, 0x2794, GRUB_BIDI_TYPE_ON}, -{0x2798, 0x27af, GRUB_BIDI_TYPE_ON}, -{0x27b1, 0x27be, GRUB_BIDI_TYPE_ON}, -{0x27c0, 0x27ca, GRUB_BIDI_TYPE_ON}, -{0x27cc, 0x27cc, GRUB_BIDI_TYPE_ON}, -{0x27d0, 0x27ff, GRUB_BIDI_TYPE_ON}, -{0x2900, 0x2b4c, GRUB_BIDI_TYPE_ON}, -{0x2b50, 0x2b54, GRUB_BIDI_TYPE_ON}, -{0x2ce5, 0x2cea, GRUB_BIDI_TYPE_ON}, -{0x2cf9, 0x2cff, GRUB_BIDI_TYPE_ON}, -{0x2de0, 0x2dff, GRUB_BIDI_TYPE_NSM}, -{0x2e00, 0x2e30, GRUB_BIDI_TYPE_ON}, -{0x2e80, 0x2e99, GRUB_BIDI_TYPE_ON}, -{0x2e9b, 0x2ef3, GRUB_BIDI_TYPE_ON}, -{0x2f00, 0x2fd5, GRUB_BIDI_TYPE_ON}, -{0x2ff0, 0x2ffb, GRUB_BIDI_TYPE_ON}, -{0x3000, 0x3000, GRUB_BIDI_TYPE_WS}, -{0x3001, 0x3004, GRUB_BIDI_TYPE_ON}, -{0x3008, 0x3020, GRUB_BIDI_TYPE_ON}, -{0x302a, 0x302f, GRUB_BIDI_TYPE_NSM}, -{0x3030, 0x3030, GRUB_BIDI_TYPE_ON}, -{0x3036, 0x3037, GRUB_BIDI_TYPE_ON}, -{0x303d, 0x303f, GRUB_BIDI_TYPE_ON}, -{0x3099, 0x309a, GRUB_BIDI_TYPE_NSM}, -{0x309b, 0x309c, GRUB_BIDI_TYPE_ON}, -{0x30a0, 0x30a0, GRUB_BIDI_TYPE_ON}, -{0x30fb, 0x30fb, GRUB_BIDI_TYPE_ON}, -{0x31c0, 0x31e3, GRUB_BIDI_TYPE_ON}, -{0x321d, 0x321e, GRUB_BIDI_TYPE_ON}, -{0x3250, 0x325f, GRUB_BIDI_TYPE_ON}, -{0x327c, 0x327e, GRUB_BIDI_TYPE_ON}, -{0x32b1, 0x32bf, GRUB_BIDI_TYPE_ON}, -{0x32cc, 0x32cf, GRUB_BIDI_TYPE_ON}, -{0x3377, 0x337a, GRUB_BIDI_TYPE_ON}, -{0x33de, 0x33df, GRUB_BIDI_TYPE_ON}, -{0x33ff, 0x33ff, GRUB_BIDI_TYPE_ON}, -{0x4dc0, 0x4dff, GRUB_BIDI_TYPE_ON}, -{0xa490, 0xa4c6, GRUB_BIDI_TYPE_ON}, -{0xa60d, 0xa60f, GRUB_BIDI_TYPE_ON}, -{0xa66f, 0xa672, GRUB_BIDI_TYPE_NSM}, -{0xa673, 0xa673, GRUB_BIDI_TYPE_ON}, -{0xa67c, 0xa67d, GRUB_BIDI_TYPE_NSM}, -{0xa67e, 0xa67f, GRUB_BIDI_TYPE_ON}, -{0xa700, 0xa721, GRUB_BIDI_TYPE_ON}, -{0xa788, 0xa788, GRUB_BIDI_TYPE_ON}, -{0xa802, 0xa802, GRUB_BIDI_TYPE_NSM}, -{0xa806, 0xa806, GRUB_BIDI_TYPE_NSM}, -{0xa80b, 0xa80b, GRUB_BIDI_TYPE_NSM}, -{0xa825, 0xa826, GRUB_BIDI_TYPE_NSM}, -{0xa828, 0xa82b, GRUB_BIDI_TYPE_ON}, -{0xa874, 0xa877, GRUB_BIDI_TYPE_ON}, -{0xa8c4, 0xa8c4, GRUB_BIDI_TYPE_NSM}, -{0xa926, 0xa92d, GRUB_BIDI_TYPE_NSM}, -{0xa947, 0xa951, GRUB_BIDI_TYPE_NSM}, -{0xaa29, 0xaa2e, GRUB_BIDI_TYPE_NSM}, -{0xaa31, 0xaa32, GRUB_BIDI_TYPE_NSM}, -{0xaa35, 0xaa36, GRUB_BIDI_TYPE_NSM}, -{0xaa43, 0xaa43, GRUB_BIDI_TYPE_NSM}, -{0xaa4c, 0xaa4c, GRUB_BIDI_TYPE_NSM}, -{0xfb1d, 0xfb1d, GRUB_BIDI_TYPE_R}, -{0xfb1e, 0xfb1e, GRUB_BIDI_TYPE_NSM}, -{0xfb1f, 0xfb28, GRUB_BIDI_TYPE_R}, -{0xfb29, 0xfb29, GRUB_BIDI_TYPE_ES}, -{0xfb2a, 0xfb36, GRUB_BIDI_TYPE_R}, -{0xfb38, 0xfb3c, GRUB_BIDI_TYPE_R}, -{0xfb3e, 0xfb3e, GRUB_BIDI_TYPE_R}, -{0xfb40, 0xfb41, GRUB_BIDI_TYPE_R}, -{0xfb43, 0xfb44, GRUB_BIDI_TYPE_R}, -{0xfb46, 0xfb4f, GRUB_BIDI_TYPE_R}, -{0xfb50, 0xfbb1, GRUB_BIDI_TYPE_AL}, -{0xfbd3, 0xfd3d, GRUB_BIDI_TYPE_AL}, -{0xfd3e, 0xfd3f, GRUB_BIDI_TYPE_ON}, -{0xfd50, 0xfd8f, GRUB_BIDI_TYPE_AL}, -{0xfd92, 0xfdc7, GRUB_BIDI_TYPE_AL}, -{0xfdf0, 0xfdfc, GRUB_BIDI_TYPE_AL}, -{0xfdfd, 0xfdfd, GRUB_BIDI_TYPE_ON}, -{0xfe00, 0xfe0f, GRUB_BIDI_TYPE_NSM}, -{0xfe10, 0xfe19, GRUB_BIDI_TYPE_ON}, -{0xfe20, 0xfe26, GRUB_BIDI_TYPE_NSM}, -{0xfe30, 0xfe4f, GRUB_BIDI_TYPE_ON}, -{0xfe50, 0xfe50, GRUB_BIDI_TYPE_CS}, -{0xfe51, 0xfe51, GRUB_BIDI_TYPE_ON}, -{0xfe52, 0xfe52, GRUB_BIDI_TYPE_CS}, -{0xfe54, 0xfe54, GRUB_BIDI_TYPE_ON}, -{0xfe55, 0xfe55, GRUB_BIDI_TYPE_CS}, -{0xfe56, 0xfe5e, GRUB_BIDI_TYPE_ON}, -{0xfe5f, 0xfe5f, GRUB_BIDI_TYPE_ET}, -{0xfe60, 0xfe61, GRUB_BIDI_TYPE_ON}, -{0xfe62, 0xfe63, GRUB_BIDI_TYPE_ES}, -{0xfe64, 0xfe66, GRUB_BIDI_TYPE_ON}, -{0xfe68, 0xfe68, GRUB_BIDI_TYPE_ON}, -{0xfe69, 0xfe6a, GRUB_BIDI_TYPE_ET}, -{0xfe6b, 0xfe6b, GRUB_BIDI_TYPE_ON}, -{0xfe70, 0xfe74, GRUB_BIDI_TYPE_AL}, -{0xfe76, 0xfefc, GRUB_BIDI_TYPE_AL}, -{0xfeff, 0xfeff, GRUB_BIDI_TYPE_BN}, -{0xff01, 0xff02, GRUB_BIDI_TYPE_ON}, -{0xff03, 0xff05, GRUB_BIDI_TYPE_ET}, -{0xff06, 0xff0a, GRUB_BIDI_TYPE_ON}, -{0xff0b, 0xff0b, GRUB_BIDI_TYPE_ES}, -{0xff0c, 0xff0c, GRUB_BIDI_TYPE_CS}, -{0xff0d, 0xff0d, GRUB_BIDI_TYPE_ES}, -{0xff0e, 0xff0f, GRUB_BIDI_TYPE_CS}, -{0xff10, 0xff19, GRUB_BIDI_TYPE_EN}, -{0xff1a, 0xff1a, GRUB_BIDI_TYPE_CS}, -{0xff1b, 0xff20, GRUB_BIDI_TYPE_ON}, -{0xff3b, 0xff40, GRUB_BIDI_TYPE_ON}, -{0xff5b, 0xff65, GRUB_BIDI_TYPE_ON}, -{0xffe0, 0xffe1, GRUB_BIDI_TYPE_ET}, -{0xffe2, 0xffe4, GRUB_BIDI_TYPE_ON}, -{0xffe5, 0xffe6, GRUB_BIDI_TYPE_ET}, -{0xffe8, 0xffee, GRUB_BIDI_TYPE_ON}, -{0xfff9, 0xfffd, GRUB_BIDI_TYPE_ON}, -{0x10101, 0x10101, GRUB_BIDI_TYPE_ON}, -{0x10140, 0x1018a, GRUB_BIDI_TYPE_ON}, -{0x10190, 0x1019b, GRUB_BIDI_TYPE_ON}, -{0x101fd, 0x101fd, GRUB_BIDI_TYPE_NSM}, -{0x10800, 0x10805, GRUB_BIDI_TYPE_R}, -{0x10808, 0x10808, GRUB_BIDI_TYPE_R}, -{0x1080a, 0x10835, GRUB_BIDI_TYPE_R}, -{0x10837, 0x10838, GRUB_BIDI_TYPE_R}, -{0x1083c, 0x1083c, GRUB_BIDI_TYPE_R}, -{0x1083f, 0x1083f, GRUB_BIDI_TYPE_R}, -{0x10900, 0x10919, GRUB_BIDI_TYPE_R}, -{0x1091f, 0x1091f, GRUB_BIDI_TYPE_ON}, -{0x10920, 0x10939, GRUB_BIDI_TYPE_R}, -{0x1093f, 0x1093f, GRUB_BIDI_TYPE_R}, -{0x10a00, 0x10a00, GRUB_BIDI_TYPE_R}, -{0x10a01, 0x10a03, GRUB_BIDI_TYPE_NSM}, -{0x10a05, 0x10a06, GRUB_BIDI_TYPE_NSM}, -{0x10a0c, 0x10a0f, GRUB_BIDI_TYPE_NSM}, -{0x10a10, 0x10a13, GRUB_BIDI_TYPE_R}, -{0x10a15, 0x10a17, GRUB_BIDI_TYPE_R}, -{0x10a19, 0x10a33, GRUB_BIDI_TYPE_R}, -{0x10a38, 0x10a3a, GRUB_BIDI_TYPE_NSM}, -{0x10a3f, 0x10a3f, GRUB_BIDI_TYPE_NSM}, -{0x10a40, 0x10a47, GRUB_BIDI_TYPE_R}, -{0x10a50, 0x10a58, GRUB_BIDI_TYPE_R}, -{0x1d167, 0x1d169, GRUB_BIDI_TYPE_NSM}, -{0x1d173, 0x1d17a, GRUB_BIDI_TYPE_BN}, -{0x1d17b, 0x1d182, GRUB_BIDI_TYPE_NSM}, -{0x1d185, 0x1d18b, GRUB_BIDI_TYPE_NSM}, -{0x1d1aa, 0x1d1ad, GRUB_BIDI_TYPE_NSM}, -{0x1d200, 0x1d241, GRUB_BIDI_TYPE_ON}, -{0x1d242, 0x1d244, GRUB_BIDI_TYPE_NSM}, -{0x1d245, 0x1d245, GRUB_BIDI_TYPE_ON}, -{0x1d300, 0x1d356, GRUB_BIDI_TYPE_ON}, -{0x1d7ce, 0x1d7ff, GRUB_BIDI_TYPE_EN}, -{0x1f000, 0x1f02b, GRUB_BIDI_TYPE_ON}, -{0x1f030, 0x1f093, GRUB_BIDI_TYPE_ON}, -{0xe0001, 0xe0001, GRUB_BIDI_TYPE_BN}, -{0xe0020, 0xe007f, GRUB_BIDI_TYPE_BN}, -{0xe0100, 0xe01ef, GRUB_BIDI_TYPE_NSM}, -{0, 0, 0}, +struct grub_unicode_compact_range grub_unicode_compact[] = { +{0x0, 0x8, GRUB_BIDI_TYPE_BN, 0}, +{0x9, 0x9, GRUB_BIDI_TYPE_S, 0}, +{0xa, 0xa, GRUB_BIDI_TYPE_B, 0}, +{0xb, 0xb, GRUB_BIDI_TYPE_S, 0}, +{0xc, 0xc, GRUB_BIDI_TYPE_WS, 0}, +{0xd, 0xd, GRUB_BIDI_TYPE_B, 0}, +{0xe, 0x1b, GRUB_BIDI_TYPE_BN, 0}, +{0x1c, 0x1e, GRUB_BIDI_TYPE_B, 0}, +{0x1f, 0x1f, GRUB_BIDI_TYPE_S, 0}, +{0x20, 0x20, GRUB_BIDI_TYPE_WS, 0}, +{0x21, 0x22, GRUB_BIDI_TYPE_ON, 0}, +{0x23, 0x25, GRUB_BIDI_TYPE_ET, 0}, +{0x26, 0x2a, GRUB_BIDI_TYPE_ON, 0}, +{0x2b, 0x2b, GRUB_BIDI_TYPE_ES, 0}, +{0x2c, 0x2c, GRUB_BIDI_TYPE_CS, 0}, +{0x2d, 0x2d, GRUB_BIDI_TYPE_ES, 0}, +{0x2e, 0x2f, GRUB_BIDI_TYPE_CS, 0}, +{0x30, 0x39, GRUB_BIDI_TYPE_EN, 0}, +{0x3a, 0x3a, GRUB_BIDI_TYPE_CS, 0}, +{0x3b, 0x40, GRUB_BIDI_TYPE_ON, 0}, +{0x5b, 0x60, GRUB_BIDI_TYPE_ON, 0}, +{0x7b, 0x7e, GRUB_BIDI_TYPE_ON, 0}, +{0x7f, 0x84, GRUB_BIDI_TYPE_BN, 0}, +{0x85, 0x85, GRUB_BIDI_TYPE_B, 0}, +{0x86, 0x9f, GRUB_BIDI_TYPE_BN, 0}, +{0xa0, 0xa0, GRUB_BIDI_TYPE_CS, 0}, +{0xa1, 0xa1, GRUB_BIDI_TYPE_ON, 0}, +{0xa2, 0xa5, GRUB_BIDI_TYPE_ET, 0}, +{0xa6, 0xa9, GRUB_BIDI_TYPE_ON, 0}, +{0xab, 0xac, GRUB_BIDI_TYPE_ON, 0}, +{0xad, 0xad, GRUB_BIDI_TYPE_BN, 0}, +{0xae, 0xaf, GRUB_BIDI_TYPE_ON, 0}, +{0xb0, 0xb1, GRUB_BIDI_TYPE_ET, 0}, +{0xb2, 0xb3, GRUB_BIDI_TYPE_EN, 0}, +{0xb4, 0xb4, GRUB_BIDI_TYPE_ON, 0}, +{0xb6, 0xb8, GRUB_BIDI_TYPE_ON, 0}, +{0xb9, 0xb9, GRUB_BIDI_TYPE_EN, 0}, +{0xbb, 0xbf, GRUB_BIDI_TYPE_ON, 0}, +{0xd7, 0xd7, GRUB_BIDI_TYPE_ON, 0}, +{0xf7, 0xf7, GRUB_BIDI_TYPE_ON, 0}, +{0x2b9, 0x2ba, GRUB_BIDI_TYPE_ON, 0}, +{0x2c2, 0x2cf, GRUB_BIDI_TYPE_ON, 0}, +{0x2d2, 0x2df, GRUB_BIDI_TYPE_ON, 0}, +{0x2e5, 0x2ed, GRUB_BIDI_TYPE_ON, 0}, +{0x2ef, 0x2ff, GRUB_BIDI_TYPE_ON, 0}, +{0x300, 0x314, GRUB_BIDI_TYPE_NSM, 230}, +{0x315, 0x315, GRUB_BIDI_TYPE_NSM, 232}, +{0x316, 0x319, GRUB_BIDI_TYPE_NSM, 220}, +{0x31a, 0x31a, GRUB_BIDI_TYPE_NSM, 232}, +{0x31b, 0x31b, GRUB_BIDI_TYPE_NSM, 216}, +{0x31c, 0x320, GRUB_BIDI_TYPE_NSM, 220}, +{0x321, 0x322, GRUB_BIDI_TYPE_NSM, 202}, +{0x323, 0x326, GRUB_BIDI_TYPE_NSM, 220}, +{0x327, 0x328, GRUB_BIDI_TYPE_NSM, 202}, +{0x329, 0x333, GRUB_BIDI_TYPE_NSM, 220}, +{0x334, 0x338, GRUB_BIDI_TYPE_NSM, 1}, +{0x339, 0x33c, GRUB_BIDI_TYPE_NSM, 220}, +{0x33d, 0x344, GRUB_BIDI_TYPE_NSM, 230}, +{0x345, 0x345, GRUB_BIDI_TYPE_NSM, 240}, +{0x346, 0x346, GRUB_BIDI_TYPE_NSM, 230}, +{0x347, 0x349, GRUB_BIDI_TYPE_NSM, 220}, +{0x34a, 0x34c, GRUB_BIDI_TYPE_NSM, 230}, +{0x34d, 0x34e, GRUB_BIDI_TYPE_NSM, 220}, +{0x34f, 0x34f, GRUB_BIDI_TYPE_NSM, 255}, +{0x350, 0x352, GRUB_BIDI_TYPE_NSM, 230}, +{0x353, 0x356, GRUB_BIDI_TYPE_NSM, 220}, +{0x357, 0x357, GRUB_BIDI_TYPE_NSM, 230}, +{0x358, 0x358, GRUB_BIDI_TYPE_NSM, 232}, +{0x359, 0x35a, GRUB_BIDI_TYPE_NSM, 220}, +{0x35b, 0x35b, GRUB_BIDI_TYPE_NSM, 230}, +{0x35c, 0x35c, GRUB_BIDI_TYPE_NSM, 233}, +{0x35d, 0x35e, GRUB_BIDI_TYPE_NSM, 234}, +{0x35f, 0x35f, GRUB_BIDI_TYPE_NSM, 233}, +{0x360, 0x361, GRUB_BIDI_TYPE_NSM, 234}, +{0x362, 0x362, GRUB_BIDI_TYPE_NSM, 233}, +{0x363, 0x36f, GRUB_BIDI_TYPE_NSM, 230}, +{0x374, 0x375, GRUB_BIDI_TYPE_ON, 0}, +{0x37e, 0x37e, GRUB_BIDI_TYPE_ON, 0}, +{0x384, 0x385, GRUB_BIDI_TYPE_ON, 0}, +{0x387, 0x387, GRUB_BIDI_TYPE_ON, 0}, +{0x3f6, 0x3f6, GRUB_BIDI_TYPE_ON, 0}, +{0x483, 0x487, GRUB_BIDI_TYPE_NSM, 230}, +{0x488, 0x489, GRUB_BIDI_TYPE_NSM, 253}, +{0x58a, 0x58a, GRUB_BIDI_TYPE_ON, 0}, +{0x591, 0x591, GRUB_BIDI_TYPE_NSM, 220}, +{0x592, 0x595, GRUB_BIDI_TYPE_NSM, 230}, +{0x596, 0x596, GRUB_BIDI_TYPE_NSM, 220}, +{0x597, 0x599, GRUB_BIDI_TYPE_NSM, 230}, +{0x59a, 0x59a, GRUB_BIDI_TYPE_NSM, 222}, +{0x59b, 0x59b, GRUB_BIDI_TYPE_NSM, 220}, +{0x59c, 0x5a1, GRUB_BIDI_TYPE_NSM, 230}, +{0x5a2, 0x5a7, GRUB_BIDI_TYPE_NSM, 220}, +{0x5a8, 0x5a9, GRUB_BIDI_TYPE_NSM, 230}, +{0x5aa, 0x5aa, GRUB_BIDI_TYPE_NSM, 220}, +{0x5ab, 0x5ac, GRUB_BIDI_TYPE_NSM, 230}, +{0x5ad, 0x5ad, GRUB_BIDI_TYPE_NSM, 222}, +{0x5ae, 0x5ae, GRUB_BIDI_TYPE_NSM, 228}, +{0x5af, 0x5af, GRUB_BIDI_TYPE_NSM, 230}, +{0x5b0, 0x5b0, GRUB_BIDI_TYPE_NSM, 10}, +{0x5b1, 0x5b1, GRUB_BIDI_TYPE_NSM, 11}, +{0x5b2, 0x5b2, GRUB_BIDI_TYPE_NSM, 12}, +{0x5b3, 0x5b3, GRUB_BIDI_TYPE_NSM, 13}, +{0x5b4, 0x5b4, GRUB_BIDI_TYPE_NSM, 14}, +{0x5b5, 0x5b5, GRUB_BIDI_TYPE_NSM, 15}, +{0x5b6, 0x5b6, GRUB_BIDI_TYPE_NSM, 16}, +{0x5b7, 0x5b7, GRUB_BIDI_TYPE_NSM, 17}, +{0x5b8, 0x5b8, GRUB_BIDI_TYPE_NSM, 18}, +{0x5b9, 0x5ba, GRUB_BIDI_TYPE_NSM, 19}, +{0x5bb, 0x5bb, GRUB_BIDI_TYPE_NSM, 20}, +{0x5bc, 0x5bc, GRUB_BIDI_TYPE_NSM, 21}, +{0x5bd, 0x5bd, GRUB_BIDI_TYPE_NSM, 22}, +{0x5be, 0x5be, GRUB_BIDI_TYPE_R, 0}, +{0x5bf, 0x5bf, GRUB_BIDI_TYPE_NSM, 23}, +{0x5c0, 0x5c0, GRUB_BIDI_TYPE_R, 0}, +{0x5c1, 0x5c1, GRUB_BIDI_TYPE_NSM, 24}, +{0x5c2, 0x5c2, GRUB_BIDI_TYPE_NSM, 25}, +{0x5c3, 0x5c3, GRUB_BIDI_TYPE_R, 0}, +{0x5c4, 0x5c4, GRUB_BIDI_TYPE_NSM, 230}, +{0x5c5, 0x5c5, GRUB_BIDI_TYPE_NSM, 220}, +{0x5c6, 0x5c6, GRUB_BIDI_TYPE_R, 0}, +{0x5c7, 0x5c7, GRUB_BIDI_TYPE_NSM, 18}, +{0x5d0, 0x5ea, GRUB_BIDI_TYPE_R, 0}, +{0x5f0, 0x5f4, GRUB_BIDI_TYPE_R, 0}, +{0x600, 0x603, GRUB_BIDI_TYPE_AN, 0}, +{0x606, 0x607, GRUB_BIDI_TYPE_ON, 0}, +{0x608, 0x608, GRUB_BIDI_TYPE_AL, 0}, +{0x609, 0x60a, GRUB_BIDI_TYPE_ET, 0}, +{0x60b, 0x60b, GRUB_BIDI_TYPE_AL, 0}, +{0x60c, 0x60c, GRUB_BIDI_TYPE_CS, 0}, +{0x60d, 0x60d, GRUB_BIDI_TYPE_AL, 0}, +{0x60e, 0x60f, GRUB_BIDI_TYPE_ON, 0}, +{0x610, 0x617, GRUB_BIDI_TYPE_NSM, 230}, +{0x618, 0x618, GRUB_BIDI_TYPE_NSM, 30}, +{0x619, 0x619, GRUB_BIDI_TYPE_NSM, 31}, +{0x61a, 0x61a, GRUB_BIDI_TYPE_NSM, 32}, +{0x61b, 0x61b, GRUB_BIDI_TYPE_AL, 0}, +{0x61e, 0x61f, GRUB_BIDI_TYPE_AL, 0}, +{0x621, 0x64a, GRUB_BIDI_TYPE_AL, 0}, +{0x64b, 0x64b, GRUB_BIDI_TYPE_NSM, 27}, +{0x64c, 0x64c, GRUB_BIDI_TYPE_NSM, 28}, +{0x64d, 0x64d, GRUB_BIDI_TYPE_NSM, 29}, +{0x64e, 0x64e, GRUB_BIDI_TYPE_NSM, 30}, +{0x64f, 0x64f, GRUB_BIDI_TYPE_NSM, 31}, +{0x650, 0x650, GRUB_BIDI_TYPE_NSM, 32}, +{0x651, 0x651, GRUB_BIDI_TYPE_NSM, 33}, +{0x652, 0x652, GRUB_BIDI_TYPE_NSM, 34}, +{0x653, 0x654, GRUB_BIDI_TYPE_NSM, 230}, +{0x655, 0x656, GRUB_BIDI_TYPE_NSM, 220}, +{0x657, 0x65b, GRUB_BIDI_TYPE_NSM, 230}, +{0x65c, 0x65c, GRUB_BIDI_TYPE_NSM, 220}, +{0x65d, 0x65e, GRUB_BIDI_TYPE_NSM, 230}, +{0x660, 0x669, GRUB_BIDI_TYPE_AN, 0}, +{0x66a, 0x66a, GRUB_BIDI_TYPE_ET, 0}, +{0x66b, 0x66c, GRUB_BIDI_TYPE_AN, 0}, +{0x66d, 0x66f, GRUB_BIDI_TYPE_AL, 0}, +{0x670, 0x670, GRUB_BIDI_TYPE_NSM, 35}, +{0x671, 0x6d5, GRUB_BIDI_TYPE_AL, 0}, +{0x6d6, 0x6dc, GRUB_BIDI_TYPE_NSM, 230}, +{0x6dd, 0x6dd, GRUB_BIDI_TYPE_AN, 0}, +{0x6de, 0x6de, GRUB_BIDI_TYPE_NSM, 253}, +{0x6df, 0x6e2, GRUB_BIDI_TYPE_NSM, 230}, +{0x6e3, 0x6e3, GRUB_BIDI_TYPE_NSM, 220}, +{0x6e4, 0x6e4, GRUB_BIDI_TYPE_NSM, 230}, +{0x6e5, 0x6e6, GRUB_BIDI_TYPE_AL, 0}, +{0x6e7, 0x6e8, GRUB_BIDI_TYPE_NSM, 230}, +{0x6e9, 0x6e9, GRUB_BIDI_TYPE_ON, 0}, +{0x6ea, 0x6ea, GRUB_BIDI_TYPE_NSM, 220}, +{0x6eb, 0x6ec, GRUB_BIDI_TYPE_NSM, 230}, +{0x6ed, 0x6ed, GRUB_BIDI_TYPE_NSM, 220}, +{0x6ee, 0x6ef, GRUB_BIDI_TYPE_AL, 0}, +{0x6f0, 0x6f9, GRUB_BIDI_TYPE_EN, 0}, +{0x6fa, 0x70d, GRUB_BIDI_TYPE_AL, 0}, +{0x70f, 0x70f, GRUB_BIDI_TYPE_BN, 0}, +{0x710, 0x710, GRUB_BIDI_TYPE_AL, 0}, +{0x711, 0x711, GRUB_BIDI_TYPE_NSM, 36}, +{0x712, 0x72f, GRUB_BIDI_TYPE_AL, 0}, +{0x730, 0x730, GRUB_BIDI_TYPE_NSM, 230}, +{0x731, 0x731, GRUB_BIDI_TYPE_NSM, 220}, +{0x732, 0x733, GRUB_BIDI_TYPE_NSM, 230}, +{0x734, 0x734, GRUB_BIDI_TYPE_NSM, 220}, +{0x735, 0x736, GRUB_BIDI_TYPE_NSM, 230}, +{0x737, 0x739, GRUB_BIDI_TYPE_NSM, 220}, +{0x73a, 0x73a, GRUB_BIDI_TYPE_NSM, 230}, +{0x73b, 0x73c, GRUB_BIDI_TYPE_NSM, 220}, +{0x73d, 0x73d, GRUB_BIDI_TYPE_NSM, 230}, +{0x73e, 0x73e, GRUB_BIDI_TYPE_NSM, 220}, +{0x73f, 0x741, GRUB_BIDI_TYPE_NSM, 230}, +{0x742, 0x742, GRUB_BIDI_TYPE_NSM, 220}, +{0x743, 0x743, GRUB_BIDI_TYPE_NSM, 230}, +{0x744, 0x744, GRUB_BIDI_TYPE_NSM, 220}, +{0x745, 0x745, GRUB_BIDI_TYPE_NSM, 230}, +{0x746, 0x746, GRUB_BIDI_TYPE_NSM, 220}, +{0x747, 0x747, GRUB_BIDI_TYPE_NSM, 230}, +{0x748, 0x748, GRUB_BIDI_TYPE_NSM, 220}, +{0x749, 0x74a, GRUB_BIDI_TYPE_NSM, 230}, +{0x74d, 0x7a5, GRUB_BIDI_TYPE_AL, 0}, +{0x7a6, 0x7b0, GRUB_BIDI_TYPE_NSM, 255}, +{0x7b1, 0x7b1, GRUB_BIDI_TYPE_AL, 0}, +{0x7c0, 0x7ea, GRUB_BIDI_TYPE_R, 0}, +{0x7eb, 0x7f1, GRUB_BIDI_TYPE_NSM, 230}, +{0x7f2, 0x7f2, GRUB_BIDI_TYPE_NSM, 220}, +{0x7f3, 0x7f3, GRUB_BIDI_TYPE_NSM, 230}, +{0x7f4, 0x7f5, GRUB_BIDI_TYPE_R, 0}, +{0x7f6, 0x7f9, GRUB_BIDI_TYPE_ON, 0}, +{0x7fa, 0x7fa, GRUB_BIDI_TYPE_R, 0}, +{0x901, 0x902, GRUB_BIDI_TYPE_NSM, 255}, +{0x903, 0x903, GRUB_BIDI_TYPE_L, 254}, +{0x93c, 0x93c, GRUB_BIDI_TYPE_NSM, 7}, +{0x93e, 0x940, GRUB_BIDI_TYPE_L, 254}, +{0x941, 0x948, GRUB_BIDI_TYPE_NSM, 255}, +{0x949, 0x94c, GRUB_BIDI_TYPE_L, 254}, +{0x94d, 0x94d, GRUB_BIDI_TYPE_NSM, 9}, +{0x951, 0x951, GRUB_BIDI_TYPE_NSM, 230}, +{0x952, 0x952, GRUB_BIDI_TYPE_NSM, 220}, +{0x953, 0x954, GRUB_BIDI_TYPE_NSM, 230}, +{0x962, 0x963, GRUB_BIDI_TYPE_NSM, 255}, +{0x981, 0x981, GRUB_BIDI_TYPE_NSM, 255}, +{0x982, 0x983, GRUB_BIDI_TYPE_L, 254}, +{0x9bc, 0x9bc, GRUB_BIDI_TYPE_NSM, 7}, +{0x9be, 0x9c0, GRUB_BIDI_TYPE_L, 254}, +{0x9c1, 0x9c4, GRUB_BIDI_TYPE_NSM, 255}, +{0x9c7, 0x9c8, GRUB_BIDI_TYPE_L, 254}, +{0x9cb, 0x9cc, GRUB_BIDI_TYPE_L, 254}, +{0x9cd, 0x9cd, GRUB_BIDI_TYPE_NSM, 9}, +{0x9d7, 0x9d7, GRUB_BIDI_TYPE_L, 254}, +{0x9e2, 0x9e3, GRUB_BIDI_TYPE_NSM, 255}, +{0x9f2, 0x9f3, GRUB_BIDI_TYPE_ET, 0}, +{0xa01, 0xa02, GRUB_BIDI_TYPE_NSM, 255}, +{0xa03, 0xa03, GRUB_BIDI_TYPE_L, 254}, +{0xa3c, 0xa3c, GRUB_BIDI_TYPE_NSM, 7}, +{0xa3e, 0xa40, GRUB_BIDI_TYPE_L, 254}, +{0xa41, 0xa42, GRUB_BIDI_TYPE_NSM, 255}, +{0xa47, 0xa48, GRUB_BIDI_TYPE_NSM, 255}, +{0xa4b, 0xa4c, GRUB_BIDI_TYPE_NSM, 255}, +{0xa4d, 0xa4d, GRUB_BIDI_TYPE_NSM, 9}, +{0xa51, 0xa51, GRUB_BIDI_TYPE_NSM, 255}, +{0xa70, 0xa71, GRUB_BIDI_TYPE_NSM, 255}, +{0xa75, 0xa75, GRUB_BIDI_TYPE_NSM, 255}, +{0xa81, 0xa82, GRUB_BIDI_TYPE_NSM, 255}, +{0xa83, 0xa83, GRUB_BIDI_TYPE_L, 254}, +{0xabc, 0xabc, GRUB_BIDI_TYPE_NSM, 7}, +{0xabe, 0xac0, GRUB_BIDI_TYPE_L, 254}, +{0xac1, 0xac5, GRUB_BIDI_TYPE_NSM, 255}, +{0xac7, 0xac8, GRUB_BIDI_TYPE_NSM, 255}, +{0xac9, 0xac9, GRUB_BIDI_TYPE_L, 254}, +{0xacb, 0xacc, GRUB_BIDI_TYPE_L, 254}, +{0xacd, 0xacd, GRUB_BIDI_TYPE_NSM, 9}, +{0xae2, 0xae3, GRUB_BIDI_TYPE_NSM, 255}, +{0xaf1, 0xaf1, GRUB_BIDI_TYPE_ET, 0}, +{0xb01, 0xb01, GRUB_BIDI_TYPE_NSM, 255}, +{0xb02, 0xb03, GRUB_BIDI_TYPE_L, 254}, +{0xb3c, 0xb3c, GRUB_BIDI_TYPE_NSM, 7}, +{0xb3e, 0xb3e, GRUB_BIDI_TYPE_L, 254}, +{0xb3f, 0xb3f, GRUB_BIDI_TYPE_NSM, 255}, +{0xb40, 0xb40, GRUB_BIDI_TYPE_L, 254}, +{0xb41, 0xb44, GRUB_BIDI_TYPE_NSM, 255}, +{0xb47, 0xb48, GRUB_BIDI_TYPE_L, 254}, +{0xb4b, 0xb4c, GRUB_BIDI_TYPE_L, 254}, +{0xb4d, 0xb4d, GRUB_BIDI_TYPE_NSM, 9}, +{0xb56, 0xb56, GRUB_BIDI_TYPE_NSM, 255}, +{0xb57, 0xb57, GRUB_BIDI_TYPE_L, 254}, +{0xb62, 0xb63, GRUB_BIDI_TYPE_NSM, 255}, +{0xb82, 0xb82, GRUB_BIDI_TYPE_NSM, 255}, +{0xbbe, 0xbbf, GRUB_BIDI_TYPE_L, 254}, +{0xbc0, 0xbc0, GRUB_BIDI_TYPE_NSM, 255}, +{0xbc1, 0xbc2, GRUB_BIDI_TYPE_L, 254}, +{0xbc6, 0xbc8, GRUB_BIDI_TYPE_L, 254}, +{0xbca, 0xbcc, GRUB_BIDI_TYPE_L, 254}, +{0xbcd, 0xbcd, GRUB_BIDI_TYPE_NSM, 9}, +{0xbd7, 0xbd7, GRUB_BIDI_TYPE_L, 254}, +{0xbf3, 0xbf8, GRUB_BIDI_TYPE_ON, 0}, +{0xbf9, 0xbf9, GRUB_BIDI_TYPE_ET, 0}, +{0xbfa, 0xbfa, GRUB_BIDI_TYPE_ON, 0}, +{0xc01, 0xc03, GRUB_BIDI_TYPE_L, 254}, +{0xc3e, 0xc40, GRUB_BIDI_TYPE_NSM, 255}, +{0xc41, 0xc44, GRUB_BIDI_TYPE_L, 254}, +{0xc46, 0xc48, GRUB_BIDI_TYPE_NSM, 255}, +{0xc4a, 0xc4c, GRUB_BIDI_TYPE_NSM, 255}, +{0xc4d, 0xc4d, GRUB_BIDI_TYPE_NSM, 9}, +{0xc55, 0xc55, GRUB_BIDI_TYPE_NSM, 84}, +{0xc56, 0xc56, GRUB_BIDI_TYPE_NSM, 91}, +{0xc62, 0xc63, GRUB_BIDI_TYPE_NSM, 255}, +{0xc78, 0xc7e, GRUB_BIDI_TYPE_ON, 0}, +{0xc82, 0xc83, GRUB_BIDI_TYPE_L, 254}, +{0xcbc, 0xcbc, GRUB_BIDI_TYPE_NSM, 7}, +{0xcbe, 0xcbe, GRUB_BIDI_TYPE_L, 254}, +{0xcbf, 0xcbf, GRUB_BIDI_TYPE_L, 255}, +{0xcc0, 0xcc4, GRUB_BIDI_TYPE_L, 254}, +{0xcc6, 0xcc6, GRUB_BIDI_TYPE_L, 255}, +{0xcc7, 0xcc8, GRUB_BIDI_TYPE_L, 254}, +{0xcca, 0xccb, GRUB_BIDI_TYPE_L, 254}, +{0xccc, 0xccc, GRUB_BIDI_TYPE_NSM, 255}, +{0xccd, 0xccd, GRUB_BIDI_TYPE_NSM, 9}, +{0xcd5, 0xcd6, GRUB_BIDI_TYPE_L, 254}, +{0xce2, 0xce3, GRUB_BIDI_TYPE_NSM, 255}, +{0xcf1, 0xcf2, GRUB_BIDI_TYPE_ON, 0}, +{0xd02, 0xd03, GRUB_BIDI_TYPE_L, 254}, +{0xd3e, 0xd40, GRUB_BIDI_TYPE_L, 254}, +{0xd41, 0xd44, GRUB_BIDI_TYPE_NSM, 255}, +{0xd46, 0xd48, GRUB_BIDI_TYPE_L, 254}, +{0xd4a, 0xd4c, GRUB_BIDI_TYPE_L, 254}, +{0xd4d, 0xd4d, GRUB_BIDI_TYPE_NSM, 9}, +{0xd57, 0xd57, GRUB_BIDI_TYPE_L, 254}, +{0xd62, 0xd63, GRUB_BIDI_TYPE_NSM, 255}, +{0xd82, 0xd83, GRUB_BIDI_TYPE_L, 254}, +{0xdca, 0xdca, GRUB_BIDI_TYPE_NSM, 9}, +{0xdcf, 0xdd1, GRUB_BIDI_TYPE_L, 254}, +{0xdd2, 0xdd4, GRUB_BIDI_TYPE_NSM, 255}, +{0xdd6, 0xdd6, GRUB_BIDI_TYPE_NSM, 255}, +{0xdd8, 0xddf, GRUB_BIDI_TYPE_L, 254}, +{0xdf2, 0xdf3, GRUB_BIDI_TYPE_L, 254}, +{0xe31, 0xe31, GRUB_BIDI_TYPE_NSM, 255}, +{0xe34, 0xe37, GRUB_BIDI_TYPE_NSM, 255}, +{0xe38, 0xe39, GRUB_BIDI_TYPE_NSM, 103}, +{0xe3a, 0xe3a, GRUB_BIDI_TYPE_NSM, 9}, +{0xe3f, 0xe3f, GRUB_BIDI_TYPE_ET, 0}, +{0xe47, 0xe47, GRUB_BIDI_TYPE_NSM, 255}, +{0xe48, 0xe4b, GRUB_BIDI_TYPE_NSM, 107}, +{0xe4c, 0xe4e, GRUB_BIDI_TYPE_NSM, 255}, +{0xeb1, 0xeb1, GRUB_BIDI_TYPE_NSM, 255}, +{0xeb4, 0xeb7, GRUB_BIDI_TYPE_NSM, 255}, +{0xeb8, 0xeb9, GRUB_BIDI_TYPE_NSM, 118}, +{0xebb, 0xebc, GRUB_BIDI_TYPE_NSM, 255}, +{0xec8, 0xecb, GRUB_BIDI_TYPE_NSM, 122}, +{0xecc, 0xecd, GRUB_BIDI_TYPE_NSM, 255}, +{0xf18, 0xf19, GRUB_BIDI_TYPE_NSM, 220}, +{0xf35, 0xf35, GRUB_BIDI_TYPE_NSM, 220}, +{0xf37, 0xf37, GRUB_BIDI_TYPE_NSM, 220}, +{0xf39, 0xf39, GRUB_BIDI_TYPE_NSM, 216}, +{0xf3a, 0xf3d, GRUB_BIDI_TYPE_ON, 0}, +{0xf3e, 0xf3f, GRUB_BIDI_TYPE_L, 254}, +{0xf71, 0xf71, GRUB_BIDI_TYPE_NSM, 129}, +{0xf72, 0xf72, GRUB_BIDI_TYPE_NSM, 130}, +{0xf73, 0xf73, GRUB_BIDI_TYPE_NSM, 255}, +{0xf74, 0xf74, GRUB_BIDI_TYPE_NSM, 132}, +{0xf75, 0xf79, GRUB_BIDI_TYPE_NSM, 255}, +{0xf7a, 0xf7d, GRUB_BIDI_TYPE_NSM, 130}, +{0xf7e, 0xf7e, GRUB_BIDI_TYPE_NSM, 255}, +{0xf7f, 0xf7f, GRUB_BIDI_TYPE_L, 254}, +{0xf80, 0xf80, GRUB_BIDI_TYPE_NSM, 130}, +{0xf81, 0xf81, GRUB_BIDI_TYPE_NSM, 255}, +{0xf82, 0xf83, GRUB_BIDI_TYPE_NSM, 230}, +{0xf84, 0xf84, GRUB_BIDI_TYPE_NSM, 9}, +{0xf86, 0xf87, GRUB_BIDI_TYPE_NSM, 230}, +{0xf90, 0xf97, GRUB_BIDI_TYPE_NSM, 255}, +{0xf99, 0xfbc, GRUB_BIDI_TYPE_NSM, 255}, +{0xfc6, 0xfc6, GRUB_BIDI_TYPE_NSM, 220}, +{0x102b, 0x102c, GRUB_BIDI_TYPE_L, 254}, +{0x102d, 0x1030, GRUB_BIDI_TYPE_NSM, 255}, +{0x1031, 0x1031, GRUB_BIDI_TYPE_L, 254}, +{0x1032, 0x1036, GRUB_BIDI_TYPE_NSM, 255}, +{0x1037, 0x1037, GRUB_BIDI_TYPE_NSM, 7}, +{0x1038, 0x1038, GRUB_BIDI_TYPE_L, 254}, +{0x1039, 0x103a, GRUB_BIDI_TYPE_NSM, 9}, +{0x103b, 0x103c, GRUB_BIDI_TYPE_L, 254}, +{0x103d, 0x103e, GRUB_BIDI_TYPE_NSM, 255}, +{0x1056, 0x1057, GRUB_BIDI_TYPE_L, 254}, +{0x1058, 0x1059, GRUB_BIDI_TYPE_NSM, 255}, +{0x105e, 0x1060, GRUB_BIDI_TYPE_NSM, 255}, +{0x1062, 0x1064, GRUB_BIDI_TYPE_L, 254}, +{0x1067, 0x106d, GRUB_BIDI_TYPE_L, 254}, +{0x1071, 0x1074, GRUB_BIDI_TYPE_NSM, 255}, +{0x1082, 0x1082, GRUB_BIDI_TYPE_NSM, 255}, +{0x1083, 0x1084, GRUB_BIDI_TYPE_L, 254}, +{0x1085, 0x1086, GRUB_BIDI_TYPE_NSM, 255}, +{0x1087, 0x108c, GRUB_BIDI_TYPE_L, 254}, +{0x108d, 0x108d, GRUB_BIDI_TYPE_NSM, 220}, +{0x108f, 0x108f, GRUB_BIDI_TYPE_L, 254}, +{0x135f, 0x135f, GRUB_BIDI_TYPE_NSM, 230}, +{0x1390, 0x1399, GRUB_BIDI_TYPE_ON, 0}, +{0x1680, 0x1680, GRUB_BIDI_TYPE_WS, 0}, +{0x169b, 0x169c, GRUB_BIDI_TYPE_ON, 0}, +{0x1712, 0x1713, GRUB_BIDI_TYPE_NSM, 255}, +{0x1714, 0x1714, GRUB_BIDI_TYPE_NSM, 9}, +{0x1732, 0x1733, GRUB_BIDI_TYPE_NSM, 255}, +{0x1734, 0x1734, GRUB_BIDI_TYPE_NSM, 9}, +{0x1752, 0x1753, GRUB_BIDI_TYPE_NSM, 255}, +{0x1772, 0x1773, GRUB_BIDI_TYPE_NSM, 255}, +{0x17b6, 0x17b6, GRUB_BIDI_TYPE_L, 254}, +{0x17b7, 0x17bd, GRUB_BIDI_TYPE_NSM, 255}, +{0x17be, 0x17c5, GRUB_BIDI_TYPE_L, 254}, +{0x17c6, 0x17c6, GRUB_BIDI_TYPE_NSM, 255}, +{0x17c7, 0x17c8, GRUB_BIDI_TYPE_L, 254}, +{0x17c9, 0x17d1, GRUB_BIDI_TYPE_NSM, 255}, +{0x17d2, 0x17d2, GRUB_BIDI_TYPE_NSM, 9}, +{0x17d3, 0x17d3, GRUB_BIDI_TYPE_NSM, 255}, +{0x17db, 0x17db, GRUB_BIDI_TYPE_ET, 0}, +{0x17dd, 0x17dd, GRUB_BIDI_TYPE_NSM, 230}, +{0x17f0, 0x17f9, GRUB_BIDI_TYPE_ON, 0}, +{0x1800, 0x180a, GRUB_BIDI_TYPE_ON, 0}, +{0x180b, 0x180d, GRUB_BIDI_TYPE_NSM, 255}, +{0x180e, 0x180e, GRUB_BIDI_TYPE_WS, 0}, +{0x18a9, 0x18a9, GRUB_BIDI_TYPE_NSM, 228}, +{0x1920, 0x1922, GRUB_BIDI_TYPE_NSM, 255}, +{0x1923, 0x1926, GRUB_BIDI_TYPE_L, 254}, +{0x1927, 0x1928, GRUB_BIDI_TYPE_NSM, 255}, +{0x1929, 0x192b, GRUB_BIDI_TYPE_L, 254}, +{0x1930, 0x1931, GRUB_BIDI_TYPE_L, 254}, +{0x1932, 0x1932, GRUB_BIDI_TYPE_NSM, 255}, +{0x1933, 0x1938, GRUB_BIDI_TYPE_L, 254}, +{0x1939, 0x1939, GRUB_BIDI_TYPE_NSM, 222}, +{0x193a, 0x193a, GRUB_BIDI_TYPE_NSM, 230}, +{0x193b, 0x193b, GRUB_BIDI_TYPE_NSM, 220}, +{0x1940, 0x1940, GRUB_BIDI_TYPE_ON, 0}, +{0x1944, 0x1945, GRUB_BIDI_TYPE_ON, 0}, +{0x19b0, 0x19c0, GRUB_BIDI_TYPE_L, 254}, +{0x19c8, 0x19c9, GRUB_BIDI_TYPE_L, 254}, +{0x19de, 0x19ff, GRUB_BIDI_TYPE_ON, 0}, +{0x1a17, 0x1a17, GRUB_BIDI_TYPE_NSM, 230}, +{0x1a18, 0x1a18, GRUB_BIDI_TYPE_NSM, 220}, +{0x1a19, 0x1a1b, GRUB_BIDI_TYPE_L, 254}, +{0x1b00, 0x1b03, GRUB_BIDI_TYPE_NSM, 255}, +{0x1b04, 0x1b04, GRUB_BIDI_TYPE_L, 254}, +{0x1b34, 0x1b34, GRUB_BIDI_TYPE_NSM, 7}, +{0x1b35, 0x1b35, GRUB_BIDI_TYPE_L, 254}, +{0x1b36, 0x1b3a, GRUB_BIDI_TYPE_NSM, 255}, +{0x1b3b, 0x1b3b, GRUB_BIDI_TYPE_L, 254}, +{0x1b3c, 0x1b3c, GRUB_BIDI_TYPE_NSM, 255}, +{0x1b3d, 0x1b41, GRUB_BIDI_TYPE_L, 254}, +{0x1b42, 0x1b42, GRUB_BIDI_TYPE_NSM, 255}, +{0x1b43, 0x1b43, GRUB_BIDI_TYPE_L, 254}, +{0x1b44, 0x1b44, GRUB_BIDI_TYPE_L, 9}, +{0x1b6b, 0x1b6b, GRUB_BIDI_TYPE_NSM, 230}, +{0x1b6c, 0x1b6c, GRUB_BIDI_TYPE_NSM, 220}, +{0x1b6d, 0x1b73, GRUB_BIDI_TYPE_NSM, 230}, +{0x1b80, 0x1b81, GRUB_BIDI_TYPE_NSM, 255}, +{0x1b82, 0x1b82, GRUB_BIDI_TYPE_L, 254}, +{0x1ba1, 0x1ba1, GRUB_BIDI_TYPE_L, 254}, +{0x1ba2, 0x1ba5, GRUB_BIDI_TYPE_NSM, 255}, +{0x1ba6, 0x1ba7, GRUB_BIDI_TYPE_L, 254}, +{0x1ba8, 0x1ba9, GRUB_BIDI_TYPE_NSM, 255}, +{0x1baa, 0x1baa, GRUB_BIDI_TYPE_L, 9}, +{0x1c24, 0x1c2b, GRUB_BIDI_TYPE_L, 254}, +{0x1c2c, 0x1c33, GRUB_BIDI_TYPE_NSM, 255}, +{0x1c34, 0x1c35, GRUB_BIDI_TYPE_L, 254}, +{0x1c36, 0x1c36, GRUB_BIDI_TYPE_NSM, 255}, +{0x1c37, 0x1c37, GRUB_BIDI_TYPE_NSM, 7}, +{0x1dc0, 0x1dc1, GRUB_BIDI_TYPE_NSM, 230}, +{0x1dc2, 0x1dc2, GRUB_BIDI_TYPE_NSM, 220}, +{0x1dc3, 0x1dc9, GRUB_BIDI_TYPE_NSM, 230}, +{0x1dca, 0x1dca, GRUB_BIDI_TYPE_NSM, 220}, +{0x1dcb, 0x1dcc, GRUB_BIDI_TYPE_NSM, 230}, +{0x1dcd, 0x1dcd, GRUB_BIDI_TYPE_NSM, 234}, +{0x1dce, 0x1dce, GRUB_BIDI_TYPE_NSM, 214}, +{0x1dcf, 0x1dcf, GRUB_BIDI_TYPE_NSM, 220}, +{0x1dd0, 0x1dd0, GRUB_BIDI_TYPE_NSM, 202}, +{0x1dd1, 0x1de6, GRUB_BIDI_TYPE_NSM, 230}, +{0x1dfe, 0x1dfe, GRUB_BIDI_TYPE_NSM, 230}, +{0x1dff, 0x1dff, GRUB_BIDI_TYPE_NSM, 220}, +{0x1fbd, 0x1fbd, GRUB_BIDI_TYPE_ON, 0}, +{0x1fbf, 0x1fc1, GRUB_BIDI_TYPE_ON, 0}, +{0x1fcd, 0x1fcf, GRUB_BIDI_TYPE_ON, 0}, +{0x1fdd, 0x1fdf, GRUB_BIDI_TYPE_ON, 0}, +{0x1fed, 0x1fef, GRUB_BIDI_TYPE_ON, 0}, +{0x1ffd, 0x1ffe, GRUB_BIDI_TYPE_ON, 0}, +{0x2000, 0x200a, GRUB_BIDI_TYPE_WS, 0}, +{0x200b, 0x200d, GRUB_BIDI_TYPE_BN, 0}, +{0x200f, 0x200f, GRUB_BIDI_TYPE_R, 0}, +{0x2010, 0x2027, GRUB_BIDI_TYPE_ON, 0}, +{0x2028, 0x2028, GRUB_BIDI_TYPE_WS, 0}, +{0x2029, 0x2029, GRUB_BIDI_TYPE_B, 0}, +{0x202a, 0x202a, GRUB_BIDI_TYPE_LRE, 0}, +{0x202b, 0x202b, GRUB_BIDI_TYPE_RLE, 0}, +{0x202c, 0x202c, GRUB_BIDI_TYPE_PDF, 0}, +{0x202d, 0x202d, GRUB_BIDI_TYPE_LRO, 0}, +{0x202e, 0x202e, GRUB_BIDI_TYPE_RLO, 0}, +{0x202f, 0x202f, GRUB_BIDI_TYPE_CS, 0}, +{0x2030, 0x2034, GRUB_BIDI_TYPE_ET, 0}, +{0x2035, 0x2043, GRUB_BIDI_TYPE_ON, 0}, +{0x2044, 0x2044, GRUB_BIDI_TYPE_CS, 0}, +{0x2045, 0x205e, GRUB_BIDI_TYPE_ON, 0}, +{0x205f, 0x205f, GRUB_BIDI_TYPE_WS, 0}, +{0x2060, 0x2064, GRUB_BIDI_TYPE_BN, 0}, +{0x206a, 0x206f, GRUB_BIDI_TYPE_BN, 0}, +{0x2070, 0x2070, GRUB_BIDI_TYPE_EN, 0}, +{0x2074, 0x2079, GRUB_BIDI_TYPE_EN, 0}, +{0x207a, 0x207b, GRUB_BIDI_TYPE_ES, 0}, +{0x207c, 0x207e, GRUB_BIDI_TYPE_ON, 0}, +{0x2080, 0x2089, GRUB_BIDI_TYPE_EN, 0}, +{0x208a, 0x208b, GRUB_BIDI_TYPE_ES, 0}, +{0x208c, 0x208e, GRUB_BIDI_TYPE_ON, 0}, +{0x20a0, 0x20b5, GRUB_BIDI_TYPE_ET, 0}, +{0x20d0, 0x20d1, GRUB_BIDI_TYPE_NSM, 230}, +{0x20d2, 0x20d3, GRUB_BIDI_TYPE_NSM, 1}, +{0x20d4, 0x20d7, GRUB_BIDI_TYPE_NSM, 230}, +{0x20d8, 0x20da, GRUB_BIDI_TYPE_NSM, 1}, +{0x20db, 0x20dc, GRUB_BIDI_TYPE_NSM, 230}, +{0x20dd, 0x20e0, GRUB_BIDI_TYPE_NSM, 253}, +{0x20e1, 0x20e1, GRUB_BIDI_TYPE_NSM, 230}, +{0x20e2, 0x20e4, GRUB_BIDI_TYPE_NSM, 253}, +{0x20e5, 0x20e6, GRUB_BIDI_TYPE_NSM, 1}, +{0x20e7, 0x20e7, GRUB_BIDI_TYPE_NSM, 230}, +{0x20e8, 0x20e8, GRUB_BIDI_TYPE_NSM, 220}, +{0x20e9, 0x20e9, GRUB_BIDI_TYPE_NSM, 230}, +{0x20ea, 0x20eb, GRUB_BIDI_TYPE_NSM, 1}, +{0x20ec, 0x20ef, GRUB_BIDI_TYPE_NSM, 220}, +{0x20f0, 0x20f0, GRUB_BIDI_TYPE_NSM, 230}, +{0x2100, 0x2101, GRUB_BIDI_TYPE_ON, 0}, +{0x2103, 0x2106, GRUB_BIDI_TYPE_ON, 0}, +{0x2108, 0x2109, GRUB_BIDI_TYPE_ON, 0}, +{0x2114, 0x2114, GRUB_BIDI_TYPE_ON, 0}, +{0x2116, 0x2118, GRUB_BIDI_TYPE_ON, 0}, +{0x211e, 0x2123, GRUB_BIDI_TYPE_ON, 0}, +{0x2125, 0x2125, GRUB_BIDI_TYPE_ON, 0}, +{0x2127, 0x2127, GRUB_BIDI_TYPE_ON, 0}, +{0x2129, 0x2129, GRUB_BIDI_TYPE_ON, 0}, +{0x212e, 0x212e, GRUB_BIDI_TYPE_ET, 0}, +{0x213a, 0x213b, GRUB_BIDI_TYPE_ON, 0}, +{0x2140, 0x2144, GRUB_BIDI_TYPE_ON, 0}, +{0x214a, 0x214d, GRUB_BIDI_TYPE_ON, 0}, +{0x2153, 0x215f, GRUB_BIDI_TYPE_ON, 0}, +{0x2190, 0x2211, GRUB_BIDI_TYPE_ON, 0}, +{0x2212, 0x2212, GRUB_BIDI_TYPE_ES, 0}, +{0x2213, 0x2213, GRUB_BIDI_TYPE_ET, 0}, +{0x2214, 0x2335, GRUB_BIDI_TYPE_ON, 0}, +{0x237b, 0x2394, GRUB_BIDI_TYPE_ON, 0}, +{0x2396, 0x23e7, GRUB_BIDI_TYPE_ON, 0}, +{0x2400, 0x2426, GRUB_BIDI_TYPE_ON, 0}, +{0x2440, 0x244a, GRUB_BIDI_TYPE_ON, 0}, +{0x2460, 0x2487, GRUB_BIDI_TYPE_ON, 0}, +{0x2488, 0x249b, GRUB_BIDI_TYPE_EN, 0}, +{0x24ea, 0x269d, GRUB_BIDI_TYPE_ON, 0}, +{0x26a0, 0x26ab, GRUB_BIDI_TYPE_ON, 0}, +{0x26ad, 0x26bc, GRUB_BIDI_TYPE_ON, 0}, +{0x26c0, 0x26c3, GRUB_BIDI_TYPE_ON, 0}, +{0x2701, 0x2704, GRUB_BIDI_TYPE_ON, 0}, +{0x2706, 0x2709, GRUB_BIDI_TYPE_ON, 0}, +{0x270c, 0x2727, GRUB_BIDI_TYPE_ON, 0}, +{0x2729, 0x274b, GRUB_BIDI_TYPE_ON, 0}, +{0x274d, 0x274d, GRUB_BIDI_TYPE_ON, 0}, +{0x274f, 0x2752, GRUB_BIDI_TYPE_ON, 0}, +{0x2756, 0x2756, GRUB_BIDI_TYPE_ON, 0}, +{0x2758, 0x275e, GRUB_BIDI_TYPE_ON, 0}, +{0x2761, 0x2794, GRUB_BIDI_TYPE_ON, 0}, +{0x2798, 0x27af, GRUB_BIDI_TYPE_ON, 0}, +{0x27b1, 0x27be, GRUB_BIDI_TYPE_ON, 0}, +{0x27c0, 0x27ca, GRUB_BIDI_TYPE_ON, 0}, +{0x27cc, 0x27cc, GRUB_BIDI_TYPE_ON, 0}, +{0x27d0, 0x27ff, GRUB_BIDI_TYPE_ON, 0}, +{0x2900, 0x2b4c, GRUB_BIDI_TYPE_ON, 0}, +{0x2b50, 0x2b54, GRUB_BIDI_TYPE_ON, 0}, +{0x2ce5, 0x2cea, GRUB_BIDI_TYPE_ON, 0}, +{0x2cf9, 0x2cff, GRUB_BIDI_TYPE_ON, 0}, +{0x2de0, 0x2dff, GRUB_BIDI_TYPE_NSM, 230}, +{0x2e00, 0x2e30, GRUB_BIDI_TYPE_ON, 0}, +{0x2e80, 0x2e99, GRUB_BIDI_TYPE_ON, 0}, +{0x2e9b, 0x2ef3, GRUB_BIDI_TYPE_ON, 0}, +{0x2f00, 0x2fd5, GRUB_BIDI_TYPE_ON, 0}, +{0x2ff0, 0x2ffb, GRUB_BIDI_TYPE_ON, 0}, +{0x3000, 0x3000, GRUB_BIDI_TYPE_WS, 0}, +{0x3001, 0x3004, GRUB_BIDI_TYPE_ON, 0}, +{0x3008, 0x3020, GRUB_BIDI_TYPE_ON, 0}, +{0x302a, 0x302a, GRUB_BIDI_TYPE_NSM, 218}, +{0x302b, 0x302b, GRUB_BIDI_TYPE_NSM, 228}, +{0x302c, 0x302c, GRUB_BIDI_TYPE_NSM, 232}, +{0x302d, 0x302d, GRUB_BIDI_TYPE_NSM, 222}, +{0x302e, 0x302f, GRUB_BIDI_TYPE_NSM, 224}, +{0x3030, 0x3030, GRUB_BIDI_TYPE_ON, 0}, +{0x3036, 0x3037, GRUB_BIDI_TYPE_ON, 0}, +{0x303d, 0x303f, GRUB_BIDI_TYPE_ON, 0}, +{0x3099, 0x309a, GRUB_BIDI_TYPE_NSM, 8}, +{0x309b, 0x309c, GRUB_BIDI_TYPE_ON, 0}, +{0x30a0, 0x30a0, GRUB_BIDI_TYPE_ON, 0}, +{0x30fb, 0x30fb, GRUB_BIDI_TYPE_ON, 0}, +{0x31c0, 0x31e3, GRUB_BIDI_TYPE_ON, 0}, +{0x321d, 0x321e, GRUB_BIDI_TYPE_ON, 0}, +{0x3250, 0x325f, GRUB_BIDI_TYPE_ON, 0}, +{0x327c, 0x327e, GRUB_BIDI_TYPE_ON, 0}, +{0x32b1, 0x32bf, GRUB_BIDI_TYPE_ON, 0}, +{0x32cc, 0x32cf, GRUB_BIDI_TYPE_ON, 0}, +{0x3377, 0x337a, GRUB_BIDI_TYPE_ON, 0}, +{0x33de, 0x33df, GRUB_BIDI_TYPE_ON, 0}, +{0x33ff, 0x33ff, GRUB_BIDI_TYPE_ON, 0}, +{0x4dc0, 0x4dff, GRUB_BIDI_TYPE_ON, 0}, +{0xa490, 0xa4c6, GRUB_BIDI_TYPE_ON, 0}, +{0xa60d, 0xa60f, GRUB_BIDI_TYPE_ON, 0}, +{0xa66f, 0xa66f, GRUB_BIDI_TYPE_NSM, 230}, +{0xa670, 0xa672, GRUB_BIDI_TYPE_NSM, 253}, +{0xa673, 0xa673, GRUB_BIDI_TYPE_ON, 0}, +{0xa67c, 0xa67d, GRUB_BIDI_TYPE_NSM, 230}, +{0xa67e, 0xa67f, GRUB_BIDI_TYPE_ON, 0}, +{0xa700, 0xa721, GRUB_BIDI_TYPE_ON, 0}, +{0xa788, 0xa788, GRUB_BIDI_TYPE_ON, 0}, +{0xa802, 0xa802, GRUB_BIDI_TYPE_NSM, 255}, +{0xa806, 0xa806, GRUB_BIDI_TYPE_NSM, 9}, +{0xa80b, 0xa80b, GRUB_BIDI_TYPE_NSM, 255}, +{0xa823, 0xa824, GRUB_BIDI_TYPE_L, 254}, +{0xa825, 0xa826, GRUB_BIDI_TYPE_NSM, 255}, +{0xa827, 0xa827, GRUB_BIDI_TYPE_L, 254}, +{0xa828, 0xa82b, GRUB_BIDI_TYPE_ON, 0}, +{0xa874, 0xa877, GRUB_BIDI_TYPE_ON, 0}, +{0xa880, 0xa881, GRUB_BIDI_TYPE_L, 254}, +{0xa8b4, 0xa8c3, GRUB_BIDI_TYPE_L, 254}, +{0xa8c4, 0xa8c4, GRUB_BIDI_TYPE_NSM, 9}, +{0xa926, 0xa92a, GRUB_BIDI_TYPE_NSM, 255}, +{0xa92b, 0xa92d, GRUB_BIDI_TYPE_NSM, 220}, +{0xa947, 0xa951, GRUB_BIDI_TYPE_NSM, 255}, +{0xa952, 0xa952, GRUB_BIDI_TYPE_L, 254}, +{0xa953, 0xa953, GRUB_BIDI_TYPE_L, 9}, +{0xaa29, 0xaa2e, GRUB_BIDI_TYPE_NSM, 255}, +{0xaa2f, 0xaa30, GRUB_BIDI_TYPE_L, 254}, +{0xaa31, 0xaa32, GRUB_BIDI_TYPE_NSM, 255}, +{0xaa33, 0xaa34, GRUB_BIDI_TYPE_L, 254}, +{0xaa35, 0xaa36, GRUB_BIDI_TYPE_NSM, 255}, +{0xaa43, 0xaa43, GRUB_BIDI_TYPE_NSM, 255}, +{0xaa4c, 0xaa4c, GRUB_BIDI_TYPE_NSM, 255}, +{0xaa4d, 0xaa4d, GRUB_BIDI_TYPE_L, 254}, +{0xfb1d, 0xfb1d, GRUB_BIDI_TYPE_R, 0}, +{0xfb1e, 0xfb1e, GRUB_BIDI_TYPE_NSM, 26}, +{0xfb1f, 0xfb28, GRUB_BIDI_TYPE_R, 0}, +{0xfb29, 0xfb29, GRUB_BIDI_TYPE_ES, 0}, +{0xfb2a, 0xfb36, GRUB_BIDI_TYPE_R, 0}, +{0xfb38, 0xfb3c, GRUB_BIDI_TYPE_R, 0}, +{0xfb3e, 0xfb3e, GRUB_BIDI_TYPE_R, 0}, +{0xfb40, 0xfb41, GRUB_BIDI_TYPE_R, 0}, +{0xfb43, 0xfb44, GRUB_BIDI_TYPE_R, 0}, +{0xfb46, 0xfb4f, GRUB_BIDI_TYPE_R, 0}, +{0xfb50, 0xfbb1, GRUB_BIDI_TYPE_AL, 0}, +{0xfbd3, 0xfd3d, GRUB_BIDI_TYPE_AL, 0}, +{0xfd3e, 0xfd3f, GRUB_BIDI_TYPE_ON, 0}, +{0xfd50, 0xfd8f, GRUB_BIDI_TYPE_AL, 0}, +{0xfd92, 0xfdc7, GRUB_BIDI_TYPE_AL, 0}, +{0xfdf0, 0xfdfc, GRUB_BIDI_TYPE_AL, 0}, +{0xfdfd, 0xfdfd, GRUB_BIDI_TYPE_ON, 0}, +{0xfe00, 0xfe0f, GRUB_BIDI_TYPE_NSM, 255}, +{0xfe10, 0xfe19, GRUB_BIDI_TYPE_ON, 0}, +{0xfe20, 0xfe26, GRUB_BIDI_TYPE_NSM, 230}, +{0xfe30, 0xfe4f, GRUB_BIDI_TYPE_ON, 0}, +{0xfe50, 0xfe50, GRUB_BIDI_TYPE_CS, 0}, +{0xfe51, 0xfe51, GRUB_BIDI_TYPE_ON, 0}, +{0xfe52, 0xfe52, GRUB_BIDI_TYPE_CS, 0}, +{0xfe54, 0xfe54, GRUB_BIDI_TYPE_ON, 0}, +{0xfe55, 0xfe55, GRUB_BIDI_TYPE_CS, 0}, +{0xfe56, 0xfe5e, GRUB_BIDI_TYPE_ON, 0}, +{0xfe5f, 0xfe5f, GRUB_BIDI_TYPE_ET, 0}, +{0xfe60, 0xfe61, GRUB_BIDI_TYPE_ON, 0}, +{0xfe62, 0xfe63, GRUB_BIDI_TYPE_ES, 0}, +{0xfe64, 0xfe66, GRUB_BIDI_TYPE_ON, 0}, +{0xfe68, 0xfe68, GRUB_BIDI_TYPE_ON, 0}, +{0xfe69, 0xfe6a, GRUB_BIDI_TYPE_ET, 0}, +{0xfe6b, 0xfe6b, GRUB_BIDI_TYPE_ON, 0}, +{0xfe70, 0xfe74, GRUB_BIDI_TYPE_AL, 0}, +{0xfe76, 0xfefc, GRUB_BIDI_TYPE_AL, 0}, +{0xfeff, 0xfeff, GRUB_BIDI_TYPE_BN, 0}, +{0xff01, 0xff02, GRUB_BIDI_TYPE_ON, 0}, +{0xff03, 0xff05, GRUB_BIDI_TYPE_ET, 0}, +{0xff06, 0xff0a, GRUB_BIDI_TYPE_ON, 0}, +{0xff0b, 0xff0b, GRUB_BIDI_TYPE_ES, 0}, +{0xff0c, 0xff0c, GRUB_BIDI_TYPE_CS, 0}, +{0xff0d, 0xff0d, GRUB_BIDI_TYPE_ES, 0}, +{0xff0e, 0xff0f, GRUB_BIDI_TYPE_CS, 0}, +{0xff10, 0xff19, GRUB_BIDI_TYPE_EN, 0}, +{0xff1a, 0xff1a, GRUB_BIDI_TYPE_CS, 0}, +{0xff1b, 0xff20, GRUB_BIDI_TYPE_ON, 0}, +{0xff3b, 0xff40, GRUB_BIDI_TYPE_ON, 0}, +{0xff5b, 0xff65, GRUB_BIDI_TYPE_ON, 0}, +{0xffe0, 0xffe1, GRUB_BIDI_TYPE_ET, 0}, +{0xffe2, 0xffe4, GRUB_BIDI_TYPE_ON, 0}, +{0xffe5, 0xffe6, GRUB_BIDI_TYPE_ET, 0}, +{0xffe8, 0xffee, GRUB_BIDI_TYPE_ON, 0}, +{0xfff9, 0xfffd, GRUB_BIDI_TYPE_ON, 0}, +{0x10101, 0x10101, GRUB_BIDI_TYPE_ON, 0}, +{0x10140, 0x1018a, GRUB_BIDI_TYPE_ON, 0}, +{0x10190, 0x1019b, GRUB_BIDI_TYPE_ON, 0}, +{0x101fd, 0x101fd, GRUB_BIDI_TYPE_NSM, 220}, +{0x10800, 0x10805, GRUB_BIDI_TYPE_R, 0}, +{0x10808, 0x10808, GRUB_BIDI_TYPE_R, 0}, +{0x1080a, 0x10835, GRUB_BIDI_TYPE_R, 0}, +{0x10837, 0x10838, GRUB_BIDI_TYPE_R, 0}, +{0x1083c, 0x1083c, GRUB_BIDI_TYPE_R, 0}, +{0x1083f, 0x1083f, GRUB_BIDI_TYPE_R, 0}, +{0x10900, 0x10919, GRUB_BIDI_TYPE_R, 0}, +{0x1091f, 0x1091f, GRUB_BIDI_TYPE_ON, 0}, +{0x10920, 0x10939, GRUB_BIDI_TYPE_R, 0}, +{0x1093f, 0x1093f, GRUB_BIDI_TYPE_R, 0}, +{0x10a00, 0x10a00, GRUB_BIDI_TYPE_R, 0}, +{0x10a01, 0x10a03, GRUB_BIDI_TYPE_NSM, 255}, +{0x10a05, 0x10a06, GRUB_BIDI_TYPE_NSM, 255}, +{0x10a0c, 0x10a0c, GRUB_BIDI_TYPE_NSM, 255}, +{0x10a0d, 0x10a0d, GRUB_BIDI_TYPE_NSM, 220}, +{0x10a0e, 0x10a0e, GRUB_BIDI_TYPE_NSM, 255}, +{0x10a0f, 0x10a0f, GRUB_BIDI_TYPE_NSM, 230}, +{0x10a10, 0x10a13, GRUB_BIDI_TYPE_R, 0}, +{0x10a15, 0x10a17, GRUB_BIDI_TYPE_R, 0}, +{0x10a19, 0x10a33, GRUB_BIDI_TYPE_R, 0}, +{0x10a38, 0x10a38, GRUB_BIDI_TYPE_NSM, 230}, +{0x10a39, 0x10a39, GRUB_BIDI_TYPE_NSM, 1}, +{0x10a3a, 0x10a3a, GRUB_BIDI_TYPE_NSM, 220}, +{0x10a3f, 0x10a3f, GRUB_BIDI_TYPE_NSM, 9}, +{0x10a40, 0x10a47, GRUB_BIDI_TYPE_R, 0}, +{0x10a50, 0x10a58, GRUB_BIDI_TYPE_R, 0}, +{0x1d165, 0x1d166, GRUB_BIDI_TYPE_L, 216}, +{0x1d167, 0x1d169, GRUB_BIDI_TYPE_NSM, 1}, +{0x1d16d, 0x1d16d, GRUB_BIDI_TYPE_L, 226}, +{0x1d16e, 0x1d172, GRUB_BIDI_TYPE_L, 216}, +{0x1d173, 0x1d17a, GRUB_BIDI_TYPE_BN, 0}, +{0x1d17b, 0x1d182, GRUB_BIDI_TYPE_NSM, 220}, +{0x1d185, 0x1d189, GRUB_BIDI_TYPE_NSM, 230}, +{0x1d18a, 0x1d18b, GRUB_BIDI_TYPE_NSM, 220}, +{0x1d1aa, 0x1d1ad, GRUB_BIDI_TYPE_NSM, 230}, +{0x1d200, 0x1d241, GRUB_BIDI_TYPE_ON, 0}, +{0x1d242, 0x1d244, GRUB_BIDI_TYPE_NSM, 230}, +{0x1d245, 0x1d245, GRUB_BIDI_TYPE_ON, 0}, +{0x1d300, 0x1d356, GRUB_BIDI_TYPE_ON, 0}, +{0x1d7ce, 0x1d7ff, GRUB_BIDI_TYPE_EN, 0}, +{0x1f000, 0x1f02b, GRUB_BIDI_TYPE_ON, 0}, +{0x1f030, 0x1f093, GRUB_BIDI_TYPE_ON, 0}, +{0xe0001, 0xe0001, GRUB_BIDI_TYPE_BN, 0}, +{0xe0020, 0xe007f, GRUB_BIDI_TYPE_BN, 0}, +{0xe0100, 0xe01ef, GRUB_BIDI_TYPE_NSM, 255}, +{0, 0, 0, 0}, }; \ No newline at end of file diff --git a/util/grub-mkfont.c b/util/grub-mkfont.c index a358ba5b0..2074c64b0 100644 --- a/util/grub-mkfont.c +++ b/util/grub-mkfont.c @@ -170,6 +170,9 @@ add_char (struct grub_font_info *font_info, FT_Face face, if ((*p_glyph) && ((*p_glyph)->char_code == char_code)) return; + if (glyph->next) + printf ("%x\n", char_code); + width = glyph->bitmap.width; height = glyph->bitmap.rows; diff --git a/util/import_bidi.py b/util/import_bidi.py deleted file mode 100644 index 543174ad9..000000000 --- a/util/import_bidi.py +++ /dev/null @@ -1,52 +0,0 @@ -#* -#* GRUB -- GRand Unified Bootloader -#* Copyright (C) 2010 Free Software Foundation, Inc. -#* -#* GRUB is free software: you can redistribute it and/or modify -#* it under the terms of the GNU General Public License as published by -#* the Free Software Foundation, either version 3 of the License, or -#* (at your option) any later version. -#* -#* GRUB is distributed in the hope that it will be useful, -#* but WITHOUT ANY WARRANTY; without even the implied warranty of -#* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -#* GNU General Public License for more details. -#* -#* You should have received a copy of the GNU General Public License -#* along with GRUB. If not, see . -#* - -import re -import sys -import os -import datetime - -if len (sys.argv) < 3: - print ("Usage: %s SOURCE DESTINATION" % sys.argv[0]) - exit (0) -infile = open (sys.argv[1], "r") -outfile = open (sys.argv[2], "w") -outfile.write ("#include \n") -outfile.write ("\n") -outfile.write ("struct grub_bidi_compact_range grub_bidi_compact[] = {\n") - -begin = -2 -last = -2 -lasttype = "X" -for line in infile: - sp = line.split (";") - cur = int (sp[0], 16) - curtype = sp[4] - if last + 1 != cur or curtype != lasttype: - if begin != -2 and lasttype != "L": - outfile.write (("{0x%x, 0x%x, GRUB_BIDI_TYPE_%s},\n" \ - % (begin, last, lasttype))) - begin = cur - last = cur - lasttype = curtype -if lasttype != "L": - outfile.write (("{0x%x, 0x%x, GRUB_BIDI_TYPE_%s},\n" \ - % (begin, last, lasttype))) -outfile.write ("{0, 0, 0},\n") - -outfile.write ("};") diff --git a/util/import_unicode.py b/util/import_unicode.py new file mode 100644 index 000000000..adba3f938 --- /dev/null +++ b/util/import_unicode.py @@ -0,0 +1,67 @@ +#* +#* GRUB -- GRand Unified Bootloader +#* Copyright (C) 2010 Free Software Foundation, Inc. +#* +#* GRUB is free software: you can redistribute it and/or modify +#* it under the terms of the GNU General Public License as published by +#* the Free Software Foundation, either version 3 of the License, or +#* (at your option) any later version. +#* +#* GRUB is distributed in the hope that it will be useful, +#* but WITHOUT ANY WARRANTY; without even the implied warranty of +#* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +#* GNU General Public License for more details. +#* +#* You should have received a copy of the GNU General Public License +#* along with GRUB. If not, see . +#* + +import re +import sys +import os +import datetime + +if len (sys.argv) < 3: + print ("Usage: %s SOURCE DESTINATION" % sys.argv[0]) + exit (0) +infile = open (sys.argv[1], "r") +outfile = open (sys.argv[2], "w") +outfile.write ("#include \n") +outfile.write ("\n") +outfile.write ("struct grub_unicode_compact_range grub_unicode_compact[] = {\n") + +begincode = -2 +lastcode = -2 +lastbiditype = "X" +lastcombtype = -1 +for line in infile: + sp = line.split (";") + curcode = int (sp[0], 16) + curbiditype = sp[4] + curcombtype = int (sp[3], 10) + if curcombtype <= 255 and curcombtype >= 253: + print ("UnicodeData.txt uses combination type %d. Conflict." \ + % curcombtype) + raise + if curcombtype == 0 and sp[2] == "Me": + curcombtype = 253 + if curcombtype == 0 and sp[2] == "Mc": + curcombtype = 254 + if curcombtype == 0 and sp[2] == "Mn": + curcombtype = 255 + if lastcode + 1 != curcode or curbiditype != lastbiditype \ + or curcombtype != lastcombtype: + if begincode != -2 and (lastbiditype != "L" or lastcombtype != 0): + outfile.write (("{0x%x, 0x%x, GRUB_BIDI_TYPE_%s, %d},\n" \ + % (begincode, lastcode, lastbiditype, \ + lastcombtype))) + begincode = curcode + lastcode = curcode + lastbiditype = curbiditype + lastcombtype = curcombtype +if lastbiditype != "L" or lastcombtype != 0: + outfile.write (("{0x%x, 0x%x, GRUB_BIDI_TYPE_%s, %d},\n" \ + % (begincode, lastcode, lastbiditype, lastcombtype))) +outfile.write ("{0, 0, 0, 0},\n") + +outfile.write ("};")