diff --git a/devices/vector/gdevtxtw.c b/devices/vector/gdevtxtw.c

index b958027..7f02608 100644

--- a/devices/vector/gdevtxtw.c

+++ b/devices/vector/gdevtxtw.c

@@ -1693,97 +1693,100 @@ static int get_unicode(textw_text_enum_t *penum, gs_font *font, gs_glyph glyph,

     length = font->procs.decode_glyph((gs_font *)font, glyph, ch, NULL, 0);

     if (length == 0) {

-        code = font->procs.glyph_name(font, glyph, &gnstr);

-        if (code >= 0 && gnstr.size == 7) {

-            if (!memcmp(gnstr.data, "uni", 3)) {

-                static const char *hexdigits = "0123456789ABCDEF";

-                char *d0 = strchr(hexdigits, gnstr.data[3]);

-                char *d1 = strchr(hexdigits, gnstr.data[4]);

-                char *d2 = strchr(hexdigits, gnstr.data[5]);

-                char *d3 = strchr(hexdigits, gnstr.data[6]);

-

-                if (d0 != NULL && d1 != NULL && d2 != NULL && d3 != NULL) {

-                    *Buffer++ = ((d0 - hexdigits) << 12) + ((d1 - hexdigits) << 8) + ((d2 - hexdigits) << 4) + (d3 - hexdigits);

-                    return 1;

-                }

-            }

-        }

-        if (length == 0) {

-            single_glyph_list_t *sentry = (single_glyph_list_t *)&SingleGlyphList;

-            double_glyph_list_t *dentry = (double_glyph_list_t *)&DoubleGlyphList;

-            treble_glyph_list_t *tentry = (treble_glyph_list_t *)&TrebleGlyphList;

-            quad_glyph_list_t *qentry = (quad_glyph_list_t *)&QuadGlyphList;

-

-            /* Search glyph to single Unicode value table */

-            while (sentry->Glyph != 0) {

-                if (sentry->Glyph[0] < gnstr.data[0]) {

-                    sentry++;

-                    continue;

-                }

-                if (sentry->Glyph[0] > gnstr.data[0]){

-                    break;

-                }

-                if (strlen(sentry->Glyph) == gnstr.size) {

-                    if(memcmp(gnstr.data, sentry->Glyph, gnstr.size) == 0) {

-                        *Buffer = sentry->Unicode;

+        if (glyph != GS_NO_GLYPH) {

+            code = font->procs.glyph_name(font, glyph, &gnstr);

+            if (code >= 0 && gnstr.size == 7) {

+                if (!memcmp(gnstr.data, "uni", 3)) {

+                    static const char *hexdigits = "0123456789ABCDEF";

+                    char *d0 = strchr(hexdigits, gnstr.data[3]);

+                    char *d1 = strchr(hexdigits, gnstr.data[4]);

+                    char *d2 = strchr(hexdigits, gnstr.data[5]);

+                    char *d3 = strchr(hexdigits, gnstr.data[6]);

+

+                    if (d0 != NULL && d1 != NULL && d2 != NULL && d3 != NULL) {

+                        *Buffer++ = ((d0 - hexdigits) << 12) + ((d1 - hexdigits) << 8) + ((d2 - hexdigits) << 4) + (d3 - hexdigits);

                         return 1;

                     }

                 }

-                sentry++;

             }

-            /* Search glyph to double Unicode value table */

-            while (dentry->Glyph != 0) {

-                if (dentry->Glyph[0] < gnstr.data[0]) {

-                    dentry++;

-                    continue;

-                }

-                if (dentry->Glyph[0] > gnstr.data[0]){

-                    break;

-                }

-                if (strlen(dentry->Glyph) == gnstr.size) {

-                    if(memcmp(gnstr.data, dentry->Glyph, gnstr.size) == 0) {

-                        memcpy(Buffer, dentry->Unicode, 2);

-                        return 2;

+            if (length == 0) {

+                single_glyph_list_t *sentry = (single_glyph_list_t *)&SingleGlyphList;

+                double_glyph_list_t *dentry = (double_glyph_list_t *)&DoubleGlyphList;

+                treble_glyph_list_t *tentry = (treble_glyph_list_t *)&TrebleGlyphList;

+                quad_glyph_list_t *qentry = (quad_glyph_list_t *)&QuadGlyphList;

+

+                /* Search glyph to single Unicode value table */

+                while (sentry->Glyph != 0) {

+                    if (sentry->Glyph[0] < gnstr.data[0]) {

+                        sentry++;

+                        continue;

+                    }

+                    if (sentry->Glyph[0] > gnstr.data[0]){

+                        break;

+                    }

+                    if (strlen(sentry->Glyph) == gnstr.size) {

+                        if(memcmp(gnstr.data, sentry->Glyph, gnstr.size) == 0) {

+                            *Buffer = sentry->Unicode;

+                            return 1;

+                        }

                     }

+                    sentry++;

                 }

-                dentry++;

-            }

-            /* Search glyph to triple Unicode value table */

-            while (tentry->Glyph != 0) {

-                if (tentry->Glyph[0] < gnstr.data[0]) {

-                    tentry++;

-                    continue;

-                }

-                if (tentry->Glyph[0] > gnstr.data[0]){

-                    break;

-                }

-                if (strlen(tentry->Glyph) == gnstr.size) {

-                    if(memcmp(gnstr.data, tentry->Glyph, gnstr.size) == 0) {

-                        memcpy(Buffer, tentry->Unicode, 3);

-                        return 3;

+                /* Search glyph to double Unicode value table */

+                while (dentry->Glyph != 0) {

+                    if (dentry->Glyph[0] < gnstr.data[0]) {

+                        dentry++;

+                        continue;

                     }

+                    if (dentry->Glyph[0] > gnstr.data[0]){

+                        break;

+                    }

+                    if (strlen(dentry->Glyph) == gnstr.size) {

+                        if(memcmp(gnstr.data, dentry->Glyph, gnstr.size) == 0) {

+                            memcpy(Buffer, dentry->Unicode, 2);

+                            return 2;

+                        }

+                    }

+                    dentry++;

                 }

-                tentry++;

-            }

-            /* Search glyph to quadruple Unicode value table */

-            while (qentry->Glyph != 0) {

-                if (qentry->Glyph[0] < gnstr.data[0]) {

-                    qentry++;

-                    continue;

-                }

-                if (qentry->Glyph[0] > gnstr.data[0]){

-                    break;

+                /* Search glyph to triple Unicode value table */

+                while (tentry->Glyph != 0) {

+                    if (tentry->Glyph[0] < gnstr.data[0]) {

+                        tentry++;

+                        continue;

+                    }

+                    if (tentry->Glyph[0] > gnstr.data[0]){

+                        break;

+                    }

+                    if (strlen(tentry->Glyph) == gnstr.size) {

+                        if(memcmp(gnstr.data, tentry->Glyph, gnstr.size) == 0) {

+                            memcpy(Buffer, tentry->Unicode, 3);

+                            return 3;

+                        }

+                    }

+                    tentry++;

                 }

-                if (strlen(qentry->Glyph) == gnstr.size) {

-                    if(memcmp(gnstr.data, qentry->Glyph, gnstr.size) == 0) {

-                        memcpy(Buffer, qentry->Unicode, 4);

-                        return 4;

+

+                /* Search glyph to quadruple Unicode value table */

+                while (qentry->Glyph != 0) {

+                    if (qentry->Glyph[0] < gnstr.data[0]) {

+                        qentry++;

+                        continue;

+                    }

+                    if (qentry->Glyph[0] > gnstr.data[0]){

+                        break;

                     }

+                    if (strlen(qentry->Glyph) == gnstr.size) {

+                        if(memcmp(gnstr.data, qentry->Glyph, gnstr.size) == 0) {

+                            memcpy(Buffer, qentry->Unicode, 4);

+                            return 4;

+                        }

+                    }

+                    qentry++;

                 }

-                qentry++;

             }

         }

         *Buffer = fallback;

@@ -1890,8 +1893,8 @@ txtwrite_process_cmap_text(gs_text_enum_t *pte)

                 pte->returned.total_width.x += dpt.x;

                 pte->returned.total_width.y += dpt.y;

-                penum->TextBufferIndex += get_unicode(penum, (gs_font *)pte->orig_font, glyph, chr, &penum->TextBuffer[penum->TextBufferIndex]);

                 penum->Widths[penum->TextBufferIndex] += dpt.x;

+                penum->TextBufferIndex += get_unicode(penum, (gs_font *)pte->orig_font, glyph, chr, &penum->TextBuffer[penum->TextBufferIndex]);

                 break;

             case 2:		/* end of string */

                 return 0;

diff --git a/psi/zbfont.c b/psi/zbfont.c

index 262fea9..abc03aa 100644

--- a/psi/zbfont.c

+++ b/psi/zbfont.c

@@ -272,7 +272,7 @@ gs_font_map_glyph_to_unicode(gs_font *font, gs_glyph glyph, int ch, ushort *u, u

          * can't be a default value for FontInfo.GlyphNames2Unicode .

          */

     }

-    if (glyph <= GS_MIN_CID_GLYPH) {

+    if (glyph <= GS_MIN_CID_GLYPH && glyph != GS_NO_GLYPH) {

         UnicodeDecoding = zfont_get_to_unicode_map(font->dir);

         if (UnicodeDecoding != NULL && r_type(UnicodeDecoding) == t_dictionary)

             return gs_font_map_glyph_by_dict(font->memory, UnicodeDecoding, glyph, u, length);