texlive[43592] Build/source/texk/web2c/luatexdir: sync with latest

commits+lscarso at tug.org commits+lscarso at tug.org
Fri Mar 24 01:38:37 CET 2017


Revision: 43592
          http://tug.org/svn/texlive?view=revision&revision=43592
Author:   lscarso
Date:     2017-03-24 01:38:37 +0100 (Fri, 24 Mar 2017)
Log Message:
-----------
sync with latest luatex from new svn repo.

Modified Paths:
--------------
    trunk/Build/source/texk/web2c/luatexdir/font/luafont.w
    trunk/Build/source/texk/web2c/luatexdir/font/luatexfont.h
    trunk/Build/source/texk/web2c/luatexdir/font/texfont.h
    trunk/Build/source/texk/web2c/luatexdir/font/texfont.w
    trunk/Build/source/texk/web2c/luatexdir/font/tt_glyf.h
    trunk/Build/source/texk/web2c/luatexdir/font/tt_glyf.w
    trunk/Build/source/texk/web2c/luatexdir/font/writecff.h
    trunk/Build/source/texk/web2c/luatexdir/font/writecff.w
    trunk/Build/source/texk/web2c/luatexdir/font/writefont.w
    trunk/Build/source/texk/web2c/luatexdir/font/writettf.w
    trunk/Build/source/texk/web2c/luatexdir/font/writetype0.w
    trunk/Build/source/texk/web2c/luatexdir/font/writetype2.w
    trunk/Build/source/texk/web2c/luatexdir/lua/lcallbacklib.c
    trunk/Build/source/texk/web2c/luatexdir/lua/luatex-api.h
    trunk/Build/source/texk/web2c/luatexdir/luatexcallbackids.h
    trunk/Build/source/texk/web2c/luatexdir/tex/dumpdata.w

Modified: trunk/Build/source/texk/web2c/luatexdir/font/luafont.w
===================================================================
--- trunk/Build/source/texk/web2c/luatexdir/font/luafont.w	2017-03-24 00:34:01 UTC (rev 43591)
+++ trunk/Build/source/texk/web2c/luatexdir/font/luafont.w	2017-03-24 00:38:37 UTC (rev 43592)
@@ -438,6 +438,7 @@
     dump_stringfield(L,writingmode,font_writingmode_strings[font_writingmode(f)]);
     dump_stringfield(L,identity,font_identity_strings[font_identity(f)]);
     dump_stringfield(L,embedding,font_embedding_strings[font_embedding(f)]);
+    dump_intfield(L,streamprovider,font_streamprovider(f));
 
     dump_intfield(L,units_per_em,font_units_per_em(f));
     dump_intfield(L,size,font_size(f));
@@ -1383,6 +1384,8 @@
     set_font_natural_dir(f, i);
     i = lua_numeric_field_by_index(L,lua_key_index(encodingbytes), 0);
     set_font_encodingbytes(f, (char) i);
+    i = lua_numeric_field_by_index(L,lua_key_index(streamprovider), 0);
+    set_font_streamprovider(f, (char) i);
     i = n_boolean_field(L,lua_key_index(oldmath), 0);
     set_font_oldmath(f, i);
     i = lua_numeric_field_by_index(L,lua_key_index(tounicode), 0);

Modified: trunk/Build/source/texk/web2c/luatexdir/font/luatexfont.h
===================================================================
--- trunk/Build/source/texk/web2c/luatexdir/font/luatexfont.h	2017-03-24 00:34:01 UTC (rev 43591)
+++ trunk/Build/source/texk/web2c/luatexdir/font/luatexfont.h	2017-03-24 00:38:37 UTC (rev 43592)
@@ -102,6 +102,7 @@
     fm_entry *fm;               /* pointer to font map structure */
     struct avl_table *tx_tree;  /* tree of non-reencoded TeX characters marked as used */
     struct avl_table *gl_tree;  /* tree of all marked glyphs */
+    internal_font_number tex_font;      /* needed for variable */
 } fd_entry;
 
 typedef struct fo_entry_ {
@@ -162,7 +163,7 @@
 /* writefont.c */
 void do_pdf_font(PDF, internal_font_number);
 fd_entry *lookup_fd_entry(char *);
-fd_entry *new_fd_entry(void);
+fd_entry *new_fd_entry(internal_font_number);
 void write_fontstuff(PDF);
 void register_fd_entry(fd_entry * fd);
 

Modified: trunk/Build/source/texk/web2c/luatexdir/font/texfont.h
===================================================================
--- trunk/Build/source/texk/web2c/luatexdir/font/texfont.h	2017-03-24 00:34:01 UTC (rev 43591)
+++ trunk/Build/source/texk/web2c/luatexdir/font/texfont.h	2017-03-24 00:38:37 UTC (rev 43592)
@@ -153,6 +153,7 @@
     int _font_writingmode;
     int _font_identity;
     int _font_embedding;
+    int _font_streamprovider;
     int _font_bc;
     int _hyphen_char;
     int _skew_char;
@@ -316,6 +317,10 @@
 #  define font_encodingbytes(a)          font_tables[a]->_font_encodingbytes
 #  define set_font_encodingbytes(a,b)    font_encodingbytes(a) = b
 
+#  define font_streamprovider(a)         font_tables[a]->_font_streamprovider
+#  define set_font_streamprovider(a,b)   font_streamprovider(a) = b
+
+
 #  define font_oldmath(a)                font_tables[a]->_font_oldmath
 #  define set_font_oldmath(a,b)          font_oldmath(a) = b
 

Modified: trunk/Build/source/texk/web2c/luatexdir/font/texfont.w
===================================================================
--- trunk/Build/source/texk/web2c/luatexdir/font/texfont.w	2017-03-24 00:34:01 UTC (rev 43591)
+++ trunk/Build/source/texk/web2c/luatexdir/font/texfont.w	2017-03-24 00:38:37 UTC (rev 43592)
@@ -1542,6 +1542,7 @@
     dump_int(f->_font_writingmode);
     dump_int(f->_font_identity);
     dump_int(f->_font_embedding);
+    dump_int(f->_font_streamprovider);
     dump_int(f->_font_bc);
     dump_int(f->_hyphen_char);
     dump_int(f->_skew_char);
@@ -1721,6 +1722,7 @@
     undump_int(x); f->_font_writingmode = x;
     undump_int(x); f->_font_identity = x;
     undump_int(x); f->_font_embedding = x;
+    undump_int(x); f->_font_streamprovider = x;
     undump_int(x); f->_font_bc = x;
     undump_int(x); f->_hyphen_char = x;
     undump_int(x); f->_skew_char = x;

Modified: trunk/Build/source/texk/web2c/luatexdir/font/tt_glyf.h
===================================================================
--- trunk/Build/source/texk/web2c/luatexdir/font/tt_glyf.h	2017-03-24 00:34:01 UTC (rev 43591)
+++ trunk/Build/source/texk/web2c/luatexdir/font/tt_glyf.h	2017-03-24 00:38:37 UTC (rev 43592)
@@ -1,5 +1,5 @@
 /* tt_glyf.h
-    
+
    Copyright 2002 by Jin-Hwan Cho and Shunsaku Hirata,
    the dvipdfmx project team <dvipdfmx at project.ktug.or.kr>
    Copyright 2006-2008 Taco Hoekwater <taco at luatex.org>
@@ -52,7 +52,7 @@
 extern USHORT tt_get_index(struct tt_glyphs *g, USHORT gid);
 extern USHORT tt_find_glyph(struct tt_glyphs *g, USHORT gid);
 
-extern int tt_build_tables(sfnt * sfont, struct tt_glyphs *g);
+extern int tt_build_tables(sfnt * sfont, struct tt_glyphs *g, fd_entry * fd);
 extern int tt_get_metrics(sfnt * sfont, struct tt_glyphs *g);
 
 #endif                          /* _TT_GLYF_H_ */

Modified: trunk/Build/source/texk/web2c/luatexdir/font/tt_glyf.w
===================================================================
--- trunk/Build/source/texk/web2c/luatexdir/font/tt_glyf.w	2017-03-24 00:34:01 UTC (rev 43591)
+++ trunk/Build/source/texk/web2c/luatexdir/font/tt_glyf.w	2017-03-24 00:38:37 UTC (rev 43592)
@@ -174,11 +174,11 @@
 }
 
 @ @c
-int tt_build_tables(sfnt * sfont, struct tt_glyphs *g)
+int tt_build_tables(sfnt * sfont, struct tt_glyphs *g, fd_entry * fd)
 {
     char *hmtx_table_data = NULL, *loca_table_data = NULL;
     char *glyf_table_data = NULL;
-    ULONG hmtx_table_size, loca_table_size, glyf_table_size;
+    ULONG hmtx_table_size, loca_table_size, glyf_table_size, glyf_table_used;
     /* some information available from other TrueType table */
     struct tt_head_table *head = NULL;
     struct tt_hhea_table *hhea = NULL;
@@ -190,6 +190,14 @@
     long i;
     USHORT *w_stat;             /* Estimate most frequently appeared width */
 
+    int tex_font = fd->tex_font;
+    int streamprovider = 0;
+    int callback_id = 0 ;
+    if ((tex_font > 0) && (font_streamprovider(tex_font) == 2)) {
+        streamprovider = font_streamprovider(tex_font);
+        callback_id = callback_defined(glyph_stream_provider_callback);
+    }
+
     ASSERT(g);
 
     if (sfont->type != SFNT_TYPE_TRUETYPE && sfont->type != SFNT_TYPE_TTC)
@@ -307,6 +315,7 @@
             formatted_error("ttf","invalid glyph data (gid %u)", gid);
         }
 
+/* todo: no need for this */
         g->gd[i].data = p = NEW(len, BYTE);
         endptr = p + len;
 
@@ -432,6 +441,7 @@
         hmtx_table_data = p = NEW(hmtx_table_size, char);
         loca_table_data = q = NEW(loca_table_size, char);
         glyf_table_data = NEW(glyf_table_size, char);
+        glyf_table_used = 0;
 
         offset = 0UL;
         prev = 0;
@@ -451,8 +461,6 @@
                     q += sfnt_put_ulong(q, (LONG) offset);
                 }
             }
-            padlen =
-                (int) ((g->gd[i].length % 4) ? (4 - (g->gd[i].length % 4)) : 0);
             if (g->gd[i].gid < hhea->numberOfHMetrics) {
                 p += sfnt_put_ushort(p, g->gd[i].advw);
             }
@@ -462,13 +470,35 @@
             } else {
                 q += sfnt_put_ulong(q, (LONG) offset);
             }
-            memset(glyf_table_data + offset, 0,
-                   (size_t) (g->gd[i].length + (ULONG) padlen));
-            memcpy(glyf_table_data + offset, g->gd[i].data, g->gd[i].length);
-            offset += (g->gd[i].length + (ULONG) padlen);
+
+            if (callback_id > 0) {
+
+                lstring * result;
+                long size = 0;
+                run_callback(callback_id, "ddd->L", tex_font, g->gd[i].gid, streamprovider, &result); /* this call can be sped up */
+                padlen = (int) ((result->l % 4) ? (4 - (result->l % 4)) : 0);
+                size = (size_t) result->l + (ULONG) padlen;
+                if (glyf_table_used + size >= glyf_table_size) {
+                    glyf_table_size = glyf_table_size + 20 * size; /* just a guess */
+                    glyf_table_data = xrealloc(glyf_table_data, (unsigned)((unsigned)glyf_table_size*sizeof(char)));
+                }
+                glyf_table_used += size;
+                memset(glyf_table_data + offset, 0, (size_t) size);
+                memcpy(glyf_table_data + offset, (const char *) result->s, (size_t) result->l);
+                offset += size;
+                xfree(result);
+
+            } else {
+
+                padlen = (int) ((g->gd[i].length % 4) ? (4 - (g->gd[i].length % 4)) : 0);
+                memset(glyf_table_data + offset, 0, (size_t) (g->gd[i].length + (ULONG) padlen));
+                memcpy(glyf_table_data + offset, g->gd[i].data, g->gd[i].length);
+                offset += (g->gd[i].length + (ULONG) padlen);
+
+            }
             prev = g->gd[i].gid;
+            RELEASE(g->gd[i].data);
             /* free data here since it consume much memory */
-            RELEASE(g->gd[i].data);
             g->gd[i].length = 0;
             g->gd[i].data = NULL;
         }
@@ -478,12 +508,12 @@
             q += sfnt_put_ulong(q, (LONG) offset);
         }
 
-        sfnt_set_table(sfont, "hmtx", (char *) hmtx_table_data,
-                       hmtx_table_size);
-        sfnt_set_table(sfont, "loca", (char *) loca_table_data,
-                       loca_table_size);
-        sfnt_set_table(sfont, "glyf", (char *) glyf_table_data,
-                       glyf_table_size);
+        sfnt_set_table(sfont, "hmtx", (char *) hmtx_table_data, hmtx_table_size);
+        sfnt_set_table(sfont, "loca", (char *) loca_table_data, loca_table_size);
+        if (callback_id > 0) {
+            glyf_table_size = glyf_table_used;
+        }
+        sfnt_set_table(sfont, "glyf", (char *) glyf_table_data, glyf_table_size);
     }
 
     head->checkSumAdjustment = 0;

Modified: trunk/Build/source/texk/web2c/luatexdir/font/writecff.h
===================================================================
--- trunk/Build/source/texk/web2c/luatexdir/font/writecff.h	2017-03-24 00:34:01 UTC (rev 43591)
+++ trunk/Build/source/texk/web2c/luatexdir/font/writecff.h	2017-03-24 00:38:37 UTC (rev 43592)
@@ -1,5 +1,5 @@
 /* writecff.h
-    
+
    Copyright 2002 by Jin-Hwan Cho and Shunsaku Hirata,
    the dvipdfmx project team <dvipdfmx at project.ktug.or.kr>
    Copyright 2006-2008 Taco Hoekwater <taco at luatex.org>
@@ -327,11 +327,6 @@
     } seac;                     /* unused in Type 2 charstring */
 } cs_ginfo;
 
-extern long cs_copy_charstring(card8 * dest, long destlen,
-                               card8 * src, long srclen,
-                               cff_index * gsubr, cff_index * subr,
-                               double default_width, double nominal_width,
-                               cs_ginfo * ginfo);
 #endif                          /* _CS_TYPE2_H_ */
 
 #define cff_is_cidfont(a) (a->flag & FONTTYPE_CIDFONT)

Modified: trunk/Build/source/texk/web2c/luatexdir/font/writecff.w
===================================================================
--- trunk/Build/source/texk/web2c/luatexdir/font/writecff.w	2017-03-24 00:34:01 UTC (rev 43591)
+++ trunk/Build/source/texk/web2c/luatexdir/font/writecff.w	2017-03-24 00:38:37 UTC (rev 43592)
@@ -19,7 +19,6 @@
 
 @ @c
 
-
 #include "ptexlib.h"
 #include "lua/luatex-api.h"
 #include "font/writecff.h"
@@ -30,6 +29,7 @@
 #define get_offset(s,n) get_unsigned(s, (n))
 #define get_card8(a)  (card8)(a->stream[a->offset++])
 #define get_card16(a) (card16)(get_unsigned(a,2))
+#define get_card32(a) (get_unsigned(a,4))
 
 #undef b0
 #undef b1
@@ -146,7 +146,6 @@
     "Black", "Bold", "Book", "Light", "Medium", "Regular", "Roman", "Semibold"
 };
 
-
 @ Only read header part but not body
 @c
 cff_index *cff_get_index_header(cff_font * cff)
@@ -153,26 +152,24 @@
 {
     cff_index *idx;
     card16 i, count;
-
     idx = xcalloc(1, sizeof(cff_index));
-
-    idx->count = count = get_card16(cff);
+    if (cff->header_major == 2) {
+        idx->count = count = get_card32(cff);
+    } else {
+        idx->count = count = get_card16(cff);
+    }
     if (count > 0) {
         idx->offsize = get_card8(cff);
         if (idx->offsize < 1 || idx->offsize > 4)
-            normal_error("cff","invalid offsize data");
-
-        idx->offset =
-            xmalloc((unsigned) (((unsigned) count + 1) * sizeof(l_offset)));
+            normal_error("cff","invalid offsize data (1)");
+        idx->offset = xmalloc((unsigned) (((unsigned) count + 1) * sizeof(l_offset)));
         for (i = 0; i <count + 1 ; i++) {
             (idx->offset)[i] = get_offset(cff, idx->offsize);
             if (i == USHRT_MAX)
                 break;
         }
-
         if (idx->offset[0] != 1)
             normal_error("cff","invalid index data");
-
         idx->data = NULL;
     } else {
         idx->offsize = 0;
@@ -179,12 +176,9 @@
         idx->offset = NULL;
         idx->data = NULL;
     }
-
     return idx;
 }
 
-
-
 @ @c
 cff_index *cff_get_index(cff_font * cff)
 {
@@ -191,30 +185,22 @@
     cff_index *idx;
     card16 i, count;
     size_t length;
-
     idx = xcalloc(1, sizeof(cff_index));
-
     idx->count = count = get_card16(cff);
     if (count > 0) {
         idx->offsize = get_card8(cff);
         if (idx->offsize < 1 || idx->offsize > 4)
-            normal_error("cff","invalid offsize data");
-
-        idx->offset =
-            xmalloc((unsigned) (((unsigned) count + 1) * sizeof(l_offset)));
+            normal_error("cff","invalid offsize data (2)");
+        idx->offset = xmalloc((unsigned) (((unsigned) count + 1) * sizeof(l_offset)));
         for (i = 0; i < count + 1; i++) {
             idx->offset[i] = get_offset(cff, idx->offsize);
         }
-
         if (idx->offset[0] != 1)
             normal_error("cff","invalid index offset data");
-
         length = (size_t) (idx->offset[count] - idx->offset[0]);
-
         idx->data = xmalloc((unsigned) length * sizeof(card8));
         memcpy(idx->data, &cff->stream[cff->offset], length);
         cff->offset += length;
-
     } else {
         idx->offsize = 0;
         idx->offset = NULL;
@@ -223,7 +209,41 @@
     return idx;
 }
 
+static cff_index *cff_empty_index(cff_font * cff)
+{
+    cff_index *idx;
+    idx = xcalloc(1, sizeof(cff_index));
+    idx->count = 0;
+    idx->offsize = 0;
+    idx->offset = NULL;
+    idx->data = NULL;
+    return idx;
+}
 
+static cff_index *cff_get_index2(cff_font * cff)
+{
+    /* we fake a dict array */
+
+    cff_index *idx;
+    size_t length;
+
+    idx = xcalloc(1, sizeof(cff_index));
+
+    length = (size_t) cff->header_offsize;
+
+    idx->offsize = 2;
+    idx->count = 1;
+    idx->offset = xmalloc((unsigned) (((unsigned) 2) * sizeof(l_offset)));
+    idx->offset[0] = 1; // get_offset(cff, idx->offsize);
+    idx->offset[1] = length + 1; // idx->offset[0] + length;
+
+    idx->data = xmalloc((unsigned) length * sizeof(card8));
+    memcpy(idx->data, &cff->stream[cff->offset], length );
+    cff->offset += length ;
+
+    return idx;
+}
+
 @ @c
 long cff_pack_index(cff_index * idx, card8 * dest, long destlen)
 {
@@ -230,7 +250,6 @@
     long len = 0;
     unsigned long datalen;
     card16 i;
-
     if (idx->count < 1) {
         if (destlen < 2)
             normal_error("cff","not enough space available");
@@ -237,16 +256,12 @@
         memset(dest, 0, 2);
         return 2;
     }
-
     len = cff_index_size(idx);
     datalen = idx->offset[idx->count] - 1;
-
     if (destlen < len)
         normal_error("cff","not enough space available");
-
     *(dest++) = (card8) ((idx->count >> 8) & 0xff);
     *(dest++) = (card8) (idx->count & 0xff);
-
     if (datalen < 0xffUL) {
         idx->offsize = 1;
         *(dest++) = 1;
@@ -278,9 +293,7 @@
             *(dest++) = (card8) (idx->offset[i] & 0xff);
         }
     }
-
     memmove(dest, idx->data, idx->offset[idx->count] - 1);
-
     return len;
 }
 
@@ -289,7 +302,6 @@
 {
     if (idx->count > 0) {
         l_offset datalen;
-
         datalen = idx->offset[idx->count] - 1;
         if (datalen < 0xffUL) {
             idx->offsize = 1;
@@ -310,11 +322,9 @@
 cff_index *cff_new_index(card16 count)
 {
     cff_index *idx;
-
     idx = xcalloc(1, sizeof(cff_index));
     idx->count = count;
     idx->offsize = 0;
-
     if (count > 0) {
         idx->offset = xcalloc((unsigned) (count + 1), sizeof(l_offset));
         (idx->offset)[0] = 1;
@@ -322,11 +332,9 @@
         idx->offset = NULL;
     }
     idx->data = NULL;
-
     return idx;
 }
 
-
 @ @c
 void cff_release_index(cff_index * idx)
 {
@@ -352,7 +360,6 @@
     }
 }
 
-
 @ @c
 void cff_release_encoding(cff_encoding * encoding)
 {
@@ -407,12 +414,10 @@
     }
 }
 
-
 @ @c
 void cff_close(cff_font * cff)
 {
     card16 i;
-
     if (cff) {
         xfree(cff->fontname);
         if (cff->name)
@@ -456,7 +461,6 @@
             cff_release_index(cff->_string);
         xfree(cff);
     }
-
     return;
 }
 
@@ -466,28 +470,22 @@
     char *fontname;
     l_offset len;
     cff_index *idx;
-
     idx = cff->name;
     len = idx->offset[cff->index + 1] - idx->offset[cff->index];
     fontname = xmalloc((unsigned) (len + 1) * sizeof(char));
     memcpy(fontname, idx->data + idx->offset[cff->index] - 1, len);
     fontname[len] = '\0';
-
     return fontname;
 }
 
-
 @ @c
 long cff_set_name(cff_font * cff, char *name)
 {
     cff_index *idx;
-
     if (strlen(name) > 127)
         normal_error("cff","FontName string length too large");
-
     if (cff->name)
         cff_release_index(cff->name);
-
     cff->name = idx = xcalloc(1, sizeof(cff_index));
     idx->count = 1;
     idx->offsize = 1;
@@ -495,8 +493,7 @@
     (idx->offset)[0] = 1;
     (idx->offset)[1] = strlen(name) + 1;
     idx->data = xmalloc((unsigned) strlen(name) * sizeof(card8));
-    memmove(idx->data, name, strlen(name));     /* no trailing |'\0'| */
-
+    memmove(idx->data, name, strlen(name)); /* no trailing |'\0'| */
     return (long) (5 + strlen(name));
 }
 
@@ -505,15 +502,16 @@
     if (destlen < 4)
         normal_error("cff","not enough space available");
 
-    *(dest++) = cff->header_major;
+    *(dest++) = 1; /* cff->header_major; */
     *(dest++) = cff->header_minor;
-    *(dest++) = 4;              /* Additional data in between header and
-                                 * Name INDEX ignored.
-                                 */
-    /* We will set all offset (0) to four-byte integer. */
     *(dest++) = 4;
+    /*
+        Additional data in between header and Name INDEX is ignored.
+
+        We will set all offset (0) to a four-byte integer.
+    */
+    *(dest++) = 4;
     cff->header_offsize = 4;
-
     return 4;
 }
 
@@ -529,7 +527,6 @@
 cff_dict *cff_new_dict(void)
 {
     cff_dict *dict;
-
     dict = xcalloc(1, sizeof(cff_dict));
     dict->max = DICT_ENTRY_MAX;
     dict->count = 0;
@@ -537,30 +534,22 @@
     return dict;
 }
 
-@
+@ Operand stack: only numbers are stored (as double). Operand types are:
 
-Operand stack:
- only numbers are stored (as double)
+\item number:  double (integer or real)
+\item boolean: stored as a number
+\item SID:     stored as a number
+\item array:   array of numbers
+\item delta:   array of numbers
 
-Operand types:
-
-number : double (integer or real)
-boolean: stored as a number
-SID    : stored as a number
-array  : array of numbers
-delta  : array of numbers
-
 @c
 #define CFF_DICT_STACK_LIMIT 64
 static int stack_top = 0;
 static double arg_stack[CFF_DICT_STACK_LIMIT];
 
-@
-CFF DICT encoding:
-TODO: default values
-
+@ CFF DICT encoding.
 @c
-#define CFF_LAST_DICT_OP1 22
+#define CFF_LAST_DICT_OP1 26  /* 22 */
 #define CFF_LAST_DICT_OP2 39
 #define CFF_LAST_DICT_OP (CFF_LAST_DICT_OP1 + CFF_LAST_DICT_OP2)
 
@@ -568,78 +557,73 @@
     const char *opname;
     int argtype;
 } dict_operator[CFF_LAST_DICT_OP] = {
-    {
-    "version", CFF_TYPE_SID}, {
-    "Notice", CFF_TYPE_SID}, {
-    "FullName", CFF_TYPE_SID}, {
-    "FamilyName", CFF_TYPE_SID}, {
-    "Weight", CFF_TYPE_SID}, {
-    "FontBBox", CFF_TYPE_ARRAY}, {
-    "BlueValues", CFF_TYPE_DELTA}, {
-    "OtherBlues", CFF_TYPE_DELTA}, {
-    "FamilyBlues", CFF_TYPE_DELTA}, {
-    "FamilyOtherBlues", CFF_TYPE_DELTA}, {
-    "StdHW", CFF_TYPE_NUMBER}, {
-    "StdVW", CFF_TYPE_NUMBER}, {
-    NULL, -1},                  /* first byte of two-byte operator */
-        /* Top */
-    {
-    "UniqueID", CFF_TYPE_NUMBER}, {
-    "XUID", CFF_TYPE_ARRAY}, {
-    "charset", CFF_TYPE_OFFSET}, {
-    "Encoding", CFF_TYPE_OFFSET}, {
-    "CharStrings", CFF_TYPE_OFFSET}, {
-    "Private", CFF_TYPE_SZOFF}, /* two numbers (size and offset) */
-        /* Private */
-    {
-    "Subrs", CFF_TYPE_OFFSET}, {
-    "defaultWidthX", CFF_TYPE_NUMBER}, {
-    "nominalWidthX", CFF_TYPE_NUMBER},
-        /* Operator 2 */
-    {
-    "Copyright", CFF_TYPE_SID}, {
-    "IsFixedPitch", CFF_TYPE_BOOLEAN}, {
-    "ItalicAngle", CFF_TYPE_NUMBER}, {
-    "UnderlinePosition", CFF_TYPE_NUMBER}, {
-    "UnderlineThickness", CFF_TYPE_NUMBER}, {
-    "PaintType", CFF_TYPE_NUMBER}, {
-    "CharstringType", CFF_TYPE_NUMBER}, {
-    "FontMatrix", CFF_TYPE_ARRAY}, {
-    "StrokeWidth", CFF_TYPE_NUMBER}, {
-    "BlueScale", CFF_TYPE_NUMBER}, {
-    "BlueShift", CFF_TYPE_NUMBER}, {
-    "BlueFuzz", CFF_TYPE_NUMBER}, {
-    "StemSnapH", CFF_TYPE_DELTA}, {
-    "StemSnapV", CFF_TYPE_DELTA}, {
-    "ForceBold", CFF_TYPE_BOOLEAN}, {
-    NULL, -1}, {
-    NULL, -1}, {
-    "LanguageGroup", CFF_TYPE_NUMBER}, {
-    "ExpansionFactor", CFF_TYPE_NUMBER}, {
-    "InitialRandomSeed", CFF_TYPE_NUMBER}, {
-    "SyntheticBase", CFF_TYPE_NUMBER}, {
-    "PostScript", CFF_TYPE_SID}, {
-    "BaseFontName", CFF_TYPE_SID}, {
-    "BaseFontBlend", CFF_TYPE_DELTA},   /* MMaster ? */
-    {
-    NULL, -1}, {
-    NULL, -1}, {
-    NULL, -1}, {
-    NULL, -1}, {
-    NULL, -1}, {
-    NULL, -1},
-        /* CID-Keyed font */
-    {
-    "ROS", CFF_TYPE_ROS},       /* SID SID number */
-    {
-    "CIDFontVersion", CFF_TYPE_NUMBER}, {
-    "CIDFontRevision", CFF_TYPE_NUMBER}, {
-    "CIDFontType", CFF_TYPE_NUMBER}, {
-    "CIDCount", CFF_TYPE_NUMBER}, {
-    "UIDBase", CFF_TYPE_NUMBER}, {
-    "FDArray", CFF_TYPE_OFFSET}, {
-    "FDSelect", CFF_TYPE_OFFSET}, {
-"FontName", CFF_TYPE_SID},};
+    { "version", CFF_TYPE_SID },
+    { "Notice", CFF_TYPE_SID },
+    { "FullName", CFF_TYPE_SID },
+    { "FamilyName", CFF_TYPE_SID },
+    { "Weight", CFF_TYPE_SID },
+    { "FontBBox", CFF_TYPE_ARRAY },
+    { "BlueValues", CFF_TYPE_DELTA },
+    { "OtherBlues", CFF_TYPE_DELTA },
+    { "FamilyBlues", CFF_TYPE_DELTA },
+    { "FamilyOtherBlues", CFF_TYPE_DELTA },
+    { "StdHW", CFF_TYPE_NUMBER },
+    { "StdVW", CFF_TYPE_NUMBER },
+    { NULL, -1 },  /* first byte of two-byte operator 12 */
+    { "UniqueID", CFF_TYPE_NUMBER },
+    { "XUID", CFF_TYPE_ARRAY },
+    { "charset", CFF_TYPE_OFFSET },
+    { "Encoding", CFF_TYPE_OFFSET },
+    { "CharStrings", CFF_TYPE_OFFSET },
+    { "Private", CFF_TYPE_SZOFF },  /* two numbers (size and offset) */
+    { "Subrs", CFF_TYPE_OFFSET },
+    { "defaultWidthX", CFF_TYPE_NUMBER },
+    { "nominalWidthX", CFF_TYPE_NUMBER },
+    { NULL, -1 },
+    { NULL, -1 },
+    { "vstore", CFF_TYPE_OFFSET },   /* cff2 */
+    { "maxstack", CFF_TYPE_NUMBER }, /* cff2 */
+    /* Here we start with operator 2 of 12 */
+    { "Copyright", CFF_TYPE_SID },
+    { "IsFixedPitch", CFF_TYPE_BOOLEAN },
+    { "ItalicAngle", CFF_TYPE_NUMBER },
+    { "UnderlinePosition", CFF_TYPE_NUMBER },
+    { "UnderlineThickness", CFF_TYPE_NUMBER },
+    { "PaintType", CFF_TYPE_NUMBER },
+    { "CharstringType", CFF_TYPE_NUMBER },
+    { "FontMatrix", CFF_TYPE_ARRAY },
+    { "StrokeWidth", CFF_TYPE_NUMBER },
+    { "BlueScale", CFF_TYPE_NUMBER },
+    { "BlueShift", CFF_TYPE_NUMBER },
+    { "BlueFuzz", CFF_TYPE_NUMBER },
+    { "StemSnapH", CFF_TYPE_DELTA },
+    { "StemSnapV", CFF_TYPE_DELTA },
+    { "ForceBold", CFF_TYPE_BOOLEAN },
+    { NULL, -1 },
+    { NULL, -1 },
+    { "LanguageGroup", CFF_TYPE_NUMBER },
+    { "ExpansionFactor", CFF_TYPE_NUMBER },
+    { "InitialRandomSeed", CFF_TYPE_NUMBER },
+    { "SyntheticBase", CFF_TYPE_NUMBER },
+    { "PostScript", CFF_TYPE_SID },
+    { "BaseFontName", CFF_TYPE_SID },
+    { "BaseFontBlend", CFF_TYPE_DELTA },
+    { NULL, -1 },
+    { NULL, -1 },
+    { NULL, -1 },
+    { NULL, -1 },
+    { NULL, -1 },
+    { NULL, -1 },
+    { "ROS", CFF_TYPE_ROS },
+    { "CIDFontVersion", CFF_TYPE_NUMBER },
+    { "CIDFontRevision", CFF_TYPE_NUMBER },
+    { "CIDFontType", CFF_TYPE_NUMBER },
+    { "CIDCount", CFF_TYPE_NUMBER },
+    { "UIDBase", CFF_TYPE_NUMBER },
+    { "FDArray", CFF_TYPE_OFFSET },
+    { "FDSelect", CFF_TYPE_OFFSET },
+    { "FontName", CFF_TYPE_SID }
+};
 
 @ Parse DICT data
 @c
@@ -833,12 +817,10 @@
 {
     cff_dict *dict;
     int status = CFF_PARSE_OK;
-
     stack_top = 0;
-
     dict = cff_new_dict();
     while (data < endptr && status == CFF_PARSE_OK) {
-        if (*data < 22) {       /* operator */
+        if (*data < CFF_LAST_DICT_OP1) {       /* operator */
             add_dict(dict, &data, endptr, &status);
         } else if (*data == 30) {       /* real - First byte of a sequence (variable) */
             if (stack_top < CFF_DICT_STACK_LIMIT) {
@@ -847,7 +829,7 @@
             } else {
                 status = CFF_CFF_ERROR_STACK_OVERFLOW;
             }
-        } else if (*data == 255 || (*data >= 22 && *data <= 27)) {      /* reserved */
+        } else if (*data == 255 || (*data >= CFF_LAST_DICT_OP1 && *data <= 27)) {      /* reserved */
             data++;
         } else {                /* everything else are integer */
             if (stack_top < CFF_DICT_STACK_LIMIT) {
@@ -858,7 +840,6 @@
             }
         }
     }
-
     if (status != CFF_PARSE_OK) {
         formatted_error("cff","parsing DICT failed (error=%d)", status);
     } else if (stack_top != 0) {
@@ -865,7 +846,6 @@
         normal_warning("cff","garbage in DICT data");
         stack_top = 0;
     }
-
     return dict;
 }
 
@@ -873,13 +853,11 @@
 int cff_dict_known(cff_dict * dict, const char *key)
 {
     int i;
-
     for (i = 0; i < dict->count; i++) {
         if (key && strcmp(key, (dict->entries)[i].key) == 0
             && (dict->entries)[i].count > 0)
             return 1;
     }
-
     return 0;
 }
 
@@ -888,9 +866,7 @@
 {
     double value = 0.0;
     int i;
-
     assert(key && dict);
-
     for (i = 0; i < dict->count; i++) {
         if (strcmp(key, (dict->entries)[i].key) == 0) {
            if ((dict->entries)[i].count > idx)
@@ -900,10 +876,8 @@
             break;
         }
     }
-
     if (i == dict->count)
         formatted_error("cff","DICT entry '%s' not found", key);
-
     return value;
 }
 
@@ -957,7 +931,6 @@
     long offset;
     int i;
 
-
     if ((cff->flag & FONTTYPE_CIDFONT) && cff->fdselect == NULL) {
         cff_read_fdselect(cff);
     }
@@ -988,23 +961,19 @@
                 len += cff_index_size((cff->subrs)[i]);
             }
         }
+    } else if (cff->private[0] == NULL || !cff_dict_known(cff->private[0], "Subrs")) {
+        (cff->subrs)[0] = NULL;
     } else {
-        if (cff->private[0] == NULL ||
-            !cff_dict_known(cff->private[0], "Subrs")) {
-            (cff->subrs)[0] = NULL;
-        } else {
-            offset = (long) cff_dict_get(cff->topdict, "Private", 1);
-            offset += (long) cff_dict_get(cff->private[0], "Subrs", 0);
-            cff->offset = (l_offset) offset;
-            (cff->subrs)[0] = cff_get_index(cff);
-            len += cff_index_size((cff->subrs)[0]);
-        }
+        offset = (long) cff_dict_get(cff->topdict, "Private", 1);
+        offset += (long) cff_dict_get(cff->private[0], "Subrs", 0);
+        cff->offset = (l_offset) offset;
+        (cff->subrs)[0] = cff_get_index(cff);
+        len += cff_index_size((cff->subrs)[0]);
     }
 
     return len;
 }
 
-
 @ @c
 long cff_read_fdarray(cff_font * cff)
 {
@@ -1057,9 +1026,8 @@
         cff->private = xmalloc((unsigned) (cff->num_fds * sizeof(cff_dict *)));
         for (i = 0; i < cff->num_fds; i++) {
             if (cff->fdarray[i] != NULL &&
-                cff_dict_known(cff->fdarray[i], "Private") &&
-                (size = (long) cff_dict_get(cff->fdarray[i], "Private", 0))
-                > 0) {
+                    cff_dict_known(cff->fdarray[i], "Private") &&
+                    (size = (long) cff_dict_get(cff->fdarray[i], "Private", 0)) > 0) {
                 offset = (long) cff_dict_get(cff->fdarray[i], "Private", 1);
                 cff->offset = (l_offset) offset;
                 data = xmalloc((unsigned) size * sizeof(card8));
@@ -1076,7 +1044,7 @@
         cff->num_fds = 1;
         cff->private = xmalloc(sizeof(cff_dict *));
         if (cff_dict_known(cff->topdict, "Private") &&
-            (size = (long) cff_dict_get(cff->topdict, "Private", 0)) > 0) {
+                (size = (long) cff_dict_get(cff->topdict, "Private", 0)) > 0) {
             offset = (long) cff_dict_get(cff->topdict, "Private", 1);
             cff->offset = (l_offset) offset;
             data = xmalloc((unsigned) size * sizeof(card8));
@@ -1102,7 +1070,6 @@
     cff_index *idx;
     long offset;
 
-
     cff = xcalloc(1, sizeof(cff_font));
 
     cff->stream = buf;
@@ -1112,13 +1079,18 @@
     cff->header_major = get_card8(cff);
     cff->header_minor = get_card8(cff);
     cff->header_hdr_size = get_card8(cff);
-    cff->header_offsize = get_card8(cff);
-    if (cff->header_offsize < 1 || cff->header_offsize > 4) {
-        normal_warning("cff","invalid offsize data");
-        cff_close(cff);
-        return NULL;
+    if (cff->header_major == 2) {
+        /* we have only one top dictionary */
+        cff->header_offsize = get_card16(cff);
+    } else {
+        cff->header_offsize = get_card8(cff);
+        if (cff->header_offsize < 1 || cff->header_offsize > 4) {
+            normal_warning("cff","invalid offsize data (4)");
+            cff_close(cff);
+            return NULL;
+        }
     }
-    if (cff->header_major > 1) {
+    if (cff->header_major > 2) {
         formatted_warning("cff","major version %u not supported", cff->header_major);
         cff_close(cff);
         return NULL;
@@ -1126,19 +1098,27 @@
     cff->offset = cff->header_hdr_size;
 
     /* Name INDEX */
-    idx = cff_get_index(cff);
-    if (n > idx->count - 1) {
-        normal_warning("cff","invalid fontset index number");
-        cff_close(cff);
-        return NULL;
+    if (cff->header_major == 2) {
+        cff->name = cff_empty_index(cff);
+    } else {
+        idx = cff_get_index(cff);
+        if (n > idx->count - 1) {
+            normal_warning("cff","invalid fontset index number");
+            cff_close(cff);
+            return NULL;
+        }
+        cff->name = idx;
+        cff->fontname = cff_get_name(cff);
     }
 
-    cff->name = idx;
+    /* Top DICT INDEX */
+    if (cff->header_major == 2) {
+        /* we fake an index (just one entry) */
+        idx = cff_get_index2(cff);
+    } else {
+        idx = cff_get_index(cff);
+    }
 
-    cff->fontname = cff_get_name(cff);
-
-    /* Top DICT INDEX */
-    idx = cff_get_index(cff);
     if (n > idx->count - 1) {
         normal_warning("cff","top DICT not exist");
         cff_close(cff);
@@ -1167,7 +1147,11 @@
     }
 
     /* String INDEX */
-    cff->string = cff_get_index(cff);
+    if (cff->header_major == 2) {
+     //   cff->string = cff_empty_index(cff);
+    } else {
+        cff->string = cff_get_index(cff);
+    }
 
     /* offset to GSubr */
     cff->gsubr_offset = cff->offset;
@@ -1211,12 +1195,12 @@
 
     if (value >= -107 && value <= 107) {
         if (destlen < 1)
-            normal_error("cff","buffer overflow");
+            normal_error("cff","buffer overflow (1)");
         dest[0] = (card8) ((value + 139) & 0xff);
         len = 1;
     } else if (value >= 108 && value <= 1131) {
         if (destlen < 2)
-            normal_error("cff","buffer overflow");
+            normal_error("cff","buffer overflow (2)");
         value = (long) 0xf700u + value - 108;
         dest[0] = (card8) ((value >> 8) & 0xff);
         dest[1] = (card8) (value & 0xff);
@@ -1223,7 +1207,7 @@
         len = 2;
     } else if (value >= -1131 && value <= -108) {
         if (destlen < 2)
-            normal_error("cff","buffer overflow");
+            normal_error("cff","buffer overflow (3)");
         value = (long) 0xfb00u - value - 108;
         dest[0] = (card8) ((value >> 8) & 0xff);
         dest[1] = (card8) (value & 0xff);
@@ -1230,7 +1214,7 @@
         len = 2;
     } else if (value >= -32768 && value <= 32767) {     /* shortint */
         if (destlen < 3)
-            normal_error("cff","buffer overflow");
+            normal_error("cff","buffer overflow (4)");
         dest[0] = 28;
         dest[1] = (card8) ((value >> 8) & 0xff);
         dest[2] = (card8) (value & 0xff);
@@ -1237,7 +1221,7 @@
         len = 3;
     } else {                    /* longint */
         if (destlen < 5)
-            normal_error("cff","buffer overflow");
+            normal_error("cff","buffer overflow (5)");
         dest[0] = 29;
         dest[1] = (card8) ((value >> 24) & 0xff);
         dest[2] = (card8) ((value >> 16) & 0xff);
@@ -1257,7 +1241,7 @@
 #define CFF_REAL_MAX_LEN 17
 
     if (destlen < 2)
-        normal_error("cff","buffer overflow");
+        normal_error("cff","buffer overflow (6)");
 
     dest[0] = 30;
 
@@ -1305,7 +1289,7 @@
         }
 
         if (destlen < pos / 2 + 1)
-            normal_error("cff","buffer overflow");
+            normal_error("cff","buffer overflow (7)");
 
         if (pos % 2) {
             dest[pos / 2] = (card8) (dest[pos / 2] + ch);
@@ -1320,7 +1304,7 @@
             dest[pos / 2] = (card8) (dest[pos / 2] + 0x0b);
         } else {
             if (destlen < pos / 2 + 1)
-                normal_error("cff","buffer overflow");
+                normal_error("cff","buffer overflow (8)");
             dest[pos / 2] = (card8) (0xb0);
         }
         pos++;
@@ -1329,7 +1313,7 @@
             dest[pos / 2] = (card8) (dest[pos / 2] + 0x0c);
         } else {
             if (destlen < pos / 2 + 1)
-                normal_error("cff","buffer overflow");
+                normal_error("cff","buffer overflow (9)");
             dest[pos / 2] = (card8) (0xc0);
         }
         e *= -1;
@@ -1351,7 +1335,7 @@
             }
 
             if (destlen < pos / 2 + 1)
-                normal_error("cff","buffer overflow");
+                normal_error("cff","buffer overflow (10)");
 
             if (pos % 2) {
                 dest[pos / 2] = (card8) (dest[pos / 2] + ch);
@@ -1367,7 +1351,7 @@
         pos++;
     } else {
         if (destlen < pos / 2 + 1)
-            normal_error("cff","buffer overflow");
+            normal_error("cff","buffer overflow (11)");
         dest[pos / 2] = (card8) (0xff);
         pos += 2;
     }
@@ -1386,10 +1370,9 @@
     /* set offset to longint */
     if (type == CFF_TYPE_OFFSET) {
         long lvalue;
-
         lvalue = (long) value;
         if (destlen < 5)
-            normal_error("cff","buffer overflow");
+            normal_error("cff","buffer overflow (12)");
         dest[0] = 29;
         dest[1] = (card8) ((lvalue >> 24) & 0xff);
         dest[2] = (card8) ((lvalue >> 16) & 0xff);
@@ -1420,16 +1403,15 @@
             type = CFF_TYPE_NUMBER;
         }
         for (i = 0; i < de->count; i++) {
-            len += cff_dict_put_number(de->values[i],
-                                       dest + len, destlen - len, type);
+            len += cff_dict_put_number(de->values[i], dest + len, destlen - len, type);
         }
         if (id >= 0 && id < CFF_LAST_DICT_OP1) {
             if (len + 1 > destlen)
-                normal_error("cff","buffer overflow");
+                normal_error("cff","buffer overflow (13)");
             dest[len++] = (card8) id;
         } else if (id >= 0 && id < CFF_LAST_DICT_OP) {
             if (len + 2 > destlen)
-                normal_error("cff","buffer overflow");
+                normal_error("cff","buffer overflow (14)");
             dest[len++] = 12;
             dest[len++] = (card8) (id - CFF_LAST_DICT_OP1);
         } else {
@@ -1461,7 +1443,6 @@
     return len;
 }
 
-
 @ @c
 void cff_dict_add(cff_dict * dict, const char *key, int count)
 {
@@ -1506,7 +1487,6 @@
     return;
 }
 
-
 @ @c
 void cff_dict_remove(cff_dict * dict, const char *key)
 {
@@ -1593,13 +1573,11 @@
     return -1;
 }
 
-
 @ @c
 void cff_update_string(cff_font * cff)
 {
     if (cff == NULL)
         normal_error("cff","CFF font not opened");
-
     if (cff->string)
         cff_release_index(cff->string);
     cff->string = cff->_string;
@@ -1606,7 +1584,6 @@
     cff->_string = NULL;
 }
 
-
 @ @c
 s_SID cff_add_string(cff_font * cff, const char *str)
 {
@@ -1613,70 +1590,64 @@
     card16 idx;
     cff_index *strings;
     l_offset offset, size;
-
-    if (cff == NULL)
+    if (cff == NULL) {
         normal_error("cff","CFF font not opened");
-
-    if (cff->_string == NULL)
+    }
+    if (cff->_string == NULL) {
         cff->_string = cff_new_index(0);
+    }
     strings = cff->_string;
-
     for (idx = 0; idx < strings->count; idx++) {
         size = strings->offset[idx + 1] - strings->offset[idx];
         offset = strings->offset[idx];
-        if (size == strlen(str) &&
-            !memcmp(strings->data + offset - 1, str, strlen(str)))
+        if (size == strlen(str) && !memcmp(strings->data + offset - 1, str, strlen(str))) {
             return (s_SID) (idx + CFF_STDSTR_MAX);
+        }
     }
-
     for (idx = 0; idx < CFF_STDSTR_MAX; idx++) {
-        if (cff_stdstr[idx] && !strcmp(cff_stdstr[idx], str))
+        if (cff_stdstr[idx] && !strcmp(cff_stdstr[idx], str)) {
             return idx;
+        }
     }
     offset = (strings->count > 0) ? strings->offset[strings->count] : 1;
-    strings->offset =
-        xrealloc(strings->offset,
-                 (unsigned) (((unsigned) strings->count +
-                              2) * sizeof(l_offset)));
+    strings->offset = xrealloc(strings->offset, (unsigned) (((unsigned) strings->count + 2) * sizeof(l_offset)));
     if (strings->count == 0)
         strings->offset[0] = 1;
     idx = strings->count;
     strings->count = (card16) (strings->count + 1);
     strings->offset[strings->count] = offset + strlen(str);
-    strings->data =
-        xrealloc(strings->data,
-                 (unsigned) ((offset + strlen(str) - 1) * sizeof(card8)));
+    strings->data = xrealloc(strings->data, (unsigned) ((offset + strlen(str) - 1) * sizeof(card8)));
     memcpy(strings->data + offset - 1, str, strlen(str));
-
     return (s_SID) (idx + CFF_STDSTR_MAX);
 }
 
-
 @ @c
 void cff_dict_update(cff_dict * dict, cff_font * cff)
 {
     int i;
-
     for (i = 0; i < dict->count; i++) {
         if ((dict->entries)[i].count > 0) {
             char *str;
             int id;
-
             id = (dict->entries)[i].id;
-
             if (dict_operator[id].argtype == CFF_TYPE_SID) {
                 str = cff_get_string(cff, (s_SID) (dict->entries)[i].values[0]);
-                (dict->entries)[i].values[0] = cff_add_string(cff, str);
-                xfree(str);
+                if (str != NULL) {
+                    (dict->entries)[i].values[0] = cff_add_string(cff, str);
+                    xfree(str);
+                }
             } else if (dict_operator[id].argtype == CFF_TYPE_ROS) {
                 str = cff_get_string(cff, (s_SID) (dict->entries)[i].values[0]);
-                (dict->entries)[i].values[0] = cff_add_string(cff, str);
-                xfree(str);
+                if (str != NULL) {
+                    (dict->entries)[i].values[0] = cff_add_string(cff, str);
+                    xfree(str);
+                }
                 str = cff_get_string(cff, (s_SID) (dict->entries)[i].values[1]);
-                (dict->entries)[i].values[1] = cff_add_string(cff, str);
-                xfree(str);
+                if (str != NULL) {
+                    (dict->entries)[i].values[1] = cff_add_string(cff, str);
+                    xfree(str);
+                }
             }
-
         }
     }
 }
@@ -1775,7 +1746,6 @@
     }
 
     if (count > 0) {
-        /* fprintf(stdout, "count=%d\n", count); */
         normal_warning("cff","charset data possibly broken (too many glyphs)");
     }
 
@@ -1793,7 +1763,7 @@
         return 0;
 
     if (destlen < 1)
-        normal_error("cff","buffer overflow");
+        normal_error("cff","buffer overflow (15)");
 
     charset = cff->charsets;
 
@@ -1801,7 +1771,7 @@
     switch (charset->format) {
     case 0:
         if (destlen < len + (charset->num_entries) * 2)
-            normal_error("cff","buffer overflow");
+            normal_error("cff","buffer overflow (16)");
         for (i = 0; i < (charset->num_entries); i++) {
             s_SID sid = (charset->data).glyphs[i];      /* or CID */
             dest[len++] = (card8) ((sid >> 8) & 0xff);
@@ -1811,10 +1781,9 @@
     case 1:
         {
             if (destlen < len + (charset->num_entries) * 3)
-                normal_error("cff","buffer overflow");
+                normal_error("cff","buffer overflow (17)");
             for (i = 0; i < (charset->num_entries); i++) {
-                dest[len++] =
-                    (card8) (((charset->data).range1[i].first >> 8) & 0xff);
+                dest[len++] = (card8) (((charset->data).range1[i].first >> 8) & 0xff);
                 dest[len++] = (card8) ((charset->data).range1[i].first & 0xff);
                 dest[len++] = (card8) ((charset->data).range1[i].n_left);
             }
@@ -1823,13 +1792,11 @@
     case 2:
         {
             if (destlen < len + (charset->num_entries) * 4)
-                normal_error("cff","buffer overflow");
+                normal_error("cff","buffer overflow (18)");
             for (i = 0; i < (charset->num_entries); i++) {
-                dest[len++] =
-                    (card8) (((charset->data).range2[i].first >> 8) & 0xff);
+                dest[len++] = (card8) (((charset->data).range2[i].first >> 8) & 0xff);
                 dest[len++] = (card8) ((charset->data).range2[i].first & 0xff);
-                dest[len++] =
-                    (card8) (((charset->data).range2[i].n_left >> 8) & 0xff);
+                dest[len++] = (card8) (((charset->data).range2[i].n_left >> 8) & 0xff);
                 dest[len++] = (card8) ((charset->data).range2[i].n_left & 0xff);
             }
         }
@@ -1869,7 +1836,6 @@
 How pseudo-random sequences are generated is not documented in the Type 2
 charstring spec..
 
-
 @c
 #define CS_TYPE2_DEBUG_STR "Type2 Charstring Parser"
 #define CS_TYPE2_DEBUG     5
@@ -1900,10 +1866,9 @@
 static int have_width = 0;
 static double width = 0.0;
 
-@
- Standard Encoding Accented Characters:
- Optional four arguments for endchar. See, CFF spec., p.35.
-  This is obsolete feature and is no longer supported.
+@ Standard Encoding Accented Characters: Optional four arguments for
+endchar. See, CFF spec., p.35. This is obsolete feature and is no longer
+supported.
 @c
 #if 0
 /* adx ady bchar achar endchar */
@@ -1920,7 +1885,7 @@
 @c
 
 /*
- 1-byte CharString operaotrs:
+ 1-byte CharString operators:
  |cs_escape| is first byte of two-byte operator
 */
 
@@ -1939,8 +1904,8 @@
 #define cs_escape     12
 /*      |cs_hsbw|       13 : TYPE1 */
 #define cs_endchar    14
-/*      RESERVED      15 */
-/*      RESERVED      16 */
+#define cs_setvsindex 15
+#define cs_blend      16
 /*      RESERVED      17 */
 #define cs_hstemhm    18
 #define cs_hintmask   19
@@ -2001,8 +1966,7 @@
 #define cs_hflex1     36
 #define cs_flex1      37
 
-@
-|clear_stack()| put all operands sotred in operand stack to dest.
+@ |clear_stack()| put all operands sotred in operand stack to dest.
 @c
 static void clear_stack(card8 ** dest, card8 * limit)
 {
@@ -2016,18 +1980,18 @@
         ivalue = (long) floor(value + 0.5);
         if (value >= 0x8000L || value <= (-0x8000L - 1)) {
             /*
-             This number cannot be represented as a single operand.
-             We must use `a b mul ...' or `a c div' to represent large values.
-             */
+                This number cannot be represented as a single operand. We must
+                use `a b mul ...' or `a c div' to represent large values.
+            */
             normal_error("cff","argument value too large (this is bug)");
         } else if (fabs(value - (double) ivalue) > 3.0e-5) {
             /* 16.16-bit signed fixed value  */
             DST_NEED(limit, *dest + 5);
             *(*dest)++ = 255;
-            ivalue = (long) floor(value);       /* mantissa */
+            ivalue = (long) floor(value); /* mantissa */
             *(*dest)++ = (card8) ((ivalue >> 8) & 0xff);
             *(*dest)++ = (card8) (ivalue & 0xff);
-            ivalue = (long) ((value - (double) ivalue) * 0x10000l);     /* fraction */
+            ivalue = (long) ((value - (double) ivalue) * 0x10000l); /* fraction */
             *(*dest)++ = (card8) ((ivalue >> 8) & 0xff);
             *(*dest)++ = (card8) (ivalue & 0xff);
             /* Everything else are integers. */
@@ -2044,7 +2008,8 @@
             ivalue = (long) 0xfb00u - ivalue - 108;
             *(*dest)++ = (card8) ((ivalue >> 8) & 0xff);
             *(*dest)++ = (card8) (ivalue & 0xff);
-        } else if (ivalue >= -32768 && ivalue <= 32767) {       /* shortint */
+        } else if (ivalue >= -32768 && ivalue <= 32767) {
+            /* shortint */
             DST_NEED(limit, *dest + 3);
             *(*dest)++ = 28;
             *(*dest)++ = (card8) ((ivalue >> 8) & 0xff);
@@ -2053,24 +2018,25 @@
             normal_error("cff","unexpected error");
         }
     }
-
-    cs2_stack_top = 0;          /* clear stack */
-
+    cs2_stack_top = 0; /* clear stack */
     return;
 }
 
-@
- Single byte operators:
-  Path construction, Operator for finishing a path, Hint operators.
+@ Single byte operators: Path construction, Operator for finishing a
+path, Hint operators. Phases:
 
- phase:
- \item 0: inital state
- \item 1: hint declaration, first stack-clearing operator appeared
- \item 2: in path construction
+\item 0: inital state
+\item 1: hint declaration, first stack-clearing operator appeared
+\item 2: in path construction
 
 @c
-static void
-do_operator1(card8 ** dest, card8 * limit, card8 ** data, card8 * endptr)
+/*
+static int vsindex = 0;
+static int blends  = 0;
+static int regions = 5;
+*/
+
+static void do_operator1(card8 ** dest, card8 * limit, card8 ** data, card8 * endptr)
 {
     card8 op = **data;
 
@@ -2151,7 +2117,24 @@
         *(*dest)++ = op;
         status = CS_CHAR_END;
         break;
-        /* above oprators are candidate for first stack-clearing operator */
+        /* above operators are candidate for first stack-clearing operator */
+    case cs_setvsindex:
+        /*
+        vsindex = cs2_arg_stack[cs2_stack_top-1];
+        cs2_stack_top -= 1;
+        */
+        normal_warning("cff2","unsupported setvindex operator");
+        status = CS_PARSE_CFF_ERROR;
+        break;
+    case cs_blend:
+        /*
+        blends = cs2_arg_stack[cs2_stack_top-1];
+        cs2_stack_top -= 1;
+        cs2_stack_top -= blends * regions ;
+        */
+        normal_warning("cff2","unsupported blend operator");
+        status = CS_PARSE_CFF_ERROR;
+        break;
     case cs_rlineto:
     case cs_hlineto:
     case cs_vlineto:
@@ -2184,20 +2167,14 @@
         status = CS_PARSE_CFF_ERROR;
         break;
     }
-
     return;
 }
 
-@
- Double byte operators:
- Flex, arithmetic, conditional, and storage operators.
+@ Double byte operators: Flex, arithmetic, conditional, and storage operators.
+The following operators are not supported: random: How random ?
 
- Following operators are not supported:
-   random: How random ?
-
 @c
-static void
-do_operator2(card8 ** dest, card8 * limit, card8 ** data, card8 * endptr)
+static void do_operator2(card8 ** dest, card8 * limit, card8 ** data, card8 * endptr)
 {
     card8 op;
 
@@ -2398,13 +2375,10 @@
         status = CS_PARSE_CFF_ERROR;
         break;
     }
-
     return;
 }
 
-@
- integer:
-  exactly the same as the DICT encoding (except 29)
+@ integer: exactly the same as the DICT encoding (except 29)
 @c
 static void cs2_get_integer(card8 ** data, card8 * endptr)
 {
@@ -2437,15 +2411,12 @@
         status = CS_PARSE_CFF_ERROR;
         return;
     }
-
     NEED(CS_ARG_STACK_MAX, cs2_stack_top + 1);
     cs2_arg_stack[cs2_stack_top++] = (double) result;
-
     return;
 }
 
-@
-Signed 16.16-bits fixed number for Type 2 charstring encoding
+@ Signed 16.16-bits fixed number for Type 2 charstring encoding
 @c
 static void get_fixed(card8 ** data, card8 * endptr)
 {
@@ -2468,14 +2439,13 @@
     return;
 }
 
-@
- Subroutines:
-  The bias for subroutine number is introduced in type 2 charstrings.
+@ Subroutines: the bias for subroutine number is introduced in type 2
+charstrings.
 
-  subr:     set to a pointer to the subroutine charstring.
-  len:      set to the length of subroutine charstring.
-  |subr_idx|: CFF INDEX data that contains subroutines.
-  id:       biased subroutine number.
+\item subr:       set to a pointer to the subroutine charstring.
+\item len:        set to the length of subroutine charstring.
+\item |subr_idx|: CFF INDEX data that contains subroutines.
+\item id:         biased subroutine number.
 
 @c
 static void get_subr(card8 ** subr, long *len, cff_index * subr_idx, long id)
@@ -2505,17 +2475,14 @@
     return;
 }
 
+@ The Type 2 interpretation of a number encoded in five-bytes (those with
+an initial byte value of 255) differs from how it is interpreted in the
+Type 1 format.
 
-@ NOTE:
- The Type 2 interpretation of a number encoded in five-bytes (those with
- an initial byte value of 255) differs from how it is interpreted in the
- Type 1 format.
-
 @c
-static void
-do_charstring(card8 ** dest, card8 * limit,
-              card8 ** data, card8 * endptr,
-              cff_index * gsubr_idx, cff_index * subr_idx)
+static void do_charstring(card8 ** dest, card8 * limit,
+      card8 ** data, card8 * endptr,
+      cff_index * gsubr_idx, cff_index * subr_idx, int cff2)
 {
     card8 b0 = 0, *subr;
     long len;
@@ -2539,8 +2506,8 @@
                 get_subr(&subr, &len, gsubr_idx,
                          (long) cs2_arg_stack[cs2_stack_top]);
                 if (*dest + len > limit)
-                    formatted_error("cff","%s: possible buffer overflow", CS_TYPE2_DEBUG_STR);
-                do_charstring(dest, limit, &subr, subr + len, gsubr_idx, subr_idx);
+                    formatted_error("cff","%s: possible buffer overflow (1)", CS_TYPE2_DEBUG_STR);
+                do_charstring(dest, limit, &subr, subr + len, gsubr_idx, subr_idx, cff2);
                 *data += 1;
             }
         } else if (b0 == cs_callsubr) {
@@ -2551,8 +2518,8 @@
                 get_subr(&subr, &len, subr_idx,
                          (long) cs2_arg_stack[cs2_stack_top]);
                 if (limit < *dest + len)
-                    formatted_error("cff","%s: possible buffer overflow", CS_TYPE2_DEBUG_STR);
-                do_charstring(dest, limit, &subr, subr + len, gsubr_idx, subr_idx);
+                    formatted_error("cff","%s: possible buffer overflow (2)", CS_TYPE2_DEBUG_STR);
+                do_charstring(dest, limit, &subr, subr + len, gsubr_idx, subr_idx, cff2);
                 *data += 1;
             }
         } else if (b0 == cs_escape) {
@@ -2566,7 +2533,12 @@
         }
     }
 
-    if (status == CS_SUBR_RETURN) {
+    if (cff2) {
+        DST_NEED(limit, *dest + 1);
+        ++endptr;
+        *(*dest)++ = cs_endchar;
+        /* no return and endchar */
+    } else if (status == CS_SUBR_RETURN) {
         status = CS_PARSE_OK;
     } else if (status == CS_CHAR_END && *data < endptr) {
         formatted_warning("cff","%s: garbage after endchar", CS_TYPE2_DEBUG_STR);
@@ -2589,14 +2561,11 @@
     cs2_stack_top = 0;
 }
 
-
 @ Not just copying...
 @c
-long
-cs_copy_charstring(card8 * dst, long dstlen,
-                   card8 * src, long srclen,
-                   cff_index * gsubr, cff_index * subr,
-                   double default_width, double nominal_width, cs_ginfo * ginfo)
+static long cs_copy_charstring(card8 * dst, long dstlen, card8 * src, long srclen,
+       cff_index * gsubr, cff_index * subr, double default_width,
+       double nominal_width, cs_ginfo * ginfo, int cff2)
 {
     card8 *save = dst;
 
@@ -2606,7 +2575,7 @@
     have_width = 0;
 
     /* expand call(g)subrs */
-    do_charstring(&dst, dst + dstlen, &src, src + srclen, gsubr, subr);
+    do_charstring(&dst, dst + dstlen, &src, src + srclen, gsubr, subr, cff2);
 
     if (ginfo) {
         ginfo->flags = 0;       /* not used */
@@ -2622,10 +2591,8 @@
 
 @* encodings.
 
-@ Encoding and Charset
+@ Encoding and Charset arrays always begin with GID = 1.
 
-Encoding and Charset arrays always begin with GID = 1.
-
 @c
 long cff_read_encoding(cff_font * cff)
 {
@@ -2686,7 +2653,6 @@
         normal_error("cff","unknown encoding format");
         break;
     }
-
     /* Supplementary data */
     if ((encoding->format) & 0x80) {
         cff_map *map;
@@ -2716,7 +2682,7 @@
         return 0;
 
     if (destlen < 2)
-        normal_error("cff","buffer overflow");
+        normal_error("cff","buffer overflow (19)");
 
     encoding = cff->encoding;
 
@@ -2725,7 +2691,7 @@
     switch (encoding->format & (~0x80)) {
     case 0:
         if (destlen < len + encoding->num_entries)
-            normal_error("cff","buffer overflow");
+            normal_error("cff","buffer overflow (20)");
         for (i = 0; i < (encoding->num_entries); i++) {
             dest[len++] = (encoding->data).codes[i];
         }
@@ -2733,7 +2699,7 @@
     case 1:
         {
             if (destlen < len + (encoding->num_entries) * 2)
-                normal_error("cff","buffer overflow");
+                normal_error("cff","buffer overflow (21)");
             for (i = 0; i < (encoding->num_entries); i++) {
                 dest[len++] = (card8) ((encoding->data).range1[i].first & 0xff);
                 dest[len++] = (card8) ((encoding->data).range1[i].n_left);
@@ -2747,7 +2713,7 @@
 
     if ((encoding->format) & 0x80) {
         if (destlen < len + (encoding->num_supps) * 3 + 1)
-            normal_error("cff","buffer overflow");
+            normal_error("cff","buffer overflow (22)");
         dest[len++] = encoding->num_supps;
         for (i = 0; i < (encoding->num_supps); i++) {
             dest[len++] = (card8) ((encoding->supp)[i].code);
@@ -2815,7 +2781,6 @@
     return length;
 }
 
-
 @ @c
 long cff_pack_fdselect(cff_font * cff, card8 * dest, long destlen)
 {
@@ -2827,7 +2792,7 @@
         return 0;
 
     if (destlen < 1)
-        normal_error("cff","buffer overflow");
+        normal_error("cff","buffer overflow (23)");
 
     fdsel = cff->fdselect;
 
@@ -2837,7 +2802,7 @@
         if (fdsel->num_entries != cff->num_glyphs)
             normal_error("cff","invalid data");
         if (destlen < len + fdsel->num_entries)
-            normal_error("cff","buffer overflow");
+            normal_error("cff","buffer overflow (24)");
         for (i = 0; i < fdsel->num_entries; i++) {
             dest[len++] = (fdsel->data).fds[i];
         }
@@ -2845,11 +2810,11 @@
     case 3:
         {
             if (destlen < len + 2)
-                normal_error("cff","buffer overflow");
+                normal_error("cff","buffer overflow (25)");
             len += 2;
             for (i = 0; i < (fdsel->num_entries); i++) {
                 if (destlen < len + 3)
-                    normal_error("cff","buffer overflow");
+                    normal_error("cff","buffer overflow (26)");
                 dest[len++] =
                     (card8) (((fdsel->data).ranges[i].first >> 8) & 0xff);
                 dest[len++] = (card8) ((fdsel->data).ranges[i].first & 0xff);
@@ -2856,7 +2821,7 @@
                 dest[len++] = (card8) ((fdsel->data).ranges[i].fd);
             }
             if (destlen < len + 2)
-                normal_error("cff","buffer overflow");
+                normal_error("cff","buffer overflow (27)");
             dest[len++] = (card8) ((cff->num_glyphs >> 8) & 0xff);
             dest[len++] = (card8) (cff->num_glyphs & 0xff);
             dest[1] = (card8) (((len / 3 - 1) >> 8) & 0xff);
@@ -2871,8 +2836,6 @@
     return len;
 }
 
-
-
 @ Create an instance of embeddable font.
 
 @c
@@ -2892,26 +2855,23 @@
     cff_dict_remove(cffont->topdict, "XUID");
     cff_dict_remove(cffont->topdict, "Private");        /* some bad font may have */
     cff_dict_remove(cffont->topdict, "Encoding");       /* some bad font may have */
+    cff_dict_remove(cffont->topdict, "vstore");         /* cff2 */
+    cff_dict_remove(cffont->topdict, "maxstack");       /* cff2 */
 
-    topdict->offset[1] = (l_offset) cff_dict_pack(cffont->topdict,
-                                                  (card8 *) work_buffer,
-                                                  WORK_BUFFER_SIZE) + 1;
+    topdict->offset[1] = (l_offset) cff_dict_pack(cffont->topdict, (card8 *) work_buffer, WORK_BUFFER_SIZE) + 1;
     for (i = 0; i < cffont->num_fds; i++) {
         size = 0;
         if (cffont->private && cffont->private[i]) {
-            size = cff_dict_pack(cffont->private[i],
-                                 (card8 *) work_buffer, WORK_BUFFER_SIZE);
-            if (size < 1) {     /* Private had contained only Subr */
+            size = cff_dict_pack(cffont->private[i], (card8 *) work_buffer, WORK_BUFFER_SIZE);
+            if (size < 1) {
+                /* Private had contained only Subr. */
                 cff_dict_remove(cffont->fdarray[i], "Private");
             }
         }
-        (private->offset)[i + 1] =
-            (unsigned long) ((private->offset)[i] + (unsigned) size);
-        (fdarray->offset)[i + 1] =
-            (unsigned long) ((fdarray->offset)[i] + (unsigned)
-                             cff_dict_pack(cffont->fdarray[i],
-                                           (card8 *) work_buffer,
-                                           WORK_BUFFER_SIZE));
+        (private->offset)[i + 1] = (unsigned long) ((private->offset)[i]
+            + (unsigned) size);
+        (fdarray->offset)[i + 1] = (unsigned long) ((fdarray->offset)[i]
+            + (unsigned) cff_dict_pack(cffont->fdarray[i], (card8 *) work_buffer, WORK_BUFFER_SIZE));
     }
 
     destlen = 4;                /* header size */
@@ -2924,7 +2884,6 @@
     destlen += cff_index_size(cffont->cstrings);
     destlen += cff_index_size(fdarray);
     destlen = (long) (destlen + (long) private->offset[private->count] - 1);    /* Private is not INDEX */
-
     dest = xcalloc((unsigned) destlen, sizeof(card8));
 
     offset = 0;
@@ -2939,30 +2898,23 @@
     offset += cff_pack_index(cffont->string, dest + offset, destlen - offset);
     /* Global Subrs */
     offset += cff_pack_index(cffont->gsubr, dest + offset, destlen - offset);
-
     /* charset */
     cff_dict_set(cffont->topdict, "charset", 0, (double) offset);
     offset += cff_pack_charsets(cffont, dest + offset, destlen - offset);
-
     /* FDSelect */
     cff_dict_set(cffont->topdict, "FDSelect", 0, (double) offset);
     offset += cff_pack_fdselect(cffont, dest + offset, destlen - offset);
-
     /* CharStrings */
     cff_dict_set(cffont->topdict, "CharStrings", 0, (double) offset);
-    offset += cff_pack_index(cffont->cstrings,
-                             dest + offset, cff_index_size(cffont->cstrings));
+    offset += cff_pack_index(cffont->cstrings, dest + offset, cff_index_size(cffont->cstrings));
     cff_release_index(cffont->cstrings);
     cffont->cstrings = NULL;    /* Charstrings cosumes huge memory */
-
     /* FDArray and Private */
     cff_dict_set(cffont->topdict, "FDArray", 0, (double) offset);
     fdarray_offset = offset;
     offset += cff_index_size(fdarray);
 
-    fdarray->data =
-        xcalloc((unsigned) (fdarray->offset[fdarray->count] - 1),
-                sizeof(card8));
+    fdarray->data = xcalloc((unsigned) (fdarray->offset[fdarray->count] - 1), sizeof(card8));
     for (i = 0; i < cffont->num_fds; i++) {
         size = (long) (private->offset[i + 1] - private->offset[i]);
         if (cffont->private[i] && size > 0) {
@@ -2970,56 +2922,27 @@
             cff_dict_set(cffont->fdarray[i], "Private", 0, (double) size);
             cff_dict_set(cffont->fdarray[i], "Private", 1, (double) offset);
         }
-        cff_dict_pack(cffont->fdarray[i],
-                      fdarray->data + (fdarray->offset)[i] - 1,
-                      (long) (fdarray->offset[fdarray->count] - 1));
+        cff_dict_pack(cffont->fdarray[i], fdarray->data + (fdarray->offset)[i] - 1, (long) (fdarray->offset[fdarray->count] - 1));
         offset += size;
     }
-
     cff_pack_index(fdarray, dest + fdarray_offset, cff_index_size(fdarray));
     cff_release_index(fdarray);
     cff_release_index(private);
 
     /* Finally Top DICT */
-    topdict->data =
-        xcalloc((unsigned) (topdict->offset[topdict->count] - 1),
-                sizeof(card8));
-    cff_dict_pack(cffont->topdict, topdict->data,
-                  (long) (topdict->offset[topdict->count] - 1));
+    topdict->data = xcalloc((unsigned) (topdict->offset[topdict->count] - 1), sizeof(card8));
+    cff_dict_pack(cffont->topdict, topdict->data, (long) (topdict->offset[topdict->count] - 1));
     cff_pack_index(topdict, dest + topdict_offset, cff_index_size(topdict));
     cff_release_index(topdict);
 
-    for (i = 0; i < offset; i++)
+    for (i = 0; i < offset; i++) {
+// printf("%i\n",(unsigned char)dest[i]);
         strbuf_putchar(pdf->fb, dest[i]);
-
+    }
     xfree(dest);
     return;
 }
 
-
-@ this block is used a few times
- at c
-#define DO_COPY_CHARSTRING()                                                   \
-  if ((avl_find(fd->gl_tree,glyph) != NULL)) {                                 \
-      size = (long)(cs_idx->offset[code+1] - cs_idx->offset[code]);            \
-    if (size > CS_STR_LEN_MAX) {                                               \
-      formatted_error("cff","charstring too long: gid=%u, %ld bytes", code, size);   \
-    }                                                                          \
-    if (charstring_len + CS_STR_LEN_MAX >= max_len) {                          \
-	max_len = (long)(charstring_len + 2 * CS_STR_LEN_MAX);		\
-	charstrings->data = xrealloc(charstrings->data, (unsigned)((unsigned)max_len*sizeof(card8))); \
-    }                                                                          \
-    (charstrings->offset)[gid] = (unsigned)(charstring_len + 1);	\
-    cffont->offset= (l_offset)((unsigned)offset + (cs_idx->offset)[code] - 1);	\
-    memcpy(data,&cffont->stream[cffont->offset],(size_t)size);		\
-    charstring_len += cs_copy_charstring(charstrings->data + charstring_len,   \
-                                         max_len - charstring_len,	\
-                                         data, size,                           \
-                                         cffont->gsubr, (cffont->subrs)[0],    \
-                                         default_width, nominal_width, NULL);  \
-    gid++;                                                                     \
-  }
-
 @ @c
 void write_cff(PDF pdf, cff_font * cffont, fd_entry * fd)
 {
@@ -3033,11 +2956,17 @@
 
     double nominal_width, default_width;
 
+    char *fontname;
     char *fullname;
 
     glw_entry *glyph, *found;
     struct avl_traverser t;
 
+cffont->_string = NULL;
+
+    fontname = xcalloc((unsigned) (1 + strlen(fd->fontname)), 1);
+    sprintf(fontname, "%s", fd->fontname);
+
     fullname = xcalloc((unsigned) (8 + strlen(fd->fontname)), 1);
     sprintf(fullname, "%s+%s", fd->subset_tag, fd->fontname);
 
@@ -3045,20 +2974,14 @@
     cff_read_private(cffont);
     cff_read_subrs(cffont);
 
-    /*
-     Widths
-     */
-    if (cffont->private[0] &&
-        cff_dict_known(cffont->private[0], "defaultWidthX")) {
-        default_width =
-            (double) cff_dict_get(cffont->private[0], "defaultWidthX", 0);
+    /* Widths */
+    if (cffont->private[0] && cff_dict_known(cffont->private[0], "defaultWidthX")) {
+        default_width = (double) cff_dict_get(cffont->private[0], "defaultWidthX", 0);
     } else {
         default_width = CFF_DEFAULTWIDTHX_DEFAULT;
     }
-    if (cffont->private[0] &&
-        cff_dict_known(cffont->private[0], "nominalWidthX")) {
-        nominal_width =
-            (double) cff_dict_get(cffont->private[0], "nominalWidthX", 0);
+    if (cffont->private[0] && cff_dict_known(cffont->private[0], "nominalWidthX")) {
+        nominal_width = (double) cff_dict_get(cffont->private[0], "nominalWidthX", 0);
     } else {
         nominal_width = CFF_NOMINALWIDTHX_DEFAULT;
     }
@@ -3113,15 +3036,31 @@
             }
         }
         cffont->charsets = charset;
+
+        if (cffont->header_major == 2) {
+            cff_dict_add(cffont->topdict, "charset", 1);
+        }
     }
-
     cff_dict_add(cffont->topdict, "CIDCount", 1);
     cff_dict_set(cffont->topdict, "CIDCount", 0, last_cid + 1);
 
+    if (cffont->header_major == 2) {
+
+        cff_dict_add(cffont->topdict, "FullName", 1);
+        cff_dict_set(cffont->topdict, "FullName", 0, (double) cff_add_string(cffont, fontname));
+
+        cff_dict_add(cffont->topdict, "FontBBox", 4);
+        cff_dict_set(cffont->topdict, "FontBBox", 0, fd->font_dim[FONTBBOX1_CODE].val);
+        cff_dict_set(cffont->topdict, "FontBBox", 1, fd->font_dim[FONTBBOX2_CODE].val);
+        cff_dict_set(cffont->topdict, "FontBBox", 2, fd->font_dim[FONTBBOX3_CODE].val);
+        cff_dict_set(cffont->topdict, "FontBBox", 3, fd->font_dim[FONTBBOX4_CODE].val);
+    }
+
     cffont->fdarray = xcalloc(1, sizeof(cff_dict *));
     cffont->fdarray[0] = cff_new_dict();
     cff_dict_add(cffont->fdarray[0], "FontName", 1);
-    cff_dict_set(cffont->fdarray[0], "FontName", 0, (double) cff_add_string(cffont, fullname)); /* FIXME: Skip XXXXXX+ */
+    /* FIXME: Skip XXXXXX+ */
+    cff_dict_set(cffont->fdarray[0], "FontName", 0, (double) cff_add_string(cffont, fullname));
     cff_dict_add(cffont->fdarray[0], "Private", 2);
     cff_dict_set(cffont->fdarray[0], "Private", 0, 0.0);
     cff_dict_set(cffont->fdarray[0], "Private", 0, 0.0);
@@ -3157,40 +3096,89 @@
 
     {
         int i;
+        int tex_font = fd->tex_font;
+        int streamprovider = 0;
+        int callback_id = 0 ;
+        if ((tex_font > 0) && (font_streamprovider(tex_font) == 1)) {
+            streamprovider = font_streamprovider(tex_font);
+            callback_id = callback_defined(glyph_stream_provider_callback);
+        }
         for (i = 0; i < cs_count1; i++) {
             code = (card16) i;
             glyph->id = code;
-            DO_COPY_CHARSTRING();
+            if ((avl_find(fd->gl_tree,glyph) != NULL)) {
+                /* this code is the same as below, apart from small details */
+                if (callback_id > 0) {
+                    lstring * result;
+                    run_callback(callback_id, "ddd->L", tex_font, i, streamprovider, &result); /* this call can be sped up */
+                    size = (size_t) result->l ;
+                    if (size > 0) {
+                        if (charstring_len + CS_STR_LEN_MAX >= max_len) {
+                            max_len = (long)(charstring_len + 2 * CS_STR_LEN_MAX);
+                            charstrings->data = xrealloc(charstrings->data, (unsigned)((unsigned)max_len*sizeof(card8)));
+                        }
+                        (charstrings->offset)[gid] = (unsigned)(charstring_len + 1);
+                cffont->offset = (l_offset)((unsigned)offset + (cs_idx->offset)[code] - 1);
+                        memcpy(charstrings->data+charstring_len,(const char *) result->s,(size_t) size);
+                        charstring_len += size;
+                        xfree(result);
+                    }
+                } else {
+                    size = (long)(cs_idx->offset[code+1] - cs_idx->offset[code]);
+                    if (size > CS_STR_LEN_MAX) {
+                        formatted_error("cff","charstring too long: gid=%u, %ld bytes", code, size);
+                    }
+                    if (charstring_len + CS_STR_LEN_MAX >= max_len) {
+                        max_len = (long)(charstring_len + 2 * CS_STR_LEN_MAX);
+                        charstrings->data = xrealloc(charstrings->data, (unsigned)((unsigned)max_len*sizeof(card8)));
+                    }
+                    (charstrings->offset)[gid] = (unsigned)(charstring_len + 1);
+                    cffont->offset = (l_offset)((unsigned)offset + (cs_idx->offset)[code] - 1);
+                    memcpy(data,&cffont->stream[cffont->offset],(size_t)size);
+                    charstring_len += cs_copy_charstring(
+                        charstrings->data + charstring_len,
+                        max_len - charstring_len,
+                        data, size,
+                        cffont->gsubr, (cffont->subrs)[0],
+                        default_width, nominal_width, NULL,
+                        cffont->header_major == 2
+                    );
+                }
+                gid++;
+            }
         }
     }
-
-    /* CIDSet: a table of bits indexed by cid, bytes with high order bit first,
-       each (set) bit is a (present) CID. */
+    /*
+        CIDSet: a table of bits indexed by cid, bytes with high order bit first,
+        each (set) bit is a (present) CID.
+    */
     if (1) {
-      int cid;
-      cidset = pdf_create_obj(pdf, obj_type_others, 0);
-      if (cidset != 0) {
-       size_t l = (last_cid/8)+1;
-       char *stream = xmalloc(l);
-       memset(stream, 0, l);
-       for (cid = 1; cid <= (long) last_cid; cid++) {
-           glyph->id = cid;
-           if (avl_find(fd->gl_tree,glyph) != NULL) {
-	      stream[(cid / 8)] |= (1 << (7 - (cid % 8)));
-           }
-       }
-       pdf_begin_obj(pdf, cidset, OBJSTM_NEVER);
-       pdf_begin_dict(pdf);
-       pdf_dict_add_streaminfo(pdf);
-       pdf_end_dict(pdf);
-       pdf_begin_stream(pdf);
-       pdf_out_block(pdf, stream, l);
-       pdf_end_stream(pdf);
-       pdf_end_obj(pdf);
-      }
+        int cid;
+        cidset = pdf_create_obj(pdf, obj_type_others, 0);
+        if (cidset != 0) {
+            size_t l = (last_cid/8)+1;
+            char *stream = xmalloc(l);
+            memset(stream, 0, l);
+            for (cid = 1; cid <= (long) last_cid; cid++) {
+                glyph->id = cid;
+                if (avl_find(fd->gl_tree,glyph) != NULL) {
+                    stream[(cid / 8)] |= (1 << (7 - (cid % 8)));
+                }
+            }
+            pdf_begin_obj(pdf, cidset, OBJSTM_NEVER);
+            pdf_begin_dict(pdf);
+            pdf_dict_add_streaminfo(pdf);
+            pdf_end_dict(pdf);
+            pdf_begin_stream(pdf);
+            pdf_out_block(pdf, stream, l);
+            pdf_end_stream(pdf);
+            pdf_end_obj(pdf);
+        }
     }
-
-    /* this happens if the internal metrics do not agree with the actual disk font */
+    /*
+        This happens if the internal metrics do not agree with the actual
+        disk font.
+    */
     if (gid < num_glyphs) {
         formatted_warning("cff","embedded subset is smaller than expected: %d instead of %d glyphs", gid, num_glyphs);
         num_glyphs = gid;
@@ -3203,10 +3191,9 @@
     charstrings->count = num_glyphs;
     cffont->num_glyphs = num_glyphs;
     cffont->cstrings = charstrings;
-
     /*
-     We don't use subroutines at all.
-     */
+        We don't use subroutines at all.
+    */
     if (cffont->gsubr)
         cff_release_index(cffont->gsubr);
     cffont->gsubr = cff_new_index(0);
@@ -3219,33 +3206,34 @@
         cff_dict_remove((cffont->private)[0], "Subrs"); /* no Subrs */
     }
 
+    cff_dict_update(cffont->topdict, cffont);
+
     cff_add_string(cffont, "Adobe");
     cff_add_string(cffont, "Identity");
-
-    cff_dict_update(cffont->topdict, cffont);
-    cff_dict_update(cffont->private[0], cffont);
+    if (cffont->header_major == 2) {
+        /* crash */
+    } else {
+        cff_dict_update(cffont->private[0], cffont);
+    }
     cff_update_string(cffont);
 
-    /* CFF code need to be rewrote... */
+    /* CFF code need to be rewritten */
     cff_dict_add(cffont->topdict, "ROS", 3);
-    cff_dict_set(cffont->topdict, "ROS", 0,
-                 (double) cff_get_sid(cffont, "Adobe"));
-    cff_dict_set(cffont->topdict, "ROS", 1,
-                 (double) cff_get_sid(cffont, "Identity"));
+    cff_dict_set(cffont->topdict, "ROS", 0, (double) cff_get_sid(cffont, "Adobe"));
+    cff_dict_set(cffont->topdict, "ROS", 1, (double) cff_get_sid(cffont, "Identity"));
     cff_dict_set(cffont->topdict, "ROS", 2, 0.0);
 
     write_fontfile(pdf, cffont, fullname);
+    xfree(fontname);
     xfree(fullname);
     cff_close(cffont);
-
 }
 
 @ @c
-#undef ERROR                    /* for mingw */
+#undef ERROR /* for mingw */
 #define ERROR(a) { perror(a); return 0; }
 
-@ Input : SID or CID (16-bit unsigned int)
- Output: glyph index
+@ Input : SID or CID (16-bit unsigned int) Output: glyph index
 
 @c
 card16 cff_charsets_lookup(cff_font * cff, card16 cid)
@@ -3279,9 +3267,7 @@
     case 1:
         for (i = 0; i < charset->num_entries; i++) {
             if (cid >= charset->data.range1[i].first &&
-                cid <=
-                charset->data.range1[i].first +
-                charset->data.range1[i].n_left) {
+                cid <= charset->data.range1[i].first + charset->data.range1[i].n_left) {
                 gid = (card16) (gid + cid - charset->data.range1[i].first + 1);
                 return gid;
             }
@@ -3291,9 +3277,7 @@
     case 2:
         for (i = 0; i < charset->num_entries; i++) {
             if (cid >= charset->data.range2[i].first &&
-                cid <=
-                charset->data.range2[i].first +
-                charset->data.range2[i].n_left) {
+                cid <= charset->data.range2[i].first + charset->data.range2[i].n_left) {
                 gid = (card16) (gid + cid - charset->data.range2[i].first + 1);
                 return gid;
             }
@@ -3307,10 +3291,10 @@
     return 0;                   /* not found */
 }
 
-
 @ @c
 #define is_cidfont(a) ((a)->flag & FONTTYPE_CIDFONT)
 #define CID_MAX 65535
+
 void write_cid_cff(PDF pdf, cff_font * cffont, fd_entry * fd)
 {
     cff_index *charstrings, *cs_idx;
@@ -3317,12 +3301,14 @@
 
     long charstring_len, max_len;
     long size, offset = 0;
+    int tex_font = fd->tex_font;
+    int streamprovider = 0;
+    int callback_id = 0 ;
 
     card8 *data;
     card16 num_glyphs, cs_count1, gid, last_cid;
 
-
-    int fdsel, prev_fd, cid_count, cid;
+    int fdsel, prev_fd, cid_count, cid ;
     char *fullname;
 
     glw_entry *glyph;
@@ -3332,12 +3318,16 @@
     cff_fdselect *fdselect = NULL;
     cff_charsets *charset = NULL;
 
-
     if (!is_cidfont(cffont)) {
         perror("Not a CIDfont.");
         return;
     }
 
+    if ((tex_font > 0) && (font_streamprovider(tex_font) == 1)) {
+        streamprovider = font_streamprovider(tex_font);
+        callback_id = callback_defined(glyph_stream_provider_callback);
+    }
+
     fullname = xcalloc((unsigned) (8 + strlen(fd->fontname)), 1);
     sprintf(fullname, "%s+%s", fd->subset_tag, fd->fontname);
 
@@ -3348,9 +3338,12 @@
     } else {
         cid_count = CFF_CIDCOUNT_DEFAULT;
     }
-    cff_read_charsets(cffont);
-    CIDToGIDMap = xmalloc((unsigned)
-                          ((2 * (unsigned) cid_count) * sizeof(unsigned char)));
+    if (cffont->header_major == 2) {
+        /* hm */
+    } else {
+        cff_read_charsets(cffont);
+    }
+    CIDToGIDMap = xmalloc((unsigned) ((2 * (unsigned) cid_count) * sizeof(unsigned char)));
     memset(CIDToGIDMap, 0, (size_t) (2 * cid_count));
 
     glyph = xtalloc(1, glw_entry);
@@ -3376,12 +3369,15 @@
             num_glyphs++;
         }
     }
-    if (last_cid >= cffont->num_glyphs) {
+    if (cffont->header_major == 2) {
+        /* hm */
+    } else if (last_cid >= cffont->num_glyphs) {
         formatted_error("cff font","bad glyph index %i",last_cid);
     }
-
-    /* CIDSet: a table of bits indexed by cid, bytes with high order bit first,
-       each (set) bit is a (present) CID. */
+    /*
+        CIDSet: a table of bits indexed by cid, bytes with high order bit
+        first, each (set) bit is a (present) CID.
+    */
     if (1) {
         cidset = pdf_create_obj(pdf, obj_type_others, 0);
         if (cidset != 0) {
@@ -3397,7 +3393,7 @@
             pdf_begin_dict(pdf);
             pdf_dict_add_streaminfo(pdf);
             pdf_end_dict(pdf);
-	    pdf_begin_stream(pdf);
+            pdf_begin_stream(pdf);
             pdf_out_block(pdf, stream, l);
             pdf_end_stream(pdf);
             pdf_end_obj(pdf);
@@ -3405,7 +3401,6 @@
         }
     }
 
-
     cff_read_fdselect(cffont);
     cff_read_fdarray(cffont);
     cff_read_private(cffont);
@@ -3412,7 +3407,6 @@
 
     cff_read_subrs(cffont);
 
-
     cffont->offset = (l_offset) cff_dict_get(cffont->topdict, "CharStrings", 0);
     cs_idx = cff_get_index_header(cffont);
 
@@ -3447,31 +3441,46 @@
         if (avl_find(fd->gl_tree, glyph) == NULL)
             continue;
 
-        gid_org =
-            (short unsigned) ((CIDToGIDMap[2 * cid] << 8) |
-                              (CIDToGIDMap[2 * cid + 1]));
-        size = (long) (cs_idx->offset[gid_org + 1] - cs_idx->offset[gid_org]);
-        if (size > CS_STR_LEN_MAX) {
-            formatted_error("cff","charstring too long: gid=%u, %ld bytes", cid, size);
-        }
-        if (charstring_len + CS_STR_LEN_MAX >= max_len) {
-            max_len = charstring_len + 2 * CS_STR_LEN_MAX;
-            charstrings->data =
-                xrealloc(charstrings->data,
-                         (unsigned) ((unsigned) max_len * sizeof(card8)));
-        }
-        (charstrings->offset)[gid] = (l_offset) (charstring_len + 1);
-        cffont->offset =
-            (l_offset) ((unsigned) offset + (cs_idx->offset)[gid_org] - 1);
-        memcpy(data, &cffont->stream[cffont->offset], (size_t) size);
+        gid_org = (short unsigned) ((CIDToGIDMap[2 * cid] << 8) | (CIDToGIDMap[2 * cid + 1]));
         fdsel = cff_fdselect_lookup(cffont, gid_org);
-        charstring_len += cs_copy_charstring(charstrings->data + charstring_len,
-                                             max_len - charstring_len,
-                                             data, size,
-                                             cffont->gsubr,
-                                             (cffont->subrs)[fdsel], 0, 0,
-                                             NULL);
 
+        if (callback_id > 0) {
+            /* the next blob is not yet tested ... i need a font */
+            lstring * result;
+            run_callback(callback_id, "ddd->L", tex_font, gid_org, streamprovider, &result); /* this call can be sped up */
+            size = (size_t) result->l ;
+            if (size > 0) {
+                if (charstring_len + CS_STR_LEN_MAX >= max_len) {
+                    max_len = (long)(charstring_len + 2 * CS_STR_LEN_MAX);
+                    charstrings->data = xrealloc(charstrings->data, (unsigned)((unsigned)max_len*sizeof(card8)));
+                }
+                (charstrings->offset)[gid] = (unsigned)(charstring_len + 1);
+        cffont->offset = (l_offset)((unsigned)offset + (cs_idx->offset)[gid_org] - 1);
+                memcpy(charstrings->data+charstring_len,(const char *) result->s,(size_t)size);
+                charstring_len += size;
+                xfree(result);
+            }
+        } else {
+            size = (long) (cs_idx->offset[gid_org + 1] - cs_idx->offset[gid_org]);
+            if (size > CS_STR_LEN_MAX) {
+                formatted_error("cff","charstring too long: gid=%u, %ld bytes", cid, size);
+            }
+            if (charstring_len + CS_STR_LEN_MAX >= max_len) {
+                max_len = charstring_len + 2 * CS_STR_LEN_MAX;
+                charstrings->data = xrealloc(charstrings->data, (unsigned) ((unsigned) max_len * sizeof(card8)));
+            }
+            (charstrings->offset)[gid] = (l_offset) (charstring_len + 1);
+            cffont->offset = (l_offset) ((unsigned) offset + (cs_idx->offset)[gid_org] - 1);
+            memcpy(data, &cffont->stream[cffont->offset], (size_t) size);
+            charstring_len += cs_copy_charstring(
+                charstrings->data + charstring_len,
+                max_len - charstring_len,
+                data, size,
+                cffont->gsubr, (cffont->subrs)[fdsel],
+                0, 0, NULL,
+                cffont->header_major == 2
+            );
+        }
         if (cid > 0 && gid_org > 0) {
             charset->data.glyphs[charset->num_entries] = (s_SID) cid;
             charset->num_entries++;
@@ -3496,15 +3505,13 @@
     charstrings->count = num_glyphs;
     cffont->num_glyphs = num_glyphs;
     cffont->cstrings = charstrings;
-
     cff_release_charsets(cffont->charsets);
     cffont->charsets = charset;
     cff_release_fdselect(cffont->fdselect);
     cffont->fdselect = fdselect;
-
     /*
-     * We don't use subroutines at all.
-     */
+        We don't use subroutines at all.
+    */
     if (cffont->gsubr)
         cff_release_index(cffont->gsubr);
     cffont->gsubr = cff_new_index(0);
@@ -3518,14 +3525,12 @@
             cff_dict_remove((cffont->private)[fdsel], "Subrs"); /* no Subrs */
         }
     }
-
     write_fontfile(pdf, cffont, fullname);
     xfree(fullname);
     cff_close(cffont);
-
 }
 
-@ here is a sneaky trick: fontforge knows how to convert Type1 to CFF, so
+@ Here is a sneaky trick: fontforge knows how to convert Type1 to CFF, so
 I have defined a utility function in luafflib.c that does exactly that.
 If it works out ok, I will clean up this code.
 

Modified: trunk/Build/source/texk/web2c/luatexdir/font/writefont.w
===================================================================
--- trunk/Build/source/texk/web2c/luatexdir/font/writefont.w	2017-03-24 00:34:01 UTC (rev 43591)
+++ trunk/Build/source/texk/web2c/luatexdir/font/writefont.w	2017-03-24 00:38:37 UTC (rev 43592)
@@ -28,23 +28,23 @@
 static void create_cid_fontdictionary(PDF pdf, internal_font_number f);
 
 const key_entry font_key[FONT_KEYS_NUM] = {
-    {"Ascent", "Ascender", 1}
-    , {"CapHeight", "CapHeight", 1}
-    , {"Descent", "Descender", 1}
-    , {"ItalicAngle", "ItalicAngle", 1}
-    , {"StemV", "StdVW", 1}
-    , {"XHeight", "XHeight", 1}
-    , {"FontBBox", "FontBBox", 1}
-    , {"", "", 0}
-    , {"", "", 0}
-    , {"", "", 0}
-    , {"FontName", "FontName", 1}
+    { "Ascent", "Ascender", 1 },
+    { "CapHeight", "CapHeight", 1 },
+    { "Descent", "Descender", 1 },
+    { "ItalicAngle", "ItalicAngle", 1 },
+    { "StemV", "StdVW", 1 },
+    { "XHeight", "XHeight", 1 },
+    { "FontBBox", "FontBBox", 1 },
+    { "", "", 0 },
+    { "", "", 0 },
+    { "", "", 0 },
+    { "FontName", "FontName", 1 }
 };
 
 @
 @c
-struct avl_table *fo_tree = NULL;       /* tree of font dictionaries */
-struct avl_table *fd_tree = NULL;       /* tree of font descriptor objects */
+struct avl_table *fo_tree = NULL; /* tree of font dictionaries */
+struct avl_table *fd_tree = NULL; /* tree of font descriptor objects */
 
 static int comp_fo_entry(const void *pa, const void *pb, void *p)
 {
@@ -83,7 +83,7 @@
 
 @ initialize data structure for /Type /FontDescriptor
 @c
-fd_entry *new_fd_entry(void)
+fd_entry *new_fd_entry(internal_font_number f)
 {
     fd_entry *fd;
     int i;
@@ -104,6 +104,7 @@
     fd->fm = NULL;
     fd->tx_tree = NULL;
     fd->gl_tree = NULL;
+    fd->tex_font = f;
     return fd;
 }
 
@@ -249,7 +250,8 @@
         assert(fd_tree != NULL);
     }
     assert(fd != NULL && fd->fm != NULL && is_fontfile(fd->fm));
-    assert(lookup_fd_entry(fd->fm->ff_name) == NULL);   /* font descriptor not yet registered */
+    /* font descriptor not yet registered: */
+    assert(lookup_fd_entry(fd->fm->ff_name) == NULL);
     aa = avl_probe(fd_tree, fd);
     assert(aa != NULL);
 }
@@ -259,11 +261,13 @@
     assert(fo != NULL);
     assert(fo->fm != NULL);
     assert(fo->fd == NULL);
-    fo->fd = new_fd_entry();
+    fo->fd = new_fd_entry(f);
     preset_fontname(fo, f);
     preset_fontmetrics(fo->fd, f);
-    fo->fd->fe = fo->fe;        /* encoding needed by TrueType writing */
-    fo->fd->fm = fo->fm;        /* map entry needed by TrueType writing */
+    /* encoding needed by TrueType writing: */
+    fo->fd->fe = fo->fe;
+    /* map entry needed by TrueType writing: */
+    fo->fd->fm = fo->fm;
     fo->fd->gl_tree = avl_create(comp_string_entry, NULL, &avl_xallocator);
     assert(fo->fd->gl_tree != NULL);
 }
@@ -285,7 +289,8 @@
         /* mark glyphs from TeX (externally reencoded characters) */
         g = fo->fe->glyph_names;
         for (i = fo->first_char; i <= fo->last_char; i++) {
-            if (pdf_char_marked(f, i) && g[i] != notdef
+            if (pdf_char_marked(f, i)
+                && g[i] != notdef
                 && (char *) avl_find(fo->fd->gl_tree, g[i]) == NULL) {
                 aa = avl_probe(fo->fd->gl_tree, xstrdup(g[i]));
                 assert(aa != NULL);
@@ -301,7 +306,7 @@
 
 @c
 static struct avl_table *mark_chars(fo_entry * fo, struct avl_table *tx_tree,
-                             internal_font_number f)
+     internal_font_number f)
 {
     int i, *j;
     void **aa;
@@ -326,7 +331,8 @@
 {
     int i;
     assert(fo != NULL);
-    for (i = font_bc(f); i <= font_ec(f); i++)  /* search for |first_char| and |last_char| */
+    /* search for |first_char| and |last_char| */
+    for (i = font_bc(f); i <= font_ec(f); i++)
         if (pdf_char_marked(f, i))
             break;
     fo->first_char = i;
@@ -334,8 +340,8 @@
         if (pdf_char_marked(f, i))
             break;
     fo->last_char = i;
-    if ((fo->first_char > fo->last_char)
-        || !pdf_char_marked(f, fo->first_char)) {       /* no character used from this font */
+    if ((fo->first_char > fo->last_char) || !pdf_char_marked(f, fo->first_char)) {
+        /* no character used from this font */
         fo->last_char = 0;
         fo->first_char = fo->last_char + 1;
     }
@@ -344,7 +350,8 @@
 static int font_has_subset(internal_font_number f)
 {
     int i, s;
-    for (i = font_bc(f); i <= font_ec(f); i++)  /* search for |first_char| and |last_char| */
+    /* search for |first_char| and |last_char| */
+    for (i = font_bc(f); i <= font_ec(f); i++)
         if (pdf_char_marked(f, i))
             break;
     s = i;
@@ -359,8 +366,7 @@
 
 @
 @c
-static void write_charwidth_array(PDF pdf, fo_entry * fo,
-                                  internal_font_number f)
+static void write_charwidth_array(PDF pdf, fo_entry * fo, internal_font_number f)
 {
     int i, j, *ip, *fip;
     struct avl_traverser t;
@@ -420,13 +426,13 @@
 }
 
 @
+In principle we could replace the pdftex derived ttf.otf inclusion part
+by using the regular code for this and assigning indices and tounicodes
+to the character blobs, but for the moment we keep the current approach.
 @c
 static void write_fontfile(PDF pdf, fd_entry * fd)
 {
     assert(is_included(fd->fm));
-    /* In principle we could replace the pdftex derived ttf.otf inclusion part */
-    /* by using the regular code for this and assigning indices and tounicodes */
-    /* to the character blobs, but for the moment we keep the current approach */
     if (is_cidkeyed(fd->fm)) {
         if (is_opentype(fd->fm)) {
             writetype0(pdf, fd);
@@ -453,7 +459,7 @@
         return;
     assert(fd->ff_objnum == 0);
     fd->ff_objnum = pdf_create_obj(pdf, obj_type_others, 0);
-    pdf_begin_obj(pdf, fd->ff_objnum, OBJSTM_NEVER);    /* font file stream */
+    pdf_begin_obj(pdf, fd->ff_objnum, OBJSTM_NEVER); /* font file stream */
     pdf_begin_dict(pdf);
     if (is_cidkeyed(fd->fm)) {
         /* No subtype is used for TrueType-based OpenType fonts */
@@ -463,17 +469,16 @@
         else
             pdf_dict_add_name(pdf, "Subtype", "OpenType");
 #endif
+    } else if (is_type1(fd->fm)) {
+        pdf_dict_add_int(pdf, "Length1", (int) t1_length1);
+        pdf_dict_add_int(pdf, "Length2", (int) t1_length2);
+        pdf_dict_add_int(pdf, "Length3", (int) t1_length3);
+    } else if (is_truetype(fd->fm)) {
+        pdf_dict_add_int(pdf, "Length1", (int) ttf_length);
+    } else if (is_opentype(fd->fm)) {
+        pdf_dict_add_name(pdf, "Subtype", "Type1C");
     } else {
-        if (is_type1(fd->fm)) {
-            pdf_dict_add_int(pdf, "Length1", (int) t1_length1);
-            pdf_dict_add_int(pdf, "Length2", (int) t1_length2);
-            pdf_dict_add_int(pdf, "Length3", (int) t1_length3);
-        } else if (is_truetype(fd->fm))
-            pdf_dict_add_int(pdf, "Length1", (int) ttf_length);
-        else if (is_opentype(fd->fm))
-            pdf_dict_add_name(pdf, "Subtype", "Type1C");
-        else
-            assert(0);
+        assert(0); /* todo: error messages */
     }
     pdf_dict_add_streaminfo(pdf);
     pdf_end_dict(pdf);
@@ -489,23 +494,25 @@
 static void write_fontdescriptor(PDF pdf, fd_entry * fd)
 {
     static const int std_flags[] = {
-        /* indices for << start with 0, but bits start with 1, so the numbers
-         * for << are 1 lower than the bits in table 5.20 */
+        /*
+            The indices for << start with 0, but bits start with 1, so the
+            numbers for << are 1 lower than the bits in table 5.20.
+        */
         /* *INDENT-OFF* */
-        1 + 2 + (1 << 5),                       /* Courier */
-        1 + 2 + (1 << 5)            + (1 << 18),/* Courier-Bold */
-        1 + 2 + (1 << 5) + (1 << 6),            /* Courier-Oblique */
-        1 + 2 + (1 << 5) + (1 << 6) + (1 << 18),/* Courier-BoldOblique */
-                (1 << 5),                       /* Helvetica */
-                (1 << 5)            + (1 << 18),/* Helvetica-Bold */
-                (1 << 5) + (1 << 6),            /* Helvetica-Oblique */
-                (1 << 5) + (1 << 6) + (1 << 18),/* Helvetica-BoldOblique */
-              4,                                /* Symbol */
-            2 + (1 << 5),                       /* Times-Roman */
-            2 + (1 << 5)            + (1 << 18),/* Times-Bold */
-            2 + (1 << 5) + (1 << 6),            /* Times-Italic */
-            2 + (1 << 5) + (1 << 6) + (1 << 18),/* Times-BoldItalic */
-              4                                 /* ZapfDingbats */
+        1 + 2 + (1 << 5),                        /* Courier */
+        1 + 2 + (1 << 5)            + (1 << 18), /* Courier-Bold */
+        1 + 2 + (1 << 5) + (1 << 6),             /* Courier-Oblique */
+        1 + 2 + (1 << 5) + (1 << 6) + (1 << 18), /* Courier-BoldOblique */
+                (1 << 5),                        /* Helvetica */
+                (1 << 5)            + (1 << 18), /* Helvetica-Bold */
+                (1 << 5) + (1 << 6),             /* Helvetica-Oblique */
+                (1 << 5) + (1 << 6) + (1 << 18), /* Helvetica-BoldOblique */
+              4,                                 /* Symbol */
+            2 + (1 << 5),                        /* Times-Roman */
+            2 + (1 << 5)            + (1 << 18), /* Times-Bold */
+            2 + (1 << 5) + (1 << 6),             /* Times-Italic */
+            2 + (1 << 5) + (1 << 6) + (1 << 18), /* Times-BoldItalic */
+              4                                  /* ZapfDingbats */
         /* *INDENT-ON* */
     };
     char *glyph;
@@ -512,9 +519,11 @@
     struct avl_traverser t;
     int fd_flags;
     assert(fd != NULL && fd->fm != NULL);
-    cidset = 0;                 /* possibly updated by |write_fontfile| */
-    if (is_fontfile(fd->fm) && is_included(fd->fm))
-        write_fontfile(pdf, fd);        /* this will set |fd->ff_found| if font file is found */
+    cidset = 0; /* possibly updated by |write_fontfile| */
+    if (is_fontfile(fd->fm) && is_included(fd->fm)) {
+        /* this will set |fd->ff_found| if font file is found */
+        write_fontfile(pdf, fd);
+    }
     if (fd->fd_objnum == 0)
         fd->fd_objnum = pdf_create_obj(pdf, obj_type_others, 0);
     pdf_begin_obj(pdf, fd->fd_objnum, OBJSTM_ALWAYS);
@@ -572,10 +581,11 @@
     if ((! pdf->omit_cidset) && (cidset != 0)) {
         pdf_dict_add_ref(pdf, "CIDSet", cidset);
     }
-    /* TODO: Other optional keys for CID fonts.
-       The most interesting one is
-       \.{/Style << /Panose <12-byte string>>>}
-     */
+    /*
+        Currently we don't export the optional keys for CID fonts like
+        \.{/Style << /Panose <12-byte string> >>} and we probably never
+        will.
+    */
     pdf_end_dict(pdf);
     pdf_end_obj(pdf);
 }
@@ -587,8 +597,7 @@
     if (fd_tree == NULL)
         return;
     avl_t_init(&t, fd_tree);
-    for (fd = (fd_entry *) avl_t_first(&t, fd_tree); fd != NULL;
-         fd = (fd_entry *) avl_t_next(&t))
+    for (fd = (fd_entry *) avl_t_first(&t, fd_tree); fd != NULL; fd = (fd_entry *) avl_t_next(&t))
         write_fontdescriptor(pdf, fd);
 }
 
@@ -598,18 +607,16 @@
 {
     assert(fo != NULL);
     assert(fo->fm != NULL);
-    assert(fo->fo_objnum != 0); /* reserved as |pdf_font_num(f)| elsewhere */
+    /* reserved as |pdf_font_num(f)| elsewhere: */
+    assert(fo->fo_objnum != 0);
 
     /* write ToUnicode entry if needed */
     if (pdf->gen_tounicode > 0 && fo->fd != NULL) {
         if (fo->fe != NULL) {
-            fo->tounicode_objnum =
-                write_tounicode(pdf, fo->fe->glyph_names, fo->fe->name);
+            fo->tounicode_objnum = write_tounicode(pdf, fo->fe->glyph_names, fo->fe->name);
         } else if (is_type1(fo->fm)) {
             assert(fo->fd->builtin_glyph_names != NULL);
-            fo->tounicode_objnum =
-                write_tounicode(pdf, fo->fd->builtin_glyph_names,
-                                fo->fm->tfm_name);
+            fo->tounicode_objnum = write_tounicode(pdf, fo->fd->builtin_glyph_names, fo->fm->tfm_name);
         }
     }
     pdf_begin_obj(pdf, fo->fo_objnum, OBJSTM_ALWAYS);
@@ -630,13 +637,11 @@
     pdf_dict_add_int(pdf, "FirstChar", (int) fo->first_char);
     pdf_dict_add_int(pdf, "LastChar", (int) fo->last_char);
     pdf_dict_add_ref(pdf, "Widths", (int) fo->cw_objnum);
-    if ((is_type1(fo->fm) || is_opentype(fo->fm)) && fo->fe != NULL
-        && fo->fe->fe_objnum != 0)
+    if ((is_type1(fo->fm) || is_opentype(fo->fm)) && fo->fe != NULL && fo->fe->fe_objnum != 0)
         pdf_dict_add_ref(pdf, "Encoding", (int) fo->fe->fe_objnum);
     if (fo->tounicode_objnum != 0)
         pdf_dict_add_ref(pdf, "ToUnicode", (int) fo->tounicode_objnum);
-    if (pdf_font_attr(fo->tex_font) != get_nullstr() &&
-        pdf_font_attr(fo->tex_font) != 0) {
+    if (pdf_font_attr(fo->tex_font) != get_nullstr() && pdf_font_attr(fo->tex_font) != 0) {
         pdf_print(pdf, pdf_font_attr(fo->tex_font));
         pdf_out(pdf, '\n');
     }
@@ -651,14 +656,12 @@
     if (fo_tree == NULL)
         return;
     avl_t_init(&t, fo_tree);
-    for (fo = (fo_entry *) avl_t_first(&t, fo_tree); fo != NULL;
-         fo = (fo_entry *) avl_t_next(&t))
+    for (fo = (fo_entry *) avl_t_first(&t, fo_tree); fo != NULL; fo = (fo_entry *) avl_t_next(&t))
         write_fontdictionary(pdf, fo);
 }
 
-@ Final flush of all font related stuff by call from
- \.{Output fonts definitions} elsewhere
-
+@ Final flush of all font related stuff by call from \.{Output fonts
+definitions} elsewhere
 @c
 void write_fontstuff(PDF pdf)
 {
@@ -673,23 +676,30 @@
 {
     fo_entry *fo = new_fo_entry();
     fm_entry *fm = font_map(f);
-    get_char_range(fo, f);      /* set |fo->first_char| and |fo->last_char| from |f| */
+    /* set |fo->first_char| and |fo->last_char| from |f| */
+    get_char_range(fo, f);
     if (fo->last_char > 255)
-        fo->last_char = 255;    /* added 9-4-2008, mantis \#25 */
+        fo->last_char = 255;
     assert(fo->last_char >= fo->first_char);
     fo->fm = fm;
     fo->fo_objnum = pdf_font_num(f);
     fo->tex_font = f;
-    if (is_reencoded(fo->fm)) { /* at least the map entry tells so */
-        fo->fe = get_fe_entry(fo->fm->encname); /* returns |NULL| if .enc file couldn't be opened */
-        if (fo->fe != NULL && (is_type1(fo->fm) || is_opentype(fo->fm))) {  /* not entered for truetype */
+    if (is_reencoded(fo->fm)) {
+        /*
+            At least the map entry tells so but it returns |NULL| if the .enc
+            file couldn't be opened.
+        */
+        fo->fe = get_fe_entry(fo->fm->encname);
+        if (fo->fe != NULL && (is_type1(fo->fm) || is_opentype(fo->fm))) {
+            /* We don't end up here for truetype fonts. */
             if (fo->fe->fe_objnum == 0)
                 fo->fe->fe_objnum = pdf_create_obj(pdf, obj_type_others, 0);    /* then it will be written out */
-            /* mark encoding pairs used by TeX to optimize encoding vector */
+            /* Mark encoding pairs used by TeX to optimize encoding vector. */
             fo->fe->tx_tree = mark_chars(fo, fo->fe->tx_tree, f);
         }
     }
-    fo->tx_tree = mark_chars(fo, fo->tx_tree, f);       /* for |write_charwidth_array| */
+    /* for |write_charwidth_array|: */
+    fo->tx_tree = mark_chars(fo, fo->tx_tree, f);
     write_charwidth_array(pdf, fo, f);
     if (!is_builtin(fo->fm)) {
         if (is_type1(fo->fm)) {
@@ -697,8 +707,9 @@
                 create_fontdescriptor(fo, f);
                 register_fd_entry(fo->fd);
             }
-        } else
+        } else {
             create_fontdescriptor(fo, f);
+        }
         if (fo->fe != NULL) {
             mark_reenc_glyphs(fo, f);
             if (!is_type1(fo->fm)) {
@@ -705,28 +716,33 @@
                 /* mark reencoded characters as chars on TeX level */
                 assert(fo->fd->tx_tree == NULL);
                 fo->fd->tx_tree = mark_chars(fo, fo->fd->tx_tree, f);
-                if (is_truetype(fo->fm))
+                if (is_truetype(fo->fm)) {
                     fo->fd->write_ttf_glyph_names = true;
+                }
             }
-        } else
+        } else {
             /* mark non-reencoded characters as chars on TeX level */
             fo->fd->tx_tree = mark_chars(fo, fo->fd->tx_tree, f);
-        if (!is_type1(fo->fm))
+        }
+        if (!is_type1(fo->fm)) {
             write_fontdescriptor(pdf, fo->fd);
+        }
     } else {
-        /* builtin fonts still need the /Widths array and /FontDescriptor
-         * (to avoid error 'font FOO contains bad /BBox')
-         */
+        /*
+            Builtin fonts still need the /Widths array and /FontDescriptor
+            (to avoid error 'font FOO contains bad /BBox').
+        */
         create_fontdescriptor(fo, f);
         write_fontdescriptor(pdf, fo->fd);
-        if (!is_std_t1font(fo->fm))
-            formatted_warning("map file", "font '%s' is not a standard font; I suppose it is available to your PDF viewer then",
-                fo->fm->ps_name);
+        if (!is_std_t1font(fo->fm)) {
+            formatted_warning("map file", "font '%s' is not a standard font; I suppose it is available to your PDF viewer then", fo->fm->ps_name);
+        }
     }
-    if (is_type1(fo->fm))
+    if (is_type1(fo->fm)) {
         register_fo_entry(fo);
-    else
+    } else {
         write_fontdictionary(pdf, fo);
+    }
 }
 
 @
@@ -751,32 +767,37 @@
 {
     int del_file = 0;
     fm_entry *fm;
-    /* TODO This is not 100\% true: CID is actually needed whenever (and
-     only) there are more than 256 separate glyphs used. But for
-     now, just assume the user knows what he is doing;
-     */
+    /*
+        This is not 100\% true: CID is actually needed whenever (and
+        only) there are more than 256 separate glyphs used. But for
+        now, we just assume the user knows what he is doing. In practice
+        this seems to be the case.
+    */
     if (!font_has_subset(f))
         return;
 
     if (font_encodingbytes(f) == 2) {
-        /* Create a virtual font map entry, as this is needed by the
-         rest of the font inclusion mechanism.
-         */
+        /*
+            Create a virtual font map entry, as this is needed by the
+            rest of the font inclusion mechanism.
+        */
         fm = font_map(f) = new_fm_entry();
         fm->tfm_name = font_name(f);    /* or whatever, not a real tfm */
         fm->ff_name = font_filename(f); /* the actual file */
         if (font_psname(f) != NULL)
-            fm->ps_name = font_psname(f);       /* the true name */
+            fm->ps_name = font_psname(f);   /* the true name */
         else
-            fm->ps_name = font_fullname(f);     /* the true name */
+            fm->ps_name = font_fullname(f); /* the true name */
         if (fm->ff_name
             && strlen(fm->ff_name) >= 6
-            && strstr(fm->ff_name,
-                      ".dfont") == (fm->ff_name + strlen(fm->ff_name) - 6)) {
-            /* In case of a .dfont, we will extract the correct ttf here,
-               and adjust |fm->ff_name| to point to the temporary file.
-               This file will be deleted later. Todo: keep a nicer name
-               somewhere for the terminal message.
+            && strstr(fm->ff_name,".dfont") == (fm->ff_name + strlen(fm->ff_name) - 6)) {
+            /*
+                In case of a .dfont, we will extract the correct ttf here,
+                and adjust |fm->ff_name| to point to the temporary file.
+                This file will be deleted later. Todo: keep a nicer name
+                somewhere for the terminal message.
+
+                Support for dfonts will be removed at some point anyhow.
              */
             char *s = FindResourceTtfFont(fm->ff_name, fm->ps_name);
             if (s != NULL) {
@@ -786,12 +807,14 @@
                 formatted_error("font","file '%s' does not contain font '%s'",fm->ff_name, fm->ps_name);
             }
         }
-        fm->encname = font_encodingname(f);     /* for the CIDSystemInfo */
-        fm->slant = font_slant(f);      /* slant factor */
+        /* Needed for the CIDSystemInfo: */
+        fm->encname = font_encodingname(f);
+        fm->slant = font_slant(f);
         set_slantset(fm);
-        fm->extend = font_extend(f);    /* extension factor */
+        fm->extend = font_extend(f);
         set_extendset(fm);
-        fm->fd_flags = 4;       /* can perhaps be done better */
+        /* Flags can perhaps be done better. */
+        fm->fd_flags = 4;
         set_inuse(fm);
 
         switch (font_format(f)) {
@@ -826,7 +849,10 @@
             unlink(fm->ff_name);
 
     } else {
-        /* by now |font_map(f)|, if any, should have been set via |pdf_init_font()| */
+        /*
+            By now |font_map(f)|, if any, should have been set via
+            |pdf_init_font()|.
+        */
         if ((fm = font_map(f)) == NULL
             || (fm->ps_name == NULL && fm->ff_name == NULL))
             writet3(pdf, f);
@@ -836,12 +862,12 @@
 }
 
 @ The glyph width is included in |glw_entry|, because that width
-   depends on the value it has in the font where it is actually
-   typeset from, not the font that is the 'owner' of the fd entry.
+depends on the value it has in the font where it is actually
+typeset from, not the font that is the 'owner' of the fd entry.
 
-   TODO: It is possible that the user messes with the metric width,
-   but handling that properly would require access to the 'hmtx' table
-   at this point in the program.
+TODO: It is possible that the user messes with the metric width,
+but handling that properly would require access to the 'hmtx' table
+at this point in the program.
 
 @c
 static int comp_glw_entry(const void *pa, const void *pb, void *p
@@ -860,19 +886,19 @@
     assert(fo != NULL);
     assert(fo->fm != NULL);
     assert(fo->fd == NULL);
-    fo->fd = new_fd_entry();
+    fo->fd = new_fd_entry(f);
     preset_fontname(fo, f);
     preset_fontmetrics(fo->fd, f);
-    fo->fd->fe = fo->fe;        /* encoding needed by TrueType writing */
-    fo->fd->fm = fo->fm;        /* map entry needed by TrueType writing */
+    fo->fd->fe = fo->fe; /* encoding needed by TrueType writing */
+    fo->fd->fm = fo->fm; /* map entry needed by TrueType writing */
     fo->fd->gl_tree = avl_create(comp_glw_entry, NULL, &avl_xallocator);
     assert(fo->fd->gl_tree != NULL);
 }
 
 
-@ The values |font_bc()| and |font_ec()| are potentially large
-   character ids, but the strings that are written out use CID
-   indexes, and those are limited to 16-bit values.
+@ The values |font_bc()| and |font_ec()| are potentially large character
+ids, but the strings that are written out use CID indexes, and those are
+limited to 16-bit values.
 
 @c
 static void mark_cid_subset_glyphs(fo_entry * fo, internal_font_number f)
@@ -900,18 +926,17 @@
     }
 }
 
+@ It is possible to compress the widths array even better, by using the
+alternate 'range' syntax and possibly even using /DW to set a default
+value.
 
-@  It is possible to compress the widths array even better, by using the
-   alternate 'range' syntax and possibly even using /DW to set
-   a default value.
+There is a some optimization here already: glyphs that are not used do
+not appear in the widths array at all.
 
-   There is a some optimization here already: glyphs that are
-   not used do not appear in the widths array at all.
+We have to make sure that we do not output an (incorrect!) width for a
+character that exists in the font, but is not used in typesetting. An
+enormous negative width is used as sentinel value
 
-   We have to make sure that we do not output an (incorrect!)
-   width for a character that exists in the font, but is not used
-   in typesetting. An enormous negative width is used as sentinel value
-
 @c
 static void write_cid_charwidth_array(PDF pdf, fo_entry * fo)
 {
@@ -977,10 +1002,10 @@
     mark_cid_subset_glyphs(fo, f);
     if (is_subsetted(fo->fm)) {
         /*
-           this is a bit sneaky. |make_subset_tag()| actually expects the glyph tree
-           to contain strings instead of |glw_entry| items. However, all calculations
-           are done using explicit typecasts, so it works out ok.
-         */
+           This is a bit sneaky. |make_subset_tag()| actually expects the glyph
+           tree to contain strings instead of |glw_entry| items. However, all
+           calculations are done using explicit typecasts, so it works out ok.
+        */
         make_subset_tag(fo->fd);
     }
     write_cid_charwidth_array(pdf, fo);
@@ -1038,15 +1063,13 @@
     pdf_dict_add_ref(pdf, "W", (int) fo->cw_objnum);
     pdf_add_name(pdf, "CIDSystemInfo");
     pdf_begin_dict(pdf);
-    pdf_dict_add_string(pdf, "Registry",
-                        (font_cidregistry(f) ? font_cidregistry(f) : "Adobe"));
-    pdf_dict_add_string(pdf, "Ordering",
-                        (font_cidordering(f) ? font_cidordering(f) :
-                         "Identity"));
+    pdf_dict_add_string(pdf, "Registry", (font_cidregistry(f) ? font_cidregistry(f) : "Adobe"));
+    pdf_dict_add_string(pdf, "Ordering", (font_cidordering(f) ? font_cidordering(f) : "Identity"));
     pdf_dict_add_int(pdf, "Supplement", (int) font_cidsupplement(f));
     pdf_end_dict(pdf);
 
     /* I doubt there is anything useful that could be written here */
+
 #if 0
     if (pdf_font_attr(fo->tex_font) != get_nullstr()) {
         pdf_out(pdf, '\n');
@@ -1054,6 +1077,7 @@
         pdf_out(pdf, '\n');
     }
 #endif
+
     pdf_end_dict(pdf);
     pdf_end_obj(pdf);
 }

Modified: trunk/Build/source/texk/web2c/luatexdir/font/writettf.w
===================================================================
--- trunk/Build/source/texk/web2c/luatexdir/font/writettf.w	2017-03-24 00:34:01 UTC (rev 43591)
+++ trunk/Build/source/texk/web2c/luatexdir/font/writettf.w	2017-03-24 00:38:37 UTC (rev 43592)
@@ -1751,7 +1751,6 @@
 
     pdf_save_offset(pdf);
     pdf_flush(pdf);
-
     if (is_subsetted(fd_cur->fm)) {
         ttf_copy_encoding();
         ttf_subset_font(pdf);
@@ -1795,9 +1794,13 @@
     if (ttf_name_lookup("post", false) != NULL)
         ttf_read_post();
     /* copy font file */
-    tab = ttf_seek_tab("CFF ", 0);
-    for (i = (long) tab->length; i > 0; i--)
+    if (ttf_name_lookup("CFF2", false) != NULL)      /* HH */
+        tab = ttf_seek_tab("CFF2", 0);               /* HH */
+    else                                             /* HH */
+        tab = ttf_seek_tab("CFF ", 0);
+    for (i = (long) tab->length; i > 0; i--) {
         copy_char();
+    }
     xfree(dir_tab);
     if (tracefilenames)
         tex_printf(">>");

Modified: trunk/Build/source/texk/web2c/luatexdir/font/writetype0.w
===================================================================
--- trunk/Build/source/texk/web2c/luatexdir/font/writetype0.w	2017-03-24 00:34:01 UTC (rev 43591)
+++ trunk/Build/source/texk/web2c/luatexdir/font/writetype0.w	2017-03-24 00:38:37 UTC (rev 43592)
@@ -19,7 +19,6 @@
 
 @ @c
 
-
 #include "ptexlib.h"
 #include "font/writettf.h"
 #include "font/writecff.h"
@@ -26,6 +25,7 @@
 
 @ @c
 extern unsigned char *ttf_buffer;
+
 void writetype0(PDF pdf, fd_entry * fd)
 {
     int callback_id;
@@ -76,7 +76,6 @@
     if (sfont->type == SFNT_TYPE_TTC)
         i = ff_get_ttc_index(fd->fm->ff_name, fd->fm->ps_name);
 
-
     if (is_subsetted(fd_cur->fm)) {
         report_start_file(filetype_subset, cur_file_name);
     } else {
@@ -83,7 +82,6 @@
         report_start_file(filetype_font, cur_file_name);
     }
 
-
     if (sfont->type == SFNT_TYPE_TTC) otc_read_tabdir(i);
     else ttf_read_tabdir();
     sfnt_close(sfont);
@@ -99,7 +97,10 @@
         ttf_read_post();
 
     /* copy font file */
-    tab = ttf_seek_tab("CFF ", 0);
+    if (ttf_name_lookup("CFF2", false) != NULL)      /* HH */
+        tab = ttf_seek_tab("CFF2", 0);               /* HH */
+    else                                             /* HH */
+        tab = ttf_seek_tab("CFF ", 0);
 
     /* TODO the next 0 is a subfont index */
     cff = read_cff(ttf_buffer + ttf_curbyte, (long) tab->length, 0);

Modified: trunk/Build/source/texk/web2c/luatexdir/font/writetype2.w
===================================================================
--- trunk/Build/source/texk/web2c/luatexdir/font/writetype2.w	2017-03-24 00:34:01 UTC (rev 43591)
+++ trunk/Build/source/texk/web2c/luatexdir/font/writetype2.w	2017-03-24 00:38:37 UTC (rev 43592)
@@ -344,7 +344,7 @@
             normal_error("type 2","there are no glyphs in the subset");
         }
 
-        if (tt_build_tables(sfont, glyphs) < 0) {
+        if (tt_build_tables(sfont, glyphs, fd) < 0) {
             normal_error("type 2","the TTF buffer can't be parsed");
         }
 

Modified: trunk/Build/source/texk/web2c/luatexdir/lua/lcallbacklib.c
===================================================================
--- trunk/Build/source/texk/web2c/luatexdir/lua/lcallbacklib.c	2017-03-24 00:34:01 UTC (rev 43591)
+++ trunk/Build/source/texk/web2c/luatexdir/lua/lcallbacklib.c	2017-03-24 00:38:37 UTC (rev 43592)
@@ -74,6 +74,7 @@
     "contribute_filter",
     "call_edit",
     "build_page_insert",
+    "glyph_stream_provider",
     NULL
 };
 

Modified: trunk/Build/source/texk/web2c/luatexdir/lua/luatex-api.h
===================================================================
--- trunk/Build/source/texk/web2c/luatexdir/lua/luatex-api.h	2017-03-24 00:34:01 UTC (rev 43591)
+++ trunk/Build/source/texk/web2c/luatexdir/lua/luatex-api.h	2017-03-24 00:38:37 UTC (rev 43592)
@@ -782,6 +782,7 @@
 make_lua_key(step);\
 make_lua_key(stream);\
 make_lua_key(streamfile);\
+make_lua_key(streamprovider);\
 make_lua_key(stretch);\
 make_lua_key(stretch_order);\
 make_lua_key(string);\
@@ -1143,6 +1144,7 @@
 init_lua_key(step);\
 init_lua_key(stream);\
 init_lua_key(streamfile);\
+init_lua_key(streamprovider);\
 init_lua_key(stretch);\
 init_lua_key(stretch_order);\
 init_lua_key(string);\
@@ -1571,6 +1573,7 @@
 use_lua_key(step);
 use_lua_key(stream);
 use_lua_key(streamfile);
+use_lua_key(streamprovider);
 use_lua_key(stretch);
 use_lua_key(stretch_order);
 use_lua_key(string);

Modified: trunk/Build/source/texk/web2c/luatexdir/luatexcallbackids.h
===================================================================
--- trunk/Build/source/texk/web2c/luatexdir/luatexcallbackids.h	2017-03-24 00:34:01 UTC (rev 43591)
+++ trunk/Build/source/texk/web2c/luatexdir/luatexcallbackids.h	2017-03-24 00:38:37 UTC (rev 43592)
@@ -68,6 +68,7 @@
     contribute_filter_callback,
     call_edit_callback,
     build_page_insert_callback,
+    glyph_stream_provider_callback,
     total_callbacks
 } callback_callback_types;
 

Modified: trunk/Build/source/texk/web2c/luatexdir/tex/dumpdata.w
===================================================================
--- trunk/Build/source/texk/web2c/luatexdir/tex/dumpdata.w	2017-03-24 00:34:01 UTC (rev 43591)
+++ trunk/Build/source/texk/web2c/luatexdir/tex/dumpdata.w	2017-03-24 00:38:37 UTC (rev 43592)
@@ -23,7 +23,7 @@
 
 /* we start with 907: the sum of the values of the bytes of "don knuth" */
 
-#define FORMAT_ID (907+27)
+#define FORMAT_ID (907+28)
 #if ((FORMAT_ID>=0) && (FORMAT_ID<=256))
 #error Wrong value for FORMAT_ID.
 #endif



More information about the tex-live-commits mailing list